@chilkat/react-native 11.6.1

package/cpp/HybridXmlDSig.cpp

@@ -0,0 +1,328 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridXmlDSig.hpp"
+#include "HybridBinData.hpp"
+#include "HybridHttp.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridPublicKey.hpp"
+#include "HybridStringArray.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridXml.hpp"
+#include "HybridXmlCertVault.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridXmlDSig::HybridXmlDSig()
+    : HybridObject(HybridXmlDSigSpec::TAG), ChilkatObject<CkXmlDSig>("XmlDSig", CkXmlDSig::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridXmlDSig::HybridXmlDSig(CkXmlDSig* owned)
+    : HybridObject(HybridXmlDSigSpec::TAG), ChilkatObject<CkXmlDSig>("XmlDSig", owned) {
+  init();
+}
+
+void HybridXmlDSig::init() {
+}
+
+void HybridXmlDSig::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridXmlDSig::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridXmlDSig::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridXmlDSig::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridXmlDSig::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridXmlDSig::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridXmlDSig::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridXmlDSig::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridXmlDSig::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridXmlDSig::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridXmlDSig::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridXmlDSig::getNumReferences() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumReferences());
+}
+double HybridXmlDSig::getNumSignatures() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumSignatures());
+}
+double HybridXmlDSig::getSelector() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Selector());
+}
+void HybridXmlDSig::setSelector(double value) {
+  this->beginCall();
+  this->ck().put_Selector(rt::toInt(value, "selector"));
+}
+bool HybridXmlDSig::getIgnoreExternalRefs() {
+  this->beginCall();
+  return this->ck().get_IgnoreExternalRefs();
+}
+void HybridXmlDSig::setIgnoreExternalRefs(bool value) {
+  this->beginCall();
+  this->ck().put_IgnoreExternalRefs(value);
+}
+double HybridXmlDSig::getRefFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_RefFailReason());
+}
+std::string HybridXmlDSig::getExternalRefDirs() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ExternalRefDirs(_s);
+  return rt::stdString(_s);
+}
+void HybridXmlDSig::setExternalRefDirs(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "externalRefDirs");
+  this->ck().put_ExternalRefDirs(value.c_str());
+}
+std::string HybridXmlDSig::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridXmlDSig::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+std::string HybridXmlDSig::canonicalizeXml(const std::string& xml, const std::string& version, bool withComments) {
+  this->beginCall();
+  return canonicalizeXml_impl(xml, version, withComments);
+}
+std::string HybridXmlDSig::canonicalizeXml_impl(const std::string& xml, const std::string& version, bool withComments) {
+  rt::checkNoNul(xml, "xml");
+  rt::checkNoNul(version, "version");
+  CkString _out;
+  if (!this->ck().CanonicalizeXml(xml.c_str(), version.c_str(), withComments, _out)) throw this->fail("canonicalizeXml");
+  return rt::stdString(_out);
+}
+
+void HybridXmlDSig::loadSignature(const std::string& xmlSig) {
+  this->beginCall();
+  loadSignature_impl(xmlSig);
+}
+void HybridXmlDSig::loadSignature_impl(const std::string& xmlSig) {
+  rt::checkNoNul(xmlSig, "xmlSig");
+  if (!this->ck().LoadSignature(xmlSig.c_str())) throw this->fail("loadSignature");
+}
+
+void HybridXmlDSig::loadSignatureSb(const std::shared_ptr<HybridStringBuilderSpec>& sbXmlSig) {
+  this->beginCall();
+  loadSignatureSb_impl(sbXmlSig);
+}
+void HybridXmlDSig::loadSignatureSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbXmlSig) {
+  if (!this->ck().LoadSignatureSb(rt::implOf<HybridStringBuilder>(sbXmlSig, "sbXmlSig").ck())) throw this->fail("loadSignatureSb");
+}
+
+bool HybridXmlDSig::isReferenceExternal(double index) {
+  this->beginCall();
+  return isReferenceExternal_impl(index);
+}
+bool HybridXmlDSig::isReferenceExternal_impl(double index) {
+  return this->ck().IsReferenceExternal(rt::toInt(index, "index"));
+}
+
+std::string HybridXmlDSig::referenceUri(double index) {
+  this->beginCall();
+  return referenceUri_impl(index);
+}
+std::string HybridXmlDSig::referenceUri_impl(double index) {
+  CkString _out;
+  if (!this->ck().ReferenceUri(rt::toInt(index, "index"), _out)) throw this->fail("referenceUri");
+  return rt::stdString(_out);
+}
+
+void HybridXmlDSig::setRefDataSb(double index, const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) {
+  this->beginCall();
+  setRefDataSb_impl(index, sb, charset);
+}
+void HybridXmlDSig::setRefDataSb_impl(double index, const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().SetRefDataSb(rt::toInt(index, "index"), rt::implOf<HybridStringBuilder>(sb, "sb").ck(), charset.c_str())) throw this->fail("setRefDataSb");
+}
+
+void HybridXmlDSig::setRefDataBd(double index, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  setRefDataBd_impl(index, binData);
+}
+void HybridXmlDSig::setRefDataBd_impl(double index, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().SetRefDataBd(rt::toInt(index, "index"), rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("setRefDataBd");
+}
+
+void HybridXmlDSig::setRefDataFile(double index, const std::string& path) {
+  this->beginCall();
+  setRefDataFile_impl(index, path);
+}
+void HybridXmlDSig::setRefDataFile_impl(double index, const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SetRefDataFile(rt::toInt(index, "index"), path.c_str())) throw this->fail("setRefDataFile");
+}
+
+bool HybridXmlDSig::verifyReferenceDigest(double index) {
+  this->beginCall();
+  return verifyReferenceDigest_impl(index);
+}
+bool HybridXmlDSig::verifyReferenceDigest_impl(double index) {
+  return this->ck().VerifyReferenceDigest(rt::toInt(index, "index"));
+}
+
+std::string HybridXmlDSig::canonicalizeFragment(const std::string& xml, const std::string& fragmentId, const std::string& version, const std::string& prefixList, bool withComments) {
+  this->beginCall();
+  return canonicalizeFragment_impl(xml, fragmentId, version, prefixList, withComments);
+}
+std::string HybridXmlDSig::canonicalizeFragment_impl(const std::string& xml, const std::string& fragmentId, const std::string& version, const std::string& prefixList, bool withComments) {
+  rt::checkNoNul(xml, "xml");
+  rt::checkNoNul(fragmentId, "fragmentId");
+  rt::checkNoNul(version, "version");
+  rt::checkNoNul(prefixList, "prefixList");
+  CkString _out;
+  if (!this->ck().CanonicalizeFragment(xml.c_str(), fragmentId.c_str(), version.c_str(), prefixList.c_str(), withComments, _out)) throw this->fail("canonicalizeFragment");
+  return rt::stdString(_out);
+}
+
+void HybridXmlDSig::loadSignatureBd(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  loadSignatureBd_impl(binData);
+}
+void HybridXmlDSig::loadSignatureBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().LoadSignatureBd(rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("loadSignatureBd");
+}
+
+void HybridXmlDSig::verifySignature(bool verifyReferenceDigests) {
+  this->beginCall();
+  verifySignature_impl(verifyReferenceDigests);
+}
+void HybridXmlDSig::verifySignature_impl(bool verifyReferenceDigests) {
+  if (!this->ck().VerifySignature(verifyReferenceDigests)) throw this->fail("verifySignature");
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXmlDSig::getKeyInfo() {
+  this->beginCall();
+  return getKeyInfo_impl();
+}
+std::shared_ptr<HybridXmlSpec> HybridXmlDSig::getKeyInfo_impl() {
+  CkXml* _r = this->ck().GetKeyInfo();
+  if (!_r) throw this->fail("getKeyInfo");
+  return std::make_shared<HybridXml>(_r);
+}
+
+std::shared_ptr<HybridPublicKeySpec> HybridXmlDSig::getPublicKey() {
+  this->beginCall();
+  return getPublicKey_impl();
+}
+std::shared_ptr<HybridPublicKeySpec> HybridXmlDSig::getPublicKey_impl() {
+  CkPublicKey* _r = this->ck().GetPublicKey();
+  if (!_r) throw this->fail("getPublicKey");
+  return std::make_shared<HybridPublicKey>(_r);
+}
+
+void HybridXmlDSig::useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& certVault) {
+  this->beginCall();
+  useCertVault_impl(certVault);
+}
+void HybridXmlDSig::useCertVault_impl(const std::shared_ptr<HybridXmlCertVaultSpec>& certVault) {
+  if (!this->ck().UseCertVault(rt::implOf<HybridXmlCertVault>(certVault, "certVault").ck())) throw this->fail("useCertVault");
+}
+
+void HybridXmlDSig::setHmacKey(const std::string& key, const std::string& encoding) {
+  this->beginCall();
+  setHmacKey_impl(key, encoding);
+}
+void HybridXmlDSig::setHmacKey_impl(const std::string& key, const std::string& encoding) {
+  rt::checkNoNul(key, "key");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().SetHmacKey(key.c_str(), encoding.c_str())) throw this->fail("setHmacKey");
+}
+
+void HybridXmlDSig::setPublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubKey) {
+  this->beginCall();
+  setPublicKey_impl(pubKey);
+}
+void HybridXmlDSig::setPublicKey_impl(const std::shared_ptr<HybridPublicKeySpec>& pubKey) {
+  if (!this->ck().SetPublicKey(rt::implOf<HybridPublicKey>(pubKey, "pubKey").ck())) throw this->fail("setPublicKey");
+}
+
+void HybridXmlDSig::getCerts(const std::shared_ptr<HybridStringArraySpec>& sa) {
+  this->beginCall();
+  getCerts_impl(sa);
+}
+void HybridXmlDSig::getCerts_impl(const std::shared_ptr<HybridStringArraySpec>& sa) {
+  if (!this->ck().GetCerts(rt::implOf<HybridStringArray>(sa, "sa").ck())) throw this->fail("getCerts");
+}
+
+bool HybridXmlDSig::hasEncapsulatedTimeStamp() {
+  this->beginCall();
+  return hasEncapsulatedTimeStamp_impl();
+}
+bool HybridXmlDSig::hasEncapsulatedTimeStamp_impl() {
+  return this->ck().HasEncapsulatedTimeStamp();
+}
+
+void HybridXmlDSig::addEncapsulatedTimeStamp(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridStringBuilderSpec>& sbOut) {
+  this->beginCall();
+  addEncapsulatedTimeStamp_impl(json, sbOut);
+}
+void HybridXmlDSig::addEncapsulatedTimeStamp_impl(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridStringBuilderSpec>& sbOut) {
+  if (!this->ck().AddEncapsulatedTimeStamp(rt::implOf<HybridJsonObject>(json, "json").ck(), rt::implOf<HybridStringBuilder>(sbOut, "sbOut").ck())) throw this->fail("addEncapsulatedTimeStamp");
+}
+
+void HybridXmlDSig::setHttpObj(const std::shared_ptr<HybridHttpSpec>& http) {
+  this->beginCall();
+  setHttpObj_impl(http);
+}
+void HybridXmlDSig::setHttpObj_impl(const std::shared_ptr<HybridHttpSpec>& http) {
+  this->ck().SetHttpObj(rt::implOf<HybridHttp>(http, "http").ck());
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridXmlDSig.hpp

@@ -0,0 +1,88 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// XmlDSig: the Nitro HybridObject over Chilkat's CkXmlDSig (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridXmlDSigSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkXmlDSig.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridXmlDSig final : public HybridXmlDSigSpec, public ChilkatObject<CkXmlDSig> {
+public:
+  HybridXmlDSig();                                  // `new XmlDSig()` from JS
+  explicit HybridXmlDSig(CkXmlDSig* 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 getNumReferences() override;
+  double getNumSignatures() override;
+  double getSelector() override;
+  void setSelector(double value) override;
+  bool getIgnoreExternalRefs() override;
+  void setIgnoreExternalRefs(bool value) override;
+  double getRefFailReason() override;
+  std::string getExternalRefDirs() override;
+  void setExternalRefDirs(const std::string& value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  std::string canonicalizeXml(const std::string& xml, const std::string& version, bool withComments) override;
+  void loadSignature(const std::string& xmlSig) override;
+  void loadSignatureSb(const std::shared_ptr<HybridStringBuilderSpec>& sbXmlSig) override;
+  bool isReferenceExternal(double index) override;
+  std::string referenceUri(double index) override;
+  void setRefDataSb(double index, const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) override;
+  void setRefDataBd(double index, const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  void setRefDataFile(double index, const std::string& path) override;
+  bool verifyReferenceDigest(double index) override;
+  std::string canonicalizeFragment(const std::string& xml, const std::string& fragmentId, const std::string& version, const std::string& prefixList, bool withComments) override;
+  void loadSignatureBd(const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  void verifySignature(bool verifyReferenceDigests) override;
+  std::shared_ptr<HybridXmlSpec> getKeyInfo() override;
+  std::shared_ptr<HybridPublicKeySpec> getPublicKey() override;
+  void useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& certVault) override;
+  void setHmacKey(const std::string& key, const std::string& encoding) override;
+  void setPublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubKey) override;
+  void getCerts(const std::shared_ptr<HybridStringArraySpec>& sa) override;
+  bool hasEncapsulatedTimeStamp() override;
+  void addEncapsulatedTimeStamp(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridStringBuilderSpec>& sbOut) override;
+  void setHttpObj(const std::shared_ptr<HybridHttpSpec>& http) override;
+
+private:
+  void init();
+  std::string canonicalizeXml_impl(const std::string& xml, const std::string& version, bool withComments);
+  void loadSignature_impl(const std::string& xmlSig);
+  void loadSignatureSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbXmlSig);
+  bool isReferenceExternal_impl(double index);
+  std::string referenceUri_impl(double index);
+  void setRefDataSb_impl(double index, const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset);
+  void setRefDataBd_impl(double index, const std::shared_ptr<HybridBinDataSpec>& binData);
+  void setRefDataFile_impl(double index, const std::string& path);
+  bool verifyReferenceDigest_impl(double index);
+  std::string canonicalizeFragment_impl(const std::string& xml, const std::string& fragmentId, const std::string& version, const std::string& prefixList, bool withComments);
+  void loadSignatureBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData);
+  void verifySignature_impl(bool verifyReferenceDigests);
+  std::shared_ptr<HybridXmlSpec> getKeyInfo_impl();
+  std::shared_ptr<HybridPublicKeySpec> getPublicKey_impl();
+  void useCertVault_impl(const std::shared_ptr<HybridXmlCertVaultSpec>& certVault);
+  void setHmacKey_impl(const std::string& key, const std::string& encoding);
+  void setPublicKey_impl(const std::shared_ptr<HybridPublicKeySpec>& pubKey);
+  void getCerts_impl(const std::shared_ptr<HybridStringArraySpec>& sa);
+  bool hasEncapsulatedTimeStamp_impl();
+  void addEncapsulatedTimeStamp_impl(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridStringBuilderSpec>& sbOut);
+  void setHttpObj_impl(const std::shared_ptr<HybridHttpSpec>& http);
+};
+
+} // namespace margelo::nitro::chilkat