@chilkat/react-native 11.6.1

package/cpp/HybridOAuth1.cpp

@@ -0,0 +1,307 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridOAuth1.hpp"
+#include "HybridPrivateKey.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridOAuth1::HybridOAuth1()
+    : HybridObject(HybridOAuth1Spec::TAG), ChilkatObject<CkOAuth1>("OAuth1", CkOAuth1::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridOAuth1::HybridOAuth1(CkOAuth1* owned)
+    : HybridObject(HybridOAuth1Spec::TAG), ChilkatObject<CkOAuth1>("OAuth1", owned) {
+  init();
+}
+
+void HybridOAuth1::init() {
+}
+
+void HybridOAuth1::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridOAuth1::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth1::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth1::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth1::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth1::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth1::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridOAuth1::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridOAuth1::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridOAuth1::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridOAuth1::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridOAuth1::getAuthorizationHeader() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AuthorizationHeader(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth1::getBaseString() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_BaseString(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth1::getConsumerKey() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ConsumerKey(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth1::setConsumerKey(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "consumerKey");
+  this->ck().put_ConsumerKey(value.c_str());
+}
+std::string HybridOAuth1::getConsumerSecret() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ConsumerSecret(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth1::setConsumerSecret(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "consumerSecret");
+  this->ck().put_ConsumerSecret(value.c_str());
+}
+std::string HybridOAuth1::getEncodedSignature() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_EncodedSignature(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth1::getGeneratedUrl() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_GeneratedUrl(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth1::getHmacKey() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HmacKey(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth1::getNonce() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Nonce(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth1::setNonce(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "nonce");
+  this->ck().put_Nonce(value.c_str());
+}
+std::string HybridOAuth1::getOauthMethod() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OauthMethod(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth1::setOauthMethod(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oauthMethod");
+  this->ck().put_OauthMethod(value.c_str());
+}
+std::string HybridOAuth1::getOauthUrl() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OauthUrl(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth1::setOauthUrl(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oauthUrl");
+  this->ck().put_OauthUrl(value.c_str());
+}
+std::string HybridOAuth1::getOauthVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OauthVersion(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth1::setOauthVersion(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oauthVersion");
+  this->ck().put_OauthVersion(value.c_str());
+}
+std::string HybridOAuth1::getQueryString() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_QueryString(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth1::getSignature() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Signature(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth1::getSignatureMethod() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SignatureMethod(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth1::setSignatureMethod(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "signatureMethod");
+  this->ck().put_SignatureMethod(value.c_str());
+}
+std::string HybridOAuth1::getTimestamp() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Timestamp(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth1::setTimestamp(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "timestamp");
+  this->ck().put_Timestamp(value.c_str());
+}
+std::string HybridOAuth1::getToken() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Token(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth1::setToken(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "token");
+  this->ck().put_Token(value.c_str());
+}
+std::string HybridOAuth1::getTokenSecret() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TokenSecret(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth1::setTokenSecret(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tokenSecret");
+  this->ck().put_TokenSecret(value.c_str());
+}
+std::string HybridOAuth1::getRealm() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Realm(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth1::setRealm(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "realm");
+  this->ck().put_Realm(value.c_str());
+}
+std::string HybridOAuth1::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth1::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridOAuth1::addParam(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addParam_impl(name, value);
+}
+void HybridOAuth1::addParam_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AddParam(name.c_str(), value.c_str())) throw this->fail("addParam");
+}
+
+void HybridOAuth1::genNonce(double numBytes) {
+  this->beginCall();
+  genNonce_impl(numBytes);
+}
+void HybridOAuth1::genNonce_impl(double numBytes) {
+  if (!this->ck().GenNonce(rt::toInt(numBytes, "numBytes"))) throw this->fail("genNonce");
+}
+
+void HybridOAuth1::genTimestamp() {
+  this->beginCall();
+  genTimestamp_impl();
+}
+void HybridOAuth1::genTimestamp_impl() {
+  if (!this->ck().GenTimestamp()) throw this->fail("genTimestamp");
+}
+
+void HybridOAuth1::generate() {
+  this->beginCall();
+  generate_impl();
+}
+void HybridOAuth1::generate_impl() {
+  if (!this->ck().Generate()) throw this->fail("generate");
+}
+
+void HybridOAuth1::removeParam(const std::string& name) {
+  this->beginCall();
+  removeParam_impl(name);
+}
+void HybridOAuth1::removeParam_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().RemoveParam(name.c_str())) throw this->fail("removeParam");
+}
+
+void HybridOAuth1::setRsaKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  setRsaKey_impl(privKey);
+}
+void HybridOAuth1::setRsaKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  if (!this->ck().SetRsaKey(rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("setRsaKey");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridOAuth1.hpp

@@ -0,0 +1,78 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// OAuth1: the Nitro HybridObject over Chilkat's CkOAuth1 (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridOAuth1Spec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkOAuth1.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridOAuth1 final : public HybridOAuth1Spec, public ChilkatObject<CkOAuth1> {
+public:
+  HybridOAuth1();                                  // `new OAuth1()` from JS
+  explicit HybridOAuth1(CkOAuth1* 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 getAuthorizationHeader() override;
+  std::string getBaseString() override;
+  std::string getConsumerKey() override;
+  void setConsumerKey(const std::string& value) override;
+  std::string getConsumerSecret() override;
+  void setConsumerSecret(const std::string& value) override;
+  std::string getEncodedSignature() override;
+  std::string getGeneratedUrl() override;
+  std::string getHmacKey() override;
+  std::string getNonce() override;
+  void setNonce(const std::string& value) override;
+  std::string getOauthMethod() override;
+  void setOauthMethod(const std::string& value) override;
+  std::string getOauthUrl() override;
+  void setOauthUrl(const std::string& value) override;
+  std::string getOauthVersion() override;
+  void setOauthVersion(const std::string& value) override;
+  std::string getQueryString() override;
+  std::string getSignature() override;
+  std::string getSignatureMethod() override;
+  void setSignatureMethod(const std::string& value) override;
+  std::string getTimestamp() override;
+  void setTimestamp(const std::string& value) override;
+  std::string getToken() override;
+  void setToken(const std::string& value) override;
+  std::string getTokenSecret() override;
+  void setTokenSecret(const std::string& value) override;
+  std::string getRealm() override;
+  void setRealm(const std::string& value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  void addParam(const std::string& name, const std::string& value) override;
+  void genNonce(double numBytes) override;
+  void genTimestamp() override;
+  void generate() override;
+  void removeParam(const std::string& name) override;
+  void setRsaKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+
+private:
+  void init();
+  void addParam_impl(const std::string& name, const std::string& value);
+  void genNonce_impl(double numBytes);
+  void genTimestamp_impl();
+  void generate_impl();
+  void removeParam_impl(const std::string& name);
+  void setRsaKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+};
+
+} // namespace margelo::nitro::chilkat