@chilkat/react-native 11.6.1

package/cpp/HybridStream.hpp

@@ -0,0 +1,123 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Stream: the Nitro HybridObject over Chilkat's CkStream (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridStreamSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkStream.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridStream final : public HybridStreamSpec, public ChilkatObject<CkStream> {
+public:
+  HybridStream();                                  // `new Stream()` from JS
+  explicit HybridStream(CkStream* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  bool getAbortCurrent() override;
+  void setAbortCurrent(bool value) override;
+  bool getCanRead() override;
+  bool getCanWrite() override;
+  bool getDataAvailable() override;
+  double getDefaultChunkSize() override;
+  void setDefaultChunkSize(double value) override;
+  bool getEndOfStream() override;
+  bool getIsWriteClosed() override;
+  double getLength() override;
+  void setLength(double value) override;
+  double getLength32() override;
+  void setLength32(double value) override;
+  double getNumReceived() override;
+  double getNumSent() override;
+  double getReadFailReason() override;
+  double getReadTimeoutMs() override;
+  void setReadTimeoutMs(double value) override;
+  std::string getSinkFile() override;
+  void setSinkFile(const std::string& value) override;
+  std::string getSourceFile() override;
+  void setSourceFile(const std::string& value) override;
+  bool getStringBom() override;
+  void setStringBom(bool value) override;
+  std::string getStringCharset() override;
+  void setStringCharset(const std::string& value) override;
+  double getWriteFailReason() override;
+  double getWriteTimeoutMs() override;
+  void setWriteTimeoutMs(double value) override;
+  double getSourceFilePart() override;
+  void setSourceFilePart(double value) override;
+  double getSourceFilePartSize() override;
+  void setSourceFilePartSize(double value) override;
+  bool getSinkFileAppend() override;
+  void setSinkFileAppend(bool value) override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+
+  // ---- Methods ----
+  std::string readBytesENC(const std::string& encoding) override;
+  std::shared_ptr<Promise<std::string>> readBytesENCAsync(const std::string& encoding) override;
+  std::string readNBytesENC(double numBytes, const std::string& encoding) override;
+  std::shared_ptr<Promise<std::string>> readNBytesENCAsync(double numBytes, const std::string& encoding) override;
+  std::string readString() override;
+  std::shared_ptr<Promise<std::string>> readStringAsync() override;
+  std::string readToCRLF() override;
+  std::shared_ptr<Promise<std::string>> readToCRLFAsync() override;
+  std::string readUntilMatch(const std::string& matchStr) override;
+  std::shared_ptr<Promise<std::string>> readUntilMatchAsync(const std::string& matchStr) override;
+  void reset() override;
+  void setSourceString(const std::string& srcStr, const std::string& charset) override;
+  void writeByte(double byteVal) override;
+  std::shared_ptr<Promise<void>> writeByteAsync(double byteVal) override;
+  void writeBytesENC(const std::string& byteData, const std::string& encoding) override;
+  std::shared_ptr<Promise<void>> writeBytesENCAsync(const std::string& byteData, const std::string& encoding) override;
+  void writeClose() override;
+  void writeString(const std::string& str) override;
+  std::shared_ptr<Promise<void>> writeStringAsync(const std::string& str) override;
+  void readBd(const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  std::shared_ptr<Promise<void>> readBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  void readSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  std::shared_ptr<Promise<void>> readSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void writeBd(const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  std::shared_ptr<Promise<void>> writeBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  void writeSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  std::shared_ptr<Promise<void>> writeSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void writeBytes2(const std::shared_ptr<ArrayBuffer>& byteData) override;
+
+  // ---- Events (ReactNativeGen_DESIGN.md §6) ----
+  std::optional<std::function<void(double)>> getOnPercentDone() override;
+  void setOnPercentDone(const std::optional<std::function<void(double)>>& cb) override;
+  std::optional<std::function<void(const std::string&, const std::string&)>> getOnProgressInfo() override;
+  void setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) override;
+  void abort() override;
+
+private:
+  void init();
+  std::string readBytesENC_impl(const std::string& encoding);
+  std::string readNBytesENC_impl(double numBytes, const std::string& encoding);
+  std::string readString_impl();
+  std::string readToCRLF_impl();
+  std::string readUntilMatch_impl(const std::string& matchStr);
+  void reset_impl();
+  void setSourceString_impl(const std::string& srcStr, const std::string& charset);
+  void writeByte_impl(double byteVal);
+  void writeBytesENC_impl(const std::string& byteData, const std::string& encoding);
+  void writeClose_impl();
+  void writeString_impl(const std::string& str);
+  void readBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData);
+  void readSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void writeBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData);
+  void writeSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void writeBytes2_impl(const uint8_t* byteDataData, size_t byteDataSize);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridStringArray.cpp

@@ -0,0 +1,368 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridStringArray.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridStringArray::HybridStringArray()
+    : HybridObject(HybridStringArraySpec::TAG), ChilkatObject<CkStringArray>("StringArray", CkStringArray::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridStringArray::HybridStringArray(CkStringArray* owned)
+    : HybridObject(HybridStringArraySpec::TAG), ChilkatObject<CkStringArray>("StringArray", owned) {
+  init();
+}
+
+void HybridStringArray::init() {
+}
+
+void HybridStringArray::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridStringArray::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStringArray::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStringArray::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStringArray::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStringArray::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridStringArray::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridStringArray::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridStringArray::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridStringArray::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridStringArray::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridStringArray::getCount() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Count());
+}
+bool HybridStringArray::getCrlf() {
+  this->beginCall();
+  return this->ck().get_Crlf();
+}
+void HybridStringArray::setCrlf(bool value) {
+  this->beginCall();
+  this->ck().put_Crlf(value);
+}
+double HybridStringArray::getLength() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Length());
+}
+bool HybridStringArray::getTrim() {
+  this->beginCall();
+  return this->ck().get_Trim();
+}
+void HybridStringArray::setTrim(bool value) {
+  this->beginCall();
+  this->ck().put_Trim(value);
+}
+bool HybridStringArray::getUnique() {
+  this->beginCall();
+  return this->ck().get_Unique();
+}
+void HybridStringArray::setUnique(bool value) {
+  this->beginCall();
+  this->ck().put_Unique(value);
+}
+
+// ---- Methods ----
+
+void HybridStringArray::append(const std::string& str) {
+  this->beginCall();
+  append_impl(str);
+}
+void HybridStringArray::append_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  if (!this->ck().Append(str.c_str())) throw this->fail("append");
+}
+
+void HybridStringArray::appendSerialized(const std::string& encodedStr) {
+  this->beginCall();
+  appendSerialized_impl(encodedStr);
+}
+void HybridStringArray::appendSerialized_impl(const std::string& encodedStr) {
+  rt::checkNoNul(encodedStr, "encodedStr");
+  if (!this->ck().AppendSerialized(encodedStr.c_str())) throw this->fail("appendSerialized");
+}
+
+void HybridStringArray::clear() {
+  this->beginCall();
+  clear_impl();
+}
+void HybridStringArray::clear_impl() {
+  this->ck().Clear();
+}
+
+bool HybridStringArray::contains(const std::string& str) {
+  this->beginCall();
+  return contains_impl(str);
+}
+bool HybridStringArray::contains_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  return this->ck().Contains(str.c_str());
+}
+
+double HybridStringArray::find(const std::string& findStr, double startIndex) {
+  this->beginCall();
+  return find_impl(findStr, startIndex);
+}
+double HybridStringArray::find_impl(const std::string& findStr, double startIndex) {
+  rt::checkNoNul(findStr, "findStr");
+  return static_cast<double>(this->ck().Find(findStr.c_str(), rt::toInt(startIndex, "startIndex")));
+}
+
+double HybridStringArray::findFirstMatch(const std::string& matchPattern, double startIndex) {
+  this->beginCall();
+  return findFirstMatch_impl(matchPattern, startIndex);
+}
+double HybridStringArray::findFirstMatch_impl(const std::string& matchPattern, double startIndex) {
+  rt::checkNoNul(matchPattern, "matchPattern");
+  return static_cast<double>(this->ck().FindFirstMatch(matchPattern.c_str(), rt::toInt(startIndex, "startIndex")));
+}
+
+std::string HybridStringArray::getString(double index) {
+  this->beginCall();
+  return getString_impl(index);
+}
+std::string HybridStringArray::getString_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetString(rt::toInt(index, "index"), _out)) throw this->fail("getString");
+  return rt::stdString(_out);
+}
+
+double HybridStringArray::getStringLen(double index) {
+  this->beginCall();
+  return getStringLen_impl(index);
+}
+double HybridStringArray::getStringLen_impl(double index) {
+  return static_cast<double>(this->ck().GetStringLen(rt::toInt(index, "index")));
+}
+
+void HybridStringArray::insertAt(double index, const std::string& str) {
+  this->beginCall();
+  insertAt_impl(index, str);
+}
+void HybridStringArray::insertAt_impl(double index, const std::string& str) {
+  rt::checkNoNul(str, "str");
+  this->ck().InsertAt(rt::toInt(index, "index"), str.c_str());
+}
+
+std::string HybridStringArray::lastString() {
+  this->beginCall();
+  return lastString_impl();
+}
+std::string HybridStringArray::lastString_impl() {
+  CkString _out;
+  if (!this->ck().LastString(_out)) throw this->fail("lastString");
+  return rt::stdString(_out);
+}
+
+void HybridStringArray::loadFromFile(const std::string& path) {
+  this->beginCall();
+  loadFromFile_impl(path);
+}
+void HybridStringArray::loadFromFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadFromFile(path.c_str())) throw this->fail("loadFromFile");
+}
+
+void HybridStringArray::loadFromFile2(const std::string& path, const std::string& charset) {
+  this->beginCall();
+  loadFromFile2_impl(path, charset);
+}
+void HybridStringArray::loadFromFile2_impl(const std::string& path, const std::string& charset) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().LoadFromFile2(path.c_str(), charset.c_str())) throw this->fail("loadFromFile2");
+}
+
+void HybridStringArray::loadFromText(const std::string& str) {
+  this->beginCall();
+  loadFromText_impl(str);
+}
+void HybridStringArray::loadFromText_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  this->ck().LoadFromText(str.c_str());
+}
+
+std::string HybridStringArray::pop() {
+  this->beginCall();
+  return pop_impl();
+}
+std::string HybridStringArray::pop_impl() {
+  CkString _out;
+  if (!this->ck().Pop(_out)) throw this->fail("pop");
+  return rt::stdString(_out);
+}
+
+void HybridStringArray::prepend(const std::string& str) {
+  this->beginCall();
+  prepend_impl(str);
+}
+void HybridStringArray::prepend_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  this->ck().Prepend(str.c_str());
+}
+
+void HybridStringArray::remove(const std::string& str) {
+  this->beginCall();
+  remove_impl(str);
+}
+void HybridStringArray::remove_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  this->ck().Remove(str.c_str());
+}
+
+void HybridStringArray::removeAt(double index) {
+  this->beginCall();
+  removeAt_impl(index);
+}
+void HybridStringArray::removeAt_impl(double index) {
+  if (!this->ck().RemoveAt(rt::toInt(index, "index"))) throw this->fail("removeAt");
+}
+
+void HybridStringArray::replaceAt(double index, const std::string& str) {
+  this->beginCall();
+  replaceAt_impl(index, str);
+}
+void HybridStringArray::replaceAt_impl(double index, const std::string& str) {
+  rt::checkNoNul(str, "str");
+  this->ck().ReplaceAt(rt::toInt(index, "index"), str.c_str());
+}
+
+void HybridStringArray::saveNthToFile(double index, const std::string& saveToPath) {
+  this->beginCall();
+  saveNthToFile_impl(index, saveToPath);
+}
+void HybridStringArray::saveNthToFile_impl(double index, const std::string& saveToPath) {
+  rt::checkNoNul(saveToPath, "saveToPath");
+  if (!this->ck().SaveNthToFile(rt::toInt(index, "index"), saveToPath.c_str())) throw this->fail("saveNthToFile");
+}
+
+void HybridStringArray::saveToFile(const std::string& path) {
+  this->beginCall();
+  saveToFile_impl(path);
+}
+void HybridStringArray::saveToFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SaveToFile(path.c_str())) throw this->fail("saveToFile");
+}
+
+void HybridStringArray::saveToFile2(const std::string& saveToPath, const std::string& charset) {
+  this->beginCall();
+  saveToFile2_impl(saveToPath, charset);
+}
+void HybridStringArray::saveToFile2_impl(const std::string& saveToPath, const std::string& charset) {
+  rt::checkNoNul(saveToPath, "saveToPath");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().SaveToFile2(saveToPath.c_str(), charset.c_str())) throw this->fail("saveToFile2");
+}
+
+std::string HybridStringArray::saveToText() {
+  this->beginCall();
+  return saveToText_impl();
+}
+std::string HybridStringArray::saveToText_impl() {
+  CkString _out;
+  if (!this->ck().SaveToText(_out)) throw this->fail("saveToText");
+  return rt::stdString(_out);
+}
+
+std::string HybridStringArray::serialize() {
+  this->beginCall();
+  return serialize_impl();
+}
+std::string HybridStringArray::serialize_impl() {
+  CkString _out;
+  if (!this->ck().Serialize(_out)) throw this->fail("serialize");
+  return rt::stdString(_out);
+}
+
+void HybridStringArray::sort(bool ascending) {
+  this->beginCall();
+  sort_impl(ascending);
+}
+void HybridStringArray::sort_impl(bool ascending) {
+  this->ck().Sort(ascending);
+}
+
+void HybridStringArray::splitAndAppend(const std::string& str, const std::string& boundary) {
+  this->beginCall();
+  splitAndAppend_impl(str, boundary);
+}
+void HybridStringArray::splitAndAppend_impl(const std::string& str, const std::string& boundary) {
+  rt::checkNoNul(str, "str");
+  rt::checkNoNul(boundary, "boundary");
+  this->ck().SplitAndAppend(str.c_str(), boundary.c_str());
+}
+
+std::string HybridStringArray::strAt(double index) {
+  this->beginCall();
+  return strAt_impl(index);
+}
+std::string HybridStringArray::strAt_impl(double index) {
+  CkString _out;
+  if (!this->ck().StrAt(rt::toInt(index, "index"), _out)) throw this->fail("strAt");
+  return rt::stdString(_out);
+}
+
+void HybridStringArray::subtract(const std::shared_ptr<HybridStringArraySpec>& stringArrayObj) {
+  this->beginCall();
+  subtract_impl(stringArrayObj);
+}
+void HybridStringArray::subtract_impl(const std::shared_ptr<HybridStringArraySpec>& stringArrayObj) {
+  this->ck().Subtract(rt::implOf<HybridStringArray>(stringArrayObj, "stringArrayObj").ck());
+}
+
+void HybridStringArray::unionWith(const std::shared_ptr<HybridStringArraySpec>& stringArrayObj) {
+  this->beginCall();
+  unionWith_impl(stringArrayObj);
+}
+void HybridStringArray::unionWith_impl(const std::shared_ptr<HybridStringArraySpec>& stringArrayObj) {
+  this->ck().Union(rt::implOf<HybridStringArray>(stringArrayObj, "stringArrayObj").ck());
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridStringArray.hpp

@@ -0,0 +1,99 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// StringArray: the Nitro HybridObject over Chilkat's CkStringArray (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridStringArraySpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkStringArray.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridStringArray final : public HybridStringArraySpec, public ChilkatObject<CkStringArray> {
+public:
+  HybridStringArray();                                  // `new StringArray()` from JS
+  explicit HybridStringArray(CkStringArray* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  double getCount() override;
+  bool getCrlf() override;
+  void setCrlf(bool value) override;
+  double getLength() override;
+  bool getTrim() override;
+  void setTrim(bool value) override;
+  bool getUnique() override;
+  void setUnique(bool value) override;
+
+  // ---- Methods ----
+  void append(const std::string& str) override;
+  void appendSerialized(const std::string& encodedStr) override;
+  void clear() override;
+  bool contains(const std::string& str) override;
+  double find(const std::string& findStr, double startIndex) override;
+  double findFirstMatch(const std::string& matchPattern, double startIndex) override;
+  std::string getString(double index) override;
+  double getStringLen(double index) override;
+  void insertAt(double index, const std::string& str) override;
+  std::string lastString() override;
+  void loadFromFile(const std::string& path) override;
+  void loadFromFile2(const std::string& path, const std::string& charset) override;
+  void loadFromText(const std::string& str) override;
+  std::string pop() override;
+  void prepend(const std::string& str) override;
+  void remove(const std::string& str) override;
+  void removeAt(double index) override;
+  void replaceAt(double index, const std::string& str) override;
+  void saveNthToFile(double index, const std::string& saveToPath) override;
+  void saveToFile(const std::string& path) override;
+  void saveToFile2(const std::string& saveToPath, const std::string& charset) override;
+  std::string saveToText() override;
+  std::string serialize() override;
+  void sort(bool ascending) override;
+  void splitAndAppend(const std::string& str, const std::string& boundary) override;
+  std::string strAt(double index) override;
+  void subtract(const std::shared_ptr<HybridStringArraySpec>& stringArrayObj) override;
+  void unionWith(const std::shared_ptr<HybridStringArraySpec>& stringArrayObj) override;
+
+private:
+  void init();
+  void append_impl(const std::string& str);
+  void appendSerialized_impl(const std::string& encodedStr);
+  void clear_impl();
+  bool contains_impl(const std::string& str);
+  double find_impl(const std::string& findStr, double startIndex);
+  double findFirstMatch_impl(const std::string& matchPattern, double startIndex);
+  std::string getString_impl(double index);
+  double getStringLen_impl(double index);
+  void insertAt_impl(double index, const std::string& str);
+  std::string lastString_impl();
+  void loadFromFile_impl(const std::string& path);
+  void loadFromFile2_impl(const std::string& path, const std::string& charset);
+  void loadFromText_impl(const std::string& str);
+  std::string pop_impl();
+  void prepend_impl(const std::string& str);
+  void remove_impl(const std::string& str);
+  void removeAt_impl(double index);
+  void replaceAt_impl(double index, const std::string& str);
+  void saveNthToFile_impl(double index, const std::string& saveToPath);
+  void saveToFile_impl(const std::string& path);
+  void saveToFile2_impl(const std::string& saveToPath, const std::string& charset);
+  std::string saveToText_impl();
+  std::string serialize_impl();
+  void sort_impl(bool ascending);
+  void splitAndAppend_impl(const std::string& str, const std::string& boundary);
+  std::string strAt_impl(double index);
+  void subtract_impl(const std::shared_ptr<HybridStringArraySpec>& stringArrayObj);
+  void unionWith_impl(const std::shared_ptr<HybridStringArraySpec>& stringArrayObj);
+};
+
+} // namespace margelo::nitro::chilkat