@chilkat/react-native 11.6.1

package/cpp/HybridBz2.cpp

@@ -0,0 +1,177 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridBz2.hpp"
+#include "HybridBinData.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridBz2::HybridBz2()
+    : HybridObject(HybridBz2Spec::TAG), ChilkatObject<CkBz2>("Bz2", CkBz2::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridBz2::HybridBz2(CkBz2* owned)
+    : HybridObject(HybridBz2Spec::TAG), ChilkatObject<CkBz2>("Bz2", owned) {
+  init();
+}
+
+void HybridBz2::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridBz2::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridBz2::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridBz2::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridBz2::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridBz2::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridBz2::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridBz2::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridBz2::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridBz2::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridBz2::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridBz2::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridBz2::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridBz2::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+bool HybridBz2::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridBz2::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+
+// ---- Methods ----
+
+void HybridBz2::compressFile(const std::string& inFilename, const std::string& toPath) {
+  this->beginCall();
+  compressFile_impl(inFilename, toPath);
+}
+void HybridBz2::compressFile_impl(const std::string& inFilename, const std::string& toPath) {
+  rt::checkNoNul(inFilename, "inFilename");
+  rt::checkNoNul(toPath, "toPath");
+  if (!this->ck().CompressFile(inFilename.c_str(), toPath.c_str())) throw this->fail("compressFile");
+}
+std::shared_ptr<Promise<void>> HybridBz2::compressFileAsync(const std::string& inFilename, const std::string& toPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridBz2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Bz2.compressFileAsync", std::move(_parts), [_self, inFilename, toPath]() {
+    _self->compressFile_impl(inFilename, toPath);
+  });
+}
+
+void HybridBz2::uncompressFile(const std::string& inFilename, const std::string& toPath) {
+  this->beginCall();
+  uncompressFile_impl(inFilename, toPath);
+}
+void HybridBz2::uncompressFile_impl(const std::string& inFilename, const std::string& toPath) {
+  rt::checkNoNul(inFilename, "inFilename");
+  rt::checkNoNul(toPath, "toPath");
+  if (!this->ck().UncompressFile(inFilename.c_str(), toPath.c_str())) throw this->fail("uncompressFile");
+}
+std::shared_ptr<Promise<void>> HybridBz2::uncompressFileAsync(const std::string& inFilename, const std::string& toPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridBz2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Bz2.uncompressFileAsync", std::move(_parts), [_self, inFilename, toPath]() {
+    _self->uncompressFile_impl(inFilename, toPath);
+  });
+}
+
+void HybridBz2::compressBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  compressBd_impl(bd);
+}
+void HybridBz2::compressBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().CompressBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("compressBd");
+}
+std::shared_ptr<Promise<void>> HybridBz2::compressBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridBz2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Bz2.compressBdAsync", std::move(_parts), [_self, bd]() {
+    _self->compressBd_impl(bd);
+  });
+}
+
+void HybridBz2::uncompressBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  uncompressBd_impl(bd);
+}
+void HybridBz2::uncompressBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().UncompressBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("uncompressBd");
+}
+std::shared_ptr<Promise<void>> HybridBz2::uncompressBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridBz2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Bz2.uncompressBdAsync", std::move(_parts), [_self, bd]() {
+    _self->uncompressBd_impl(bd);
+  });
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridBz2::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridBz2::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridBz2::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridBz2::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridBz2::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridBz2.hpp

@@ -0,0 +1,58 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Bz2: the Nitro HybridObject over Chilkat's CkBz2 (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridBz2Spec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkBz2.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridBz2 final : public HybridBz2Spec, public ChilkatObject<CkBz2> {
+public:
+  HybridBz2();                                  // `new Bz2()` from JS
+  explicit HybridBz2(CkBz2* 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 getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+  bool getAbortCurrent() override;
+  void setAbortCurrent(bool value) override;
+
+  // ---- Methods ----
+  void compressFile(const std::string& inFilename, const std::string& toPath) override;
+  std::shared_ptr<Promise<void>> compressFileAsync(const std::string& inFilename, const std::string& toPath) override;
+  void uncompressFile(const std::string& inFilename, const std::string& toPath) override;
+  std::shared_ptr<Promise<void>> uncompressFileAsync(const std::string& inFilename, const std::string& toPath) override;
+  void compressBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  std::shared_ptr<Promise<void>> compressBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void uncompressBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  std::shared_ptr<Promise<void>> uncompressBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd) 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 compressFile_impl(const std::string& inFilename, const std::string& toPath);
+  void uncompressFile_impl(const std::string& inFilename, const std::string& toPath);
+  void compressBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void uncompressBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridCache.cpp

@@ -0,0 +1,314 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridCache.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCkDateTime.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridCache::HybridCache()
+    : HybridObject(HybridCacheSpec::TAG), ChilkatObject<CkCache>("Cache", CkCache::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridCache::HybridCache(CkCache* owned)
+    : HybridObject(HybridCacheSpec::TAG), ChilkatObject<CkCache>("Cache", owned) {
+  init();
+}
+
+void HybridCache::init() {
+}
+
+void HybridCache::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridCache::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCache::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCache::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCache::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCache::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridCache::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridCache::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridCache::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridCache::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridCache::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridCache::getLastEtagFetched() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastEtagFetched(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCache::getLastExpirationFetchedStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastExpirationFetchedStr(_s);
+  return rt::stdString(_s);
+}
+bool HybridCache::getLastHitExpired() {
+  this->beginCall();
+  return this->ck().get_LastHitExpired();
+}
+std::string HybridCache::getLastKeyFetched() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastKeyFetched(_s);
+  return rt::stdString(_s);
+}
+double HybridCache::getLevel() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Level());
+}
+void HybridCache::setLevel(double value) {
+  this->beginCall();
+  this->ck().put_Level(rt::toInt(value, "level"));
+}
+double HybridCache::getNumRoots() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumRoots());
+}
+
+// ---- Methods ----
+
+void HybridCache::addRoot(const std::string& path) {
+  this->beginCall();
+  addRoot_impl(path);
+}
+void HybridCache::addRoot_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  this->ck().AddRoot(path.c_str());
+}
+
+double HybridCache::deleteAll() {
+  this->beginCall();
+  return deleteAll_impl();
+}
+double HybridCache::deleteAll_impl() {
+  return static_cast<double>(this->ck().DeleteAll());
+}
+
+double HybridCache::deleteAllExpired() {
+  this->beginCall();
+  return deleteAllExpired_impl();
+}
+double HybridCache::deleteAllExpired_impl() {
+  return static_cast<double>(this->ck().DeleteAllExpired());
+}
+
+void HybridCache::deleteFromCache(const std::string& key) {
+  this->beginCall();
+  deleteFromCache_impl(key);
+}
+void HybridCache::deleteFromCache_impl(const std::string& key) {
+  rt::checkNoNul(key, "key");
+  if (!this->ck().DeleteFromCache(key.c_str())) throw this->fail("deleteFromCache");
+}
+
+double HybridCache::deleteOlderDt(const std::shared_ptr<HybridCkDateTimeSpec>& dt) {
+  this->beginCall();
+  return deleteOlderDt_impl(dt);
+}
+double HybridCache::deleteOlderDt_impl(const std::shared_ptr<HybridCkDateTimeSpec>& dt) {
+  return static_cast<double>(this->ck().DeleteOlderDt(rt::implOf<HybridCkDateTime>(dt, "dt").ck()));
+}
+
+double HybridCache::deleteOlderStr(const std::string& dateTimeStr) {
+  this->beginCall();
+  return deleteOlderStr_impl(dateTimeStr);
+}
+double HybridCache::deleteOlderStr_impl(const std::string& dateTimeStr) {
+  rt::checkNoNul(dateTimeStr, "dateTimeStr");
+  return static_cast<double>(this->ck().DeleteOlderStr(dateTimeStr.c_str()));
+}
+
+std::string HybridCache::fetchText(const std::string& key) {
+  this->beginCall();
+  return fetchText_impl(key);
+}
+std::string HybridCache::fetchText_impl(const std::string& key) {
+  rt::checkNoNul(key, "key");
+  CkString _out;
+  if (!this->ck().FetchText(key.c_str(), _out)) throw this->fail("fetchText");
+  return rt::stdString(_out);
+}
+
+std::string HybridCache::getEtag(const std::string& key) {
+  this->beginCall();
+  return getEtag_impl(key);
+}
+std::string HybridCache::getEtag_impl(const std::string& key) {
+  rt::checkNoNul(key, "key");
+  CkString _out;
+  if (!this->ck().GetEtag(key.c_str(), _out)) throw this->fail("getEtag");
+  return rt::stdString(_out);
+}
+
+std::string HybridCache::getExpirationStr(const std::string& url) {
+  this->beginCall();
+  return getExpirationStr_impl(url);
+}
+std::string HybridCache::getExpirationStr_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  CkString _out;
+  if (!this->ck().GetExpirationStr(url.c_str(), _out)) throw this->fail("getExpirationStr");
+  return rt::stdString(_out);
+}
+
+std::string HybridCache::getFilename(const std::string& key) {
+  this->beginCall();
+  return getFilename_impl(key);
+}
+std::string HybridCache::getFilename_impl(const std::string& key) {
+  rt::checkNoNul(key, "key");
+  CkString _out;
+  if (!this->ck().GetFilename(key.c_str(), _out)) throw this->fail("getFilename");
+  return rt::stdString(_out);
+}
+
+std::string HybridCache::getRoot(double index) {
+  this->beginCall();
+  return getRoot_impl(index);
+}
+std::string HybridCache::getRoot_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetRoot(rt::toInt(index, "index"), _out)) throw this->fail("getRoot");
+  return rt::stdString(_out);
+}
+
+bool HybridCache::isCached(const std::string& key) {
+  this->beginCall();
+  return isCached_impl(key);
+}
+bool HybridCache::isCached_impl(const std::string& key) {
+  rt::checkNoNul(key, "key");
+  return this->ck().IsCached(key.c_str());
+}
+
+void HybridCache::saveTextDt(const std::string& key, const std::shared_ptr<HybridCkDateTimeSpec>& expireDateTime, const std::string& eTag, const std::string& itemTextData) {
+  this->beginCall();
+  saveTextDt_impl(key, expireDateTime, eTag, itemTextData);
+}
+void HybridCache::saveTextDt_impl(const std::string& key, const std::shared_ptr<HybridCkDateTimeSpec>& expireDateTime, const std::string& eTag, const std::string& itemTextData) {
+  rt::checkNoNul(key, "key");
+  rt::checkNoNul(eTag, "eTag");
+  rt::checkNoNul(itemTextData, "itemTextData");
+  if (!this->ck().SaveTextDt(key.c_str(), rt::implOf<HybridCkDateTime>(expireDateTime, "expireDateTime").ck(), eTag.c_str(), itemTextData.c_str())) throw this->fail("saveTextDt");
+}
+
+void HybridCache::saveTextNoExpire(const std::string& key, const std::string& eTag, const std::string& itemTextData) {
+  this->beginCall();
+  saveTextNoExpire_impl(key, eTag, itemTextData);
+}
+void HybridCache::saveTextNoExpire_impl(const std::string& key, const std::string& eTag, const std::string& itemTextData) {
+  rt::checkNoNul(key, "key");
+  rt::checkNoNul(eTag, "eTag");
+  rt::checkNoNul(itemTextData, "itemTextData");
+  if (!this->ck().SaveTextNoExpire(key.c_str(), eTag.c_str(), itemTextData.c_str())) throw this->fail("saveTextNoExpire");
+}
+
+void HybridCache::saveTextStr(const std::string& key, const std::string& expireDateTime, const std::string& eTag, const std::string& itemTextData) {
+  this->beginCall();
+  saveTextStr_impl(key, expireDateTime, eTag, itemTextData);
+}
+void HybridCache::saveTextStr_impl(const std::string& key, const std::string& expireDateTime, const std::string& eTag, const std::string& itemTextData) {
+  rt::checkNoNul(key, "key");
+  rt::checkNoNul(expireDateTime, "expireDateTime");
+  rt::checkNoNul(eTag, "eTag");
+  rt::checkNoNul(itemTextData, "itemTextData");
+  if (!this->ck().SaveTextStr(key.c_str(), expireDateTime.c_str(), eTag.c_str(), itemTextData.c_str())) throw this->fail("saveTextStr");
+}
+
+void HybridCache::updateExpirationDt(const std::string& key, const std::shared_ptr<HybridCkDateTimeSpec>& expireDateTime) {
+  this->beginCall();
+  updateExpirationDt_impl(key, expireDateTime);
+}
+void HybridCache::updateExpirationDt_impl(const std::string& key, const std::shared_ptr<HybridCkDateTimeSpec>& expireDateTime) {
+  rt::checkNoNul(key, "key");
+  if (!this->ck().UpdateExpirationDt(key.c_str(), rt::implOf<HybridCkDateTime>(expireDateTime, "expireDateTime").ck())) throw this->fail("updateExpirationDt");
+}
+
+void HybridCache::updateExpirationStr(const std::string& key, const std::string& expireDateTime) {
+  this->beginCall();
+  updateExpirationStr_impl(key, expireDateTime);
+}
+void HybridCache::updateExpirationStr_impl(const std::string& key, const std::string& expireDateTime) {
+  rt::checkNoNul(key, "key");
+  rt::checkNoNul(expireDateTime, "expireDateTime");
+  if (!this->ck().UpdateExpirationStr(key.c_str(), expireDateTime.c_str())) throw this->fail("updateExpirationStr");
+}
+
+void HybridCache::fetchBd(const std::string& key, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  fetchBd_impl(key, bd);
+}
+void HybridCache::fetchBd_impl(const std::string& key, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(key, "key");
+  if (!this->ck().FetchBd(key.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("fetchBd");
+}
+
+void HybridCache::fetchSb(const std::string& key, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  fetchSb_impl(key, sb);
+}
+void HybridCache::fetchSb_impl(const std::string& key, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  rt::checkNoNul(key, "key");
+  if (!this->ck().FetchSb(key.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("fetchSb");
+}
+
+void HybridCache::saveBd(const std::string& key, const std::string& expiration, const std::string& etag, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  saveBd_impl(key, expiration, etag, bd);
+}
+void HybridCache::saveBd_impl(const std::string& key, const std::string& expiration, const std::string& etag, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(key, "key");
+  rt::checkNoNul(expiration, "expiration");
+  rt::checkNoNul(etag, "etag");
+  if (!this->ck().SaveBd(key.c_str(), expiration.c_str(), etag.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("saveBd");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridCache.hpp

@@ -0,0 +1,82 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Cache: the Nitro HybridObject over Chilkat's CkCache (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridCacheSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkCache.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridCache final : public HybridCacheSpec, public ChilkatObject<CkCache> {
+public:
+  HybridCache();                                  // `new Cache()` from JS
+  explicit HybridCache(CkCache* 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 getLastEtagFetched() override;
+  std::string getLastExpirationFetchedStr() override;
+  bool getLastHitExpired() override;
+  std::string getLastKeyFetched() override;
+  double getLevel() override;
+  void setLevel(double value) override;
+  double getNumRoots() override;
+
+  // ---- Methods ----
+  void addRoot(const std::string& path) override;
+  double deleteAll() override;
+  double deleteAllExpired() override;
+  void deleteFromCache(const std::string& key) override;
+  double deleteOlderDt(const std::shared_ptr<HybridCkDateTimeSpec>& dt) override;
+  double deleteOlderStr(const std::string& dateTimeStr) override;
+  std::string fetchText(const std::string& key) override;
+  std::string getEtag(const std::string& key) override;
+  std::string getExpirationStr(const std::string& url) override;
+  std::string getFilename(const std::string& key) override;
+  std::string getRoot(double index) override;
+  bool isCached(const std::string& key) override;
+  void saveTextDt(const std::string& key, const std::shared_ptr<HybridCkDateTimeSpec>& expireDateTime, const std::string& eTag, const std::string& itemTextData) override;
+  void saveTextNoExpire(const std::string& key, const std::string& eTag, const std::string& itemTextData) override;
+  void saveTextStr(const std::string& key, const std::string& expireDateTime, const std::string& eTag, const std::string& itemTextData) override;
+  void updateExpirationDt(const std::string& key, const std::shared_ptr<HybridCkDateTimeSpec>& expireDateTime) override;
+  void updateExpirationStr(const std::string& key, const std::string& expireDateTime) override;
+  void fetchBd(const std::string& key, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void fetchSb(const std::string& key, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void saveBd(const std::string& key, const std::string& expiration, const std::string& etag, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+
+private:
+  void init();
+  void addRoot_impl(const std::string& path);
+  double deleteAll_impl();
+  double deleteAllExpired_impl();
+  void deleteFromCache_impl(const std::string& key);
+  double deleteOlderDt_impl(const std::shared_ptr<HybridCkDateTimeSpec>& dt);
+  double deleteOlderStr_impl(const std::string& dateTimeStr);
+  std::string fetchText_impl(const std::string& key);
+  std::string getEtag_impl(const std::string& key);
+  std::string getExpirationStr_impl(const std::string& url);
+  std::string getFilename_impl(const std::string& key);
+  std::string getRoot_impl(double index);
+  bool isCached_impl(const std::string& key);
+  void saveTextDt_impl(const std::string& key, const std::shared_ptr<HybridCkDateTimeSpec>& expireDateTime, const std::string& eTag, const std::string& itemTextData);
+  void saveTextNoExpire_impl(const std::string& key, const std::string& eTag, const std::string& itemTextData);
+  void saveTextStr_impl(const std::string& key, const std::string& expireDateTime, const std::string& eTag, const std::string& itemTextData);
+  void updateExpirationDt_impl(const std::string& key, const std::shared_ptr<HybridCkDateTimeSpec>& expireDateTime);
+  void updateExpirationStr_impl(const std::string& key, const std::string& expireDateTime);
+  void fetchBd_impl(const std::string& key, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void fetchSb_impl(const std::string& key, const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void saveBd_impl(const std::string& key, const std::string& expiration, const std::string& etag, const std::shared_ptr<HybridBinDataSpec>& bd);
+};
+
+} // namespace margelo::nitro::chilkat