@chilkat/react-native 11.6.1

package/cpp/HybridUpload.cpp

@@ -0,0 +1,427 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridUpload.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridUpload::HybridUpload()
+    : HybridObject(HybridUploadSpec::TAG), ChilkatObject<CkUpload>("Upload", CkUpload::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridUpload::HybridUpload(CkUpload* owned)
+    : HybridObject(HybridUploadSpec::TAG), ChilkatObject<CkUpload>("Upload", owned) {
+  init();
+}
+
+void HybridUpload::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridUpload::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridUpload::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUpload::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUpload::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUpload::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUpload::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridUpload::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridUpload::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridUpload::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridUpload::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridUpload::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridUpload::getBandwidthThrottleUp() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_BandwidthThrottleUp());
+}
+void HybridUpload::setBandwidthThrottleUp(double value) {
+  this->beginCall();
+  this->ck().put_BandwidthThrottleUp(rt::toInt(value, "bandwidthThrottleUp"));
+}
+double HybridUpload::getChunkSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ChunkSize());
+}
+void HybridUpload::setChunkSize(double value) {
+  this->beginCall();
+  this->ck().put_ChunkSize(rt::toInt(value, "chunkSize"));
+}
+std::string HybridUpload::getClientIpAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientIpAddress(_s);
+  return rt::stdString(_s);
+}
+void HybridUpload::setClientIpAddress(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientIpAddress");
+  this->ck().put_ClientIpAddress(value.c_str());
+}
+bool HybridUpload::getExpect100Continue() {
+  this->beginCall();
+  return this->ck().get_Expect100Continue();
+}
+void HybridUpload::setExpect100Continue(bool value) {
+  this->beginCall();
+  this->ck().put_Expect100Continue(value);
+}
+double HybridUpload::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridUpload::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+std::string HybridUpload::getHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Hostname(_s);
+  return rt::stdString(_s);
+}
+void HybridUpload::setHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "hostname");
+  this->ck().put_Hostname(value.c_str());
+}
+double HybridUpload::getIdleTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_IdleTimeoutMs());
+}
+void HybridUpload::setIdleTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_IdleTimeoutMs(rt::toInt(value, "idleTimeoutMs"));
+}
+std::string HybridUpload::getLogin() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Login(_s);
+  return rt::stdString(_s);
+}
+void HybridUpload::setLogin(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "login");
+  this->ck().put_Login(value.c_str());
+}
+double HybridUpload::getNumBytesSent() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumBytesSent());
+}
+std::string HybridUpload::getPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Password(_s);
+  return rt::stdString(_s);
+}
+void HybridUpload::setPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "password");
+  this->ck().put_Password(value.c_str());
+}
+std::string HybridUpload::getPath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Path(_s);
+  return rt::stdString(_s);
+}
+void HybridUpload::setPath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "path");
+  this->ck().put_Path(value.c_str());
+}
+double HybridUpload::getPercentDoneScale() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_PercentDoneScale());
+}
+void HybridUpload::setPercentDoneScale(double value) {
+  this->beginCall();
+  this->ck().put_PercentDoneScale(rt::toInt(value, "percentDoneScale"));
+}
+double HybridUpload::getPercentUploaded() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_PercentUploaded());
+}
+double HybridUpload::getPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Port());
+}
+void HybridUpload::setPort(double value) {
+  this->beginCall();
+  this->ck().put_Port(rt::toInt(value, "port"));
+}
+bool HybridUpload::getPreferIpv6() {
+  this->beginCall();
+  return this->ck().get_PreferIpv6();
+}
+void HybridUpload::setPreferIpv6(bool value) {
+  this->beginCall();
+  this->ck().put_PreferIpv6(value);
+}
+std::string HybridUpload::getProxyDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridUpload::setProxyDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyDomain");
+  this->ck().put_ProxyDomain(value.c_str());
+}
+std::string HybridUpload::getProxyLogin() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyLogin(_s);
+  return rt::stdString(_s);
+}
+void HybridUpload::setProxyLogin(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyLogin");
+  this->ck().put_ProxyLogin(value.c_str());
+}
+std::string HybridUpload::getProxyPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridUpload::setProxyPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyPassword");
+  this->ck().put_ProxyPassword(value.c_str());
+}
+double HybridUpload::getProxyPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ProxyPort());
+}
+void HybridUpload::setProxyPort(double value) {
+  this->beginCall();
+  this->ck().put_ProxyPort(rt::toInt(value, "proxyPort"));
+}
+std::string HybridUpload::getResponseHeader() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ResponseHeader(_s);
+  return rt::stdString(_s);
+}
+double HybridUpload::getResponseStatus() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ResponseStatus());
+}
+bool HybridUpload::getSsl() {
+  this->beginCall();
+  return this->ck().get_Ssl();
+}
+void HybridUpload::setSsl(bool value) {
+  this->beginCall();
+  this->ck().put_Ssl(value);
+}
+double HybridUpload::getTotalUploadSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_TotalUploadSize());
+}
+bool HybridUpload::getUploadInProgress() {
+  this->beginCall();
+  return this->ck().get_UploadInProgress();
+}
+bool HybridUpload::getUploadSuccess() {
+  this->beginCall();
+  return this->ck().get_UploadSuccess();
+}
+std::string HybridUpload::getTlsPinSet() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsPinSet(_s);
+  return rt::stdString(_s);
+}
+void HybridUpload::setTlsPinSet(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tlsPinSet");
+  this->ck().put_TlsPinSet(value.c_str());
+}
+std::string HybridUpload::getSslAllowedCiphers() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SslAllowedCiphers(_s);
+  return rt::stdString(_s);
+}
+void HybridUpload::setSslAllowedCiphers(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sslAllowedCiphers");
+  this->ck().put_SslAllowedCiphers(value.c_str());
+}
+std::string HybridUpload::getSslProtocol() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SslProtocol(_s);
+  return rt::stdString(_s);
+}
+void HybridUpload::setSslProtocol(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sslProtocol");
+  this->ck().put_SslProtocol(value.c_str());
+}
+bool HybridUpload::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridUpload::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+std::string HybridUpload::getResponseBodyStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ResponseBodyStr(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUpload::getCurrentFilename() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CurrentFilename(_s);
+  return rt::stdString(_s);
+}
+
+// ---- Methods ----
+
+void HybridUpload::abortUpload() {
+  this->beginCall();
+  abortUpload_impl();
+}
+void HybridUpload::abortUpload_impl() {
+  this->ck().AbortUpload();
+}
+
+void HybridUpload::addCustomHeader(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addCustomHeader_impl(name, value);
+}
+void HybridUpload::addCustomHeader_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  this->ck().AddCustomHeader(name.c_str(), value.c_str());
+}
+
+void HybridUpload::addFileReference(const std::string& name, const std::string& filename) {
+  this->beginCall();
+  addFileReference_impl(name, filename);
+}
+void HybridUpload::addFileReference_impl(const std::string& name, const std::string& filename) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(filename, "filename");
+  this->ck().AddFileReference(name.c_str(), filename.c_str());
+}
+
+void HybridUpload::addParam(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addParam_impl(name, value);
+}
+void HybridUpload::addParam_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  this->ck().AddParam(name.c_str(), value.c_str());
+}
+
+void HybridUpload::beginUpload() {
+  this->beginCall();
+  beginUpload_impl();
+}
+void HybridUpload::beginUpload_impl() {
+  if (!this->ck().BeginUpload()) throw this->fail("beginUpload");
+}
+
+void HybridUpload::blockingUpload() {
+  this->beginCall();
+  blockingUpload_impl();
+}
+void HybridUpload::blockingUpload_impl() {
+  if (!this->ck().BlockingUpload()) throw this->fail("blockingUpload");
+}
+std::shared_ptr<Promise<void>> HybridUpload::blockingUploadAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridUpload>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Upload.blockingUploadAsync", std::move(_parts), [_self]() {
+    _self->blockingUpload_impl();
+  });
+}
+
+void HybridUpload::clearFileReferences() {
+  this->beginCall();
+  clearFileReferences_impl();
+}
+void HybridUpload::clearFileReferences_impl() {
+  this->ck().ClearFileReferences();
+}
+
+void HybridUpload::clearParams() {
+  this->beginCall();
+  clearParams_impl();
+}
+void HybridUpload::clearParams_impl() {
+  this->ck().ClearParams();
+}
+
+void HybridUpload::sleepMs(double millisec) {
+  this->beginCall();
+  sleepMs_impl(millisec);
+}
+void HybridUpload::sleepMs_impl(double millisec) {
+  this->ck().SleepMs(rt::toInt(millisec, "millisec"));
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridUpload::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridUpload::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridUpload::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridUpload::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridUpload::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridUpload.hpp

@@ -0,0 +1,114 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Upload: the Nitro HybridObject over Chilkat's CkUpload (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridUploadSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkUpload.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridUpload final : public HybridUploadSpec, public ChilkatObject<CkUpload> {
+public:
+  HybridUpload();                                  // `new Upload()` from JS
+  explicit HybridUpload(CkUpload* 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 getBandwidthThrottleUp() override;
+  void setBandwidthThrottleUp(double value) override;
+  double getChunkSize() override;
+  void setChunkSize(double value) override;
+  std::string getClientIpAddress() override;
+  void setClientIpAddress(const std::string& value) override;
+  bool getExpect100Continue() override;
+  void setExpect100Continue(bool value) override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+  std::string getHostname() override;
+  void setHostname(const std::string& value) override;
+  double getIdleTimeoutMs() override;
+  void setIdleTimeoutMs(double value) override;
+  std::string getLogin() override;
+  void setLogin(const std::string& value) override;
+  double getNumBytesSent() override;
+  std::string getPassword() override;
+  void setPassword(const std::string& value) override;
+  std::string getPath() override;
+  void setPath(const std::string& value) override;
+  double getPercentDoneScale() override;
+  void setPercentDoneScale(double value) override;
+  double getPercentUploaded() override;
+  double getPort() override;
+  void setPort(double value) override;
+  bool getPreferIpv6() override;
+  void setPreferIpv6(bool value) override;
+  std::string getProxyDomain() override;
+  void setProxyDomain(const std::string& value) override;
+  std::string getProxyLogin() override;
+  void setProxyLogin(const std::string& value) override;
+  std::string getProxyPassword() override;
+  void setProxyPassword(const std::string& value) override;
+  double getProxyPort() override;
+  void setProxyPort(double value) override;
+  std::string getResponseHeader() override;
+  double getResponseStatus() override;
+  bool getSsl() override;
+  void setSsl(bool value) override;
+  double getTotalUploadSize() override;
+  bool getUploadInProgress() override;
+  bool getUploadSuccess() override;
+  std::string getTlsPinSet() override;
+  void setTlsPinSet(const std::string& value) override;
+  std::string getSslAllowedCiphers() override;
+  void setSslAllowedCiphers(const std::string& value) override;
+  std::string getSslProtocol() override;
+  void setSslProtocol(const std::string& value) override;
+  bool getAbortCurrent() override;
+  void setAbortCurrent(bool value) override;
+  std::string getResponseBodyStr() override;
+  std::string getCurrentFilename() override;
+
+  // ---- Methods ----
+  void abortUpload() override;
+  void addCustomHeader(const std::string& name, const std::string& value) override;
+  void addFileReference(const std::string& name, const std::string& filename) override;
+  void addParam(const std::string& name, const std::string& value) override;
+  void beginUpload() override;
+  void blockingUpload() override;
+  std::shared_ptr<Promise<void>> blockingUploadAsync() override;
+  void clearFileReferences() override;
+  void clearParams() override;
+  void sleepMs(double millisec) override;
+
+  // ---- Events (ReactNativeGen_DESIGN.md §6) ----
+  std::optional<std::function<void(double)>> getOnPercentDone() override;
+  void setOnPercentDone(const std::optional<std::function<void(double)>>& cb) override;
+  std::optional<std::function<void(const std::string&, const std::string&)>> getOnProgressInfo() override;
+  void setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) override;
+  void abort() override;
+
+private:
+  void init();
+  void abortUpload_impl();
+  void addCustomHeader_impl(const std::string& name, const std::string& value);
+  void addFileReference_impl(const std::string& name, const std::string& filename);
+  void addParam_impl(const std::string& name, const std::string& value);
+  void beginUpload_impl();
+  void blockingUpload_impl();
+  void clearFileReferences_impl();
+  void clearParams_impl();
+  void sleepMs_impl(double millisec);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridUrl.cpp

@@ -0,0 +1,152 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridUrl.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridUrl::HybridUrl()
+    : HybridObject(HybridUrlSpec::TAG), ChilkatObject<CkUrl>("Url", CkUrl::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridUrl::HybridUrl(CkUrl* owned)
+    : HybridObject(HybridUrlSpec::TAG), ChilkatObject<CkUrl>("Url", owned) {
+  init();
+}
+
+void HybridUrl::init() {
+}
+
+void HybridUrl::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridUrl::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUrl::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUrl::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUrl::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUrl::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridUrl::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridUrl::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridUrl::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridUrl::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridUrl::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridUrl::getFrag() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Frag(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUrl::getHost() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Host(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUrl::getHostType() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HostType(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUrl::getLogin() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Login(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUrl::getPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Password(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUrl::getPath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Path(_s);
+  return rt::stdString(_s);
+}
+double HybridUrl::getPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Port());
+}
+std::string HybridUrl::getQuery() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Query(_s);
+  return rt::stdString(_s);
+}
+bool HybridUrl::getSsl() {
+  this->beginCall();
+  return this->ck().get_Ssl();
+}
+std::string HybridUrl::getPathWithQueryParams() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_PathWithQueryParams(_s);
+  return rt::stdString(_s);
+}
+std::string HybridUrl::getScheme() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Scheme(_s);
+  return rt::stdString(_s);
+}
+
+// ---- Methods ----
+
+void HybridUrl::parseUrl(const std::string& url) {
+  this->beginCall();
+  parseUrl_impl(url);
+}
+void HybridUrl::parseUrl_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  if (!this->ck().ParseUrl(url.c_str())) throw this->fail("parseUrl");
+}
+
+} // namespace margelo::nitro::chilkat