@chilkat/react-native 11.6.1

package/cpp/HybridHttpResponse.cpp

@@ -0,0 +1,340 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridHttpResponse.hpp"
+#include "HybridBinData.hpp"
+#include "HybridJsonArray.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridXml.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridHttpResponse::HybridHttpResponse()
+    : HybridObject(HybridHttpResponseSpec::TAG), ChilkatObject<CkHttpResponse>("HttpResponse", CkHttpResponse::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridHttpResponse::HybridHttpResponse(CkHttpResponse* owned)
+    : HybridObject(HybridHttpResponseSpec::TAG), ChilkatObject<CkHttpResponse>("HttpResponse", owned) {
+  init();
+}
+
+void HybridHttpResponse::init() {
+}
+
+void HybridHttpResponse::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridHttpResponse::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpResponse::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpResponse::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpResponse::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpResponse::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridHttpResponse::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridHttpResponse::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridHttpResponse::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridHttpResponse::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridHttpResponse::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridHttpResponse::getBodyQP() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_BodyQP(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpResponse::getBodyStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_BodyStr(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpResponse::getCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Charset(_s);
+  return rt::stdString(_s);
+}
+double HybridHttpResponse::getContentLength() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ContentLength());
+}
+double HybridHttpResponse::getContentLength64() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ContentLength64());
+}
+std::string HybridHttpResponse::getDateStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DateStr(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpResponse::getDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Domain(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpResponse::getFinalRedirectUrl() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FinalRedirectUrl(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpResponse::getFullMime() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FullMime(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpResponse::getHeader() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Header(_s);
+  return rt::stdString(_s);
+}
+double HybridHttpResponse::getNumCookies() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumCookies());
+}
+double HybridHttpResponse::getNumHeaderFields() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumHeaderFields());
+}
+double HybridHttpResponse::getStatusCode() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_StatusCode());
+}
+std::string HybridHttpResponse::getStatusLine() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_StatusLine(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpResponse::getStatusText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_StatusText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpResponse::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridHttpResponse::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+std::string HybridHttpResponse::getCookieDomain(double index) {
+  this->beginCall();
+  return getCookieDomain_impl(index);
+}
+std::string HybridHttpResponse::getCookieDomain_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetCookieDomain(rt::toInt(index, "index"), _out)) throw this->fail("getCookieDomain");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpResponse::getCookieExpiresStr(double index) {
+  this->beginCall();
+  return getCookieExpiresStr_impl(index);
+}
+std::string HybridHttpResponse::getCookieExpiresStr_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetCookieExpiresStr(rt::toInt(index, "index"), _out)) throw this->fail("getCookieExpiresStr");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpResponse::getCookieName(double index) {
+  this->beginCall();
+  return getCookieName_impl(index);
+}
+std::string HybridHttpResponse::getCookieName_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetCookieName(rt::toInt(index, "index"), _out)) throw this->fail("getCookieName");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpResponse::getCookiePath(double index) {
+  this->beginCall();
+  return getCookiePath_impl(index);
+}
+std::string HybridHttpResponse::getCookiePath_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetCookiePath(rt::toInt(index, "index"), _out)) throw this->fail("getCookiePath");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpResponse::getCookieValue(double index) {
+  this->beginCall();
+  return getCookieValue_impl(index);
+}
+std::string HybridHttpResponse::getCookieValue_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetCookieValue(rt::toInt(index, "index"), _out)) throw this->fail("getCookieValue");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpResponse::getHeaderField(const std::string& fieldName) {
+  this->beginCall();
+  return getHeaderField_impl(fieldName);
+}
+std::string HybridHttpResponse::getHeaderField_impl(const std::string& fieldName) {
+  rt::checkNoNul(fieldName, "fieldName");
+  CkString _out;
+  if (!this->ck().GetHeaderField(fieldName.c_str(), _out)) throw this->fail("getHeaderField");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpResponse::getHeaderFieldAttr(const std::string& fieldName, const std::string& attrName) {
+  this->beginCall();
+  return getHeaderFieldAttr_impl(fieldName, attrName);
+}
+std::string HybridHttpResponse::getHeaderFieldAttr_impl(const std::string& fieldName, const std::string& attrName) {
+  rt::checkNoNul(fieldName, "fieldName");
+  rt::checkNoNul(attrName, "attrName");
+  CkString _out;
+  if (!this->ck().GetHeaderFieldAttr(fieldName.c_str(), attrName.c_str(), _out)) throw this->fail("getHeaderFieldAttr");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpResponse::getHeaderName(double index) {
+  this->beginCall();
+  return getHeaderName_impl(index);
+}
+std::string HybridHttpResponse::getHeaderName_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetHeaderName(rt::toInt(index, "index"), _out)) throw this->fail("getHeaderName");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpResponse::getHeaderValue(double index) {
+  this->beginCall();
+  return getHeaderValue_impl(index);
+}
+std::string HybridHttpResponse::getHeaderValue_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetHeaderValue(rt::toInt(index, "index"), _out)) throw this->fail("getHeaderValue");
+  return rt::stdString(_out);
+}
+
+void HybridHttpResponse::saveBodyBinary(const std::string& path) {
+  this->beginCall();
+  saveBodyBinary_impl(path);
+}
+void HybridHttpResponse::saveBodyBinary_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SaveBodyBinary(path.c_str())) throw this->fail("saveBodyBinary");
+}
+
+void HybridHttpResponse::saveBodyText(bool bCrlf, const std::string& path) {
+  this->beginCall();
+  saveBodyText_impl(bCrlf, path);
+}
+void HybridHttpResponse::saveBodyText_impl(bool bCrlf, const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SaveBodyText(bCrlf, path.c_str())) throw this->fail("saveBodyText");
+}
+
+std::string HybridHttpResponse::urlEncParamValue(const std::string& encodedParamString, const std::string& paramName) {
+  this->beginCall();
+  return urlEncParamValue_impl(encodedParamString, paramName);
+}
+std::string HybridHttpResponse::urlEncParamValue_impl(const std::string& encodedParamString, const std::string& paramName) {
+  rt::checkNoNul(encodedParamString, "encodedParamString");
+  rt::checkNoNul(paramName, "paramName");
+  CkString _out;
+  if (!this->ck().UrlEncParamValue(encodedParamString.c_str(), paramName.c_str(), _out)) throw this->fail("urlEncParamValue");
+  return rt::stdString(_out);
+}
+
+void HybridHttpResponse::getBodySb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  getBodySb_impl(sb);
+}
+void HybridHttpResponse::getBodySb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().GetBodySb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("getBodySb");
+}
+
+void HybridHttpResponse::getBodyBd(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  getBodyBd_impl(binData);
+}
+void HybridHttpResponse::getBodyBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().GetBodyBd(rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("getBodyBd");
+}
+
+void HybridHttpResponse::getBodyJson(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getBodyJson_impl(json);
+}
+void HybridHttpResponse::getBodyJson_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().GetBodyJson(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getBodyJson");
+}
+
+void HybridHttpResponse::getBodyJarr(const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  this->beginCall();
+  getBodyJarr_impl(jarr);
+}
+void HybridHttpResponse::getBodyJarr_impl(const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  if (!this->ck().GetBodyJarr(rt::implOf<HybridJsonArray>(jarr, "jarr").ck())) throw this->fail("getBodyJarr");
+}
+
+void HybridHttpResponse::getBodyXml(const std::shared_ptr<HybridXmlSpec>& xml) {
+  this->beginCall();
+  getBodyXml_impl(xml);
+}
+void HybridHttpResponse::getBodyXml_impl(const std::shared_ptr<HybridXmlSpec>& xml) {
+  if (!this->ck().GetBodyXml(rt::implOf<HybridXml>(xml, "xml").ck())) throw this->fail("getBodyXml");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridHttpResponse.hpp

@@ -0,0 +1,86 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// HttpResponse: the Nitro HybridObject over Chilkat's CkHttpResponse (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridHttpResponseSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkHttpResponse.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridHttpResponse final : public HybridHttpResponseSpec, public ChilkatObject<CkHttpResponse> {
+public:
+  HybridHttpResponse();                                  // `new HttpResponse()` from JS
+  explicit HybridHttpResponse(CkHttpResponse* 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 getBodyQP() override;
+  std::string getBodyStr() override;
+  std::string getCharset() override;
+  double getContentLength() override;
+  double getContentLength64() override;
+  std::string getDateStr() override;
+  std::string getDomain() override;
+  std::string getFinalRedirectUrl() override;
+  std::string getFullMime() override;
+  std::string getHeader() override;
+  double getNumCookies() override;
+  double getNumHeaderFields() override;
+  double getStatusCode() override;
+  std::string getStatusLine() override;
+  std::string getStatusText() override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  std::string getCookieDomain(double index) override;
+  std::string getCookieExpiresStr(double index) override;
+  std::string getCookieName(double index) override;
+  std::string getCookiePath(double index) override;
+  std::string getCookieValue(double index) override;
+  std::string getHeaderField(const std::string& fieldName) override;
+  std::string getHeaderFieldAttr(const std::string& fieldName, const std::string& attrName) override;
+  std::string getHeaderName(double index) override;
+  std::string getHeaderValue(double index) override;
+  void saveBodyBinary(const std::string& path) override;
+  void saveBodyText(bool bCrlf, const std::string& path) override;
+  std::string urlEncParamValue(const std::string& encodedParamString, const std::string& paramName) override;
+  void getBodySb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void getBodyBd(const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  void getBodyJson(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void getBodyJarr(const std::shared_ptr<HybridJsonArraySpec>& jarr) override;
+  void getBodyXml(const std::shared_ptr<HybridXmlSpec>& xml) override;
+
+private:
+  void init();
+  std::string getCookieDomain_impl(double index);
+  std::string getCookieExpiresStr_impl(double index);
+  std::string getCookieName_impl(double index);
+  std::string getCookiePath_impl(double index);
+  std::string getCookieValue_impl(double index);
+  std::string getHeaderField_impl(const std::string& fieldName);
+  std::string getHeaderFieldAttr_impl(const std::string& fieldName, const std::string& attrName);
+  std::string getHeaderName_impl(double index);
+  std::string getHeaderValue_impl(double index);
+  void saveBodyBinary_impl(const std::string& path);
+  void saveBodyText_impl(bool bCrlf, const std::string& path);
+  std::string urlEncParamValue_impl(const std::string& encodedParamString, const std::string& paramName);
+  void getBodySb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void getBodyBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData);
+  void getBodyJson_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void getBodyJarr_impl(const std::shared_ptr<HybridJsonArraySpec>& jarr);
+  void getBodyXml_impl(const std::shared_ptr<HybridXmlSpec>& xml);
+};
+
+} // namespace margelo::nitro::chilkat