@chilkat/react-native 11.6.1

package/cpp/HybridCertStore.hpp

@@ -0,0 +1,78 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// CertStore: the Nitro HybridObject over Chilkat's CkCertStore (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridCertStoreSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkCertStore.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridCertStore final : public HybridCertStoreSpec, public ChilkatObject<CkCertStore> {
+public:
+  HybridCertStore();                                  // `new CertStore()` from JS
+  explicit HybridCertStore(CkCertStore* 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 getAvoidWindowsPkAccess() override;
+  void setAvoidWindowsPkAccess(bool value) override;
+  double getNumCertificates() override;
+  std::string getSmartCardPin() override;
+  void setSmartCardPin(const std::string& value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  void addCertificate(const std::shared_ptr<HybridCertSpec>& cert) override;
+  void createFileStore(const std::string& filename) override;
+  void createMemoryStore() override;
+  void createRegistryStore(const std::string& regRoot, const std::string& regPath) override;
+  void loadPemFile(const std::string& pemPath) override;
+  void loadPemStr(const std::string& pemString) override;
+  void loadPfxFile(const std::string& pfxFilename, const std::string& password) override;
+  void openCurrentUserStore(bool bReadOnly) override;
+  void openFileStore(const std::string& filename, bool bReadOnly) override;
+  void openLocalSystemStore(bool bReadOnly) override;
+  void openRegistryStore(const std::string& regRoot, const std::string& regPath, bool bReadOnly) override;
+  void openWindowsStore(const std::string& storeLocation, const std::string& storeName, bool bReadOnly) override;
+  void removeCertificate(const std::shared_ptr<HybridCertSpec>& cert) override;
+  void openSmartcard(const std::string& csp) override;
+  void closeCertStore() override;
+  void findCert(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridCertSpec>& cert) override;
+  void loadPfxBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) override;
+  void getCert(double index, const std::shared_ptr<HybridCertSpec>& cert) override;
+
+private:
+  void init();
+  void addCertificate_impl(const std::shared_ptr<HybridCertSpec>& cert);
+  void createFileStore_impl(const std::string& filename);
+  void createMemoryStore_impl();
+  void createRegistryStore_impl(const std::string& regRoot, const std::string& regPath);
+  void loadPemFile_impl(const std::string& pemPath);
+  void loadPemStr_impl(const std::string& pemString);
+  void loadPfxFile_impl(const std::string& pfxFilename, const std::string& password);
+  void openCurrentUserStore_impl(bool bReadOnly);
+  void openFileStore_impl(const std::string& filename, bool bReadOnly);
+  void openLocalSystemStore_impl(bool bReadOnly);
+  void openRegistryStore_impl(const std::string& regRoot, const std::string& regPath, bool bReadOnly);
+  void openWindowsStore_impl(const std::string& storeLocation, const std::string& storeName, bool bReadOnly);
+  void removeCertificate_impl(const std::shared_ptr<HybridCertSpec>& cert);
+  void openSmartcard_impl(const std::string& csp);
+  void closeCertStore_impl();
+  void findCert_impl(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridCertSpec>& cert);
+  void loadPfxBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password);
+  void getCert_impl(double index, const std::shared_ptr<HybridCertSpec>& cert);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridCharset.cpp

@@ -0,0 +1,333 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridCharset.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridCharset::HybridCharset()
+    : HybridObject(HybridCharsetSpec::TAG), ChilkatObject<CkCharset>("Charset", CkCharset::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridCharset::HybridCharset(CkCharset* owned)
+    : HybridObject(HybridCharsetSpec::TAG), ChilkatObject<CkCharset>("Charset", owned) {
+  init();
+}
+
+void HybridCharset::init() {
+}
+
+void HybridCharset::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridCharset::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCharset::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCharset::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCharset::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCharset::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridCharset::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridCharset::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridCharset::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridCharset::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridCharset::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridCharset::getAltToCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AltToCharset(_s);
+  return rt::stdString(_s);
+}
+void HybridCharset::setAltToCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "altToCharset");
+  this->ck().put_AltToCharset(value.c_str());
+}
+double HybridCharset::getErrorAction() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ErrorAction());
+}
+void HybridCharset::setErrorAction(double value) {
+  this->beginCall();
+  this->ck().put_ErrorAction(rt::toInt(value, "errorAction"));
+}
+std::string HybridCharset::getFromCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FromCharset(_s);
+  return rt::stdString(_s);
+}
+void HybridCharset::setFromCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "fromCharset");
+  this->ck().put_FromCharset(value.c_str());
+}
+std::string HybridCharset::getLastInputAsHex() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastInputAsHex(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCharset::getLastInputAsQP() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastInputAsQP(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCharset::getLastOutputAsHex() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastOutputAsHex(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCharset::getLastOutputAsQP() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastOutputAsQP(_s);
+  return rt::stdString(_s);
+}
+bool HybridCharset::getSaveLast() {
+  this->beginCall();
+  return this->ck().get_SaveLast();
+}
+void HybridCharset::setSaveLast(bool value) {
+  this->beginCall();
+  this->ck().put_SaveLast(value);
+}
+std::string HybridCharset::getToCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ToCharset(_s);
+  return rt::stdString(_s);
+}
+void HybridCharset::setToCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "toCharset");
+  this->ck().put_ToCharset(value.c_str());
+}
+
+// ---- Methods ----
+
+double HybridCharset::charsetToCodePage(const std::string& charsetName) {
+  this->beginCall();
+  return charsetToCodePage_impl(charsetName);
+}
+double HybridCharset::charsetToCodePage_impl(const std::string& charsetName) {
+  rt::checkNoNul(charsetName, "charsetName");
+  return static_cast<double>(this->ck().CharsetToCodePage(charsetName.c_str()));
+}
+
+std::string HybridCharset::codePageToCharset(double codePage) {
+  this->beginCall();
+  return codePageToCharset_impl(codePage);
+}
+std::string HybridCharset::codePageToCharset_impl(double codePage) {
+  CkString _out;
+  if (!this->ck().CodePageToCharset(rt::toInt(codePage, "codePage"), _out)) throw this->fail("codePageToCharset");
+  return rt::stdString(_out);
+}
+
+void HybridCharset::convertFile(const std::string& inPath, const std::string& destPath) {
+  this->beginCall();
+  convertFile_impl(inPath, destPath);
+}
+void HybridCharset::convertFile_impl(const std::string& inPath, const std::string& destPath) {
+  rt::checkNoNul(inPath, "inPath");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().ConvertFile(inPath.c_str(), destPath.c_str())) throw this->fail("convertFile");
+}
+
+void HybridCharset::convertFileNoPreamble(const std::string& inPath, const std::string& destPath) {
+  this->beginCall();
+  convertFileNoPreamble_impl(inPath, destPath);
+}
+void HybridCharset::convertFileNoPreamble_impl(const std::string& inPath, const std::string& destPath) {
+  rt::checkNoNul(inPath, "inPath");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().ConvertFileNoPreamble(inPath.c_str(), destPath.c_str())) throw this->fail("convertFileNoPreamble");
+}
+
+void HybridCharset::convertHtmlFile(const std::string& inPath, const std::string& destPath) {
+  this->beginCall();
+  convertHtmlFile_impl(inPath, destPath);
+}
+void HybridCharset::convertHtmlFile_impl(const std::string& inPath, const std::string& destPath) {
+  rt::checkNoNul(inPath, "inPath");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().ConvertHtmlFile(inPath.c_str(), destPath.c_str())) throw this->fail("convertHtmlFile");
+}
+
+std::string HybridCharset::entityEncodeDec(const std::string& str) {
+  this->beginCall();
+  return entityEncodeDec_impl(str);
+}
+std::string HybridCharset::entityEncodeDec_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  CkString _out;
+  if (!this->ck().EntityEncodeDec(str.c_str(), _out)) throw this->fail("entityEncodeDec");
+  return rt::stdString(_out);
+}
+
+std::string HybridCharset::entityEncodeHex(const std::string& str) {
+  this->beginCall();
+  return entityEncodeHex_impl(str);
+}
+std::string HybridCharset::entityEncodeHex_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  CkString _out;
+  if (!this->ck().EntityEncodeHex(str.c_str(), _out)) throw this->fail("entityEncodeHex");
+  return rt::stdString(_out);
+}
+
+std::string HybridCharset::getHtmlFileCharset(const std::string& htmlFilePath) {
+  this->beginCall();
+  return getHtmlFileCharset_impl(htmlFilePath);
+}
+std::string HybridCharset::getHtmlFileCharset_impl(const std::string& htmlFilePath) {
+  rt::checkNoNul(htmlFilePath, "htmlFilePath");
+  CkString _out;
+  if (!this->ck().GetHtmlFileCharset(htmlFilePath.c_str(), _out)) throw this->fail("getHtmlFileCharset");
+  return rt::stdString(_out);
+}
+
+std::string HybridCharset::htmlDecodeToStr(const std::string& inStr) {
+  this->beginCall();
+  return htmlDecodeToStr_impl(inStr);
+}
+std::string HybridCharset::htmlDecodeToStr_impl(const std::string& inStr) {
+  rt::checkNoNul(inStr, "inStr");
+  CkString _out;
+  if (!this->ck().HtmlDecodeToStr(inStr.c_str(), _out)) throw this->fail("htmlDecodeToStr");
+  return rt::stdString(_out);
+}
+
+void HybridCharset::htmlEntityDecodeFile(const std::string& inPath, const std::string& destPath) {
+  this->beginCall();
+  htmlEntityDecodeFile_impl(inPath, destPath);
+}
+void HybridCharset::htmlEntityDecodeFile_impl(const std::string& inPath, const std::string& destPath) {
+  rt::checkNoNul(inPath, "inPath");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().HtmlEntityDecodeFile(inPath.c_str(), destPath.c_str())) throw this->fail("htmlEntityDecodeFile");
+}
+
+std::string HybridCharset::lowerCase(const std::string& inStr) {
+  this->beginCall();
+  return lowerCase_impl(inStr);
+}
+std::string HybridCharset::lowerCase_impl(const std::string& inStr) {
+  rt::checkNoNul(inStr, "inStr");
+  CkString _out;
+  if (!this->ck().LowerCase(inStr.c_str(), _out)) throw this->fail("lowerCase");
+  return rt::stdString(_out);
+}
+
+std::string HybridCharset::readFileToString(const std::string& path, const std::string& charset) {
+  this->beginCall();
+  return readFileToString_impl(path, charset);
+}
+std::string HybridCharset::readFileToString_impl(const std::string& path, const std::string& charset) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().ReadFileToString(path.c_str(), charset.c_str(), _out)) throw this->fail("readFileToString");
+  return rt::stdString(_out);
+}
+
+void HybridCharset::setErrorString(const std::string& str, const std::string& charset) {
+  this->beginCall();
+  setErrorString_impl(str, charset);
+}
+void HybridCharset::setErrorString_impl(const std::string& str, const std::string& charset) {
+  rt::checkNoNul(str, "str");
+  rt::checkNoNul(charset, "charset");
+  this->ck().SetErrorString(str.c_str(), charset.c_str());
+}
+
+std::string HybridCharset::upperCase(const std::string& inStr) {
+  this->beginCall();
+  return upperCase_impl(inStr);
+}
+std::string HybridCharset::upperCase_impl(const std::string& inStr) {
+  rt::checkNoNul(inStr, "inStr");
+  CkString _out;
+  if (!this->ck().UpperCase(inStr.c_str(), _out)) throw this->fail("upperCase");
+  return rt::stdString(_out);
+}
+
+std::string HybridCharset::urlDecodeStr(const std::string& inStr) {
+  this->beginCall();
+  return urlDecodeStr_impl(inStr);
+}
+std::string HybridCharset::urlDecodeStr_impl(const std::string& inStr) {
+  rt::checkNoNul(inStr, "inStr");
+  CkString _out;
+  if (!this->ck().UrlDecodeStr(inStr.c_str(), _out)) throw this->fail("urlDecodeStr");
+  return rt::stdString(_out);
+}
+
+bool HybridCharset::verifyFile(const std::string& charset, const std::string& path) {
+  this->beginCall();
+  return verifyFile_impl(charset, path);
+}
+bool HybridCharset::verifyFile_impl(const std::string& charset, const std::string& path) {
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(path, "path");
+  return this->ck().VerifyFile(charset.c_str(), path.c_str());
+}
+
+void HybridCharset::writeStringToFile(const std::string& textData, const std::string& path, const std::string& charset) {
+  this->beginCall();
+  writeStringToFile_impl(textData, path, charset);
+}
+void HybridCharset::writeStringToFile_impl(const std::string& textData, const std::string& path, const std::string& charset) {
+  rt::checkNoNul(textData, "textData");
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().WriteStringToFile(textData.c_str(), path.c_str(), charset.c_str())) throw this->fail("writeStringToFile");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridCharset.hpp

@@ -0,0 +1,83 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Charset: the Nitro HybridObject over Chilkat's CkCharset (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridCharsetSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkCharset.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridCharset final : public HybridCharsetSpec, public ChilkatObject<CkCharset> {
+public:
+  HybridCharset();                                  // `new Charset()` from JS
+  explicit HybridCharset(CkCharset* 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;
+  std::string getAltToCharset() override;
+  void setAltToCharset(const std::string& value) override;
+  double getErrorAction() override;
+  void setErrorAction(double value) override;
+  std::string getFromCharset() override;
+  void setFromCharset(const std::string& value) override;
+  std::string getLastInputAsHex() override;
+  std::string getLastInputAsQP() override;
+  std::string getLastOutputAsHex() override;
+  std::string getLastOutputAsQP() override;
+  bool getSaveLast() override;
+  void setSaveLast(bool value) override;
+  std::string getToCharset() override;
+  void setToCharset(const std::string& value) override;
+
+  // ---- Methods ----
+  double charsetToCodePage(const std::string& charsetName) override;
+  std::string codePageToCharset(double codePage) override;
+  void convertFile(const std::string& inPath, const std::string& destPath) override;
+  void convertFileNoPreamble(const std::string& inPath, const std::string& destPath) override;
+  void convertHtmlFile(const std::string& inPath, const std::string& destPath) override;
+  std::string entityEncodeDec(const std::string& str) override;
+  std::string entityEncodeHex(const std::string& str) override;
+  std::string getHtmlFileCharset(const std::string& htmlFilePath) override;
+  std::string htmlDecodeToStr(const std::string& inStr) override;
+  void htmlEntityDecodeFile(const std::string& inPath, const std::string& destPath) override;
+  std::string lowerCase(const std::string& inStr) override;
+  std::string readFileToString(const std::string& path, const std::string& charset) override;
+  void setErrorString(const std::string& str, const std::string& charset) override;
+  std::string upperCase(const std::string& inStr) override;
+  std::string urlDecodeStr(const std::string& inStr) override;
+  bool verifyFile(const std::string& charset, const std::string& path) override;
+  void writeStringToFile(const std::string& textData, const std::string& path, const std::string& charset) override;
+
+private:
+  void init();
+  double charsetToCodePage_impl(const std::string& charsetName);
+  std::string codePageToCharset_impl(double codePage);
+  void convertFile_impl(const std::string& inPath, const std::string& destPath);
+  void convertFileNoPreamble_impl(const std::string& inPath, const std::string& destPath);
+  void convertHtmlFile_impl(const std::string& inPath, const std::string& destPath);
+  std::string entityEncodeDec_impl(const std::string& str);
+  std::string entityEncodeHex_impl(const std::string& str);
+  std::string getHtmlFileCharset_impl(const std::string& htmlFilePath);
+  std::string htmlDecodeToStr_impl(const std::string& inStr);
+  void htmlEntityDecodeFile_impl(const std::string& inPath, const std::string& destPath);
+  std::string lowerCase_impl(const std::string& inStr);
+  std::string readFileToString_impl(const std::string& path, const std::string& charset);
+  void setErrorString_impl(const std::string& str, const std::string& charset);
+  std::string upperCase_impl(const std::string& inStr);
+  std::string urlDecodeStr_impl(const std::string& inStr);
+  bool verifyFile_impl(const std::string& charset, const std::string& path);
+  void writeStringToFile_impl(const std::string& textData, const std::string& path, const std::string& charset);
+};
+
+} // namespace margelo::nitro::chilkat