@chilkat/react-native 11.6.1

package/cpp/HybridPrng.cpp

@@ -0,0 +1,192 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridPrng.hpp"
+#include "HybridBinData.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridPrng::HybridPrng()
+    : HybridObject(HybridPrngSpec::TAG), ChilkatObject<CkPrng>("Prng", CkPrng::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridPrng::HybridPrng(CkPrng* owned)
+    : HybridObject(HybridPrngSpec::TAG), ChilkatObject<CkPrng>("Prng", owned) {
+  init();
+}
+
+void HybridPrng::init() {
+}
+
+void HybridPrng::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridPrng::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPrng::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPrng::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPrng::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPrng::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridPrng::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridPrng::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridPrng::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridPrng::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridPrng::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridPrng::getPrngName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_PrngName(_s);
+  return rt::stdString(_s);
+}
+void HybridPrng::setPrngName(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "prngName");
+  this->ck().put_PrngName(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridPrng::addEntropy(const std::string& entropy, const std::string& encoding) {
+  this->beginCall();
+  addEntropy_impl(entropy, encoding);
+}
+void HybridPrng::addEntropy_impl(const std::string& entropy, const std::string& encoding) {
+  rt::checkNoNul(entropy, "entropy");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().AddEntropy(entropy.c_str(), encoding.c_str())) throw this->fail("addEntropy");
+}
+
+std::string HybridPrng::exportEntropy() {
+  this->beginCall();
+  return exportEntropy_impl();
+}
+std::string HybridPrng::exportEntropy_impl() {
+  CkString _out;
+  if (!this->ck().ExportEntropy(_out)) throw this->fail("exportEntropy");
+  return rt::stdString(_out);
+}
+
+std::string HybridPrng::firebasePushId() {
+  this->beginCall();
+  return firebasePushId_impl();
+}
+std::string HybridPrng::firebasePushId_impl() {
+  CkString _out;
+  if (!this->ck().FirebasePushId(_out)) throw this->fail("firebasePushId");
+  return rt::stdString(_out);
+}
+
+std::string HybridPrng::genRandom(double numBytes, const std::string& encoding) {
+  this->beginCall();
+  return genRandom_impl(numBytes, encoding);
+}
+std::string HybridPrng::genRandom_impl(double numBytes, const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GenRandom(rt::toInt(numBytes, "numBytes"), encoding.c_str(), _out)) throw this->fail("genRandom");
+  return rt::stdString(_out);
+}
+
+std::string HybridPrng::getEntropy(double numBytes, const std::string& encoding) {
+  this->beginCall();
+  return getEntropy_impl(numBytes, encoding);
+}
+std::string HybridPrng::getEntropy_impl(double numBytes, const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetEntropy(rt::toInt(numBytes, "numBytes"), encoding.c_str(), _out)) throw this->fail("getEntropy");
+  return rt::stdString(_out);
+}
+
+void HybridPrng::importEntropy(const std::string& entropy) {
+  this->beginCall();
+  importEntropy_impl(entropy);
+}
+void HybridPrng::importEntropy_impl(const std::string& entropy) {
+  rt::checkNoNul(entropy, "entropy");
+  if (!this->ck().ImportEntropy(entropy.c_str())) throw this->fail("importEntropy");
+}
+
+double HybridPrng::randomInt(double low, double high) {
+  this->beginCall();
+  return randomInt_impl(low, high);
+}
+double HybridPrng::randomInt_impl(double low, double high) {
+  return static_cast<double>(this->ck().RandomInt(rt::toInt(low, "low"), rt::toInt(high, "high")));
+}
+
+std::string HybridPrng::randomPassword(double length, bool mustIncludeDigit, bool upperAndLowercase, const std::string& mustHaveOneOf, const std::string& excludeChars) {
+  this->beginCall();
+  return randomPassword_impl(length, mustIncludeDigit, upperAndLowercase, mustHaveOneOf, excludeChars);
+}
+std::string HybridPrng::randomPassword_impl(double length, bool mustIncludeDigit, bool upperAndLowercase, const std::string& mustHaveOneOf, const std::string& excludeChars) {
+  rt::checkNoNul(mustHaveOneOf, "mustHaveOneOf");
+  rt::checkNoNul(excludeChars, "excludeChars");
+  CkString _out;
+  if (!this->ck().RandomPassword(rt::toInt(length, "length"), mustIncludeDigit, upperAndLowercase, mustHaveOneOf.c_str(), excludeChars.c_str(), _out)) throw this->fail("randomPassword");
+  return rt::stdString(_out);
+}
+
+std::string HybridPrng::randomString(double length, bool bDigits, bool bLower, bool bUpper) {
+  this->beginCall();
+  return randomString_impl(length, bDigits, bLower, bUpper);
+}
+std::string HybridPrng::randomString_impl(double length, bool bDigits, bool bLower, bool bUpper) {
+  CkString _out;
+  if (!this->ck().RandomString(rt::toInt(length, "length"), bDigits, bLower, bUpper, _out)) throw this->fail("randomString");
+  return rt::stdString(_out);
+}
+
+void HybridPrng::genRandomBd(double numBytes, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  genRandomBd_impl(numBytes, bd);
+}
+void HybridPrng::genRandomBd_impl(double numBytes, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().GenRandomBd(rt::toInt(numBytes, "numBytes"), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("genRandomBd");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridPrng.hpp

@@ -0,0 +1,57 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Prng: the Nitro HybridObject over Chilkat's CkPrng (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridPrngSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkPrng.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridPrng final : public HybridPrngSpec, public ChilkatObject<CkPrng> {
+public:
+  HybridPrng();                                  // `new Prng()` from JS
+  explicit HybridPrng(CkPrng* 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 getPrngName() override;
+  void setPrngName(const std::string& value) override;
+
+  // ---- Methods ----
+  void addEntropy(const std::string& entropy, const std::string& encoding) override;
+  std::string exportEntropy() override;
+  std::string firebasePushId() override;
+  std::string genRandom(double numBytes, const std::string& encoding) override;
+  std::string getEntropy(double numBytes, const std::string& encoding) override;
+  void importEntropy(const std::string& entropy) override;
+  double randomInt(double low, double high) override;
+  std::string randomPassword(double length, bool mustIncludeDigit, bool upperAndLowercase, const std::string& mustHaveOneOf, const std::string& excludeChars) override;
+  std::string randomString(double length, bool bDigits, bool bLower, bool bUpper) override;
+  void genRandomBd(double numBytes, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+
+private:
+  void init();
+  void addEntropy_impl(const std::string& entropy, const std::string& encoding);
+  std::string exportEntropy_impl();
+  std::string firebasePushId_impl();
+  std::string genRandom_impl(double numBytes, const std::string& encoding);
+  std::string getEntropy_impl(double numBytes, const std::string& encoding);
+  void importEntropy_impl(const std::string& entropy);
+  double randomInt_impl(double low, double high);
+  std::string randomPassword_impl(double length, bool mustIncludeDigit, bool upperAndLowercase, const std::string& mustHaveOneOf, const std::string& excludeChars);
+  std::string randomString_impl(double length, bool bDigits, bool bLower, bool bUpper);
+  void genRandomBd_impl(double numBytes, const std::shared_ptr<HybridBinDataSpec>& bd);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridPublicKey.cpp

@@ -0,0 +1,238 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridPublicKey.hpp"
+#include "HybridBinData.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridPublicKey::HybridPublicKey()
+    : HybridObject(HybridPublicKeySpec::TAG), ChilkatObject<CkPublicKey>("PublicKey", CkPublicKey::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridPublicKey::HybridPublicKey(CkPublicKey* owned)
+    : HybridObject(HybridPublicKeySpec::TAG), ChilkatObject<CkPublicKey>("PublicKey", owned) {
+  init();
+}
+
+void HybridPublicKey::init() {
+}
+
+void HybridPublicKey::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridPublicKey::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPublicKey::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPublicKey::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPublicKey::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPublicKey::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridPublicKey::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridPublicKey::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridPublicKey::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridPublicKey::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridPublicKey::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridPublicKey::getKeyType() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_KeyType(_s);
+  return rt::stdString(_s);
+}
+double HybridPublicKey::getKeySize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_KeySize());
+}
+bool HybridPublicKey::getEmpty() {
+  this->beginCall();
+  return this->ck().get_Empty();
+}
+
+// ---- Methods ----
+
+std::string HybridPublicKey::getXml() {
+  this->beginCall();
+  return getXml_impl();
+}
+std::string HybridPublicKey::getXml_impl() {
+  CkString _out;
+  if (!this->ck().GetXml(_out)) throw this->fail("getXml");
+  return rt::stdString(_out);
+}
+
+void HybridPublicKey::loadBase64(const std::string& keyStr) {
+  this->beginCall();
+  loadBase64_impl(keyStr);
+}
+void HybridPublicKey::loadBase64_impl(const std::string& keyStr) {
+  rt::checkNoNul(keyStr, "keyStr");
+  if (!this->ck().LoadBase64(keyStr.c_str())) throw this->fail("loadBase64");
+}
+
+void HybridPublicKey::saveXmlFile(const std::string& path) {
+  this->beginCall();
+  saveXmlFile_impl(path);
+}
+void HybridPublicKey::saveXmlFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SaveXmlFile(path.c_str())) throw this->fail("saveXmlFile");
+}
+
+void HybridPublicKey::loadFromString(const std::string& keyString) {
+  this->beginCall();
+  loadFromString_impl(keyString);
+}
+void HybridPublicKey::loadFromString_impl(const std::string& keyString) {
+  rt::checkNoNul(keyString, "keyString");
+  if (!this->ck().LoadFromString(keyString.c_str())) throw this->fail("loadFromString");
+}
+
+void HybridPublicKey::loadFromFile(const std::string& path) {
+  this->beginCall();
+  loadFromFile_impl(path);
+}
+void HybridPublicKey::loadFromFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadFromFile(path.c_str())) throw this->fail("loadFromFile");
+}
+
+std::string HybridPublicKey::getPem(bool preferPkcs1) {
+  this->beginCall();
+  return getPem_impl(preferPkcs1);
+}
+std::string HybridPublicKey::getPem_impl(bool preferPkcs1) {
+  CkString _out;
+  if (!this->ck().GetPem(preferPkcs1, _out)) throw this->fail("getPem");
+  return rt::stdString(_out);
+}
+
+std::string HybridPublicKey::getEncoded(bool preferPkcs1, const std::string& encoding) {
+  this->beginCall();
+  return getEncoded_impl(preferPkcs1, encoding);
+}
+std::string HybridPublicKey::getEncoded_impl(bool preferPkcs1, const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetEncoded(preferPkcs1, encoding.c_str(), _out)) throw this->fail("getEncoded");
+  return rt::stdString(_out);
+}
+
+void HybridPublicKey::saveDerFile(bool preferPkcs1, const std::string& path) {
+  this->beginCall();
+  saveDerFile_impl(preferPkcs1, path);
+}
+void HybridPublicKey::saveDerFile_impl(bool preferPkcs1, const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SaveDerFile(preferPkcs1, path.c_str())) throw this->fail("saveDerFile");
+}
+
+void HybridPublicKey::savePemFile(bool preferPkcs1, const std::string& path) {
+  this->beginCall();
+  savePemFile_impl(preferPkcs1, path);
+}
+void HybridPublicKey::savePemFile_impl(bool preferPkcs1, const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SavePemFile(preferPkcs1, path.c_str())) throw this->fail("savePemFile");
+}
+
+std::string HybridPublicKey::getJwk() {
+  this->beginCall();
+  return getJwk_impl();
+}
+std::string HybridPublicKey::getJwk_impl() {
+  CkString _out;
+  if (!this->ck().GetJwk(_out)) throw this->fail("getJwk");
+  return rt::stdString(_out);
+}
+
+std::string HybridPublicKey::getJwkThumbprint(const std::string& hashAlg) {
+  this->beginCall();
+  return getJwkThumbprint_impl(hashAlg);
+}
+std::string HybridPublicKey::getJwkThumbprint_impl(const std::string& hashAlg) {
+  rt::checkNoNul(hashAlg, "hashAlg");
+  CkString _out;
+  if (!this->ck().GetJwkThumbprint(hashAlg.c_str(), _out)) throw this->fail("getJwkThumbprint");
+  return rt::stdString(_out);
+}
+
+void HybridPublicKey::loadEd25519(const std::string& pubKey) {
+  this->beginCall();
+  loadEd25519_impl(pubKey);
+}
+void HybridPublicKey::loadEd25519_impl(const std::string& pubKey) {
+  rt::checkNoNul(pubKey, "pubKey");
+  if (!this->ck().LoadEd25519(pubKey.c_str())) throw this->fail("loadEd25519");
+}
+
+void HybridPublicKey::loadBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  loadBd_impl(bd);
+}
+void HybridPublicKey::loadBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().LoadBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("loadBd");
+}
+
+void HybridPublicKey::loadEcdsa(const std::string& curveName, const std::string& qx, const std::string& qy) {
+  this->beginCall();
+  loadEcdsa_impl(curveName, qx, qy);
+}
+void HybridPublicKey::loadEcdsa_impl(const std::string& curveName, const std::string& qx, const std::string& qy) {
+  rt::checkNoNul(curveName, "curveName");
+  rt::checkNoNul(qx, "qx");
+  rt::checkNoNul(qy, "qy");
+  if (!this->ck().LoadEcdsa(curveName.c_str(), qx.c_str(), qy.c_str())) throw this->fail("loadEcdsa");
+}
+
+void HybridPublicKey::getDerBd(bool preferPkcs1, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  getDerBd_impl(preferPkcs1, bd);
+}
+void HybridPublicKey::getDerBd_impl(bool preferPkcs1, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().GetDerBd(preferPkcs1, rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("getDerBd");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridPublicKey.hpp

@@ -0,0 +1,68 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// PublicKey: the Nitro HybridObject over Chilkat's CkPublicKey (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridPublicKeySpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkPublicKey.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridPublicKey final : public HybridPublicKeySpec, public ChilkatObject<CkPublicKey> {
+public:
+  HybridPublicKey();                                  // `new PublicKey()` from JS
+  explicit HybridPublicKey(CkPublicKey* 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 getKeyType() override;
+  double getKeySize() override;
+  bool getEmpty() override;
+
+  // ---- Methods ----
+  std::string getXml() override;
+  void loadBase64(const std::string& keyStr) override;
+  void saveXmlFile(const std::string& path) override;
+  void loadFromString(const std::string& keyString) override;
+  void loadFromFile(const std::string& path) override;
+  std::string getPem(bool preferPkcs1) override;
+  std::string getEncoded(bool preferPkcs1, const std::string& encoding) override;
+  void saveDerFile(bool preferPkcs1, const std::string& path) override;
+  void savePemFile(bool preferPkcs1, const std::string& path) override;
+  std::string getJwk() override;
+  std::string getJwkThumbprint(const std::string& hashAlg) override;
+  void loadEd25519(const std::string& pubKey) override;
+  void loadBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void loadEcdsa(const std::string& curveName, const std::string& qx, const std::string& qy) override;
+  void getDerBd(bool preferPkcs1, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+
+private:
+  void init();
+  std::string getXml_impl();
+  void loadBase64_impl(const std::string& keyStr);
+  void saveXmlFile_impl(const std::string& path);
+  void loadFromString_impl(const std::string& keyString);
+  void loadFromFile_impl(const std::string& path);
+  std::string getPem_impl(bool preferPkcs1);
+  std::string getEncoded_impl(bool preferPkcs1, const std::string& encoding);
+  void saveDerFile_impl(bool preferPkcs1, const std::string& path);
+  void savePemFile_impl(bool preferPkcs1, const std::string& path);
+  std::string getJwk_impl();
+  std::string getJwkThumbprint_impl(const std::string& hashAlg);
+  void loadEd25519_impl(const std::string& pubKey);
+  void loadBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void loadEcdsa_impl(const std::string& curveName, const std::string& qx, const std::string& qy);
+  void getDerBd_impl(bool preferPkcs1, const std::shared_ptr<HybridBinDataSpec>& bd);
+};
+
+} // namespace margelo::nitro::chilkat