@chilkat/react-native 11.6.1

package/cpp/HybridUrl.hpp

@@ -0,0 +1,48 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Url: the Nitro HybridObject over Chilkat's CkUrl (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridUrlSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkUrl.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridUrl final : public HybridUrlSpec, public ChilkatObject<CkUrl> {
+public:
+  HybridUrl();                                  // `new Url()` from JS
+  explicit HybridUrl(CkUrl* 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 getFrag() override;
+  std::string getHost() override;
+  std::string getHostType() override;
+  std::string getLogin() override;
+  std::string getPassword() override;
+  std::string getPath() override;
+  double getPort() override;
+  std::string getQuery() override;
+  bool getSsl() override;
+  std::string getPathWithQueryParams() override;
+  std::string getScheme() override;
+
+  // ---- Methods ----
+  void parseUrl(const std::string& url) override;
+
+private:
+  void init();
+  void parseUrl_impl(const std::string& url);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridWebSocket.cpp

@@ -0,0 +1,378 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridWebSocket.hpp"
+#include "HybridBinData.hpp"
+#include "HybridRest.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridWebSocket::HybridWebSocket()
+    : HybridObject(HybridWebSocketSpec::TAG), ChilkatObject<CkWebSocket>("WebSocket", CkWebSocket::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridWebSocket::HybridWebSocket(CkWebSocket* owned)
+    : HybridObject(HybridWebSocketSpec::TAG), ChilkatObject<CkWebSocket>("WebSocket", owned) {
+  init();
+}
+
+void HybridWebSocket::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridWebSocket::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridWebSocket::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridWebSocket::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridWebSocket::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridWebSocket::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridWebSocket::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridWebSocket::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridWebSocket::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridWebSocket::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridWebSocket::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridWebSocket::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridWebSocket::getIdleTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_IdleTimeoutMs());
+}
+void HybridWebSocket::setIdleTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_IdleTimeoutMs(rt::toInt(value, "idleTimeoutMs"));
+}
+std::string HybridWebSocket::getFrameOpcode() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FrameOpcode(_s);
+  return rt::stdString(_s);
+}
+double HybridWebSocket::getFrameDataLen() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_FrameDataLen());
+}
+bool HybridWebSocket::getFinalFrame() {
+  this->beginCall();
+  return this->ck().get_FinalFrame();
+}
+bool HybridWebSocket::getIsConnected() {
+  this->beginCall();
+  return this->ck().get_IsConnected();
+}
+bool HybridWebSocket::getCloseAutoRespond() {
+  this->beginCall();
+  return this->ck().get_CloseAutoRespond();
+}
+void HybridWebSocket::setCloseAutoRespond(bool value) {
+  this->beginCall();
+  this->ck().put_CloseAutoRespond(value);
+}
+bool HybridWebSocket::getPingAutoRespond() {
+  this->beginCall();
+  return this->ck().get_PingAutoRespond();
+}
+void HybridWebSocket::setPingAutoRespond(bool value) {
+  this->beginCall();
+  this->ck().put_PingAutoRespond(value);
+}
+bool HybridWebSocket::getNeedSendPong() {
+  this->beginCall();
+  return this->ck().get_NeedSendPong();
+}
+bool HybridWebSocket::getCloseReceived() {
+  this->beginCall();
+  return this->ck().get_CloseReceived();
+}
+double HybridWebSocket::getCloseStatusCode() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_CloseStatusCode());
+}
+std::string HybridWebSocket::getCloseReason() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CloseReason(_s);
+  return rt::stdString(_s);
+}
+bool HybridWebSocket::getPongAutoConsume() {
+  this->beginCall();
+  return this->ck().get_PongAutoConsume();
+}
+void HybridWebSocket::setPongAutoConsume(bool value) {
+  this->beginCall();
+  this->ck().put_PongAutoConsume(value);
+}
+bool HybridWebSocket::getPongConsumed() {
+  this->beginCall();
+  return this->ck().get_PongConsumed();
+}
+double HybridWebSocket::getReadFrameFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ReadFrameFailReason());
+}
+double HybridWebSocket::getFrameOpcodeInt() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_FrameOpcodeInt());
+}
+std::string HybridWebSocket::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+double HybridWebSocket::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridWebSocket::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+
+// ---- Methods ----
+
+void HybridWebSocket::useConnection(const std::shared_ptr<HybridRestSpec>& connection) {
+  this->beginCall();
+  useConnection_impl(connection);
+}
+void HybridWebSocket::useConnection_impl(const std::shared_ptr<HybridRestSpec>& connection) {
+  if (!this->ck().UseConnection(rt::implOf<HybridRest>(connection, "connection").ck())) throw this->fail("useConnection");
+}
+
+void HybridWebSocket::addClientHeaders() {
+  this->beginCall();
+  addClientHeaders_impl();
+}
+void HybridWebSocket::addClientHeaders_impl() {
+  if (!this->ck().AddClientHeaders()) throw this->fail("addClientHeaders");
+}
+
+void HybridWebSocket::validateServerHandshake() {
+  this->beginCall();
+  validateServerHandshake_impl();
+}
+void HybridWebSocket::validateServerHandshake_impl() {
+  if (!this->ck().ValidateServerHandshake()) throw this->fail("validateServerHandshake");
+}
+
+void HybridWebSocket::sendFrame(const std::string& stringToSend, bool finalFrame) {
+  this->beginCall();
+  sendFrame_impl(stringToSend, finalFrame);
+}
+void HybridWebSocket::sendFrame_impl(const std::string& stringToSend, bool finalFrame) {
+  rt::checkNoNul(stringToSend, "stringToSend");
+  if (!this->ck().SendFrame(stringToSend.c_str(), finalFrame)) throw this->fail("sendFrame");
+}
+std::shared_ptr<Promise<void>> HybridWebSocket::sendFrameAsync(const std::string& stringToSend, bool finalFrame) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridWebSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("WebSocket.sendFrameAsync", std::move(_parts), [_self, stringToSend, finalFrame]() {
+    _self->sendFrame_impl(stringToSend, finalFrame);
+  });
+}
+
+void HybridWebSocket::readFrame() {
+  this->beginCall();
+  readFrame_impl();
+}
+void HybridWebSocket::readFrame_impl() {
+  if (!this->ck().ReadFrame()) throw this->fail("readFrame");
+}
+std::shared_ptr<Promise<void>> HybridWebSocket::readFrameAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridWebSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("WebSocket.readFrameAsync", std::move(_parts), [_self]() {
+    _self->readFrame_impl();
+  });
+}
+
+std::string HybridWebSocket::getFrameData() {
+  this->beginCall();
+  return getFrameData_impl();
+}
+std::string HybridWebSocket::getFrameData_impl() {
+  CkString _out;
+  if (!this->ck().GetFrameData(_out)) throw this->fail("getFrameData");
+  return rt::stdString(_out);
+}
+
+void HybridWebSocket::getFrameDataBd(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  getFrameDataBd_impl(binData);
+}
+void HybridWebSocket::getFrameDataBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().GetFrameDataBd(rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("getFrameDataBd");
+}
+
+void HybridWebSocket::getFrameDataSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  getFrameDataSb_impl(sb);
+}
+void HybridWebSocket::getFrameDataSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().GetFrameDataSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("getFrameDataSb");
+}
+
+void HybridWebSocket::sendFrameSb(const std::shared_ptr<HybridStringBuilderSpec>& sbToSend, bool finalFrame) {
+  this->beginCall();
+  sendFrameSb_impl(sbToSend, finalFrame);
+}
+void HybridWebSocket::sendFrameSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbToSend, bool finalFrame) {
+  if (!this->ck().SendFrameSb(rt::implOf<HybridStringBuilder>(sbToSend, "sbToSend").ck(), finalFrame)) throw this->fail("sendFrameSb");
+}
+std::shared_ptr<Promise<void>> HybridWebSocket::sendFrameSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sbToSend, bool finalFrame) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridWebSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sbToSend);
+  return rt::runAsync<void>("WebSocket.sendFrameSbAsync", std::move(_parts), [_self, sbToSend, finalFrame]() {
+    _self->sendFrameSb_impl(sbToSend, finalFrame);
+  });
+}
+
+void HybridWebSocket::sendFrameBd(const std::shared_ptr<HybridBinDataSpec>& bdToSend, bool finalFrame) {
+  this->beginCall();
+  sendFrameBd_impl(bdToSend, finalFrame);
+}
+void HybridWebSocket::sendFrameBd_impl(const std::shared_ptr<HybridBinDataSpec>& bdToSend, bool finalFrame) {
+  if (!this->ck().SendFrameBd(rt::implOf<HybridBinData>(bdToSend, "bdToSend").ck(), finalFrame)) throw this->fail("sendFrameBd");
+}
+std::shared_ptr<Promise<void>> HybridWebSocket::sendFrameBdAsync(const std::shared_ptr<HybridBinDataSpec>& bdToSend, bool finalFrame) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridWebSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bdToSend);
+  return rt::runAsync<void>("WebSocket.sendFrameBdAsync", std::move(_parts), [_self, bdToSend, finalFrame]() {
+    _self->sendFrameBd_impl(bdToSend, finalFrame);
+  });
+}
+
+bool HybridWebSocket::pollDataAvailable() {
+  this->beginCall();
+  return pollDataAvailable_impl();
+}
+bool HybridWebSocket::pollDataAvailable_impl() {
+  return this->ck().PollDataAvailable();
+}
+
+void HybridWebSocket::sendPing(const std::string& pingData) {
+  this->beginCall();
+  sendPing_impl(pingData);
+}
+void HybridWebSocket::sendPing_impl(const std::string& pingData) {
+  rt::checkNoNul(pingData, "pingData");
+  if (!this->ck().SendPing(pingData.c_str())) throw this->fail("sendPing");
+}
+std::shared_ptr<Promise<void>> HybridWebSocket::sendPingAsync(const std::string& pingData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridWebSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("WebSocket.sendPingAsync", std::move(_parts), [_self, pingData]() {
+    _self->sendPing_impl(pingData);
+  });
+}
+
+void HybridWebSocket::sendPong() {
+  this->beginCall();
+  sendPong_impl();
+}
+void HybridWebSocket::sendPong_impl() {
+  if (!this->ck().SendPong()) throw this->fail("sendPong");
+}
+std::shared_ptr<Promise<void>> HybridWebSocket::sendPongAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridWebSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("WebSocket.sendPongAsync", std::move(_parts), [_self]() {
+    _self->sendPong_impl();
+  });
+}
+
+void HybridWebSocket::sendClose(bool includeStatus, double statusCode, const std::string& reason) {
+  this->beginCall();
+  sendClose_impl(includeStatus, statusCode, reason);
+}
+void HybridWebSocket::sendClose_impl(bool includeStatus, double statusCode, const std::string& reason) {
+  rt::checkNoNul(reason, "reason");
+  if (!this->ck().SendClose(includeStatus, rt::toInt(statusCode, "statusCode"), reason.c_str())) throw this->fail("sendClose");
+}
+std::shared_ptr<Promise<void>> HybridWebSocket::sendCloseAsync(bool includeStatus, double statusCode, const std::string& reason) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridWebSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("WebSocket.sendCloseAsync", std::move(_parts), [_self, includeStatus, statusCode, reason]() {
+    _self->sendClose_impl(includeStatus, statusCode, reason);
+  });
+}
+
+void HybridWebSocket::closeConnection() {
+  this->beginCall();
+  closeConnection_impl();
+}
+void HybridWebSocket::closeConnection_impl() {
+  if (!this->ck().CloseConnection()) throw this->fail("closeConnection");
+}
+
+void HybridWebSocket::shareConnection(const std::shared_ptr<HybridWebSocketSpec>& ws) {
+  this->beginCall();
+  shareConnection_impl(ws);
+}
+void HybridWebSocket::shareConnection_impl(const std::shared_ptr<HybridWebSocketSpec>& ws) {
+  if (!this->ck().ShareConnection(rt::implOf<HybridWebSocket>(ws, "ws").ck())) throw this->fail("shareConnection");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridWebSocket::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridWebSocket::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridWebSocket::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridWebSocket::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridWebSocket::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridWebSocket.hpp

@@ -0,0 +1,103 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// WebSocket: the Nitro HybridObject over Chilkat's CkWebSocket (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridWebSocketSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkWebSocket.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridWebSocket final : public HybridWebSocketSpec, public ChilkatObject<CkWebSocket> {
+public:
+  HybridWebSocket();                                  // `new WebSocket()` from JS
+  explicit HybridWebSocket(CkWebSocket* 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 getIdleTimeoutMs() override;
+  void setIdleTimeoutMs(double value) override;
+  std::string getFrameOpcode() override;
+  double getFrameDataLen() override;
+  bool getFinalFrame() override;
+  bool getIsConnected() override;
+  bool getCloseAutoRespond() override;
+  void setCloseAutoRespond(bool value) override;
+  bool getPingAutoRespond() override;
+  void setPingAutoRespond(bool value) override;
+  bool getNeedSendPong() override;
+  bool getCloseReceived() override;
+  double getCloseStatusCode() override;
+  std::string getCloseReason() override;
+  bool getPongAutoConsume() override;
+  void setPongAutoConsume(bool value) override;
+  bool getPongConsumed() override;
+  double getReadFrameFailReason() override;
+  double getFrameOpcodeInt() override;
+  std::string getUncommonOptions() override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+
+  // ---- Methods ----
+  void useConnection(const std::shared_ptr<HybridRestSpec>& connection) override;
+  void addClientHeaders() override;
+  void validateServerHandshake() override;
+  void sendFrame(const std::string& stringToSend, bool finalFrame) override;
+  std::shared_ptr<Promise<void>> sendFrameAsync(const std::string& stringToSend, bool finalFrame) override;
+  void readFrame() override;
+  std::shared_ptr<Promise<void>> readFrameAsync() override;
+  std::string getFrameData() override;
+  void getFrameDataBd(const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  void getFrameDataSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void sendFrameSb(const std::shared_ptr<HybridStringBuilderSpec>& sbToSend, bool finalFrame) override;
+  std::shared_ptr<Promise<void>> sendFrameSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sbToSend, bool finalFrame) override;
+  void sendFrameBd(const std::shared_ptr<HybridBinDataSpec>& bdToSend, bool finalFrame) override;
+  std::shared_ptr<Promise<void>> sendFrameBdAsync(const std::shared_ptr<HybridBinDataSpec>& bdToSend, bool finalFrame) override;
+  bool pollDataAvailable() override;
+  void sendPing(const std::string& pingData) override;
+  std::shared_ptr<Promise<void>> sendPingAsync(const std::string& pingData) override;
+  void sendPong() override;
+  std::shared_ptr<Promise<void>> sendPongAsync() override;
+  void sendClose(bool includeStatus, double statusCode, const std::string& reason) override;
+  std::shared_ptr<Promise<void>> sendCloseAsync(bool includeStatus, double statusCode, const std::string& reason) override;
+  void closeConnection() override;
+  void shareConnection(const std::shared_ptr<HybridWebSocketSpec>& ws) 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 useConnection_impl(const std::shared_ptr<HybridRestSpec>& connection);
+  void addClientHeaders_impl();
+  void validateServerHandshake_impl();
+  void sendFrame_impl(const std::string& stringToSend, bool finalFrame);
+  void readFrame_impl();
+  std::string getFrameData_impl();
+  void getFrameDataBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData);
+  void getFrameDataSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void sendFrameSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbToSend, bool finalFrame);
+  void sendFrameBd_impl(const std::shared_ptr<HybridBinDataSpec>& bdToSend, bool finalFrame);
+  bool pollDataAvailable_impl();
+  void sendPing_impl(const std::string& pingData);
+  void sendPong_impl();
+  void sendClose_impl(bool includeStatus, double statusCode, const std::string& reason);
+  void closeConnection_impl();
+  void shareConnection_impl(const std::shared_ptr<HybridWebSocketSpec>& ws);
+};
+
+} // namespace margelo::nitro::chilkat