@chilkat/react-native 11.6.1

package/nitrogen/generated/shared/c++/HybridSocketSpec.cpp

@@ -0,0 +1,262 @@
+///
+/// HybridSocketSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridSocketSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridSocketSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridSocketSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridSocketSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridSocketSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridSocketSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridSocketSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridSocketSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridSocketSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridSocketSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridSocketSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridSocketSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("abortCurrent", &HybridSocketSpec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridSocketSpec::setAbortCurrent);
+      prototype.registerHybridGetter("acceptFailReason", &HybridSocketSpec::getAcceptFailReason);
+      prototype.registerHybridGetter("bandwidthThrottleDown", &HybridSocketSpec::getBandwidthThrottleDown);
+      prototype.registerHybridSetter("bandwidthThrottleDown", &HybridSocketSpec::setBandwidthThrottleDown);
+      prototype.registerHybridGetter("bandwidthThrottleUp", &HybridSocketSpec::getBandwidthThrottleUp);
+      prototype.registerHybridSetter("bandwidthThrottleUp", &HybridSocketSpec::setBandwidthThrottleUp);
+      prototype.registerHybridGetter("bigEndian", &HybridSocketSpec::getBigEndian);
+      prototype.registerHybridSetter("bigEndian", &HybridSocketSpec::setBigEndian);
+      prototype.registerHybridGetter("clientIpAddress", &HybridSocketSpec::getClientIpAddress);
+      prototype.registerHybridSetter("clientIpAddress", &HybridSocketSpec::setClientIpAddress);
+      prototype.registerHybridGetter("clientPort", &HybridSocketSpec::getClientPort);
+      prototype.registerHybridSetter("clientPort", &HybridSocketSpec::setClientPort);
+      prototype.registerHybridGetter("connectFailReason", &HybridSocketSpec::getConnectFailReason);
+      prototype.registerHybridGetter("elapsedSeconds", &HybridSocketSpec::getElapsedSeconds);
+      prototype.registerHybridGetter("heartbeatMs", &HybridSocketSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridSocketSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("httpProxyAuthMethod", &HybridSocketSpec::getHttpProxyAuthMethod);
+      prototype.registerHybridSetter("httpProxyAuthMethod", &HybridSocketSpec::setHttpProxyAuthMethod);
+      prototype.registerHybridGetter("httpProxyDomain", &HybridSocketSpec::getHttpProxyDomain);
+      prototype.registerHybridSetter("httpProxyDomain", &HybridSocketSpec::setHttpProxyDomain);
+      prototype.registerHybridGetter("httpProxyHostname", &HybridSocketSpec::getHttpProxyHostname);
+      prototype.registerHybridSetter("httpProxyHostname", &HybridSocketSpec::setHttpProxyHostname);
+      prototype.registerHybridGetter("httpProxyPassword", &HybridSocketSpec::getHttpProxyPassword);
+      prototype.registerHybridSetter("httpProxyPassword", &HybridSocketSpec::setHttpProxyPassword);
+      prototype.registerHybridGetter("httpProxyPort", &HybridSocketSpec::getHttpProxyPort);
+      prototype.registerHybridSetter("httpProxyPort", &HybridSocketSpec::setHttpProxyPort);
+      prototype.registerHybridGetter("httpProxyUsername", &HybridSocketSpec::getHttpProxyUsername);
+      prototype.registerHybridSetter("httpProxyUsername", &HybridSocketSpec::setHttpProxyUsername);
+      prototype.registerHybridGetter("isConnected", &HybridSocketSpec::getIsConnected);
+      prototype.registerHybridGetter("keepAlive", &HybridSocketSpec::getKeepAlive);
+      prototype.registerHybridSetter("keepAlive", &HybridSocketSpec::setKeepAlive);
+      prototype.registerHybridGetter("keepSessionLog", &HybridSocketSpec::getKeepSessionLog);
+      prototype.registerHybridSetter("keepSessionLog", &HybridSocketSpec::setKeepSessionLog);
+      prototype.registerHybridGetter("lastMethodFailed", &HybridSocketSpec::getLastMethodFailed);
+      prototype.registerHybridGetter("localIpAddress", &HybridSocketSpec::getLocalIpAddress);
+      prototype.registerHybridGetter("localPort", &HybridSocketSpec::getLocalPort);
+      prototype.registerHybridGetter("maxReadIdleMs", &HybridSocketSpec::getMaxReadIdleMs);
+      prototype.registerHybridSetter("maxReadIdleMs", &HybridSocketSpec::setMaxReadIdleMs);
+      prototype.registerHybridGetter("maxSendIdleMs", &HybridSocketSpec::getMaxSendIdleMs);
+      prototype.registerHybridSetter("maxSendIdleMs", &HybridSocketSpec::setMaxSendIdleMs);
+      prototype.registerHybridGetter("myIpAddress", &HybridSocketSpec::getMyIpAddress);
+      prototype.registerHybridGetter("numReceivedClientCerts", &HybridSocketSpec::getNumReceivedClientCerts);
+      prototype.registerHybridGetter("numSocketsInSet", &HybridSocketSpec::getNumSocketsInSet);
+      prototype.registerHybridGetter("numSslAcceptableClientCAs", &HybridSocketSpec::getNumSslAcceptableClientCAs);
+      prototype.registerHybridGetter("objectId", &HybridSocketSpec::getObjectId);
+      prototype.registerHybridGetter("percentDoneScale", &HybridSocketSpec::getPercentDoneScale);
+      prototype.registerHybridSetter("percentDoneScale", &HybridSocketSpec::setPercentDoneScale);
+      prototype.registerHybridGetter("preferIpv6", &HybridSocketSpec::getPreferIpv6);
+      prototype.registerHybridSetter("preferIpv6", &HybridSocketSpec::setPreferIpv6);
+      prototype.registerHybridGetter("receiveFailReason", &HybridSocketSpec::getReceiveFailReason);
+      prototype.registerHybridGetter("receivePacketSize", &HybridSocketSpec::getReceivePacketSize);
+      prototype.registerHybridSetter("receivePacketSize", &HybridSocketSpec::setReceivePacketSize);
+      prototype.registerHybridGetter("receivedCount", &HybridSocketSpec::getReceivedCount);
+      prototype.registerHybridSetter("receivedCount", &HybridSocketSpec::setReceivedCount);
+      prototype.registerHybridGetter("receivedInt", &HybridSocketSpec::getReceivedInt);
+      prototype.registerHybridSetter("receivedInt", &HybridSocketSpec::setReceivedInt);
+      prototype.registerHybridGetter("remoteIpAddress", &HybridSocketSpec::getRemoteIpAddress);
+      prototype.registerHybridGetter("remotePort", &HybridSocketSpec::getRemotePort);
+      prototype.registerHybridGetter("requireSslCertVerify", &HybridSocketSpec::getRequireSslCertVerify);
+      prototype.registerHybridSetter("requireSslCertVerify", &HybridSocketSpec::setRequireSslCertVerify);
+      prototype.registerHybridGetter("selectorIndex", &HybridSocketSpec::getSelectorIndex);
+      prototype.registerHybridSetter("selectorIndex", &HybridSocketSpec::setSelectorIndex);
+      prototype.registerHybridGetter("selectorReadIndex", &HybridSocketSpec::getSelectorReadIndex);
+      prototype.registerHybridSetter("selectorReadIndex", &HybridSocketSpec::setSelectorReadIndex);
+      prototype.registerHybridGetter("selectorWriteIndex", &HybridSocketSpec::getSelectorWriteIndex);
+      prototype.registerHybridSetter("selectorWriteIndex", &HybridSocketSpec::setSelectorWriteIndex);
+      prototype.registerHybridGetter("sendFailReason", &HybridSocketSpec::getSendFailReason);
+      prototype.registerHybridGetter("sendPacketSize", &HybridSocketSpec::getSendPacketSize);
+      prototype.registerHybridSetter("sendPacketSize", &HybridSocketSpec::setSendPacketSize);
+      prototype.registerHybridGetter("sessionLog", &HybridSocketSpec::getSessionLog);
+      prototype.registerHybridGetter("sessionLogEncoding", &HybridSocketSpec::getSessionLogEncoding);
+      prototype.registerHybridSetter("sessionLogEncoding", &HybridSocketSpec::setSessionLogEncoding);
+      prototype.registerHybridGetter("soRcvBuf", &HybridSocketSpec::getSoRcvBuf);
+      prototype.registerHybridSetter("soRcvBuf", &HybridSocketSpec::setSoRcvBuf);
+      prototype.registerHybridGetter("soReuseAddr", &HybridSocketSpec::getSoReuseAddr);
+      prototype.registerHybridSetter("soReuseAddr", &HybridSocketSpec::setSoReuseAddr);
+      prototype.registerHybridGetter("soSndBuf", &HybridSocketSpec::getSoSndBuf);
+      prototype.registerHybridSetter("soSndBuf", &HybridSocketSpec::setSoSndBuf);
+      prototype.registerHybridGetter("socksHostname", &HybridSocketSpec::getSocksHostname);
+      prototype.registerHybridSetter("socksHostname", &HybridSocketSpec::setSocksHostname);
+      prototype.registerHybridGetter("socksPassword", &HybridSocketSpec::getSocksPassword);
+      prototype.registerHybridSetter("socksPassword", &HybridSocketSpec::setSocksPassword);
+      prototype.registerHybridGetter("socksPort", &HybridSocketSpec::getSocksPort);
+      prototype.registerHybridSetter("socksPort", &HybridSocketSpec::setSocksPort);
+      prototype.registerHybridGetter("socksUsername", &HybridSocketSpec::getSocksUsername);
+      prototype.registerHybridSetter("socksUsername", &HybridSocketSpec::setSocksUsername);
+      prototype.registerHybridGetter("socksVersion", &HybridSocketSpec::getSocksVersion);
+      prototype.registerHybridSetter("socksVersion", &HybridSocketSpec::setSocksVersion);
+      prototype.registerHybridGetter("ssl", &HybridSocketSpec::getSsl);
+      prototype.registerHybridSetter("ssl", &HybridSocketSpec::setSsl);
+      prototype.registerHybridGetter("sslAllowedCiphers", &HybridSocketSpec::getSslAllowedCiphers);
+      prototype.registerHybridSetter("sslAllowedCiphers", &HybridSocketSpec::setSslAllowedCiphers);
+      prototype.registerHybridGetter("sslProtocol", &HybridSocketSpec::getSslProtocol);
+      prototype.registerHybridSetter("sslProtocol", &HybridSocketSpec::setSslProtocol);
+      prototype.registerHybridGetter("stringCharset", &HybridSocketSpec::getStringCharset);
+      prototype.registerHybridSetter("stringCharset", &HybridSocketSpec::setStringCharset);
+      prototype.registerHybridGetter("tcpNoDelay", &HybridSocketSpec::getTcpNoDelay);
+      prototype.registerHybridSetter("tcpNoDelay", &HybridSocketSpec::setTcpNoDelay);
+      prototype.registerHybridGetter("tlsCipherSuite", &HybridSocketSpec::getTlsCipherSuite);
+      prototype.registerHybridGetter("tlsPinSet", &HybridSocketSpec::getTlsPinSet);
+      prototype.registerHybridSetter("tlsPinSet", &HybridSocketSpec::setTlsPinSet);
+      prototype.registerHybridGetter("tlsVersion", &HybridSocketSpec::getTlsVersion);
+      prototype.registerHybridGetter("userData", &HybridSocketSpec::getUserData);
+      prototype.registerHybridSetter("userData", &HybridSocketSpec::setUserData);
+      prototype.registerHybridGetter("listenPort", &HybridSocketSpec::getListenPort);
+      prototype.registerHybridGetter("httpProxyForHttp", &HybridSocketSpec::getHttpProxyForHttp);
+      prototype.registerHybridSetter("httpProxyForHttp", &HybridSocketSpec::setHttpProxyForHttp);
+      prototype.registerHybridGetter("rcvBytesPerSec", &HybridSocketSpec::getRcvBytesPerSec);
+      prototype.registerHybridGetter("sendBytesPerSec", &HybridSocketSpec::getSendBytesPerSec);
+      prototype.registerHybridGetter("uncommonOptions", &HybridSocketSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridSocketSpec::setUncommonOptions);
+      prototype.registerHybridGetter("alpnProtocol", &HybridSocketSpec::getAlpnProtocol);
+      prototype.registerHybridSetter("alpnProtocol", &HybridSocketSpec::setAlpnProtocol);
+      prototype.registerHybridGetter("sniHostname", &HybridSocketSpec::getSniHostname);
+      prototype.registerHybridSetter("sniHostname", &HybridSocketSpec::setSniHostname);
+      prototype.registerHybridGetter("numBytesAvailable", &HybridSocketSpec::getNumBytesAvailable);
+      prototype.registerHybridGetter("onPercentDone", &HybridSocketSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridSocketSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridSocketSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridSocketSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("addSslAcceptableClientCaDn", &HybridSocketSpec::addSslAcceptableClientCaDn);
+      prototype.registerHybridMethod("bindAndListen", &HybridSocketSpec::bindAndListen);
+      prototype.registerHybridMethod("bindAndListenAsync", &HybridSocketSpec::bindAndListenAsync);
+      prototype.registerHybridMethod("buildHttpGetRequest", &HybridSocketSpec::buildHttpGetRequest);
+      prototype.registerHybridMethod("checkWriteable", &HybridSocketSpec::checkWriteable);
+      prototype.registerHybridMethod("checkWriteableAsync", &HybridSocketSpec::checkWriteableAsync);
+      prototype.registerHybridMethod("clearSessionLog", &HybridSocketSpec::clearSessionLog);
+      prototype.registerHybridMethod("close", &HybridSocketSpec::close);
+      prototype.registerHybridMethod("closeAsync", &HybridSocketSpec::closeAsync);
+      prototype.registerHybridMethod("connect", &HybridSocketSpec::connect);
+      prototype.registerHybridMethod("connectAsync", &HybridSocketSpec::connectAsync);
+      prototype.registerHybridMethod("convertFromSsl", &HybridSocketSpec::convertFromSsl);
+      prototype.registerHybridMethod("convertFromSslAsync", &HybridSocketSpec::convertFromSslAsync);
+      prototype.registerHybridMethod("convertToSsl", &HybridSocketSpec::convertToSsl);
+      prototype.registerHybridMethod("convertToSslAsync", &HybridSocketSpec::convertToSslAsync);
+      prototype.registerHybridMethod("dnsCacheClear", &HybridSocketSpec::dnsCacheClear);
+      prototype.registerHybridMethod("dnsLookup", &HybridSocketSpec::dnsLookup);
+      prototype.registerHybridMethod("dnsLookupAsync", &HybridSocketSpec::dnsLookupAsync);
+      prototype.registerHybridMethod("getSslAcceptableClientCaDn", &HybridSocketSpec::getSslAcceptableClientCaDn);
+      prototype.registerHybridMethod("initSslServer", &HybridSocketSpec::initSslServer);
+      prototype.registerHybridMethod("pollDataAvailable", &HybridSocketSpec::pollDataAvailable);
+      prototype.registerHybridMethod("pollDataAvailableAsync", &HybridSocketSpec::pollDataAvailableAsync);
+      prototype.registerHybridMethod("receiveByte", &HybridSocketSpec::receiveByte);
+      prototype.registerHybridMethod("receiveByteAsync", &HybridSocketSpec::receiveByteAsync);
+      prototype.registerHybridMethod("receiveBytesENC", &HybridSocketSpec::receiveBytesENC);
+      prototype.registerHybridMethod("receiveBytesENCAsync", &HybridSocketSpec::receiveBytesENCAsync);
+      prototype.registerHybridMethod("receiveBytesToFile", &HybridSocketSpec::receiveBytesToFile);
+      prototype.registerHybridMethod("receiveBytesToFileAsync", &HybridSocketSpec::receiveBytesToFileAsync);
+      prototype.registerHybridMethod("receiveCount", &HybridSocketSpec::receiveCount);
+      prototype.registerHybridMethod("receiveCountAsync", &HybridSocketSpec::receiveCountAsync);
+      prototype.registerHybridMethod("receiveInt16", &HybridSocketSpec::receiveInt16);
+      prototype.registerHybridMethod("receiveInt16Async", &HybridSocketSpec::receiveInt16Async);
+      prototype.registerHybridMethod("receiveInt32", &HybridSocketSpec::receiveInt32);
+      prototype.registerHybridMethod("receiveInt32Async", &HybridSocketSpec::receiveInt32Async);
+      prototype.registerHybridMethod("receiveNBytesENC", &HybridSocketSpec::receiveNBytesENC);
+      prototype.registerHybridMethod("receiveNBytesENCAsync", &HybridSocketSpec::receiveNBytesENCAsync);
+      prototype.registerHybridMethod("receiveString", &HybridSocketSpec::receiveString);
+      prototype.registerHybridMethod("receiveStringAsync", &HybridSocketSpec::receiveStringAsync);
+      prototype.registerHybridMethod("receiveStringMaxN", &HybridSocketSpec::receiveStringMaxN);
+      prototype.registerHybridMethod("receiveStringMaxNAsync", &HybridSocketSpec::receiveStringMaxNAsync);
+      prototype.registerHybridMethod("receiveStringUntilByte", &HybridSocketSpec::receiveStringUntilByte);
+      prototype.registerHybridMethod("receiveStringUntilByteAsync", &HybridSocketSpec::receiveStringUntilByteAsync);
+      prototype.registerHybridMethod("receiveToCRLF", &HybridSocketSpec::receiveToCRLF);
+      prototype.registerHybridMethod("receiveToCRLFAsync", &HybridSocketSpec::receiveToCRLFAsync);
+      prototype.registerHybridMethod("receiveUntilMatch", &HybridSocketSpec::receiveUntilMatch);
+      prototype.registerHybridMethod("receiveUntilMatchAsync", &HybridSocketSpec::receiveUntilMatchAsync);
+      prototype.registerHybridMethod("selectForReading", &HybridSocketSpec::selectForReading);
+      prototype.registerHybridMethod("selectForReadingAsync", &HybridSocketSpec::selectForReadingAsync);
+      prototype.registerHybridMethod("selectForWriting", &HybridSocketSpec::selectForWriting);
+      prototype.registerHybridMethod("selectForWritingAsync", &HybridSocketSpec::selectForWritingAsync);
+      prototype.registerHybridMethod("sendByte", &HybridSocketSpec::sendByte);
+      prototype.registerHybridMethod("sendByteAsync", &HybridSocketSpec::sendByteAsync);
+      prototype.registerHybridMethod("sendBytesENC", &HybridSocketSpec::sendBytesENC);
+      prototype.registerHybridMethod("sendBytesENCAsync", &HybridSocketSpec::sendBytesENCAsync);
+      prototype.registerHybridMethod("sendCount", &HybridSocketSpec::sendCount);
+      prototype.registerHybridMethod("sendCountAsync", &HybridSocketSpec::sendCountAsync);
+      prototype.registerHybridMethod("sendInt16", &HybridSocketSpec::sendInt16);
+      prototype.registerHybridMethod("sendInt16Async", &HybridSocketSpec::sendInt16Async);
+      prototype.registerHybridMethod("sendInt32", &HybridSocketSpec::sendInt32);
+      prototype.registerHybridMethod("sendInt32Async", &HybridSocketSpec::sendInt32Async);
+      prototype.registerHybridMethod("sendString", &HybridSocketSpec::sendString);
+      prototype.registerHybridMethod("sendStringAsync", &HybridSocketSpec::sendStringAsync);
+      prototype.registerHybridMethod("setSslClientCert", &HybridSocketSpec::setSslClientCert);
+      prototype.registerHybridMethod("setSslClientCertPem", &HybridSocketSpec::setSslClientCertPem);
+      prototype.registerHybridMethod("setSslClientCertPfx", &HybridSocketSpec::setSslClientCertPfx);
+      prototype.registerHybridMethod("sleepMs", &HybridSocketSpec::sleepMs);
+      prototype.registerHybridMethod("sshAuthenticatePk", &HybridSocketSpec::sshAuthenticatePk);
+      prototype.registerHybridMethod("sshAuthenticatePkAsync", &HybridSocketSpec::sshAuthenticatePkAsync);
+      prototype.registerHybridMethod("sshAuthenticatePw", &HybridSocketSpec::sshAuthenticatePw);
+      prototype.registerHybridMethod("sshAuthenticatePwAsync", &HybridSocketSpec::sshAuthenticatePwAsync);
+      prototype.registerHybridMethod("sshCloseTunnel", &HybridSocketSpec::sshCloseTunnel);
+      prototype.registerHybridMethod("sshCloseTunnelAsync", &HybridSocketSpec::sshCloseTunnelAsync);
+      prototype.registerHybridMethod("sshOpenTunnel", &HybridSocketSpec::sshOpenTunnel);
+      prototype.registerHybridMethod("sshOpenTunnelAsync", &HybridSocketSpec::sshOpenTunnelAsync);
+      prototype.registerHybridMethod("startTiming", &HybridSocketSpec::startTiming);
+      prototype.registerHybridMethod("takeSocket", &HybridSocketSpec::takeSocket);
+      prototype.registerHybridMethod("tlsRenegotiate", &HybridSocketSpec::tlsRenegotiate);
+      prototype.registerHybridMethod("tlsRenegotiateAsync", &HybridSocketSpec::tlsRenegotiateAsync);
+      prototype.registerHybridMethod("useSsh", &HybridSocketSpec::useSsh);
+      prototype.registerHybridMethod("receiveBd", &HybridSocketSpec::receiveBd);
+      prototype.registerHybridMethod("receiveBdAsync", &HybridSocketSpec::receiveBdAsync);
+      prototype.registerHybridMethod("receiveSb", &HybridSocketSpec::receiveSb);
+      prototype.registerHybridMethod("receiveSbAsync", &HybridSocketSpec::receiveSbAsync);
+      prototype.registerHybridMethod("sendBd", &HybridSocketSpec::sendBd);
+      prototype.registerHybridMethod("sendBdAsync", &HybridSocketSpec::sendBdAsync);
+      prototype.registerHybridMethod("sendSb", &HybridSocketSpec::sendSb);
+      prototype.registerHybridMethod("sendSbAsync", &HybridSocketSpec::sendSbAsync);
+      prototype.registerHybridMethod("receiveBdN", &HybridSocketSpec::receiveBdN);
+      prototype.registerHybridMethod("receiveBdNAsync", &HybridSocketSpec::receiveBdNAsync);
+      prototype.registerHybridMethod("sendWakeOnLan", &HybridSocketSpec::sendWakeOnLan);
+      prototype.registerHybridMethod("bindAndListenPortRange", &HybridSocketSpec::bindAndListenPortRange);
+      prototype.registerHybridMethod("bindAndListenPortRangeAsync", &HybridSocketSpec::bindAndListenPortRangeAsync);
+      prototype.registerHybridMethod("receiveUntilByteBd", &HybridSocketSpec::receiveUntilByteBd);
+      prototype.registerHybridMethod("receiveUntilByteBdAsync", &HybridSocketSpec::receiveUntilByteBdAsync);
+      prototype.registerHybridMethod("sendWakeOnLan2", &HybridSocketSpec::sendWakeOnLan2);
+      prototype.registerHybridMethod("takeConnection", &HybridSocketSpec::takeConnection);
+      prototype.registerHybridMethod("resetPerf", &HybridSocketSpec::resetPerf);
+      prototype.registerHybridMethod("sendBytes2", &HybridSocketSpec::sendBytes2);
+      prototype.registerHybridMethod("receiveUntilMatchSb", &HybridSocketSpec::receiveUntilMatchSb);
+      prototype.registerHybridMethod("receiveUntilMatchSbAsync", &HybridSocketSpec::receiveUntilMatchSbAsync);
+      prototype.registerHybridMethod("getAdaptersAddresses", &HybridSocketSpec::getAdaptersAddresses);
+      prototype.registerHybridMethod("getLastJsonData", &HybridSocketSpec::getLastJsonData);
+      prototype.registerHybridMethod("getServerCert", &HybridSocketSpec::getServerCert);
+      prototype.registerHybridMethod("acceptNext", &HybridSocketSpec::acceptNext);
+      prototype.registerHybridMethod("acceptNextAsync", &HybridSocketSpec::acceptNextAsync);
+      prototype.registerHybridMethod("dupSocket", &HybridSocketSpec::dupSocket);
+      prototype.registerHybridMethod("getMyServerCert", &HybridSocketSpec::getMyServerCert);
+      prototype.registerHybridMethod("getRcvdClientCert", &HybridSocketSpec::getRcvdClientCert);
+      prototype.registerHybridMethod("sshNewChannel", &HybridSocketSpec::sshNewChannel);
+      prototype.registerHybridMethod("sshNewChannelAsync", &HybridSocketSpec::sshNewChannelAsync);
+      prototype.registerHybridMethod("abort", &HybridSocketSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridSocketSpec.hpp

@@ -0,0 +1,327 @@
+///
+/// HybridSocketSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridCertSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCertSpec; }
+// Forward declaration of `HybridSshKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSshKeySpec; }
+// Forward declaration of `HybridSocketSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSocketSpec; }
+// Forward declaration of `HybridSshSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSshSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridCertSpec.hpp"
+#include "HybridSshKeySpec.hpp"
+#include "HybridSocketSpec.hpp"
+#include "HybridSshSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include "HybridJsonObjectSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Socket`
+   * Inherit this class to create instances of `HybridSocketSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridSocket: public HybridSocketSpec {
+   * public:
+   *   HybridSocket(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridSocketSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridSocketSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridSocketSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual bool getAbortCurrent() = 0;
+      virtual void setAbortCurrent(bool abortCurrent) = 0;
+      virtual double getAcceptFailReason() = 0;
+      virtual double getBandwidthThrottleDown() = 0;
+      virtual void setBandwidthThrottleDown(double bandwidthThrottleDown) = 0;
+      virtual double getBandwidthThrottleUp() = 0;
+      virtual void setBandwidthThrottleUp(double bandwidthThrottleUp) = 0;
+      virtual bool getBigEndian() = 0;
+      virtual void setBigEndian(bool bigEndian) = 0;
+      virtual std::string getClientIpAddress() = 0;
+      virtual void setClientIpAddress(const std::string& clientIpAddress) = 0;
+      virtual double getClientPort() = 0;
+      virtual void setClientPort(double clientPort) = 0;
+      virtual double getConnectFailReason() = 0;
+      virtual double getElapsedSeconds() = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual std::string getHttpProxyAuthMethod() = 0;
+      virtual void setHttpProxyAuthMethod(const std::string& httpProxyAuthMethod) = 0;
+      virtual std::string getHttpProxyDomain() = 0;
+      virtual void setHttpProxyDomain(const std::string& httpProxyDomain) = 0;
+      virtual std::string getHttpProxyHostname() = 0;
+      virtual void setHttpProxyHostname(const std::string& httpProxyHostname) = 0;
+      virtual std::string getHttpProxyPassword() = 0;
+      virtual void setHttpProxyPassword(const std::string& httpProxyPassword) = 0;
+      virtual double getHttpProxyPort() = 0;
+      virtual void setHttpProxyPort(double httpProxyPort) = 0;
+      virtual std::string getHttpProxyUsername() = 0;
+      virtual void setHttpProxyUsername(const std::string& httpProxyUsername) = 0;
+      virtual bool getIsConnected() = 0;
+      virtual bool getKeepAlive() = 0;
+      virtual void setKeepAlive(bool keepAlive) = 0;
+      virtual bool getKeepSessionLog() = 0;
+      virtual void setKeepSessionLog(bool keepSessionLog) = 0;
+      virtual bool getLastMethodFailed() = 0;
+      virtual std::string getLocalIpAddress() = 0;
+      virtual double getLocalPort() = 0;
+      virtual double getMaxReadIdleMs() = 0;
+      virtual void setMaxReadIdleMs(double maxReadIdleMs) = 0;
+      virtual double getMaxSendIdleMs() = 0;
+      virtual void setMaxSendIdleMs(double maxSendIdleMs) = 0;
+      virtual std::string getMyIpAddress() = 0;
+      virtual double getNumReceivedClientCerts() = 0;
+      virtual double getNumSocketsInSet() = 0;
+      virtual double getNumSslAcceptableClientCAs() = 0;
+      virtual double getObjectId() = 0;
+      virtual double getPercentDoneScale() = 0;
+      virtual void setPercentDoneScale(double percentDoneScale) = 0;
+      virtual bool getPreferIpv6() = 0;
+      virtual void setPreferIpv6(bool preferIpv6) = 0;
+      virtual double getReceiveFailReason() = 0;
+      virtual double getReceivePacketSize() = 0;
+      virtual void setReceivePacketSize(double receivePacketSize) = 0;
+      virtual double getReceivedCount() = 0;
+      virtual void setReceivedCount(double receivedCount) = 0;
+      virtual double getReceivedInt() = 0;
+      virtual void setReceivedInt(double receivedInt) = 0;
+      virtual std::string getRemoteIpAddress() = 0;
+      virtual double getRemotePort() = 0;
+      virtual bool getRequireSslCertVerify() = 0;
+      virtual void setRequireSslCertVerify(bool requireSslCertVerify) = 0;
+      virtual double getSelectorIndex() = 0;
+      virtual void setSelectorIndex(double selectorIndex) = 0;
+      virtual double getSelectorReadIndex() = 0;
+      virtual void setSelectorReadIndex(double selectorReadIndex) = 0;
+      virtual double getSelectorWriteIndex() = 0;
+      virtual void setSelectorWriteIndex(double selectorWriteIndex) = 0;
+      virtual double getSendFailReason() = 0;
+      virtual double getSendPacketSize() = 0;
+      virtual void setSendPacketSize(double sendPacketSize) = 0;
+      virtual std::string getSessionLog() = 0;
+      virtual std::string getSessionLogEncoding() = 0;
+      virtual void setSessionLogEncoding(const std::string& sessionLogEncoding) = 0;
+      virtual double getSoRcvBuf() = 0;
+      virtual void setSoRcvBuf(double soRcvBuf) = 0;
+      virtual bool getSoReuseAddr() = 0;
+      virtual void setSoReuseAddr(bool soReuseAddr) = 0;
+      virtual double getSoSndBuf() = 0;
+      virtual void setSoSndBuf(double soSndBuf) = 0;
+      virtual std::string getSocksHostname() = 0;
+      virtual void setSocksHostname(const std::string& socksHostname) = 0;
+      virtual std::string getSocksPassword() = 0;
+      virtual void setSocksPassword(const std::string& socksPassword) = 0;
+      virtual double getSocksPort() = 0;
+      virtual void setSocksPort(double socksPort) = 0;
+      virtual std::string getSocksUsername() = 0;
+      virtual void setSocksUsername(const std::string& socksUsername) = 0;
+      virtual double getSocksVersion() = 0;
+      virtual void setSocksVersion(double socksVersion) = 0;
+      virtual bool getSsl() = 0;
+      virtual void setSsl(bool ssl) = 0;
+      virtual std::string getSslAllowedCiphers() = 0;
+      virtual void setSslAllowedCiphers(const std::string& sslAllowedCiphers) = 0;
+      virtual std::string getSslProtocol() = 0;
+      virtual void setSslProtocol(const std::string& sslProtocol) = 0;
+      virtual std::string getStringCharset() = 0;
+      virtual void setStringCharset(const std::string& stringCharset) = 0;
+      virtual bool getTcpNoDelay() = 0;
+      virtual void setTcpNoDelay(bool tcpNoDelay) = 0;
+      virtual std::string getTlsCipherSuite() = 0;
+      virtual std::string getTlsPinSet() = 0;
+      virtual void setTlsPinSet(const std::string& tlsPinSet) = 0;
+      virtual std::string getTlsVersion() = 0;
+      virtual std::string getUserData() = 0;
+      virtual void setUserData(const std::string& userData) = 0;
+      virtual double getListenPort() = 0;
+      virtual bool getHttpProxyForHttp() = 0;
+      virtual void setHttpProxyForHttp(bool httpProxyForHttp) = 0;
+      virtual double getRcvBytesPerSec() = 0;
+      virtual double getSendBytesPerSec() = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual std::string getAlpnProtocol() = 0;
+      virtual void setAlpnProtocol(const std::string& alpnProtocol) = 0;
+      virtual std::string getSniHostname() = 0;
+      virtual void setSniHostname(const std::string& sniHostname) = 0;
+      virtual double getNumBytesAvailable() = 0;
+      virtual std::optional<std::function<void(double /* pctDone */)>> getOnPercentDone() = 0;
+      virtual void setOnPercentDone(const std::optional<std::function<void(double /* pctDone */)>>& onPercentDone) = 0;
+      virtual std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>> getOnProgressInfo() = 0;
+      virtual void setOnProgressInfo(const std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>>& onProgressInfo) = 0;
+
+    public:
+      // Methods
+      virtual void addSslAcceptableClientCaDn(const std::string& certAuthDN) = 0;
+      virtual void bindAndListen(double port, double backLog) = 0;
+      virtual std::shared_ptr<Promise<void>> bindAndListenAsync(double port, double backLog) = 0;
+      virtual std::string buildHttpGetRequest(const std::string& url) = 0;
+      virtual double checkWriteable(double maxWaitMs) = 0;
+      virtual std::shared_ptr<Promise<double>> checkWriteableAsync(double maxWaitMs) = 0;
+      virtual void clearSessionLog() = 0;
+      virtual void close(double maxWaitMs) = 0;
+      virtual std::shared_ptr<Promise<void>> closeAsync(double maxWaitMs) = 0;
+      virtual void connect(const std::string& hostname, double port, bool ssl, double maxWaitMs) = 0;
+      virtual std::shared_ptr<Promise<void>> connectAsync(const std::string& hostname, double port, bool ssl, double maxWaitMs) = 0;
+      virtual void convertFromSsl() = 0;
+      virtual std::shared_ptr<Promise<void>> convertFromSslAsync() = 0;
+      virtual void convertToSsl() = 0;
+      virtual std::shared_ptr<Promise<void>> convertToSslAsync() = 0;
+      virtual void dnsCacheClear() = 0;
+      virtual std::string dnsLookup(const std::string& hostname, double maxWaitMs) = 0;
+      virtual std::shared_ptr<Promise<std::string>> dnsLookupAsync(const std::string& hostname, double maxWaitMs) = 0;
+      virtual std::string getSslAcceptableClientCaDn(double index) = 0;
+      virtual void initSslServer(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual bool pollDataAvailable() = 0;
+      virtual std::shared_ptr<Promise<bool>> pollDataAvailableAsync() = 0;
+      virtual void receiveByte(bool bUnsigned) = 0;
+      virtual std::shared_ptr<Promise<void>> receiveByteAsync(bool bUnsigned) = 0;
+      virtual std::string receiveBytesENC(const std::string& encodingAlg) = 0;
+      virtual std::shared_ptr<Promise<std::string>> receiveBytesENCAsync(const std::string& encodingAlg) = 0;
+      virtual void receiveBytesToFile(const std::string& appendFilename) = 0;
+      virtual std::shared_ptr<Promise<void>> receiveBytesToFileAsync(const std::string& appendFilename) = 0;
+      virtual double receiveCount() = 0;
+      virtual std::shared_ptr<Promise<double>> receiveCountAsync() = 0;
+      virtual void receiveInt16(bool bigEndian, bool bUnsigned) = 0;
+      virtual std::shared_ptr<Promise<void>> receiveInt16Async(bool bigEndian, bool bUnsigned) = 0;
+      virtual void receiveInt32(bool bigEndian) = 0;
+      virtual std::shared_ptr<Promise<void>> receiveInt32Async(bool bigEndian) = 0;
+      virtual std::string receiveNBytesENC(double numBytes, const std::string& encodingAlg) = 0;
+      virtual std::shared_ptr<Promise<std::string>> receiveNBytesENCAsync(double numBytes, const std::string& encodingAlg) = 0;
+      virtual std::string receiveString() = 0;
+      virtual std::shared_ptr<Promise<std::string>> receiveStringAsync() = 0;
+      virtual std::string receiveStringMaxN(double maxByteCount) = 0;
+      virtual std::shared_ptr<Promise<std::string>> receiveStringMaxNAsync(double maxByteCount) = 0;
+      virtual std::string receiveStringUntilByte(double lookForByte) = 0;
+      virtual std::shared_ptr<Promise<std::string>> receiveStringUntilByteAsync(double lookForByte) = 0;
+      virtual std::string receiveToCRLF() = 0;
+      virtual std::shared_ptr<Promise<std::string>> receiveToCRLFAsync() = 0;
+      virtual std::string receiveUntilMatch(const std::string& matchStr) = 0;
+      virtual std::shared_ptr<Promise<std::string>> receiveUntilMatchAsync(const std::string& matchStr) = 0;
+      virtual double selectForReading(double timeoutMs) = 0;
+      virtual std::shared_ptr<Promise<double>> selectForReadingAsync(double timeoutMs) = 0;
+      virtual double selectForWriting(double timeoutMs) = 0;
+      virtual std::shared_ptr<Promise<double>> selectForWritingAsync(double timeoutMs) = 0;
+      virtual void sendByte(double value) = 0;
+      virtual std::shared_ptr<Promise<void>> sendByteAsync(double value) = 0;
+      virtual void sendBytesENC(const std::string& encodedBytes, const std::string& encodingAlg) = 0;
+      virtual std::shared_ptr<Promise<void>> sendBytesENCAsync(const std::string& encodedBytes, const std::string& encodingAlg) = 0;
+      virtual void sendCount(double byteCount) = 0;
+      virtual std::shared_ptr<Promise<void>> sendCountAsync(double byteCount) = 0;
+      virtual void sendInt16(double value, bool bigEndian) = 0;
+      virtual std::shared_ptr<Promise<void>> sendInt16Async(double value, bool bigEndian) = 0;
+      virtual void sendInt32(double value, bool bigEndian) = 0;
+      virtual std::shared_ptr<Promise<void>> sendInt32Async(double value, bool bigEndian) = 0;
+      virtual void sendString(const std::string& stringToSend) = 0;
+      virtual std::shared_ptr<Promise<void>> sendStringAsync(const std::string& stringToSend) = 0;
+      virtual void setSslClientCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void setSslClientCertPem(const std::string& pemDataOrFilename, const std::string& pemPassword) = 0;
+      virtual void setSslClientCertPfx(const std::string& pfxFilename, const std::string& pfxPassword) = 0;
+      virtual void sleepMs(double millisec) = 0;
+      virtual void sshAuthenticatePk(const std::string& sshLogin, const std::shared_ptr<HybridSshKeySpec>& privateKey) = 0;
+      virtual std::shared_ptr<Promise<void>> sshAuthenticatePkAsync(const std::string& sshLogin, const std::shared_ptr<HybridSshKeySpec>& privateKey) = 0;
+      virtual void sshAuthenticatePw(const std::string& sshLogin, const std::string& sshPassword) = 0;
+      virtual std::shared_ptr<Promise<void>> sshAuthenticatePwAsync(const std::string& sshLogin, const std::string& sshPassword) = 0;
+      virtual void sshCloseTunnel() = 0;
+      virtual std::shared_ptr<Promise<void>> sshCloseTunnelAsync() = 0;
+      virtual void sshOpenTunnel(const std::string& sshHostname, double sshPort) = 0;
+      virtual std::shared_ptr<Promise<void>> sshOpenTunnelAsync(const std::string& sshHostname, double sshPort) = 0;
+      virtual void startTiming() = 0;
+      virtual void takeSocket(const std::shared_ptr<HybridSocketSpec>& sock) = 0;
+      virtual void tlsRenegotiate() = 0;
+      virtual std::shared_ptr<Promise<void>> tlsRenegotiateAsync() = 0;
+      virtual void useSsh(const std::shared_ptr<HybridSshSpec>& ssh) = 0;
+      virtual void receiveBd(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual std::shared_ptr<Promise<void>> receiveBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual void receiveSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual std::shared_ptr<Promise<void>> receiveSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void sendBd(const std::shared_ptr<HybridBinDataSpec>& binData, double offset, double numBytes) = 0;
+      virtual std::shared_ptr<Promise<void>> sendBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData, double offset, double numBytes) = 0;
+      virtual void sendSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual std::shared_ptr<Promise<void>> sendSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void receiveBdN(double numBytes, const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual std::shared_ptr<Promise<void>> receiveBdNAsync(double numBytes, const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual void sendWakeOnLan(const std::string& macAddress, double port, const std::string& ipBroadcastAddr) = 0;
+      virtual double bindAndListenPortRange(double beginPort, double endPort, double backLog) = 0;
+      virtual std::shared_ptr<Promise<double>> bindAndListenPortRangeAsync(double beginPort, double endPort, double backLog) = 0;
+      virtual void receiveUntilByteBd(double lookForByte, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual std::shared_ptr<Promise<void>> receiveUntilByteBdAsync(double lookForByte, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void sendWakeOnLan2(const std::string& macAddress, double port, const std::string& ipBroadcastAddr, const std::string& password) = 0;
+      virtual void takeConnection(const std::shared_ptr<HybridSocketSpec>& sock) = 0;
+      virtual void resetPerf(bool rcvPerf) = 0;
+      virtual void sendBytes2(const std::shared_ptr<ArrayBuffer>& byteData) = 0;
+      virtual void receiveUntilMatchSb(const std::string& matchStr, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual std::shared_ptr<Promise<void>> receiveUntilMatchSbAsync(const std::string& matchStr, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void getAdaptersAddresses(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getServerCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void acceptNext(double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& socket) = 0;
+      virtual std::shared_ptr<Promise<void>> acceptNextAsync(double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& socket) = 0;
+      virtual void dupSocket(const std::shared_ptr<HybridSocketSpec>& dest) = 0;
+      virtual void getMyServerCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void getRcvdClientCert(double index, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void sshNewChannel(const std::string& hostname, double port, bool ssl, double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& channel) = 0;
+      virtual std::shared_ptr<Promise<void>> sshNewChannelAsync(const std::string& hostname, double port, bool ssl, double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& channel) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Socket";
+  };
+
+} // namespace margelo::nitro::chilkat