@chilkat/react-native 11.6.1

package/nitrogen/generated/shared/c++/HybridStreamSpec.cpp

@@ -0,0 +1,100 @@
+///
+/// HybridStreamSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridStreamSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridStreamSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridStreamSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridStreamSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridStreamSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridStreamSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridStreamSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridStreamSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridStreamSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridStreamSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridStreamSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridStreamSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("abortCurrent", &HybridStreamSpec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridStreamSpec::setAbortCurrent);
+      prototype.registerHybridGetter("canRead", &HybridStreamSpec::getCanRead);
+      prototype.registerHybridGetter("canWrite", &HybridStreamSpec::getCanWrite);
+      prototype.registerHybridGetter("dataAvailable", &HybridStreamSpec::getDataAvailable);
+      prototype.registerHybridGetter("defaultChunkSize", &HybridStreamSpec::getDefaultChunkSize);
+      prototype.registerHybridSetter("defaultChunkSize", &HybridStreamSpec::setDefaultChunkSize);
+      prototype.registerHybridGetter("endOfStream", &HybridStreamSpec::getEndOfStream);
+      prototype.registerHybridGetter("isWriteClosed", &HybridStreamSpec::getIsWriteClosed);
+      prototype.registerHybridGetter("length", &HybridStreamSpec::getLength);
+      prototype.registerHybridSetter("length", &HybridStreamSpec::setLength);
+      prototype.registerHybridGetter("length32", &HybridStreamSpec::getLength32);
+      prototype.registerHybridSetter("length32", &HybridStreamSpec::setLength32);
+      prototype.registerHybridGetter("numReceived", &HybridStreamSpec::getNumReceived);
+      prototype.registerHybridGetter("numSent", &HybridStreamSpec::getNumSent);
+      prototype.registerHybridGetter("readFailReason", &HybridStreamSpec::getReadFailReason);
+      prototype.registerHybridGetter("readTimeoutMs", &HybridStreamSpec::getReadTimeoutMs);
+      prototype.registerHybridSetter("readTimeoutMs", &HybridStreamSpec::setReadTimeoutMs);
+      prototype.registerHybridGetter("sinkFile", &HybridStreamSpec::getSinkFile);
+      prototype.registerHybridSetter("sinkFile", &HybridStreamSpec::setSinkFile);
+      prototype.registerHybridGetter("sourceFile", &HybridStreamSpec::getSourceFile);
+      prototype.registerHybridSetter("sourceFile", &HybridStreamSpec::setSourceFile);
+      prototype.registerHybridGetter("stringBom", &HybridStreamSpec::getStringBom);
+      prototype.registerHybridSetter("stringBom", &HybridStreamSpec::setStringBom);
+      prototype.registerHybridGetter("stringCharset", &HybridStreamSpec::getStringCharset);
+      prototype.registerHybridSetter("stringCharset", &HybridStreamSpec::setStringCharset);
+      prototype.registerHybridGetter("writeFailReason", &HybridStreamSpec::getWriteFailReason);
+      prototype.registerHybridGetter("writeTimeoutMs", &HybridStreamSpec::getWriteTimeoutMs);
+      prototype.registerHybridSetter("writeTimeoutMs", &HybridStreamSpec::setWriteTimeoutMs);
+      prototype.registerHybridGetter("sourceFilePart", &HybridStreamSpec::getSourceFilePart);
+      prototype.registerHybridSetter("sourceFilePart", &HybridStreamSpec::setSourceFilePart);
+      prototype.registerHybridGetter("sourceFilePartSize", &HybridStreamSpec::getSourceFilePartSize);
+      prototype.registerHybridSetter("sourceFilePartSize", &HybridStreamSpec::setSourceFilePartSize);
+      prototype.registerHybridGetter("sinkFileAppend", &HybridStreamSpec::getSinkFileAppend);
+      prototype.registerHybridSetter("sinkFileAppend", &HybridStreamSpec::setSinkFileAppend);
+      prototype.registerHybridGetter("heartbeatMs", &HybridStreamSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridStreamSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("onPercentDone", &HybridStreamSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridStreamSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridStreamSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridStreamSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("readBytesENC", &HybridStreamSpec::readBytesENC);
+      prototype.registerHybridMethod("readBytesENCAsync", &HybridStreamSpec::readBytesENCAsync);
+      prototype.registerHybridMethod("readNBytesENC", &HybridStreamSpec::readNBytesENC);
+      prototype.registerHybridMethod("readNBytesENCAsync", &HybridStreamSpec::readNBytesENCAsync);
+      prototype.registerHybridMethod("readString", &HybridStreamSpec::readString);
+      prototype.registerHybridMethod("readStringAsync", &HybridStreamSpec::readStringAsync);
+      prototype.registerHybridMethod("readToCRLF", &HybridStreamSpec::readToCRLF);
+      prototype.registerHybridMethod("readToCRLFAsync", &HybridStreamSpec::readToCRLFAsync);
+      prototype.registerHybridMethod("readUntilMatch", &HybridStreamSpec::readUntilMatch);
+      prototype.registerHybridMethod("readUntilMatchAsync", &HybridStreamSpec::readUntilMatchAsync);
+      prototype.registerHybridMethod("reset", &HybridStreamSpec::reset);
+      prototype.registerHybridMethod("setSourceString", &HybridStreamSpec::setSourceString);
+      prototype.registerHybridMethod("writeByte", &HybridStreamSpec::writeByte);
+      prototype.registerHybridMethod("writeByteAsync", &HybridStreamSpec::writeByteAsync);
+      prototype.registerHybridMethod("writeBytesENC", &HybridStreamSpec::writeBytesENC);
+      prototype.registerHybridMethod("writeBytesENCAsync", &HybridStreamSpec::writeBytesENCAsync);
+      prototype.registerHybridMethod("writeClose", &HybridStreamSpec::writeClose);
+      prototype.registerHybridMethod("writeString", &HybridStreamSpec::writeString);
+      prototype.registerHybridMethod("writeStringAsync", &HybridStreamSpec::writeStringAsync);
+      prototype.registerHybridMethod("readBd", &HybridStreamSpec::readBd);
+      prototype.registerHybridMethod("readBdAsync", &HybridStreamSpec::readBdAsync);
+      prototype.registerHybridMethod("readSb", &HybridStreamSpec::readSb);
+      prototype.registerHybridMethod("readSbAsync", &HybridStreamSpec::readSbAsync);
+      prototype.registerHybridMethod("writeBd", &HybridStreamSpec::writeBd);
+      prototype.registerHybridMethod("writeBdAsync", &HybridStreamSpec::writeBdAsync);
+      prototype.registerHybridMethod("writeSb", &HybridStreamSpec::writeSb);
+      prototype.registerHybridMethod("writeSbAsync", &HybridStreamSpec::writeSbAsync);
+      prototype.registerHybridMethod("writeBytes2", &HybridStreamSpec::writeBytes2);
+      prototype.registerHybridMethod("abort", &HybridStreamSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridStreamSpec.hpp

@@ -0,0 +1,150 @@
+///
+/// HybridStreamSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridBinDataSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Stream`
+   * Inherit this class to create instances of `HybridStreamSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridStream: public HybridStreamSpec {
+   * public:
+   *   HybridStream(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridStreamSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridStreamSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridStreamSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual bool getAbortCurrent() = 0;
+      virtual void setAbortCurrent(bool abortCurrent) = 0;
+      virtual bool getCanRead() = 0;
+      virtual bool getCanWrite() = 0;
+      virtual bool getDataAvailable() = 0;
+      virtual double getDefaultChunkSize() = 0;
+      virtual void setDefaultChunkSize(double defaultChunkSize) = 0;
+      virtual bool getEndOfStream() = 0;
+      virtual bool getIsWriteClosed() = 0;
+      virtual double getLength() = 0;
+      virtual void setLength(double length) = 0;
+      virtual double getLength32() = 0;
+      virtual void setLength32(double length32) = 0;
+      virtual double getNumReceived() = 0;
+      virtual double getNumSent() = 0;
+      virtual double getReadFailReason() = 0;
+      virtual double getReadTimeoutMs() = 0;
+      virtual void setReadTimeoutMs(double readTimeoutMs) = 0;
+      virtual std::string getSinkFile() = 0;
+      virtual void setSinkFile(const std::string& sinkFile) = 0;
+      virtual std::string getSourceFile() = 0;
+      virtual void setSourceFile(const std::string& sourceFile) = 0;
+      virtual bool getStringBom() = 0;
+      virtual void setStringBom(bool stringBom) = 0;
+      virtual std::string getStringCharset() = 0;
+      virtual void setStringCharset(const std::string& stringCharset) = 0;
+      virtual double getWriteFailReason() = 0;
+      virtual double getWriteTimeoutMs() = 0;
+      virtual void setWriteTimeoutMs(double writeTimeoutMs) = 0;
+      virtual double getSourceFilePart() = 0;
+      virtual void setSourceFilePart(double sourceFilePart) = 0;
+      virtual double getSourceFilePartSize() = 0;
+      virtual void setSourceFilePartSize(double sourceFilePartSize) = 0;
+      virtual bool getSinkFileAppend() = 0;
+      virtual void setSinkFileAppend(bool sinkFileAppend) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual std::optional<std::function<void(double /* pctDone */)>> getOnPercentDone() = 0;
+      virtual void setOnPercentDone(const std::optional<std::function<void(double /* pctDone */)>>& onPercentDone) = 0;
+      virtual std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>> getOnProgressInfo() = 0;
+      virtual void setOnProgressInfo(const std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>>& onProgressInfo) = 0;
+
+    public:
+      // Methods
+      virtual std::string readBytesENC(const std::string& encoding) = 0;
+      virtual std::shared_ptr<Promise<std::string>> readBytesENCAsync(const std::string& encoding) = 0;
+      virtual std::string readNBytesENC(double numBytes, const std::string& encoding) = 0;
+      virtual std::shared_ptr<Promise<std::string>> readNBytesENCAsync(double numBytes, const std::string& encoding) = 0;
+      virtual std::string readString() = 0;
+      virtual std::shared_ptr<Promise<std::string>> readStringAsync() = 0;
+      virtual std::string readToCRLF() = 0;
+      virtual std::shared_ptr<Promise<std::string>> readToCRLFAsync() = 0;
+      virtual std::string readUntilMatch(const std::string& matchStr) = 0;
+      virtual std::shared_ptr<Promise<std::string>> readUntilMatchAsync(const std::string& matchStr) = 0;
+      virtual void reset() = 0;
+      virtual void setSourceString(const std::string& srcStr, const std::string& charset) = 0;
+      virtual void writeByte(double byteVal) = 0;
+      virtual std::shared_ptr<Promise<void>> writeByteAsync(double byteVal) = 0;
+      virtual void writeBytesENC(const std::string& byteData, const std::string& encoding) = 0;
+      virtual std::shared_ptr<Promise<void>> writeBytesENCAsync(const std::string& byteData, const std::string& encoding) = 0;
+      virtual void writeClose() = 0;
+      virtual void writeString(const std::string& str) = 0;
+      virtual std::shared_ptr<Promise<void>> writeStringAsync(const std::string& str) = 0;
+      virtual void readBd(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual std::shared_ptr<Promise<void>> readBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual void readSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual std::shared_ptr<Promise<void>> readSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void writeBd(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual std::shared_ptr<Promise<void>> writeBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual void writeSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual std::shared_ptr<Promise<void>> writeSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void writeBytes2(const std::shared_ptr<ArrayBuffer>& byteData) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Stream";
+  };
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridStringArraySpec.cpp

@@ -0,0 +1,66 @@
+///
+/// HybridStringArraySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridStringArraySpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridStringArraySpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridStringArraySpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridStringArraySpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridStringArraySpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridStringArraySpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridStringArraySpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridStringArraySpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridStringArraySpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridStringArraySpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridStringArraySpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridStringArraySpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("count", &HybridStringArraySpec::getCount);
+      prototype.registerHybridGetter("crlf", &HybridStringArraySpec::getCrlf);
+      prototype.registerHybridSetter("crlf", &HybridStringArraySpec::setCrlf);
+      prototype.registerHybridGetter("length", &HybridStringArraySpec::getLength);
+      prototype.registerHybridGetter("trim", &HybridStringArraySpec::getTrim);
+      prototype.registerHybridSetter("trim", &HybridStringArraySpec::setTrim);
+      prototype.registerHybridGetter("unique", &HybridStringArraySpec::getUnique);
+      prototype.registerHybridSetter("unique", &HybridStringArraySpec::setUnique);
+      prototype.registerHybridMethod("append", &HybridStringArraySpec::append);
+      prototype.registerHybridMethod("appendSerialized", &HybridStringArraySpec::appendSerialized);
+      prototype.registerHybridMethod("clear", &HybridStringArraySpec::clear);
+      prototype.registerHybridMethod("contains", &HybridStringArraySpec::contains);
+      prototype.registerHybridMethod("find", &HybridStringArraySpec::find);
+      prototype.registerHybridMethod("findFirstMatch", &HybridStringArraySpec::findFirstMatch);
+      prototype.registerHybridMethod("getString", &HybridStringArraySpec::getString);
+      prototype.registerHybridMethod("getStringLen", &HybridStringArraySpec::getStringLen);
+      prototype.registerHybridMethod("insertAt", &HybridStringArraySpec::insertAt);
+      prototype.registerHybridMethod("lastString", &HybridStringArraySpec::lastString);
+      prototype.registerHybridMethod("loadFromFile", &HybridStringArraySpec::loadFromFile);
+      prototype.registerHybridMethod("loadFromFile2", &HybridStringArraySpec::loadFromFile2);
+      prototype.registerHybridMethod("loadFromText", &HybridStringArraySpec::loadFromText);
+      prototype.registerHybridMethod("pop", &HybridStringArraySpec::pop);
+      prototype.registerHybridMethod("prepend", &HybridStringArraySpec::prepend);
+      prototype.registerHybridMethod("remove", &HybridStringArraySpec::remove);
+      prototype.registerHybridMethod("removeAt", &HybridStringArraySpec::removeAt);
+      prototype.registerHybridMethod("replaceAt", &HybridStringArraySpec::replaceAt);
+      prototype.registerHybridMethod("saveNthToFile", &HybridStringArraySpec::saveNthToFile);
+      prototype.registerHybridMethod("saveToFile", &HybridStringArraySpec::saveToFile);
+      prototype.registerHybridMethod("saveToFile2", &HybridStringArraySpec::saveToFile2);
+      prototype.registerHybridMethod("saveToText", &HybridStringArraySpec::saveToText);
+      prototype.registerHybridMethod("serialize", &HybridStringArraySpec::serialize);
+      prototype.registerHybridMethod("sort", &HybridStringArraySpec::sort);
+      prototype.registerHybridMethod("splitAndAppend", &HybridStringArraySpec::splitAndAppend);
+      prototype.registerHybridMethod("strAt", &HybridStringArraySpec::strAt);
+      prototype.registerHybridMethod("subtract", &HybridStringArraySpec::subtract);
+      prototype.registerHybridMethod("unionWith", &HybridStringArraySpec::unionWith);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridStringArraySpec.hpp

@@ -0,0 +1,109 @@
+///
+/// HybridStringArraySpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridStringArraySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringArraySpec; }
+
+#include <string>
+#include <memory>
+#include "HybridStringArraySpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `StringArray`
+   * Inherit this class to create instances of `HybridStringArraySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridStringArray: public HybridStringArraySpec {
+   * public:
+   *   HybridStringArray(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridStringArraySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridStringArraySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridStringArraySpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual double getCount() = 0;
+      virtual bool getCrlf() = 0;
+      virtual void setCrlf(bool crlf) = 0;
+      virtual double getLength() = 0;
+      virtual bool getTrim() = 0;
+      virtual void setTrim(bool trim) = 0;
+      virtual bool getUnique() = 0;
+      virtual void setUnique(bool unique) = 0;
+
+    public:
+      // Methods
+      virtual void append(const std::string& str) = 0;
+      virtual void appendSerialized(const std::string& encodedStr) = 0;
+      virtual void clear() = 0;
+      virtual bool contains(const std::string& str) = 0;
+      virtual double find(const std::string& findStr, double startIndex) = 0;
+      virtual double findFirstMatch(const std::string& matchPattern, double startIndex) = 0;
+      virtual std::string getString(double index) = 0;
+      virtual double getStringLen(double index) = 0;
+      virtual void insertAt(double index, const std::string& str) = 0;
+      virtual std::string lastString() = 0;
+      virtual void loadFromFile(const std::string& path) = 0;
+      virtual void loadFromFile2(const std::string& path, const std::string& charset) = 0;
+      virtual void loadFromText(const std::string& str) = 0;
+      virtual std::string pop() = 0;
+      virtual void prepend(const std::string& str) = 0;
+      virtual void remove(const std::string& str) = 0;
+      virtual void removeAt(double index) = 0;
+      virtual void replaceAt(double index, const std::string& str) = 0;
+      virtual void saveNthToFile(double index, const std::string& saveToPath) = 0;
+      virtual void saveToFile(const std::string& path) = 0;
+      virtual void saveToFile2(const std::string& saveToPath, const std::string& charset) = 0;
+      virtual std::string saveToText() = 0;
+      virtual std::string serialize() = 0;
+      virtual void sort(bool ascending) = 0;
+      virtual void splitAndAppend(const std::string& str, const std::string& boundary) = 0;
+      virtual std::string strAt(double index) = 0;
+      virtual void subtract(const std::shared_ptr<HybridStringArraySpec>& stringArrayObj) = 0;
+      virtual void unionWith(const std::shared_ptr<HybridStringArraySpec>& stringArrayObj) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "StringArray";
+  };
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridStringBuilderSpec.cpp

@@ -0,0 +1,104 @@
+///
+/// HybridStringBuilderSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridStringBuilderSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridStringBuilderSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridStringBuilderSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridStringBuilderSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridStringBuilderSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridStringBuilderSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridStringBuilderSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridStringBuilderSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridStringBuilderSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridStringBuilderSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridStringBuilderSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridStringBuilderSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("length", &HybridStringBuilderSpec::getLength);
+      prototype.registerHybridGetter("intValue", &HybridStringBuilderSpec::getIntValue);
+      prototype.registerHybridSetter("intValue", &HybridStringBuilderSpec::setIntValue);
+      prototype.registerHybridGetter("isBase64", &HybridStringBuilderSpec::getIsBase64);
+      prototype.registerHybridGetter("hasEmojis", &HybridStringBuilderSpec::getHasEmojis);
+      prototype.registerHybridMethod("append", &HybridStringBuilderSpec::append);
+      prototype.registerHybridMethod("appendInt", &HybridStringBuilderSpec::appendInt);
+      prototype.registerHybridMethod("appendInt64", &HybridStringBuilderSpec::appendInt64);
+      prototype.registerHybridMethod("clear", &HybridStringBuilderSpec::clear);
+      prototype.registerHybridMethod("replace", &HybridStringBuilderSpec::replace);
+      prototype.registerHybridMethod("getAsString", &HybridStringBuilderSpec::getAsString);
+      prototype.registerHybridMethod("contentsEqual", &HybridStringBuilderSpec::contentsEqual);
+      prototype.registerHybridMethod("contains", &HybridStringBuilderSpec::contains);
+      prototype.registerHybridMethod("isWellFormed", &HybridStringBuilderSpec::isWellFormed);
+      prototype.registerHybridMethod("prepend", &HybridStringBuilderSpec::prepend);
+      prototype.registerHybridMethod("setString", &HybridStringBuilderSpec::setString);
+      prototype.registerHybridMethod("encode", &HybridStringBuilderSpec::encode);
+      prototype.registerHybridMethod("getEncoded", &HybridStringBuilderSpec::getEncoded);
+      prototype.registerHybridMethod("decode", &HybridStringBuilderSpec::decode);
+      prototype.registerHybridMethod("trim", &HybridStringBuilderSpec::trim);
+      prototype.registerHybridMethod("trimInsideSpaces", &HybridStringBuilderSpec::trimInsideSpaces);
+      prototype.registerHybridMethod("startsWith", &HybridStringBuilderSpec::startsWith);
+      prototype.registerHybridMethod("endsWith", &HybridStringBuilderSpec::endsWith);
+      prototype.registerHybridMethod("toLowercase", &HybridStringBuilderSpec::toLowercase);
+      prototype.registerHybridMethod("toUppercase", &HybridStringBuilderSpec::toUppercase);
+      prototype.registerHybridMethod("toCRLF", &HybridStringBuilderSpec::toCRLF);
+      prototype.registerHybridMethod("toLF", &HybridStringBuilderSpec::toLF);
+      prototype.registerHybridMethod("entityDecode", &HybridStringBuilderSpec::entityDecode);
+      prototype.registerHybridMethod("replaceWord", &HybridStringBuilderSpec::replaceWord);
+      prototype.registerHybridMethod("replaceBetween", &HybridStringBuilderSpec::replaceBetween);
+      prototype.registerHybridMethod("getBetween", &HybridStringBuilderSpec::getBetween);
+      prototype.registerHybridMethod("getAfterBetween", &HybridStringBuilderSpec::getAfterBetween);
+      prototype.registerHybridMethod("getNth", &HybridStringBuilderSpec::getNth);
+      prototype.registerHybridMethod("setNth", &HybridStringBuilderSpec::setNth);
+      prototype.registerHybridMethod("loadFile", &HybridStringBuilderSpec::loadFile);
+      prototype.registerHybridMethod("writeFile", &HybridStringBuilderSpec::writeFile);
+      prototype.registerHybridMethod("appendSb", &HybridStringBuilderSpec::appendSb);
+      prototype.registerHybridMethod("contentsEqualSb", &HybridStringBuilderSpec::contentsEqualSb);
+      prototype.registerHybridMethod("lastNLines", &HybridStringBuilderSpec::lastNLines);
+      prototype.registerHybridMethod("appendBd", &HybridStringBuilderSpec::appendBd);
+      prototype.registerHybridMethod("replaceAllBetween", &HybridStringBuilderSpec::replaceAllBetween);
+      prototype.registerHybridMethod("appendLine", &HybridStringBuilderSpec::appendLine);
+      prototype.registerHybridMethod("secureClear", &HybridStringBuilderSpec::secureClear);
+      prototype.registerHybridMethod("replaceI", &HybridStringBuilderSpec::replaceI);
+      prototype.registerHybridMethod("containsWord", &HybridStringBuilderSpec::containsWord);
+      prototype.registerHybridMethod("punyEncode", &HybridStringBuilderSpec::punyEncode);
+      prototype.registerHybridMethod("punyDecode", &HybridStringBuilderSpec::punyDecode);
+      prototype.registerHybridMethod("replaceAfterFinal", &HybridStringBuilderSpec::replaceAfterFinal);
+      prototype.registerHybridMethod("writeFileIfModified", &HybridStringBuilderSpec::writeFileIfModified);
+      prototype.registerHybridMethod("getBefore", &HybridStringBuilderSpec::getBefore);
+      prototype.registerHybridMethod("removeBefore", &HybridStringBuilderSpec::removeBefore);
+      prototype.registerHybridMethod("replaceFirst", &HybridStringBuilderSpec::replaceFirst);
+      prototype.registerHybridMethod("getAfterFinal", &HybridStringBuilderSpec::getAfterFinal);
+      prototype.registerHybridMethod("removeAfterFinal", &HybridStringBuilderSpec::removeAfterFinal);
+      prototype.registerHybridMethod("obfuscate", &HybridStringBuilderSpec::obfuscate);
+      prototype.registerHybridMethod("unobfuscate", &HybridStringBuilderSpec::unobfuscate);
+      prototype.registerHybridMethod("replaceNoCase", &HybridStringBuilderSpec::replaceNoCase);
+      prototype.registerHybridMethod("decodeAndAppend", &HybridStringBuilderSpec::decodeAndAppend);
+      prototype.registerHybridMethod("shorten", &HybridStringBuilderSpec::shorten);
+      prototype.registerHybridMethod("removeCharsAt", &HybridStringBuilderSpec::removeCharsAt);
+      prototype.registerHybridMethod("getRange", &HybridStringBuilderSpec::getRange);
+      prototype.registerHybridMethod("getHash", &HybridStringBuilderSpec::getHash);
+      prototype.registerHybridMethod("removeAccents", &HybridStringBuilderSpec::removeAccents);
+      prototype.registerHybridMethod("appendUuid", &HybridStringBuilderSpec::appendUuid);
+      prototype.registerHybridMethod("appendRandom", &HybridStringBuilderSpec::appendRandom);
+      prototype.registerHybridMethod("appendUuid7", &HybridStringBuilderSpec::appendUuid7);
+      prototype.registerHybridMethod("removeEmojis", &HybridStringBuilderSpec::removeEmojis);
+      prototype.registerHybridMethod("regexMatch", &HybridStringBuilderSpec::regexMatch);
+      prototype.registerHybridMethod("regexReplace", &HybridStringBuilderSpec::regexReplace);
+      prototype.registerHybridMethod("maskQuotedStrings", &HybridStringBuilderSpec::maskQuotedStrings);
+      prototype.registerHybridMethod("restoreMaskedStrings", &HybridStringBuilderSpec::restoreMaskedStrings);
+      prototype.registerHybridMethod("markdownToHtml", &HybridStringBuilderSpec::markdownToHtml);
+      prototype.registerHybridMethod("getRangeSb", &HybridStringBuilderSpec::getRangeSb);
+      prototype.registerHybridMethod("appendLn", &HybridStringBuilderSpec::appendLn);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat