@chilkat/react-native 11.6.1

package/cpp/HybridPem.cpp

@@ -0,0 +1,327 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridPem.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.hpp"
+#include "HybridCertChain.hpp"
+#include "HybridJavaKeyStore.hpp"
+#include "HybridPfx.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridPublicKey.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridPem::HybridPem()
+    : HybridObject(HybridPemSpec::TAG), ChilkatObject<CkPem>("Pem", CkPem::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridPem::HybridPem(CkPem* owned)
+    : HybridObject(HybridPemSpec::TAG), ChilkatObject<CkPem>("Pem", owned) {
+  init();
+}
+
+void HybridPem::init() {
+}
+
+void HybridPem::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridPem::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPem::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPem::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPem::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPem::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridPem::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridPem::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridPem::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridPem::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridPem::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridPem::getAppendMode() {
+  this->beginCall();
+  return this->ck().get_AppendMode();
+}
+void HybridPem::setAppendMode(bool value) {
+  this->beginCall();
+  this->ck().put_AppendMode(value);
+}
+double HybridPem::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridPem::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+double HybridPem::getNumCerts() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumCerts());
+}
+double HybridPem::getNumCsrs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumCsrs());
+}
+double HybridPem::getNumPrivateKeys() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumPrivateKeys());
+}
+double HybridPem::getNumPublicKeys() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumPublicKeys());
+}
+std::string HybridPem::getPrivateKeyFormat() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_PrivateKeyFormat(_s);
+  return rt::stdString(_s);
+}
+void HybridPem::setPrivateKeyFormat(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "privateKeyFormat");
+  this->ck().put_PrivateKeyFormat(value.c_str());
+}
+std::string HybridPem::getPublicKeyFormat() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_PublicKeyFormat(_s);
+  return rt::stdString(_s);
+}
+void HybridPem::setPublicKeyFormat(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "publicKeyFormat");
+  this->ck().put_PublicKeyFormat(value.c_str());
+}
+double HybridPem::getNumCrls() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumCrls());
+}
+
+// ---- Methods ----
+
+void HybridPem::addCert(const std::shared_ptr<HybridCertSpec>& cert, bool includeChain) {
+  this->beginCall();
+  addCert_impl(cert, includeChain);
+}
+void HybridPem::addCert_impl(const std::shared_ptr<HybridCertSpec>& cert, bool includeChain) {
+  if (!this->ck().AddCert(rt::implOf<HybridCert>(cert, "cert").ck(), includeChain)) throw this->fail("addCert");
+}
+
+void HybridPem::addPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privateKey) {
+  this->beginCall();
+  addPrivateKey_impl(privateKey);
+}
+void HybridPem::addPrivateKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privateKey) {
+  if (!this->ck().AddPrivateKey(rt::implOf<HybridPrivateKey>(privateKey, "privateKey").ck())) throw this->fail("addPrivateKey");
+}
+
+void HybridPem::addPrivateKey2(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridCertChainSpec>& certChain) {
+  this->beginCall();
+  addPrivateKey2_impl(privKey, certChain);
+}
+void HybridPem::addPrivateKey2_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridCertChainSpec>& certChain) {
+  if (!this->ck().AddPrivateKey2(rt::implOf<HybridPrivateKey>(privKey, "privKey").ck(), rt::implOf<HybridCertChain>(certChain, "certChain").ck())) throw this->fail("addPrivateKey2");
+}
+
+void HybridPem::addPublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubkey) {
+  this->beginCall();
+  addPublicKey_impl(pubkey);
+}
+void HybridPem::addPublicKey_impl(const std::shared_ptr<HybridPublicKeySpec>& pubkey) {
+  if (!this->ck().AddPublicKey(rt::implOf<HybridPublicKey>(pubkey, "pubkey").ck())) throw this->fail("addPublicKey");
+}
+
+void HybridPem::clear() {
+  this->beginCall();
+  clear_impl();
+}
+void HybridPem::clear_impl() {
+  if (!this->ck().Clear()) throw this->fail("clear");
+}
+
+std::string HybridPem::getEncodedItem(const std::string& itemType, const std::string& itemSubType, const std::string& encoding, double index) {
+  this->beginCall();
+  return getEncodedItem_impl(itemType, itemSubType, encoding, index);
+}
+std::string HybridPem::getEncodedItem_impl(const std::string& itemType, const std::string& itemSubType, const std::string& encoding, double index) {
+  rt::checkNoNul(itemType, "itemType");
+  rt::checkNoNul(itemSubType, "itemSubType");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetEncodedItem(itemType.c_str(), itemSubType.c_str(), encoding.c_str(), rt::toInt(index, "index"), _out)) throw this->fail("getEncodedItem");
+  return rt::stdString(_out);
+}
+
+void HybridPem::loadP7bFile(const std::string& path) {
+  this->beginCall();
+  loadP7bFile_impl(path);
+}
+void HybridPem::loadP7bFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadP7bFile(path.c_str())) throw this->fail("loadP7bFile");
+}
+
+void HybridPem::loadPem(const std::string& pemContent, const std::string& password) {
+  this->beginCall();
+  loadPem_impl(pemContent, password);
+}
+void HybridPem::loadPem_impl(const std::string& pemContent, const std::string& password) {
+  rt::checkNoNul(pemContent, "pemContent");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadPem(pemContent.c_str(), password.c_str())) throw this->fail("loadPem");
+}
+
+void HybridPem::loadPemFile(const std::string& path, const std::string& password) {
+  this->beginCall();
+  loadPemFile_impl(path, password);
+}
+void HybridPem::loadPemFile_impl(const std::string& path, const std::string& password) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadPemFile(path.c_str(), password.c_str())) throw this->fail("loadPemFile");
+}
+
+void HybridPem::removeCert(double index) {
+  this->beginCall();
+  removeCert_impl(index);
+}
+void HybridPem::removeCert_impl(double index) {
+  if (!this->ck().RemoveCert(rt::toInt(index, "index"))) throw this->fail("removeCert");
+}
+
+void HybridPem::removePrivateKey(double index) {
+  this->beginCall();
+  removePrivateKey_impl(index);
+}
+void HybridPem::removePrivateKey_impl(double index) {
+  if (!this->ck().RemovePrivateKey(rt::toInt(index, "index"))) throw this->fail("removePrivateKey");
+}
+
+std::string HybridPem::toPem() {
+  this->beginCall();
+  return toPem_impl();
+}
+std::string HybridPem::toPem_impl() {
+  CkString _out;
+  if (!this->ck().ToPem(_out)) throw this->fail("toPem");
+  return rt::stdString(_out);
+}
+
+std::string HybridPem::toPemEx(bool extendedAttrs, bool noKeys, bool noCerts, bool noCaCerts, const std::string& encryptAlg, const std::string& password) {
+  this->beginCall();
+  return toPemEx_impl(extendedAttrs, noKeys, noCerts, noCaCerts, encryptAlg, password);
+}
+std::string HybridPem::toPemEx_impl(bool extendedAttrs, bool noKeys, bool noCerts, bool noCaCerts, const std::string& encryptAlg, const std::string& password) {
+  rt::checkNoNul(encryptAlg, "encryptAlg");
+  rt::checkNoNul(password, "password");
+  CkString _out;
+  if (!this->ck().ToPemEx(extendedAttrs, noKeys, noCerts, noCaCerts, encryptAlg.c_str(), password.c_str(), _out)) throw this->fail("toPemEx");
+  return rt::stdString(_out);
+}
+
+void HybridPem::addItem(const std::string& itemType, const std::string& encoding, const std::string& itemData) {
+  this->beginCall();
+  addItem_impl(itemType, encoding, itemData);
+}
+void HybridPem::addItem_impl(const std::string& itemType, const std::string& encoding, const std::string& itemData) {
+  rt::checkNoNul(itemType, "itemType");
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(itemData, "itemData");
+  if (!this->ck().AddItem(itemType.c_str(), encoding.c_str(), itemData.c_str())) throw this->fail("addItem");
+}
+
+void HybridPem::certAt(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  certAt_impl(index, cert);
+}
+void HybridPem::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");
+}
+
+void HybridPem::privateKeyAt(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  privateKeyAt_impl(index, privKey);
+}
+void HybridPem::privateKeyAt_impl(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  if (!this->ck().PrivateKeyAt(rt::toInt(index, "index"), rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("privateKeyAt");
+}
+
+void HybridPem::publicKeyAt(double index, const std::shared_ptr<HybridPublicKeySpec>& pubKey) {
+  this->beginCall();
+  publicKeyAt_impl(index, pubKey);
+}
+void HybridPem::publicKeyAt_impl(double index, const std::shared_ptr<HybridPublicKeySpec>& pubKey) {
+  if (!this->ck().PublicKeyAt(rt::toInt(index, "index"), rt::implOf<HybridPublicKey>(pubKey, "pubKey").ck())) throw this->fail("publicKeyAt");
+}
+
+void HybridPem::toJksObj(const std::string& aliasName, const std::string& password, const std::shared_ptr<HybridJavaKeyStoreSpec>& jksObj) {
+  this->beginCall();
+  toJksObj_impl(aliasName, password, jksObj);
+}
+void HybridPem::toJksObj_impl(const std::string& aliasName, const std::string& password, const std::shared_ptr<HybridJavaKeyStoreSpec>& jksObj) {
+  rt::checkNoNul(aliasName, "aliasName");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().ToJksObj(aliasName.c_str(), password.c_str(), rt::implOf<HybridJavaKeyStore>(jksObj, "jksObj").ck())) throw this->fail("toJksObj");
+}
+
+void HybridPem::toPfxObj(const std::shared_ptr<HybridPfxSpec>& pfxObj) {
+  this->beginCall();
+  toPfxObj_impl(pfxObj);
+}
+void HybridPem::toPfxObj_impl(const std::shared_ptr<HybridPfxSpec>& pfxObj) {
+  if (!this->ck().ToPfxObj(rt::implOf<HybridPfx>(pfxObj, "pfxObj").ck())) throw this->fail("toPfxObj");
+}
+
+void HybridPem::addP7b(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  addP7b_impl(bd);
+}
+void HybridPem::addP7b_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().AddP7b(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("addP7b");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridPem.hpp

@@ -0,0 +1,88 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Pem: the Nitro HybridObject over Chilkat's CkPem (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridPemSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkPem.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridPem final : public HybridPemSpec, public ChilkatObject<CkPem> {
+public:
+  HybridPem();                                  // `new Pem()` from JS
+  explicit HybridPem(CkPem* 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 getAppendMode() override;
+  void setAppendMode(bool value) override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+  double getNumCerts() override;
+  double getNumCsrs() override;
+  double getNumPrivateKeys() override;
+  double getNumPublicKeys() override;
+  std::string getPrivateKeyFormat() override;
+  void setPrivateKeyFormat(const std::string& value) override;
+  std::string getPublicKeyFormat() override;
+  void setPublicKeyFormat(const std::string& value) override;
+  double getNumCrls() override;
+
+  // ---- Methods ----
+  void addCert(const std::shared_ptr<HybridCertSpec>& cert, bool includeChain) override;
+  void addPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privateKey) override;
+  void addPrivateKey2(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridCertChainSpec>& certChain) override;
+  void addPublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubkey) override;
+  void clear() override;
+  std::string getEncodedItem(const std::string& itemType, const std::string& itemSubType, const std::string& encoding, double index) override;
+  void loadP7bFile(const std::string& path) override;
+  void loadPem(const std::string& pemContent, const std::string& password) override;
+  void loadPemFile(const std::string& path, const std::string& password) override;
+  void removeCert(double index) override;
+  void removePrivateKey(double index) override;
+  std::string toPem() override;
+  std::string toPemEx(bool extendedAttrs, bool noKeys, bool noCerts, bool noCaCerts, const std::string& encryptAlg, const std::string& password) override;
+  void addItem(const std::string& itemType, const std::string& encoding, const std::string& itemData) override;
+  void certAt(double index, const std::shared_ptr<HybridCertSpec>& cert) override;
+  void privateKeyAt(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+  void publicKeyAt(double index, const std::shared_ptr<HybridPublicKeySpec>& pubKey) override;
+  void toJksObj(const std::string& aliasName, const std::string& password, const std::shared_ptr<HybridJavaKeyStoreSpec>& jksObj) override;
+  void toPfxObj(const std::shared_ptr<HybridPfxSpec>& pfxObj) override;
+  void addP7b(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+
+private:
+  void init();
+  void addCert_impl(const std::shared_ptr<HybridCertSpec>& cert, bool includeChain);
+  void addPrivateKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privateKey);
+  void addPrivateKey2_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridCertChainSpec>& certChain);
+  void addPublicKey_impl(const std::shared_ptr<HybridPublicKeySpec>& pubkey);
+  void clear_impl();
+  std::string getEncodedItem_impl(const std::string& itemType, const std::string& itemSubType, const std::string& encoding, double index);
+  void loadP7bFile_impl(const std::string& path);
+  void loadPem_impl(const std::string& pemContent, const std::string& password);
+  void loadPemFile_impl(const std::string& path, const std::string& password);
+  void removeCert_impl(double index);
+  void removePrivateKey_impl(double index);
+  std::string toPem_impl();
+  std::string toPemEx_impl(bool extendedAttrs, bool noKeys, bool noCerts, bool noCaCerts, const std::string& encryptAlg, const std::string& password);
+  void addItem_impl(const std::string& itemType, const std::string& encoding, const std::string& itemData);
+  void certAt_impl(double index, const std::shared_ptr<HybridCertSpec>& cert);
+  void privateKeyAt_impl(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+  void publicKeyAt_impl(double index, const std::shared_ptr<HybridPublicKeySpec>& pubKey);
+  void toJksObj_impl(const std::string& aliasName, const std::string& password, const std::shared_ptr<HybridJavaKeyStoreSpec>& jksObj);
+  void toPfxObj_impl(const std::shared_ptr<HybridPfxSpec>& pfxObj);
+  void addP7b_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+};
+
+} // namespace margelo::nitro::chilkat