@chilkat/react-native 11.6.1

package/cpp/HybridBinData.cpp

@@ -0,0 +1,439 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridBinData.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridBinData::HybridBinData()
+    : HybridObject(HybridBinDataSpec::TAG), ChilkatObject<CkBinData>("BinData", CkBinData::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridBinData::HybridBinData(CkBinData* owned)
+    : HybridObject(HybridBinDataSpec::TAG), ChilkatObject<CkBinData>("BinData", owned) {
+  init();
+}
+
+void HybridBinData::init() {
+}
+
+void HybridBinData::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridBinData::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridBinData::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridBinData::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridBinData::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridBinData::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridBinData::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridBinData::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridBinData::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridBinData::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridBinData::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridBinData::getNumBytes() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumBytes());
+}
+
+// ---- Methods ----
+
+void HybridBinData::loadEncoded(const std::string& encData, const std::string& encoding) {
+  this->beginCall();
+  loadEncoded_impl(encData, encoding);
+}
+void HybridBinData::loadEncoded_impl(const std::string& encData, const std::string& encoding) {
+  rt::checkNoNul(encData, "encData");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().LoadEncoded(encData.c_str(), encoding.c_str())) throw this->fail("loadEncoded");
+}
+
+std::string HybridBinData::getEncoded(const std::string& encoding) {
+  this->beginCall();
+  return getEncoded_impl(encoding);
+}
+std::string HybridBinData::getEncoded_impl(const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetEncoded(encoding.c_str(), _out)) throw this->fail("getEncoded");
+  return rt::stdString(_out);
+}
+
+void HybridBinData::appendEncoded(const std::string& encData, const std::string& encoding) {
+  this->beginCall();
+  appendEncoded_impl(encData, encoding);
+}
+void HybridBinData::appendEncoded_impl(const std::string& encData, const std::string& encoding) {
+  rt::checkNoNul(encData, "encData");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().AppendEncoded(encData.c_str(), encoding.c_str())) throw this->fail("appendEncoded");
+}
+
+void HybridBinData::clear() {
+  this->beginCall();
+  clear_impl();
+}
+void HybridBinData::clear_impl() {
+  if (!this->ck().Clear()) throw this->fail("clear");
+}
+
+void HybridBinData::loadFile(const std::string& path) {
+  this->beginCall();
+  loadFile_impl(path);
+}
+void HybridBinData::loadFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadFile(path.c_str())) throw this->fail("loadFile");
+}
+
+std::string HybridBinData::getEncodedChunk(double offset, double numBytes, const std::string& encoding) {
+  this->beginCall();
+  return getEncodedChunk_impl(offset, numBytes, encoding);
+}
+std::string HybridBinData::getEncodedChunk_impl(double offset, double numBytes, const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetEncodedChunk(rt::toInt(offset, "offset"), rt::toInt(numBytes, "numBytes"), encoding.c_str(), _out)) throw this->fail("getEncodedChunk");
+  return rt::stdString(_out);
+}
+
+void HybridBinData::removeChunk(double offset, double numBytes) {
+  this->beginCall();
+  removeChunk_impl(offset, numBytes);
+}
+void HybridBinData::removeChunk_impl(double offset, double numBytes) {
+  if (!this->ck().RemoveChunk(rt::toInt(offset, "offset"), rt::toInt(numBytes, "numBytes"))) throw this->fail("removeChunk");
+}
+
+void HybridBinData::writeFile(const std::string& path) {
+  this->beginCall();
+  writeFile_impl(path);
+}
+void HybridBinData::writeFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().WriteFile(path.c_str())) throw this->fail("writeFile");
+}
+
+void HybridBinData::getEncodedSb(const std::string& encoding, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  getEncodedSb_impl(encoding, sb);
+}
+void HybridBinData::getEncodedSb_impl(const std::string& encoding, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().GetEncodedSb(encoding.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("getEncodedSb");
+}
+
+void HybridBinData::appendBd(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  appendBd_impl(binData);
+}
+void HybridBinData::appendBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().AppendBd(rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("appendBd");
+}
+
+void HybridBinData::appendString(const std::string& str, const std::string& charset) {
+  this->beginCall();
+  appendString_impl(str, charset);
+}
+void HybridBinData::appendString_impl(const std::string& str, const std::string& charset) {
+  rt::checkNoNul(str, "str");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AppendString(str.c_str(), charset.c_str())) throw this->fail("appendString");
+}
+
+void HybridBinData::appendSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) {
+  this->beginCall();
+  appendSb_impl(sb, charset);
+}
+void HybridBinData::appendSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AppendSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), charset.c_str())) throw this->fail("appendSb");
+}
+
+void HybridBinData::appendBom(const std::string& charset) {
+  this->beginCall();
+  appendBom_impl(charset);
+}
+void HybridBinData::appendBom_impl(const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AppendBom(charset.c_str())) throw this->fail("appendBom");
+}
+
+void HybridBinData::appendEncodedSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& encoding) {
+  this->beginCall();
+  appendEncodedSb_impl(sb, encoding);
+}
+void HybridBinData::appendEncodedSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().AppendEncodedSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), encoding.c_str())) throw this->fail("appendEncodedSb");
+}
+
+bool HybridBinData::contentsEqual(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  return contentsEqual_impl(binData);
+}
+bool HybridBinData::contentsEqual_impl(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  return this->ck().ContentsEqual(rt::implOf<HybridBinData>(binData, "binData").ck());
+}
+
+void HybridBinData::secureClear() {
+  this->beginCall();
+  secureClear_impl();
+}
+void HybridBinData::secureClear_impl() {
+  if (!this->ck().SecureClear()) throw this->fail("secureClear");
+}
+
+std::string HybridBinData::getString(const std::string& charset) {
+  this->beginCall();
+  return getString_impl(charset);
+}
+std::string HybridBinData::getString_impl(const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().GetString(charset.c_str(), _out)) throw this->fail("getString");
+  return rt::stdString(_out);
+}
+
+void HybridBinData::appendByte(double byteValue) {
+  this->beginCall();
+  appendByte_impl(byteValue);
+}
+void HybridBinData::appendByte_impl(double byteValue) {
+  if (!this->ck().AppendByte(rt::toInt(byteValue, "byteValue"))) throw this->fail("appendByte");
+}
+
+void HybridBinData::appendInt4(double value, bool littleEndian) {
+  this->beginCall();
+  appendInt4_impl(value, littleEndian);
+}
+void HybridBinData::appendInt4_impl(double value, bool littleEndian) {
+  if (!this->ck().AppendInt4(rt::toInt(value, "value"), littleEndian)) throw this->fail("appendInt4");
+}
+
+void HybridBinData::appendInt2(double value, bool littleEndian) {
+  this->beginCall();
+  appendInt2_impl(value, littleEndian);
+}
+void HybridBinData::appendInt2_impl(double value, bool littleEndian) {
+  if (!this->ck().AppendInt2(rt::toInt(value, "value"), littleEndian)) throw this->fail("appendInt2");
+}
+
+void HybridBinData::appendPadded(const std::string& str, const std::string& charset, bool padWithSpace, double fieldLen) {
+  this->beginCall();
+  appendPadded_impl(str, charset, padWithSpace, fieldLen);
+}
+void HybridBinData::appendPadded_impl(const std::string& str, const std::string& charset, bool padWithSpace, double fieldLen) {
+  rt::checkNoNul(str, "str");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AppendPadded(str.c_str(), charset.c_str(), padWithSpace, rt::toInt(fieldLen, "fieldLen"))) throw this->fail("appendPadded");
+}
+
+double HybridBinData::findString(const std::string& str, double startIdx, const std::string& charset) {
+  this->beginCall();
+  return findString_impl(str, startIdx, charset);
+}
+double HybridBinData::findString_impl(const std::string& str, double startIdx, const std::string& charset) {
+  rt::checkNoNul(str, "str");
+  rt::checkNoNul(charset, "charset");
+  return static_cast<double>(this->ck().FindString(str.c_str(), rt::toInt(startIdx, "startIdx"), charset.c_str()));
+}
+
+std::string HybridBinData::getTextChunk(double startIdx, double numBytes, const std::string& charset) {
+  this->beginCall();
+  return getTextChunk_impl(startIdx, numBytes, charset);
+}
+std::string HybridBinData::getTextChunk_impl(double startIdx, double numBytes, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().GetTextChunk(rt::toInt(startIdx, "startIdx"), rt::toInt(numBytes, "numBytes"), charset.c_str(), _out)) throw this->fail("getTextChunk");
+  return rt::stdString(_out);
+}
+
+double HybridBinData::getInt2(double index, bool littleEndian) {
+  this->beginCall();
+  return getInt2_impl(index, littleEndian);
+}
+double HybridBinData::getInt2_impl(double index, bool littleEndian) {
+  return static_cast<double>(this->ck().GetInt2(rt::toInt(index, "index"), littleEndian));
+}
+
+double HybridBinData::getInt4(double index, bool littleEndian) {
+  this->beginCall();
+  return getInt4_impl(index, littleEndian);
+}
+double HybridBinData::getInt4_impl(double index, bool littleEndian) {
+  return static_cast<double>(this->ck().GetInt4(rt::toInt(index, "index"), littleEndian));
+}
+
+double HybridBinData::getUInt2(double index, bool littleEndian) {
+  this->beginCall();
+  return getUInt2_impl(index, littleEndian);
+}
+double HybridBinData::getUInt2_impl(double index, bool littleEndian) {
+  return static_cast<double>(this->ck().GetUInt2(rt::toInt(index, "index"), littleEndian));
+}
+
+double HybridBinData::getUInt4(double index, bool littleEndian) {
+  this->beginCall();
+  return getUInt4_impl(index, littleEndian);
+}
+double HybridBinData::getUInt4_impl(double index, bool littleEndian) {
+  return static_cast<double>(this->ck().GetUInt4(rt::toInt(index, "index"), littleEndian));
+}
+
+void HybridBinData::removeByteVal(double value) {
+  this->beginCall();
+  removeByteVal_impl(value);
+}
+void HybridBinData::removeByteVal_impl(double value) {
+  this->ck().RemoveByteVal(rt::toInt(value, "value"));
+}
+
+void HybridBinData::writeAppendFile(const std::string& path) {
+  this->beginCall();
+  writeAppendFile_impl(path);
+}
+void HybridBinData::writeAppendFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().WriteAppendFile(path.c_str())) throw this->fail("writeAppendFile");
+}
+
+std::string HybridBinData::getHash(const std::string& algorithm, const std::string& encoding) {
+  this->beginCall();
+  return getHash_impl(algorithm, encoding);
+}
+std::string HybridBinData::getHash_impl(const std::string& algorithm, const std::string& encoding) {
+  rt::checkNoNul(algorithm, "algorithm");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetHash(algorithm.c_str(), encoding.c_str(), _out)) throw this->fail("getHash");
+  return rt::stdString(_out);
+}
+
+void HybridBinData::appendCountedString(double numCountBytes, bool bigEndian, const std::string& str, const std::string& charset) {
+  this->beginCall();
+  appendCountedString_impl(numCountBytes, bigEndian, str, charset);
+}
+void HybridBinData::appendCountedString_impl(double numCountBytes, bool bigEndian, const std::string& str, const std::string& charset) {
+  rt::checkNoNul(str, "str");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AppendCountedString(rt::toInt(numCountBytes, "numCountBytes"), bigEndian, str.c_str(), charset.c_str())) throw this->fail("appendCountedString");
+}
+
+double HybridBinData::getByte(double index) {
+  this->beginCall();
+  return getByte_impl(index);
+}
+double HybridBinData::getByte_impl(double index) {
+  return static_cast<double>(this->ck().GetByte(rt::toInt(index, "index")));
+}
+
+bool HybridBinData::isValidUtf8() {
+  this->beginCall();
+  return isValidUtf8_impl();
+}
+bool HybridBinData::isValidUtf8_impl() {
+  return this->ck().IsValidUtf8();
+}
+
+void HybridBinData::byteSwap(double size) {
+  this->beginCall();
+  byteSwap_impl(size);
+}
+void HybridBinData::byteSwap_impl(double size) {
+  this->ck().ByteSwap(rt::toInt(size, "size"));
+}
+
+void HybridBinData::charsetConvert(const std::string& fromCharset, const std::string& toCharset, bool allOrNone) {
+  this->beginCall();
+  charsetConvert_impl(fromCharset, toCharset, allOrNone);
+}
+void HybridBinData::charsetConvert_impl(const std::string& fromCharset, const std::string& toCharset, bool allOrNone) {
+  rt::checkNoNul(fromCharset, "fromCharset");
+  rt::checkNoNul(toCharset, "toCharset");
+  if (!this->ck().CharsetConvert(fromCharset.c_str(), toCharset.c_str(), allOrNone)) throw this->fail("charsetConvert");
+}
+
+void HybridBinData::appendData(const std::shared_ptr<ArrayBuffer>& data) {
+  this->beginCall();
+  rt::ByteView _data = rt::viewOf(data);
+  appendData_impl(_data.data, _data.size);
+}
+void HybridBinData::appendData_impl(const uint8_t* dataData, size_t dataSize) {
+  if (dataSize == 0) return;
+  if (!this->ck().AppendData(static_cast<const void*>(dataData), rt::sizeToInt(dataSize, "data"))) throw this->fail("appendData");
+}
+
+std::shared_ptr<ArrayBuffer> HybridBinData::getData() {
+  this->beginCall();
+  return getData_impl();
+}
+std::shared_ptr<ArrayBuffer> HybridBinData::getData_impl() {
+  int _n = this->ck().get_NumBytes();
+  const void* _p = _n > 0 ? this->ck().GetData() : nullptr;
+  return rt::toArrayBuffer(_p, _n > 0 ? static_cast<size_t>(_n) : 0);
+}
+
+std::shared_ptr<ArrayBuffer> HybridBinData::getDataChunk(double offset, double numBytes) {
+  this->beginCall();
+  return getDataChunk_impl(offset, numBytes);
+}
+std::shared_ptr<ArrayBuffer> HybridBinData::getDataChunk_impl(double offset, double numBytes) {
+  int _off = rt::toInt(offset, "offset");
+  int _cnt = rt::toInt(numBytes, "numBytes");
+  int _total = this->ck().get_NumBytes();
+  if (_off < 0) _off = 0;
+  if (_off > _total) _off = _total;
+  if (_cnt < 0) _cnt = 0;
+  if (_cnt > _total - _off) _cnt = _total - _off;
+  const void* _p = _cnt > 0 ? this->ck().GetDataChunk(_off, _cnt) : nullptr;
+  return rt::toArrayBuffer(_p, _cnt > 0 ? static_cast<size_t>(_cnt) : 0);
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridBinData.hpp

@@ -0,0 +1,112 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// BinData: the Nitro HybridObject over Chilkat's CkBinData (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridBinDataSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkBinData.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridBinData final : public HybridBinDataSpec, public ChilkatObject<CkBinData> {
+public:
+  HybridBinData();                                  // `new BinData()` from JS
+  explicit HybridBinData(CkBinData* 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 getNumBytes() override;
+
+  // ---- Methods ----
+  void loadEncoded(const std::string& encData, const std::string& encoding) override;
+  std::string getEncoded(const std::string& encoding) override;
+  void appendEncoded(const std::string& encData, const std::string& encoding) override;
+  void clear() override;
+  void loadFile(const std::string& path) override;
+  std::string getEncodedChunk(double offset, double numBytes, const std::string& encoding) override;
+  void removeChunk(double offset, double numBytes) override;
+  void writeFile(const std::string& path) override;
+  void getEncodedSb(const std::string& encoding, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void appendBd(const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  void appendString(const std::string& str, const std::string& charset) override;
+  void appendSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) override;
+  void appendBom(const std::string& charset) override;
+  void appendEncodedSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& encoding) override;
+  bool contentsEqual(const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  void secureClear() override;
+  std::string getString(const std::string& charset) override;
+  void appendByte(double byteValue) override;
+  void appendInt4(double value, bool littleEndian) override;
+  void appendInt2(double value, bool littleEndian) override;
+  void appendPadded(const std::string& str, const std::string& charset, bool padWithSpace, double fieldLen) override;
+  double findString(const std::string& str, double startIdx, const std::string& charset) override;
+  std::string getTextChunk(double startIdx, double numBytes, const std::string& charset) override;
+  double getInt2(double index, bool littleEndian) override;
+  double getInt4(double index, bool littleEndian) override;
+  double getUInt2(double index, bool littleEndian) override;
+  double getUInt4(double index, bool littleEndian) override;
+  void removeByteVal(double value) override;
+  void writeAppendFile(const std::string& path) override;
+  std::string getHash(const std::string& algorithm, const std::string& encoding) override;
+  void appendCountedString(double numCountBytes, bool bigEndian, const std::string& str, const std::string& charset) override;
+  double getByte(double index) override;
+  bool isValidUtf8() override;
+  void byteSwap(double size) override;
+  void charsetConvert(const std::string& fromCharset, const std::string& toCharset, bool allOrNone) override;
+  void appendData(const std::shared_ptr<ArrayBuffer>& data) override;
+  std::shared_ptr<ArrayBuffer> getData() override;
+  std::shared_ptr<ArrayBuffer> getDataChunk(double offset, double numBytes) override;
+
+private:
+  void init();
+  void loadEncoded_impl(const std::string& encData, const std::string& encoding);
+  std::string getEncoded_impl(const std::string& encoding);
+  void appendEncoded_impl(const std::string& encData, const std::string& encoding);
+  void clear_impl();
+  void loadFile_impl(const std::string& path);
+  std::string getEncodedChunk_impl(double offset, double numBytes, const std::string& encoding);
+  void removeChunk_impl(double offset, double numBytes);
+  void writeFile_impl(const std::string& path);
+  void getEncodedSb_impl(const std::string& encoding, const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void appendBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData);
+  void appendString_impl(const std::string& str, const std::string& charset);
+  void appendSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset);
+  void appendBom_impl(const std::string& charset);
+  void appendEncodedSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& encoding);
+  bool contentsEqual_impl(const std::shared_ptr<HybridBinDataSpec>& binData);
+  void secureClear_impl();
+  std::string getString_impl(const std::string& charset);
+  void appendByte_impl(double byteValue);
+  void appendInt4_impl(double value, bool littleEndian);
+  void appendInt2_impl(double value, bool littleEndian);
+  void appendPadded_impl(const std::string& str, const std::string& charset, bool padWithSpace, double fieldLen);
+  double findString_impl(const std::string& str, double startIdx, const std::string& charset);
+  std::string getTextChunk_impl(double startIdx, double numBytes, const std::string& charset);
+  double getInt2_impl(double index, bool littleEndian);
+  double getInt4_impl(double index, bool littleEndian);
+  double getUInt2_impl(double index, bool littleEndian);
+  double getUInt4_impl(double index, bool littleEndian);
+  void removeByteVal_impl(double value);
+  void writeAppendFile_impl(const std::string& path);
+  std::string getHash_impl(const std::string& algorithm, const std::string& encoding);
+  void appendCountedString_impl(double numCountBytes, bool bigEndian, const std::string& str, const std::string& charset);
+  double getByte_impl(double index);
+  bool isValidUtf8_impl();
+  void byteSwap_impl(double size);
+  void charsetConvert_impl(const std::string& fromCharset, const std::string& toCharset, bool allOrNone);
+  void appendData_impl(const uint8_t* dataData, size_t dataSize);
+  std::shared_ptr<ArrayBuffer> getData_impl();
+  std::shared_ptr<ArrayBuffer> getDataChunk_impl(double offset, double numBytes);
+};
+
+} // namespace margelo::nitro::chilkat