@chilkat/react-native 11.6.1

package/cpp/HybridPfx.cpp

@@ -0,0 +1,343 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridPfx.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.hpp"
+#include "HybridCertChain.hpp"
+#include "HybridJavaKeyStore.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridXmlCertVault.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridPfx::HybridPfx()
+    : HybridObject(HybridPfxSpec::TAG), ChilkatObject<CkPfx>("Pfx", CkPfx::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridPfx::HybridPfx(CkPfx* owned)
+    : HybridObject(HybridPfxSpec::TAG), ChilkatObject<CkPfx>("Pfx", owned) {
+  init();
+}
+
+void HybridPfx::init() {
+}
+
+void HybridPfx::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridPfx::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPfx::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPfx::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPfx::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPfx::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridPfx::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridPfx::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridPfx::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridPfx::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridPfx::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridPfx::getNumCerts() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumCerts());
+}
+double HybridPfx::getNumPrivateKeys() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumPrivateKeys());
+}
+std::string HybridPfx::getAlgorithmId() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AlgorithmId(_s);
+  return rt::stdString(_s);
+}
+void HybridPfx::setAlgorithmId(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "algorithmId");
+  this->ck().put_AlgorithmId(value.c_str());
+}
+std::string HybridPfx::getPbes2CryptAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Pbes2CryptAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridPfx::setPbes2CryptAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "pbes2CryptAlg");
+  this->ck().put_Pbes2CryptAlg(value.c_str());
+}
+std::string HybridPfx::getPbes2HmacAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Pbes2HmacAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridPfx::setPbes2HmacAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "pbes2HmacAlg");
+  this->ck().put_Pbes2HmacAlg(value.c_str());
+}
+std::string HybridPfx::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridPfx::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridPfx::addCert(const std::shared_ptr<HybridCertSpec>& cert, bool includeChain) {
+  this->beginCall();
+  addCert_impl(cert, includeChain);
+}
+void HybridPfx::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 HybridPfx::addPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridCertChainSpec>& certChain) {
+  this->beginCall();
+  addPrivateKey_impl(privKey, certChain);
+}
+void HybridPfx::addPrivateKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridCertChainSpec>& certChain) {
+  if (!this->ck().AddPrivateKey(rt::implOf<HybridPrivateKey>(privKey, "privKey").ck(), rt::implOf<HybridCertChain>(certChain, "certChain").ck())) throw this->fail("addPrivateKey");
+}
+
+void HybridPfx::loadPem(const std::string& pemStr, const std::string& password) {
+  this->beginCall();
+  loadPem_impl(pemStr, password);
+}
+void HybridPfx::loadPem_impl(const std::string& pemStr, const std::string& password) {
+  rt::checkNoNul(pemStr, "pemStr");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadPem(pemStr.c_str(), password.c_str())) throw this->fail("loadPem");
+}
+
+void HybridPfx::loadPfxEncoded(const std::string& encodedData, const std::string& encoding, const std::string& password) {
+  this->beginCall();
+  loadPfxEncoded_impl(encodedData, encoding, password);
+}
+void HybridPfx::loadPfxEncoded_impl(const std::string& encodedData, const std::string& encoding, const std::string& password) {
+  rt::checkNoNul(encodedData, "encodedData");
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadPfxEncoded(encodedData.c_str(), encoding.c_str(), password.c_str())) throw this->fail("loadPfxEncoded");
+}
+
+void HybridPfx::loadPfxFile(const std::string& path, const std::string& password) {
+  this->beginCall();
+  loadPfxFile_impl(path, password);
+}
+void HybridPfx::loadPfxFile_impl(const std::string& path, const std::string& password) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadPfxFile(path.c_str(), password.c_str())) throw this->fail("loadPfxFile");
+}
+
+std::string HybridPfx::toEncodedString(const std::string& password, const std::string& encoding) {
+  this->beginCall();
+  return toEncodedString_impl(password, encoding);
+}
+std::string HybridPfx::toEncodedString_impl(const std::string& password, const std::string& encoding) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().ToEncodedString(password.c_str(), encoding.c_str(), _out)) throw this->fail("toEncodedString");
+  return rt::stdString(_out);
+}
+
+void HybridPfx::toFile(const std::string& password, const std::string& path) {
+  this->beginCall();
+  toFile_impl(password, path);
+}
+void HybridPfx::toFile_impl(const std::string& password, const std::string& path) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(path, "path");
+  if (!this->ck().ToFile(password.c_str(), path.c_str())) throw this->fail("toFile");
+}
+
+std::string HybridPfx::toPem() {
+  this->beginCall();
+  return toPem_impl();
+}
+std::string HybridPfx::toPem_impl() {
+  CkString _out;
+  if (!this->ck().ToPem(_out)) throw this->fail("toPem");
+  return rt::stdString(_out);
+}
+
+std::string HybridPfx::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 HybridPfx::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 HybridPfx::useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  this->beginCall();
+  useCertVault_impl(vault);
+}
+void HybridPfx::useCertVault_impl(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  if (!this->ck().UseCertVault(rt::implOf<HybridXmlCertVault>(vault, "vault").ck())) throw this->fail("useCertVault");
+}
+
+void HybridPfx::setSafeBagAttr(bool forPrivateKey, double index, const std::string& name, const std::string& value, const std::string& encoding) {
+  this->beginCall();
+  setSafeBagAttr_impl(forPrivateKey, index, name, value, encoding);
+}
+void HybridPfx::setSafeBagAttr_impl(bool forPrivateKey, double index, const std::string& name, const std::string& value, const std::string& encoding) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().SetSafeBagAttr(forPrivateKey, rt::toInt(index, "index"), name.c_str(), value.c_str(), encoding.c_str())) throw this->fail("setSafeBagAttr");
+}
+
+void HybridPfx::importToWindows(bool exportable, bool userProtected, bool machineKeyset, bool allowOverwriteKey, bool allowExport, const std::string& leafStore, const std::string& intermediateStore, const std::string& rootStore, const std::string& extraOptions) {
+  this->beginCall();
+  importToWindows_impl(exportable, userProtected, machineKeyset, allowOverwriteKey, allowExport, leafStore, intermediateStore, rootStore, extraOptions);
+}
+void HybridPfx::importToWindows_impl(bool exportable, bool userProtected, bool machineKeyset, bool allowOverwriteKey, bool allowExport, const std::string& leafStore, const std::string& intermediateStore, const std::string& rootStore, const std::string& extraOptions) {
+  rt::checkNoNul(leafStore, "leafStore");
+  rt::checkNoNul(intermediateStore, "intermediateStore");
+  rt::checkNoNul(rootStore, "rootStore");
+  rt::checkNoNul(extraOptions, "extraOptions");
+  if (!this->ck().ImportToWindows(exportable, userProtected, machineKeyset, allowOverwriteKey, allowExport, leafStore.c_str(), intermediateStore.c_str(), rootStore.c_str(), extraOptions.c_str())) throw this->fail("importToWindows");
+}
+
+std::string HybridPfx::getSafeBagAttr(bool forPrivateKey, double index, const std::string& attrName) {
+  this->beginCall();
+  return getSafeBagAttr_impl(forPrivateKey, index, attrName);
+}
+std::string HybridPfx::getSafeBagAttr_impl(bool forPrivateKey, double index, const std::string& attrName) {
+  rt::checkNoNul(attrName, "attrName");
+  CkString _out;
+  if (!this->ck().GetSafeBagAttr(forPrivateKey, rt::toInt(index, "index"), attrName.c_str(), _out)) throw this->fail("getSafeBagAttr");
+  return rt::stdString(_out);
+}
+
+void HybridPfx::importToKeychain(const std::shared_ptr<HybridJsonObjectSpec>& opts) {
+  this->beginCall();
+  importToKeychain_impl(opts);
+}
+void HybridPfx::importToKeychain_impl(const std::shared_ptr<HybridJsonObjectSpec>& opts) {
+  if (!this->ck().ImportToKeychain(rt::implOf<HybridJsonObject>(opts, "opts").ck())) throw this->fail("importToKeychain");
+}
+
+void HybridPfx::getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getLastJsonData_impl(json);
+}
+void HybridPfx::getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->ck().GetLastJsonData(rt::implOf<HybridJsonObject>(json, "json").ck());
+}
+
+void HybridPfx::certAt(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  certAt_impl(index, cert);
+}
+void HybridPfx::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 HybridPfx::certByLocalKeyId(const std::string& localKeyId, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  certByLocalKeyId_impl(localKeyId, encoding, cert);
+}
+void HybridPfx::certByLocalKeyId_impl(const std::string& localKeyId, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert) {
+  rt::checkNoNul(localKeyId, "localKeyId");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().CertByLocalKeyId(localKeyId.c_str(), encoding.c_str(), rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("certByLocalKeyId");
+}
+
+void HybridPfx::privateKeyAt(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  privateKeyAt_impl(index, privKey);
+}
+void HybridPfx::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 HybridPfx::toJksObj(const std::string& aliasName, const std::string& password, const std::shared_ptr<HybridJavaKeyStoreSpec>& jksObj) {
+  this->beginCall();
+  toJksObj_impl(aliasName, password, jksObj);
+}
+void HybridPfx::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 HybridPfx::loadPfxBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) {
+  this->beginCall();
+  loadPfxBd_impl(bd, password);
+}
+void HybridPfx::loadPfxBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadPfxBd(rt::implOf<HybridBinData>(bd, "bd").ck(), password.c_str())) throw this->fail("loadPfxBd");
+}
+
+void HybridPfx::toBd(const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  toBd_impl(password, bd);
+}
+void HybridPfx::toBd_impl(const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().ToBd(password.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("toBd");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridPfx.hpp

@@ -0,0 +1,87 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Pfx: the Nitro HybridObject over Chilkat's CkPfx (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridPfxSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkPfx.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridPfx final : public HybridPfxSpec, public ChilkatObject<CkPfx> {
+public:
+  HybridPfx();                                  // `new Pfx()` from JS
+  explicit HybridPfx(CkPfx* 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;
+  double getNumPrivateKeys() override;
+  std::string getAlgorithmId() override;
+  void setAlgorithmId(const std::string& value) override;
+  std::string getPbes2CryptAlg() override;
+  void setPbes2CryptAlg(const std::string& value) override;
+  std::string getPbes2HmacAlg() override;
+  void setPbes2HmacAlg(const std::string& value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  void addCert(const std::shared_ptr<HybridCertSpec>& cert, bool includeChain) override;
+  void addPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridCertChainSpec>& certChain) override;
+  void loadPem(const std::string& pemStr, const std::string& password) override;
+  void loadPfxEncoded(const std::string& encodedData, const std::string& encoding, const std::string& password) override;
+  void loadPfxFile(const std::string& path, const std::string& password) override;
+  std::string toEncodedString(const std::string& password, const std::string& encoding) override;
+  void toFile(const std::string& password, const std::string& path) 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 useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) override;
+  void setSafeBagAttr(bool forPrivateKey, double index, const std::string& name, const std::string& value, const std::string& encoding) override;
+  void importToWindows(bool exportable, bool userProtected, bool machineKeyset, bool allowOverwriteKey, bool allowExport, const std::string& leafStore, const std::string& intermediateStore, const std::string& rootStore, const std::string& extraOptions) override;
+  std::string getSafeBagAttr(bool forPrivateKey, double index, const std::string& attrName) override;
+  void importToKeychain(const std::shared_ptr<HybridJsonObjectSpec>& opts) override;
+  void getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void certAt(double index, const std::shared_ptr<HybridCertSpec>& cert) override;
+  void certByLocalKeyId(const std::string& localKeyId, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert) override;
+  void privateKeyAt(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+  void toJksObj(const std::string& aliasName, const std::string& password, const std::shared_ptr<HybridJavaKeyStoreSpec>& jksObj) override;
+  void loadPfxBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) override;
+  void toBd(const std::string& password, 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>& privKey, const std::shared_ptr<HybridCertChainSpec>& certChain);
+  void loadPem_impl(const std::string& pemStr, const std::string& password);
+  void loadPfxEncoded_impl(const std::string& encodedData, const std::string& encoding, const std::string& password);
+  void loadPfxFile_impl(const std::string& path, const std::string& password);
+  std::string toEncodedString_impl(const std::string& password, const std::string& encoding);
+  void toFile_impl(const std::string& password, const std::string& path);
+  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 useCertVault_impl(const std::shared_ptr<HybridXmlCertVaultSpec>& vault);
+  void setSafeBagAttr_impl(bool forPrivateKey, double index, const std::string& name, const std::string& value, const std::string& encoding);
+  void importToWindows_impl(bool exportable, bool userProtected, bool machineKeyset, bool allowOverwriteKey, bool allowExport, const std::string& leafStore, const std::string& intermediateStore, const std::string& rootStore, const std::string& extraOptions);
+  std::string getSafeBagAttr_impl(bool forPrivateKey, double index, const std::string& attrName);
+  void importToKeychain_impl(const std::shared_ptr<HybridJsonObjectSpec>& opts);
+  void getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void certAt_impl(double index, const std::shared_ptr<HybridCertSpec>& cert);
+  void certByLocalKeyId_impl(const std::string& localKeyId, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert);
+  void privateKeyAt_impl(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+  void toJksObj_impl(const std::string& aliasName, const std::string& password, const std::shared_ptr<HybridJavaKeyStoreSpec>& jksObj);
+  void loadPfxBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password);
+  void toBd_impl(const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd);
+};
+
+} // namespace margelo::nitro::chilkat