@chilkat/react-native 11.6.1

package/cpp/HybridTrustedRoots.cpp

@@ -0,0 +1,178 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridTrustedRoots.hpp"
+#include "HybridCert.hpp"
+#include "HybridJavaKeyStore.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridTrustedRoots::HybridTrustedRoots()
+    : HybridObject(HybridTrustedRootsSpec::TAG), ChilkatObject<CkTrustedRoots>("TrustedRoots", CkTrustedRoots::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridTrustedRoots::HybridTrustedRoots(CkTrustedRoots* owned)
+    : HybridObject(HybridTrustedRootsSpec::TAG), ChilkatObject<CkTrustedRoots>("TrustedRoots", owned) {
+  init();
+}
+
+void HybridTrustedRoots::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridTrustedRoots::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridTrustedRoots::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridTrustedRoots::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridTrustedRoots::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridTrustedRoots::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridTrustedRoots::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridTrustedRoots::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridTrustedRoots::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridTrustedRoots::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridTrustedRoots::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridTrustedRoots::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridTrustedRoots::getNumCerts() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumCerts());
+}
+bool HybridTrustedRoots::getTrustSystemCaRoots() {
+  this->beginCall();
+  return this->ck().get_TrustSystemCaRoots();
+}
+void HybridTrustedRoots::setTrustSystemCaRoots(bool value) {
+  this->beginCall();
+  this->ck().put_TrustSystemCaRoots(value);
+}
+bool HybridTrustedRoots::getRejectSelfSignedCerts() {
+  this->beginCall();
+  return this->ck().get_RejectSelfSignedCerts();
+}
+void HybridTrustedRoots::setRejectSelfSignedCerts(bool value) {
+  this->beginCall();
+  this->ck().put_RejectSelfSignedCerts(value);
+}
+
+// ---- Methods ----
+
+void HybridTrustedRoots::activate() {
+  this->beginCall();
+  activate_impl();
+}
+void HybridTrustedRoots::activate_impl() {
+  if (!this->ck().Activate()) throw this->fail("activate");
+}
+
+void HybridTrustedRoots::addCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  addCert_impl(cert);
+}
+void HybridTrustedRoots::addCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().AddCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("addCert");
+}
+
+void HybridTrustedRoots::addJavaKeyStore(const std::shared_ptr<HybridJavaKeyStoreSpec>& keystore) {
+  this->beginCall();
+  addJavaKeyStore_impl(keystore);
+}
+void HybridTrustedRoots::addJavaKeyStore_impl(const std::shared_ptr<HybridJavaKeyStoreSpec>& keystore) {
+  if (!this->ck().AddJavaKeyStore(rt::implOf<HybridJavaKeyStore>(keystore, "keystore").ck())) throw this->fail("addJavaKeyStore");
+}
+std::shared_ptr<Promise<void>> HybridTrustedRoots::addJavaKeyStoreAsync(const std::shared_ptr<HybridJavaKeyStoreSpec>& keystore) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridTrustedRoots>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(keystore);
+  return rt::runAsync<void>("TrustedRoots.addJavaKeyStoreAsync", std::move(_parts), [_self, keystore]() {
+    _self->addJavaKeyStore_impl(keystore);
+  });
+}
+
+void HybridTrustedRoots::deactivate() {
+  this->beginCall();
+  deactivate_impl();
+}
+void HybridTrustedRoots::deactivate_impl() {
+  if (!this->ck().Deactivate()) throw this->fail("deactivate");
+}
+
+void HybridTrustedRoots::loadCaCertsPem(const std::string& path) {
+  this->beginCall();
+  loadCaCertsPem_impl(path);
+}
+void HybridTrustedRoots::loadCaCertsPem_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadCaCertsPem(path.c_str())) throw this->fail("loadCaCertsPem");
+}
+std::shared_ptr<Promise<void>> HybridTrustedRoots::loadCaCertsPemAsync(const std::string& path) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridTrustedRoots>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("TrustedRoots.loadCaCertsPemAsync", std::move(_parts), [_self, path]() {
+    _self->loadCaCertsPem_impl(path);
+  });
+}
+
+void HybridTrustedRoots::certAt(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  certAt_impl(index, cert);
+}
+void HybridTrustedRoots::certAt_impl(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().CertAt(rt::toInt(index, "index"), rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("certAt");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridTrustedRoots::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridTrustedRoots::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridTrustedRoots::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridTrustedRoots::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridTrustedRoots::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridTrustedRoots.hpp

@@ -0,0 +1,61 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// TrustedRoots: the Nitro HybridObject over Chilkat's CkTrustedRoots (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridTrustedRootsSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkTrustedRoots.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridTrustedRoots final : public HybridTrustedRootsSpec, public ChilkatObject<CkTrustedRoots> {
+public:
+  HybridTrustedRoots();                                  // `new TrustedRoots()` from JS
+  explicit HybridTrustedRoots(CkTrustedRoots* 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 getNumCerts() override;
+  bool getTrustSystemCaRoots() override;
+  void setTrustSystemCaRoots(bool value) override;
+  bool getRejectSelfSignedCerts() override;
+  void setRejectSelfSignedCerts(bool value) override;
+
+  // ---- Methods ----
+  void activate() override;
+  void addCert(const std::shared_ptr<HybridCertSpec>& cert) override;
+  void addJavaKeyStore(const std::shared_ptr<HybridJavaKeyStoreSpec>& keystore) override;
+  std::shared_ptr<Promise<void>> addJavaKeyStoreAsync(const std::shared_ptr<HybridJavaKeyStoreSpec>& keystore) override;
+  void deactivate() override;
+  void loadCaCertsPem(const std::string& path) override;
+  std::shared_ptr<Promise<void>> loadCaCertsPemAsync(const std::string& path) override;
+  void certAt(double index, const std::shared_ptr<HybridCertSpec>& cert) 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();
+  void activate_impl();
+  void addCert_impl(const std::shared_ptr<HybridCertSpec>& cert);
+  void addJavaKeyStore_impl(const std::shared_ptr<HybridJavaKeyStoreSpec>& keystore);
+  void deactivate_impl();
+  void loadCaCertsPem_impl(const std::string& path);
+  void certAt_impl(double index, const std::shared_ptr<HybridCertSpec>& cert);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridUnixCompress.cpp

@@ -0,0 +1,191 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridUnixCompress.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridUnixCompress::HybridUnixCompress()
+    : HybridObject(HybridUnixCompressSpec::TAG), ChilkatObject<CkUnixCompress>("UnixCompress", CkUnixCompress::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridUnixCompress::HybridUnixCompress(CkUnixCompress* owned)
+    : HybridObject(HybridUnixCompressSpec::TAG), ChilkatObject<CkUnixCompress>("UnixCompress", owned) {
+  init();
+}
+
+void HybridUnixCompress::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridUnixCompress::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridUnixCompress::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUnixCompress::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUnixCompress::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUnixCompress::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUnixCompress::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridUnixCompress::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridUnixCompress::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridUnixCompress::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridUnixCompress::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridUnixCompress::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridUnixCompress::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridUnixCompress::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+bool HybridUnixCompress::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridUnixCompress::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+
+// ---- Methods ----
+
+void HybridUnixCompress::compressFile(const std::string& inFilename, const std::string& destPath) {
+  this->beginCall();
+  compressFile_impl(inFilename, destPath);
+}
+void HybridUnixCompress::compressFile_impl(const std::string& inFilename, const std::string& destPath) {
+  rt::checkNoNul(inFilename, "inFilename");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().CompressFile(inFilename.c_str(), destPath.c_str())) throw this->fail("compressFile");
+}
+std::shared_ptr<Promise<void>> HybridUnixCompress::compressFileAsync(const std::string& inFilename, const std::string& destPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridUnixCompress>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("UnixCompress.compressFileAsync", std::move(_parts), [_self, inFilename, destPath]() {
+    _self->compressFile_impl(inFilename, destPath);
+  });
+}
+
+void HybridUnixCompress::compressStringToFile(const std::string& inStr, const std::string& charset, const std::string& destPath) {
+  this->beginCall();
+  compressStringToFile_impl(inStr, charset, destPath);
+}
+void HybridUnixCompress::compressStringToFile_impl(const std::string& inStr, const std::string& charset, const std::string& destPath) {
+  rt::checkNoNul(inStr, "inStr");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().CompressStringToFile(inStr.c_str(), charset.c_str(), destPath.c_str())) throw this->fail("compressStringToFile");
+}
+
+void HybridUnixCompress::unTarZ(const std::string& zFilename, const std::string& destDir, bool bNoAbsolute) {
+  this->beginCall();
+  unTarZ_impl(zFilename, destDir, bNoAbsolute);
+}
+void HybridUnixCompress::unTarZ_impl(const std::string& zFilename, const std::string& destDir, bool bNoAbsolute) {
+  rt::checkNoNul(zFilename, "zFilename");
+  rt::checkNoNul(destDir, "destDir");
+  if (!this->ck().UnTarZ(zFilename.c_str(), destDir.c_str(), bNoAbsolute)) throw this->fail("unTarZ");
+}
+std::shared_ptr<Promise<void>> HybridUnixCompress::unTarZAsync(const std::string& zFilename, const std::string& destDir, bool bNoAbsolute) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridUnixCompress>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("UnixCompress.unTarZAsync", std::move(_parts), [_self, zFilename, destDir, bNoAbsolute]() {
+    _self->unTarZ_impl(zFilename, destDir, bNoAbsolute);
+  });
+}
+
+void HybridUnixCompress::uncompressFile(const std::string& inFilename, const std::string& destPath) {
+  this->beginCall();
+  uncompressFile_impl(inFilename, destPath);
+}
+void HybridUnixCompress::uncompressFile_impl(const std::string& inFilename, const std::string& destPath) {
+  rt::checkNoNul(inFilename, "inFilename");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().UncompressFile(inFilename.c_str(), destPath.c_str())) throw this->fail("uncompressFile");
+}
+std::shared_ptr<Promise<void>> HybridUnixCompress::uncompressFileAsync(const std::string& inFilename, const std::string& destPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridUnixCompress>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("UnixCompress.uncompressFileAsync", std::move(_parts), [_self, inFilename, destPath]() {
+    _self->uncompressFile_impl(inFilename, destPath);
+  });
+}
+
+std::string HybridUnixCompress::uncompressFileToString(const std::string& zFilename, const std::string& charset) {
+  this->beginCall();
+  return uncompressFileToString_impl(zFilename, charset);
+}
+std::string HybridUnixCompress::uncompressFileToString_impl(const std::string& zFilename, const std::string& charset) {
+  rt::checkNoNul(zFilename, "zFilename");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().UncompressFileToString(zFilename.c_str(), charset.c_str(), _out)) throw this->fail("uncompressFileToString");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridUnixCompress::uncompressFileToStringAsync(const std::string& zFilename, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridUnixCompress>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("UnixCompress.uncompressFileToStringAsync", std::move(_parts), [_self, zFilename, charset]() {
+    return _self->uncompressFileToString_impl(zFilename, charset);
+  });
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridUnixCompress::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridUnixCompress::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridUnixCompress::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridUnixCompress::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridUnixCompress::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridUnixCompress.hpp

@@ -0,0 +1,60 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// UnixCompress: the Nitro HybridObject over Chilkat's CkUnixCompress (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridUnixCompressSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkUnixCompress.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridUnixCompress final : public HybridUnixCompressSpec, public ChilkatObject<CkUnixCompress> {
+public:
+  HybridUnixCompress();                                  // `new UnixCompress()` from JS
+  explicit HybridUnixCompress(CkUnixCompress* 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 getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+  bool getAbortCurrent() override;
+  void setAbortCurrent(bool value) override;
+
+  // ---- Methods ----
+  void compressFile(const std::string& inFilename, const std::string& destPath) override;
+  std::shared_ptr<Promise<void>> compressFileAsync(const std::string& inFilename, const std::string& destPath) override;
+  void compressStringToFile(const std::string& inStr, const std::string& charset, const std::string& destPath) override;
+  void unTarZ(const std::string& zFilename, const std::string& destDir, bool bNoAbsolute) override;
+  std::shared_ptr<Promise<void>> unTarZAsync(const std::string& zFilename, const std::string& destDir, bool bNoAbsolute) override;
+  void uncompressFile(const std::string& inFilename, const std::string& destPath) override;
+  std::shared_ptr<Promise<void>> uncompressFileAsync(const std::string& inFilename, const std::string& destPath) override;
+  std::string uncompressFileToString(const std::string& zFilename, const std::string& charset) override;
+  std::shared_ptr<Promise<std::string>> uncompressFileToStringAsync(const std::string& zFilename, const std::string& charset) 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();
+  void compressFile_impl(const std::string& inFilename, const std::string& destPath);
+  void compressStringToFile_impl(const std::string& inStr, const std::string& charset, const std::string& destPath);
+  void unTarZ_impl(const std::string& zFilename, const std::string& destDir, bool bNoAbsolute);
+  void uncompressFile_impl(const std::string& inFilename, const std::string& destPath);
+  std::string uncompressFileToString_impl(const std::string& zFilename, const std::string& charset);
+};
+
+} // namespace margelo::nitro::chilkat