@chilkat/react-native 11.6.1

package/cpp/HybridStringBuilder.cpp

@@ -0,0 +1,739 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridStringBuilder.hpp"
+#include "HybridBinData.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridStringTable.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridStringBuilder::HybridStringBuilder()
+    : HybridObject(HybridStringBuilderSpec::TAG), ChilkatObject<CkStringBuilder>("StringBuilder", CkStringBuilder::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridStringBuilder::HybridStringBuilder(CkStringBuilder* owned)
+    : HybridObject(HybridStringBuilderSpec::TAG), ChilkatObject<CkStringBuilder>("StringBuilder", owned) {
+  init();
+}
+
+void HybridStringBuilder::init() {
+}
+
+void HybridStringBuilder::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridStringBuilder::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStringBuilder::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStringBuilder::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStringBuilder::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStringBuilder::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridStringBuilder::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridStringBuilder::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridStringBuilder::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridStringBuilder::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridStringBuilder::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridStringBuilder::getLength() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Length());
+}
+double HybridStringBuilder::getIntValue() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_IntValue());
+}
+void HybridStringBuilder::setIntValue(double value) {
+  this->beginCall();
+  this->ck().put_IntValue(rt::toInt(value, "intValue"));
+}
+bool HybridStringBuilder::getIsBase64() {
+  this->beginCall();
+  return this->ck().get_IsBase64();
+}
+bool HybridStringBuilder::getHasEmojis() {
+  this->beginCall();
+  return this->ck().get_HasEmojis();
+}
+
+// ---- Methods ----
+
+void HybridStringBuilder::append(const std::string& value) {
+  this->beginCall();
+  append_impl(value);
+}
+void HybridStringBuilder::append_impl(const std::string& value) {
+  rt::checkNoNul(value, "value");
+  if (!this->ck().Append(value.c_str())) throw this->fail("append");
+}
+
+void HybridStringBuilder::appendInt(double value) {
+  this->beginCall();
+  appendInt_impl(value);
+}
+void HybridStringBuilder::appendInt_impl(double value) {
+  if (!this->ck().AppendInt(rt::toInt(value, "value"))) throw this->fail("appendInt");
+}
+
+void HybridStringBuilder::appendInt64(double value) {
+  this->beginCall();
+  appendInt64_impl(value);
+}
+void HybridStringBuilder::appendInt64_impl(double value) {
+  if (!this->ck().AppendInt64(rt::toInt64(value, "value"))) throw this->fail("appendInt64");
+}
+
+void HybridStringBuilder::clear() {
+  this->beginCall();
+  clear_impl();
+}
+void HybridStringBuilder::clear_impl() {
+  this->ck().Clear();
+}
+
+double HybridStringBuilder::replace(const std::string& value, const std::string& replacement) {
+  this->beginCall();
+  return replace_impl(value, replacement);
+}
+double HybridStringBuilder::replace_impl(const std::string& value, const std::string& replacement) {
+  rt::checkNoNul(value, "value");
+  rt::checkNoNul(replacement, "replacement");
+  return static_cast<double>(this->ck().Replace(value.c_str(), replacement.c_str()));
+}
+
+std::string HybridStringBuilder::getAsString() {
+  this->beginCall();
+  return getAsString_impl();
+}
+std::string HybridStringBuilder::getAsString_impl() {
+  CkString _out;
+  if (!this->ck().GetAsString(_out)) throw this->fail("getAsString");
+  return rt::stdString(_out);
+}
+
+bool HybridStringBuilder::contentsEqual(const std::string& str, bool caseSensitive) {
+  this->beginCall();
+  return contentsEqual_impl(str, caseSensitive);
+}
+bool HybridStringBuilder::contentsEqual_impl(const std::string& str, bool caseSensitive) {
+  rt::checkNoNul(str, "str");
+  return this->ck().ContentsEqual(str.c_str(), caseSensitive);
+}
+
+bool HybridStringBuilder::contains(const std::string& str, bool caseSensitive) {
+  this->beginCall();
+  return contains_impl(str, caseSensitive);
+}
+bool HybridStringBuilder::contains_impl(const std::string& str, bool caseSensitive) {
+  rt::checkNoNul(str, "str");
+  return this->ck().Contains(str.c_str(), caseSensitive);
+}
+
+bool HybridStringBuilder::isWellFormed(const std::string& format) {
+  this->beginCall();
+  return isWellFormed_impl(format);
+}
+bool HybridStringBuilder::isWellFormed_impl(const std::string& format) {
+  rt::checkNoNul(format, "format");
+  return this->ck().IsWellFormed(format.c_str());
+}
+
+void HybridStringBuilder::prepend(const std::string& value) {
+  this->beginCall();
+  prepend_impl(value);
+}
+void HybridStringBuilder::prepend_impl(const std::string& value) {
+  rt::checkNoNul(value, "value");
+  if (!this->ck().Prepend(value.c_str())) throw this->fail("prepend");
+}
+
+void HybridStringBuilder::setString(const std::string& value) {
+  this->beginCall();
+  setString_impl(value);
+}
+void HybridStringBuilder::setString_impl(const std::string& value) {
+  rt::checkNoNul(value, "value");
+  if (!this->ck().SetString(value.c_str())) throw this->fail("setString");
+}
+
+void HybridStringBuilder::encode(const std::string& encoding, const std::string& charset) {
+  this->beginCall();
+  encode_impl(encoding, charset);
+}
+void HybridStringBuilder::encode_impl(const std::string& encoding, const std::string& charset) {
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().Encode(encoding.c_str(), charset.c_str())) throw this->fail("encode");
+}
+
+std::string HybridStringBuilder::getEncoded(const std::string& encoding, const std::string& charset) {
+  this->beginCall();
+  return getEncoded_impl(encoding, charset);
+}
+std::string HybridStringBuilder::getEncoded_impl(const std::string& encoding, const std::string& charset) {
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().GetEncoded(encoding.c_str(), charset.c_str(), _out)) throw this->fail("getEncoded");
+  return rt::stdString(_out);
+}
+
+void HybridStringBuilder::decode(const std::string& encoding, const std::string& charset) {
+  this->beginCall();
+  decode_impl(encoding, charset);
+}
+void HybridStringBuilder::decode_impl(const std::string& encoding, const std::string& charset) {
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().Decode(encoding.c_str(), charset.c_str())) throw this->fail("decode");
+}
+
+void HybridStringBuilder::trim() {
+  this->beginCall();
+  trim_impl();
+}
+void HybridStringBuilder::trim_impl() {
+  if (!this->ck().Trim()) throw this->fail("trim");
+}
+
+void HybridStringBuilder::trimInsideSpaces() {
+  this->beginCall();
+  trimInsideSpaces_impl();
+}
+void HybridStringBuilder::trimInsideSpaces_impl() {
+  if (!this->ck().TrimInsideSpaces()) throw this->fail("trimInsideSpaces");
+}
+
+bool HybridStringBuilder::startsWith(const std::string& substr, bool caseSensitive) {
+  this->beginCall();
+  return startsWith_impl(substr, caseSensitive);
+}
+bool HybridStringBuilder::startsWith_impl(const std::string& substr, bool caseSensitive) {
+  rt::checkNoNul(substr, "substr");
+  return this->ck().StartsWith(substr.c_str(), caseSensitive);
+}
+
+bool HybridStringBuilder::endsWith(const std::string& substr, bool caseSensitive) {
+  this->beginCall();
+  return endsWith_impl(substr, caseSensitive);
+}
+bool HybridStringBuilder::endsWith_impl(const std::string& substr, bool caseSensitive) {
+  rt::checkNoNul(substr, "substr");
+  return this->ck().EndsWith(substr.c_str(), caseSensitive);
+}
+
+void HybridStringBuilder::toLowercase() {
+  this->beginCall();
+  toLowercase_impl();
+}
+void HybridStringBuilder::toLowercase_impl() {
+  if (!this->ck().ToLowercase()) throw this->fail("toLowercase");
+}
+
+void HybridStringBuilder::toUppercase() {
+  this->beginCall();
+  toUppercase_impl();
+}
+void HybridStringBuilder::toUppercase_impl() {
+  if (!this->ck().ToUppercase()) throw this->fail("toUppercase");
+}
+
+void HybridStringBuilder::toCRLF() {
+  this->beginCall();
+  toCRLF_impl();
+}
+void HybridStringBuilder::toCRLF_impl() {
+  if (!this->ck().ToCRLF()) throw this->fail("toCRLF");
+}
+
+void HybridStringBuilder::toLF() {
+  this->beginCall();
+  toLF_impl();
+}
+void HybridStringBuilder::toLF_impl() {
+  if (!this->ck().ToLF()) throw this->fail("toLF");
+}
+
+void HybridStringBuilder::entityDecode() {
+  this->beginCall();
+  entityDecode_impl();
+}
+void HybridStringBuilder::entityDecode_impl() {
+  if (!this->ck().EntityDecode()) throw this->fail("entityDecode");
+}
+
+double HybridStringBuilder::replaceWord(const std::string& value, const std::string& replacement) {
+  this->beginCall();
+  return replaceWord_impl(value, replacement);
+}
+double HybridStringBuilder::replaceWord_impl(const std::string& value, const std::string& replacement) {
+  rt::checkNoNul(value, "value");
+  rt::checkNoNul(replacement, "replacement");
+  return static_cast<double>(this->ck().ReplaceWord(value.c_str(), replacement.c_str()));
+}
+
+double HybridStringBuilder::replaceBetween(const std::string& beginMark, const std::string& endMark, const std::string& value, const std::string& replacement) {
+  this->beginCall();
+  return replaceBetween_impl(beginMark, endMark, value, replacement);
+}
+double HybridStringBuilder::replaceBetween_impl(const std::string& beginMark, const std::string& endMark, const std::string& value, const std::string& replacement) {
+  rt::checkNoNul(beginMark, "beginMark");
+  rt::checkNoNul(endMark, "endMark");
+  rt::checkNoNul(value, "value");
+  rt::checkNoNul(replacement, "replacement");
+  return static_cast<double>(this->ck().ReplaceBetween(beginMark.c_str(), endMark.c_str(), value.c_str(), replacement.c_str()));
+}
+
+std::string HybridStringBuilder::getBetween(const std::string& beginMark, const std::string& endMark) {
+  this->beginCall();
+  return getBetween_impl(beginMark, endMark);
+}
+std::string HybridStringBuilder::getBetween_impl(const std::string& beginMark, const std::string& endMark) {
+  rt::checkNoNul(beginMark, "beginMark");
+  rt::checkNoNul(endMark, "endMark");
+  CkString _out;
+  if (!this->ck().GetBetween(beginMark.c_str(), endMark.c_str(), _out)) throw this->fail("getBetween");
+  return rt::stdString(_out);
+}
+
+std::string HybridStringBuilder::getAfterBetween(const std::string& searchAfter, const std::string& beginMark, const std::string& endMark) {
+  this->beginCall();
+  return getAfterBetween_impl(searchAfter, beginMark, endMark);
+}
+std::string HybridStringBuilder::getAfterBetween_impl(const std::string& searchAfter, const std::string& beginMark, const std::string& endMark) {
+  rt::checkNoNul(searchAfter, "searchAfter");
+  rt::checkNoNul(beginMark, "beginMark");
+  rt::checkNoNul(endMark, "endMark");
+  CkString _out;
+  if (!this->ck().GetAfterBetween(searchAfter.c_str(), beginMark.c_str(), endMark.c_str(), _out)) throw this->fail("getAfterBetween");
+  return rt::stdString(_out);
+}
+
+std::string HybridStringBuilder::getNth(double index, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped) {
+  this->beginCall();
+  return getNth_impl(index, delimiterChar, exceptDoubleQuoted, exceptEscaped);
+}
+std::string HybridStringBuilder::getNth_impl(double index, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped) {
+  rt::checkNoNul(delimiterChar, "delimiterChar");
+  CkString _out;
+  if (!this->ck().GetNth(rt::toInt(index, "index"), delimiterChar.c_str(), exceptDoubleQuoted, exceptEscaped, _out)) throw this->fail("getNth");
+  return rt::stdString(_out);
+}
+
+void HybridStringBuilder::setNth(double index, const std::string& value, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped) {
+  this->beginCall();
+  setNth_impl(index, value, delimiterChar, exceptDoubleQuoted, exceptEscaped);
+}
+void HybridStringBuilder::setNth_impl(double index, const std::string& value, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped) {
+  rt::checkNoNul(value, "value");
+  rt::checkNoNul(delimiterChar, "delimiterChar");
+  if (!this->ck().SetNth(rt::toInt(index, "index"), value.c_str(), delimiterChar.c_str(), exceptDoubleQuoted, exceptEscaped)) throw this->fail("setNth");
+}
+
+void HybridStringBuilder::loadFile(const std::string& path, const std::string& charset) {
+  this->beginCall();
+  loadFile_impl(path, charset);
+}
+void HybridStringBuilder::loadFile_impl(const std::string& path, const std::string& charset) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().LoadFile(path.c_str(), charset.c_str())) throw this->fail("loadFile");
+}
+
+void HybridStringBuilder::writeFile(const std::string& path, const std::string& charset, bool emitBom) {
+  this->beginCall();
+  writeFile_impl(path, charset, emitBom);
+}
+void HybridStringBuilder::writeFile_impl(const std::string& path, const std::string& charset, bool emitBom) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().WriteFile(path.c_str(), charset.c_str(), emitBom)) throw this->fail("writeFile");
+}
+
+void HybridStringBuilder::appendSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  appendSb_impl(sb);
+}
+void HybridStringBuilder::appendSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().AppendSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("appendSb");
+}
+
+bool HybridStringBuilder::contentsEqualSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool caseSensitive) {
+  this->beginCall();
+  return contentsEqualSb_impl(sb, caseSensitive);
+}
+bool HybridStringBuilder::contentsEqualSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool caseSensitive) {
+  return this->ck().ContentsEqualSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), caseSensitive);
+}
+
+std::string HybridStringBuilder::lastNLines(double numLines, bool bCrlf) {
+  this->beginCall();
+  return lastNLines_impl(numLines, bCrlf);
+}
+std::string HybridStringBuilder::lastNLines_impl(double numLines, bool bCrlf) {
+  CkString _out;
+  if (!this->ck().LastNLines(rt::toInt(numLines, "numLines"), bCrlf, _out)) throw this->fail("lastNLines");
+  return rt::stdString(_out);
+}
+
+void HybridStringBuilder::appendBd(const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& charset, double offset, double numBytes) {
+  this->beginCall();
+  appendBd_impl(binData, charset, offset, numBytes);
+}
+void HybridStringBuilder::appendBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& charset, double offset, double numBytes) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AppendBd(rt::implOf<HybridBinData>(binData, "binData").ck(), charset.c_str(), rt::toInt(offset, "offset"), rt::toInt(numBytes, "numBytes"))) throw this->fail("appendBd");
+}
+
+void HybridStringBuilder::replaceAllBetween(const std::string& beginMark, const std::string& endMark, const std::string& replacement, bool replaceMarks) {
+  this->beginCall();
+  replaceAllBetween_impl(beginMark, endMark, replacement, replaceMarks);
+}
+void HybridStringBuilder::replaceAllBetween_impl(const std::string& beginMark, const std::string& endMark, const std::string& replacement, bool replaceMarks) {
+  rt::checkNoNul(beginMark, "beginMark");
+  rt::checkNoNul(endMark, "endMark");
+  rt::checkNoNul(replacement, "replacement");
+  if (!this->ck().ReplaceAllBetween(beginMark.c_str(), endMark.c_str(), replacement.c_str(), replaceMarks)) throw this->fail("replaceAllBetween");
+}
+
+void HybridStringBuilder::appendLine(const std::string& str, bool crlf) {
+  this->beginCall();
+  appendLine_impl(str, crlf);
+}
+void HybridStringBuilder::appendLine_impl(const std::string& str, bool crlf) {
+  rt::checkNoNul(str, "str");
+  if (!this->ck().AppendLine(str.c_str(), crlf)) throw this->fail("appendLine");
+}
+
+void HybridStringBuilder::secureClear() {
+  this->beginCall();
+  secureClear_impl();
+}
+void HybridStringBuilder::secureClear_impl() {
+  this->ck().SecureClear();
+}
+
+double HybridStringBuilder::replaceI(const std::string& value, double replacement) {
+  this->beginCall();
+  return replaceI_impl(value, replacement);
+}
+double HybridStringBuilder::replaceI_impl(const std::string& value, double replacement) {
+  rt::checkNoNul(value, "value");
+  return static_cast<double>(this->ck().ReplaceI(value.c_str(), rt::toInt(replacement, "replacement")));
+}
+
+bool HybridStringBuilder::containsWord(const std::string& word, bool caseSensitive) {
+  this->beginCall();
+  return containsWord_impl(word, caseSensitive);
+}
+bool HybridStringBuilder::containsWord_impl(const std::string& word, bool caseSensitive) {
+  rt::checkNoNul(word, "word");
+  return this->ck().ContainsWord(word.c_str(), caseSensitive);
+}
+
+void HybridStringBuilder::punyEncode() {
+  this->beginCall();
+  punyEncode_impl();
+}
+void HybridStringBuilder::punyEncode_impl() {
+  if (!this->ck().PunyEncode()) throw this->fail("punyEncode");
+}
+
+void HybridStringBuilder::punyDecode() {
+  this->beginCall();
+  punyDecode_impl();
+}
+void HybridStringBuilder::punyDecode_impl() {
+  if (!this->ck().PunyDecode()) throw this->fail("punyDecode");
+}
+
+void HybridStringBuilder::replaceAfterFinal(const std::string& marker, const std::string& replacement) {
+  this->beginCall();
+  replaceAfterFinal_impl(marker, replacement);
+}
+void HybridStringBuilder::replaceAfterFinal_impl(const std::string& marker, const std::string& replacement) {
+  rt::checkNoNul(marker, "marker");
+  rt::checkNoNul(replacement, "replacement");
+  if (!this->ck().ReplaceAfterFinal(marker.c_str(), replacement.c_str())) throw this->fail("replaceAfterFinal");
+}
+
+void HybridStringBuilder::writeFileIfModified(const std::string& path, const std::string& charset, bool emitBom) {
+  this->beginCall();
+  writeFileIfModified_impl(path, charset, emitBom);
+}
+void HybridStringBuilder::writeFileIfModified_impl(const std::string& path, const std::string& charset, bool emitBom) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().WriteFileIfModified(path.c_str(), charset.c_str(), emitBom)) throw this->fail("writeFileIfModified");
+}
+
+std::string HybridStringBuilder::getBefore(const std::string& marker, bool removeFlag) {
+  this->beginCall();
+  return getBefore_impl(marker, removeFlag);
+}
+std::string HybridStringBuilder::getBefore_impl(const std::string& marker, bool removeFlag) {
+  rt::checkNoNul(marker, "marker");
+  CkString _out;
+  if (!this->ck().GetBefore(marker.c_str(), removeFlag, _out)) throw this->fail("getBefore");
+  return rt::stdString(_out);
+}
+
+void HybridStringBuilder::removeBefore(const std::string& marker) {
+  this->beginCall();
+  removeBefore_impl(marker);
+}
+void HybridStringBuilder::removeBefore_impl(const std::string& marker) {
+  rt::checkNoNul(marker, "marker");
+  if (!this->ck().RemoveBefore(marker.c_str())) throw this->fail("removeBefore");
+}
+
+void HybridStringBuilder::replaceFirst(const std::string& value, const std::string& replacement) {
+  this->beginCall();
+  replaceFirst_impl(value, replacement);
+}
+void HybridStringBuilder::replaceFirst_impl(const std::string& value, const std::string& replacement) {
+  rt::checkNoNul(value, "value");
+  rt::checkNoNul(replacement, "replacement");
+  if (!this->ck().ReplaceFirst(value.c_str(), replacement.c_str())) throw this->fail("replaceFirst");
+}
+
+std::string HybridStringBuilder::getAfterFinal(const std::string& marker, bool removeFlag) {
+  this->beginCall();
+  return getAfterFinal_impl(marker, removeFlag);
+}
+std::string HybridStringBuilder::getAfterFinal_impl(const std::string& marker, bool removeFlag) {
+  rt::checkNoNul(marker, "marker");
+  CkString _out;
+  if (!this->ck().GetAfterFinal(marker.c_str(), removeFlag, _out)) throw this->fail("getAfterFinal");
+  return rt::stdString(_out);
+}
+
+void HybridStringBuilder::removeAfterFinal(const std::string& marker) {
+  this->beginCall();
+  removeAfterFinal_impl(marker);
+}
+void HybridStringBuilder::removeAfterFinal_impl(const std::string& marker) {
+  rt::checkNoNul(marker, "marker");
+  if (!this->ck().RemoveAfterFinal(marker.c_str())) throw this->fail("removeAfterFinal");
+}
+
+void HybridStringBuilder::obfuscate() {
+  this->beginCall();
+  obfuscate_impl();
+}
+void HybridStringBuilder::obfuscate_impl() {
+  this->ck().Obfuscate();
+}
+
+void HybridStringBuilder::unobfuscate() {
+  this->beginCall();
+  unobfuscate_impl();
+}
+void HybridStringBuilder::unobfuscate_impl() {
+  this->ck().Unobfuscate();
+}
+
+double HybridStringBuilder::replaceNoCase(const std::string& value, const std::string& replacement) {
+  this->beginCall();
+  return replaceNoCase_impl(value, replacement);
+}
+double HybridStringBuilder::replaceNoCase_impl(const std::string& value, const std::string& replacement) {
+  rt::checkNoNul(value, "value");
+  rt::checkNoNul(replacement, "replacement");
+  return static_cast<double>(this->ck().ReplaceNoCase(value.c_str(), replacement.c_str()));
+}
+
+void HybridStringBuilder::decodeAndAppend(const std::string& value, const std::string& encoding, const std::string& charset) {
+  this->beginCall();
+  decodeAndAppend_impl(value, encoding, charset);
+}
+void HybridStringBuilder::decodeAndAppend_impl(const std::string& value, const std::string& encoding, const std::string& charset) {
+  rt::checkNoNul(value, "value");
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().DecodeAndAppend(value.c_str(), encoding.c_str(), charset.c_str())) throw this->fail("decodeAndAppend");
+}
+
+void HybridStringBuilder::shorten(double numChars) {
+  this->beginCall();
+  shorten_impl(numChars);
+}
+void HybridStringBuilder::shorten_impl(double numChars) {
+  if (!this->ck().Shorten(rt::toInt(numChars, "numChars"))) throw this->fail("shorten");
+}
+
+void HybridStringBuilder::removeCharsAt(double startIndex, double numChars) {
+  this->beginCall();
+  removeCharsAt_impl(startIndex, numChars);
+}
+void HybridStringBuilder::removeCharsAt_impl(double startIndex, double numChars) {
+  if (!this->ck().RemoveCharsAt(rt::toInt(startIndex, "startIndex"), rt::toInt(numChars, "numChars"))) throw this->fail("removeCharsAt");
+}
+
+std::string HybridStringBuilder::getRange(double startIndex, double numChars, bool removeFlag) {
+  this->beginCall();
+  return getRange_impl(startIndex, numChars, removeFlag);
+}
+std::string HybridStringBuilder::getRange_impl(double startIndex, double numChars, bool removeFlag) {
+  CkString _out;
+  if (!this->ck().GetRange(rt::toInt(startIndex, "startIndex"), rt::toInt(numChars, "numChars"), removeFlag, _out)) throw this->fail("getRange");
+  return rt::stdString(_out);
+}
+
+std::string HybridStringBuilder::getHash(const std::string& algorithm, const std::string& encoding, const std::string& charset) {
+  this->beginCall();
+  return getHash_impl(algorithm, encoding, charset);
+}
+std::string HybridStringBuilder::getHash_impl(const std::string& algorithm, const std::string& encoding, const std::string& charset) {
+  rt::checkNoNul(algorithm, "algorithm");
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().GetHash(algorithm.c_str(), encoding.c_str(), charset.c_str(), _out)) throw this->fail("getHash");
+  return rt::stdString(_out);
+}
+
+void HybridStringBuilder::removeAccents() {
+  this->beginCall();
+  removeAccents_impl();
+}
+void HybridStringBuilder::removeAccents_impl() {
+  if (!this->ck().RemoveAccents()) throw this->fail("removeAccents");
+}
+
+void HybridStringBuilder::appendUuid(bool lowerCase) {
+  this->beginCall();
+  appendUuid_impl(lowerCase);
+}
+void HybridStringBuilder::appendUuid_impl(bool lowerCase) {
+  if (!this->ck().AppendUuid(lowerCase)) throw this->fail("appendUuid");
+}
+
+void HybridStringBuilder::appendRandom(double numBytes, const std::string& encoding) {
+  this->beginCall();
+  appendRandom_impl(numBytes, encoding);
+}
+void HybridStringBuilder::appendRandom_impl(double numBytes, const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().AppendRandom(rt::toInt(numBytes, "numBytes"), encoding.c_str())) throw this->fail("appendRandom");
+}
+
+void HybridStringBuilder::appendUuid7(bool lowerCase) {
+  this->beginCall();
+  appendUuid7_impl(lowerCase);
+}
+void HybridStringBuilder::appendUuid7_impl(bool lowerCase) {
+  if (!this->ck().AppendUuid7(lowerCase)) throw this->fail("appendUuid7");
+}
+
+void HybridStringBuilder::removeEmojis() {
+  this->beginCall();
+  removeEmojis_impl();
+}
+void HybridStringBuilder::removeEmojis_impl() {
+  this->ck().RemoveEmojis();
+}
+
+double HybridStringBuilder::regexMatch(const std::string& pattern, const std::shared_ptr<HybridJsonObjectSpec>& json, double timeoutMs) {
+  this->beginCall();
+  return regexMatch_impl(pattern, json, timeoutMs);
+}
+double HybridStringBuilder::regexMatch_impl(const std::string& pattern, const std::shared_ptr<HybridJsonObjectSpec>& json, double timeoutMs) {
+  rt::checkNoNul(pattern, "pattern");
+  return static_cast<double>(this->ck().RegexMatch(pattern.c_str(), rt::implOf<HybridJsonObject>(json, "json").ck(), rt::toInt(timeoutMs, "timeoutMs")));
+}
+
+void HybridStringBuilder::regexReplace(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  regexReplace_impl(json);
+}
+void HybridStringBuilder::regexReplace_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().RegexReplace(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("regexReplace");
+}
+
+void HybridStringBuilder::maskQuotedStrings(const std::string& maskChar, double quoteType, const std::shared_ptr<HybridStringTableSpec>& maskedStrings) {
+  this->beginCall();
+  maskQuotedStrings_impl(maskChar, quoteType, maskedStrings);
+}
+void HybridStringBuilder::maskQuotedStrings_impl(const std::string& maskChar, double quoteType, const std::shared_ptr<HybridStringTableSpec>& maskedStrings) {
+  rt::checkNoNul(maskChar, "maskChar");
+  if (!this->ck().MaskQuotedStrings(maskChar.c_str(), rt::toInt(quoteType, "quoteType"), rt::implOf<HybridStringTable>(maskedStrings, "maskedStrings").ck())) throw this->fail("maskQuotedStrings");
+}
+
+void HybridStringBuilder::restoreMaskedStrings(double quoteType, const std::shared_ptr<HybridStringTableSpec>& maskedStrings) {
+  this->beginCall();
+  restoreMaskedStrings_impl(quoteType, maskedStrings);
+}
+void HybridStringBuilder::restoreMaskedStrings_impl(double quoteType, const std::shared_ptr<HybridStringTableSpec>& maskedStrings) {
+  if (!this->ck().RestoreMaskedStrings(rt::toInt(quoteType, "quoteType"), rt::implOf<HybridStringTable>(maskedStrings, "maskedStrings").ck())) throw this->fail("restoreMaskedStrings");
+}
+
+void HybridStringBuilder::markdownToHtml(const std::shared_ptr<HybridJsonObjectSpec>& options, const std::shared_ptr<HybridStringBuilderSpec>& sbHtml) {
+  this->beginCall();
+  markdownToHtml_impl(options, sbHtml);
+}
+void HybridStringBuilder::markdownToHtml_impl(const std::shared_ptr<HybridJsonObjectSpec>& options, const std::shared_ptr<HybridStringBuilderSpec>& sbHtml) {
+  if (!this->ck().MarkdownToHtml(rt::implOf<HybridJsonObject>(options, "options").ck(), rt::implOf<HybridStringBuilder>(sbHtml, "sbHtml").ck())) throw this->fail("markdownToHtml");
+}
+
+void HybridStringBuilder::getRangeSb(double startIndex, double numChars, bool removeFlag, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  getRangeSb_impl(startIndex, numChars, removeFlag, sb);
+}
+void HybridStringBuilder::getRangeSb_impl(double startIndex, double numChars, bool removeFlag, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().GetRangeSb(rt::toInt(startIndex, "startIndex"), rt::toInt(numChars, "numChars"), removeFlag, rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("getRangeSb");
+}
+
+void HybridStringBuilder::appendLn(const std::string& str) {
+  this->beginCall();
+  appendLn_impl(str);
+}
+void HybridStringBuilder::appendLn_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  if (!this->ck().AppendLn(str.c_str())) throw this->fail("appendLn");
+}
+
+} // namespace margelo::nitro::chilkat