706 lines
29 KiB
C++
706 lines
29 KiB
C++
// CkStringBuilder.h: interface for the CkStringBuilder class.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// This header is generated for Chilkat 11.3.0
|
|
|
|
#define _CkVersion 11.3.0
|
|
|
|
#ifndef _CkStringBuilder_H
|
|
#define _CkStringBuilder_H
|
|
|
|
#include "chilkatDefs.h"
|
|
#include "CkString.h"
|
|
#include "CkMultiByteBase.h"
|
|
|
|
class CkBinData;
|
|
class CkByteData;
|
|
class CkJsonObject;
|
|
class CkStringTable;
|
|
|
|
|
|
|
|
#if !defined(__sun__) && !defined(__sun)
|
|
#pragma pack (push, 8)
|
|
#endif
|
|
|
|
|
|
#undef Copy
|
|
|
|
// CLASS: CkStringBuilder
|
|
class CK_VISIBLE_PUBLIC CkStringBuilder : public CkMultiByteBase
|
|
{
|
|
private:
|
|
|
|
// Don't allow assignment or copying these objects.
|
|
CkStringBuilder(const CkStringBuilder &);
|
|
CkStringBuilder &operator=(const CkStringBuilder &);
|
|
|
|
public:
|
|
CkStringBuilder(void);
|
|
virtual ~CkStringBuilder(void);
|
|
|
|
static CkStringBuilder *createNew(void);
|
|
static CkStringBuilder *createNew2(int progLang);
|
|
void CK_VISIBLE_PRIVATE inject(void *impl);
|
|
|
|
// May be called when finished with the object to free/dispose of any
|
|
// internal resources held by the object.
|
|
void dispose(void);
|
|
|
|
|
|
|
|
|
|
|
|
// BEGIN PUBLIC INTERFACE
|
|
|
|
// ----------------------
|
|
// Properties
|
|
// ----------------------
|
|
// Returns true if the content contains one or more emoji characters.
|
|
bool get_HasEmojis(void);
|
|
|
|
// Returns the content of the string converted to an integer.
|
|
int get_IntValue(void);
|
|
// Returns the content of the string converted to an integer.
|
|
void put_IntValue(int newVal);
|
|
|
|
// Returns true if the content contains only those characters allowed in the
|
|
// base64 encoding. A base64 string is composed of characters 'A'..'Z', 'a'..'z',
|
|
// '0'..'9', '+', '/' and it is often padded at the end with up to two '=', to make
|
|
// the length a multiple of 4. Whitespace is ignored.
|
|
bool get_IsBase64(void);
|
|
|
|
// The number of characters of the string contained within this instance.
|
|
int get_Length(void);
|
|
|
|
|
|
|
|
// ----------------------
|
|
// Methods
|
|
// ----------------------
|
|
// Appends a copy of the specified string to this instance.
|
|
bool Append(const char *value);
|
|
|
|
|
|
// Appends the contents of binData. The charset specifies the character encoding of the
|
|
// bytes contained in binData. The charset can be any of the supported encodings listed
|
|
// at Chilkat Supported Character Encodings. To append the entire contents of binData,
|
|
// set offset and numBytes equal to zero. To append a range of binData, set the offset and
|
|
// numBytes to specify the range.
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
|
|
bool AppendBd(CkBinData &binData, const char *charset, int offset, int numBytes);
|
|
|
|
|
|
// Appends binary data using the encoding specified by encoding, such as base64 , hex ,
|
|
// etc.
|
|
bool AppendEncoded(CkByteData &binaryData, const char *encoding);
|
|
|
|
|
|
// Appends the string representation of a specified 32-bit signed integer to this
|
|
// instance.
|
|
bool AppendInt(int value);
|
|
|
|
|
|
// Appends the string representation of a specified 64-bit signed integer to this
|
|
// instance.
|
|
bool AppendInt64(__int64 value);
|
|
|
|
|
|
// Appends the value followed by a CRLF or LF to the end of the curent StringBuilder
|
|
// object. If crlf is true, then a CRLF line ending is used. Otherwise a LF line
|
|
// ending is used.
|
|
bool AppendLine(const char *value, bool crlf);
|
|
|
|
|
|
// Append numBytes random bytes encoded according to encoding. encoding can be hex , hex_lower
|
|
// , base64 , base64url , or any other encoding supported by Chilkat.
|
|
bool AppendRandom(int numBytes, const char *encoding);
|
|
|
|
|
|
// Appends the contents of another StringBuilder to this instance.
|
|
bool AppendSb(CkStringBuilder &sb);
|
|
|
|
|
|
// Generates and appends a random GUID/UUID such as
|
|
// 63c35f38-2b5f-4600-b3da-3ddee86d62b3. If lowerCase is true, then the hex values use
|
|
// lowercase ( a - f ). If lowerCase is false then uppercase is used ( A - F ).
|
|
//
|
|
// Note: This generates a version 4 UUID.
|
|
//
|
|
bool AppendUuid(bool lowerCase);
|
|
|
|
|
|
// Generates and appends a random version 7 UUID. If lowerCase is true, then the hex
|
|
// values use lowercase ( a - f ). If lowerCase is false then uppercase is used ( A -
|
|
// F ).
|
|
bool AppendUuid7(bool lowerCase);
|
|
|
|
|
|
// Removes all characters from the current StringBuilder instance.
|
|
void Clear(void);
|
|
|
|
|
|
// Returns true if the str is contained within this object. For case sensitive
|
|
// matching, set caseSensitive equal to true. For case-insensitive, set caseSensitive equal to
|
|
// false.
|
|
bool Contains(const char *str, bool caseSensitive);
|
|
|
|
|
|
// Returns true if the word is contained within this object, but only if it is a
|
|
// whole word. This method is limited to finding whole words in strings that only
|
|
// contains characters in the Latin1 charset (i.e. iso-8859-1 or Windows-1252). A
|
|
// whole word can only contain alphanumeric chars where the alpha chars are
|
|
// restricted to those of the Latin1 alpha chars. (The underscore character is also
|
|
// considered part of a word.)
|
|
//
|
|
// For case sensitive matching, set caseSensitive equal to true. For case-insensitive, set
|
|
// caseSensitive equal to false.
|
|
//
|
|
bool ContainsWord(const char *word, bool caseSensitive);
|
|
|
|
|
|
// Returns true if the contents of this object equals the str. Returns false
|
|
// if unequal. For case insensitive equality, set caseSensitive equal to false.
|
|
bool ContentsEqual(const char *str, bool caseSensitive);
|
|
|
|
|
|
// Returns true if the contents of this object equals the sb. Returns false
|
|
// if unequal. For case insensitive equality, set caseSensitive equal to false.
|
|
bool ContentsEqualSb(CkStringBuilder &sb, bool caseSensitive);
|
|
|
|
|
|
// Decodes and replaces the contents with the decoded string. The encoding can be set
|
|
// to any of the following strings: base64 , hex , quoted-printable (or qp ), url ,
|
|
// base32 , Q , B , url_rc1738 , url_rfc2396 , url_rfc3986 , url_oauth , uu ,
|
|
// modBase64 , or html (for HTML entity encoding). The full up-to-date list of
|
|
// supported binary encodings is available at the link entitled Supported Binary
|
|
// Encodings below.
|
|
//
|
|
// Note: This method can only be called if the encoded content decodes to a string.
|
|
// The charset indicates the charset to be used in intepreting the decoded bytes. For
|
|
// example, the charset can be utf-8 , utf-16 , iso-8859-1 , shift_JIS , etc.
|
|
//
|
|
bool Decode(const char *encoding, const char *charset);
|
|
|
|
|
|
// Decodes a binary encoded string, where the binary encoding (such as url , hex ,
|
|
// base64 , etc.) is specified by encoding, and the underlying charset encoding (such
|
|
// as utf-8 , windows-1252 , etc.) is specified by charset. The decoded string is
|
|
// appended to this object.
|
|
bool DecodeAndAppend(const char *value, const char *encoding, const char *charset);
|
|
|
|
|
|
// Encodes to base64, hex, quoted-printable, URL encoding, etc. The encoding can be set
|
|
// to any of the following strings: base64 , hex , quoted-printable (or qp ), url ,
|
|
// base32 , Q , B , url_rc1738 , url_rfc2396 , url_rfc3986 , url_oauth , uu ,
|
|
// modBase64 , or html (for HTML entity encoding). The full up-to-date list of
|
|
// supported binary encodings is available at the link entitled Supported Binary
|
|
// Encodings below.
|
|
bool Encode(const char *encoding, const char *charset);
|
|
|
|
|
|
// Returns true if the string ends with substr. Otherwise returns false. The
|
|
// comparison is case sensitive if caseSensitive is true, and case insensitive if caseSensitive is
|
|
// false.
|
|
bool EndsWith(const char *substr, bool caseSensitive);
|
|
|
|
|
|
// Decodes HTML entities. See HTML entities for more information about HTML
|
|
// entities.
|
|
//
|
|
// References:
|
|
// 1: https://duckduckgo.com/?q=html+entities&bext=wfp&ia=web
|
|
bool EntityDecode(void);
|
|
|
|
|
|
// Begin searching after the 1st occurrence of searchAfter is found, and then return the
|
|
// substring found between the next occurrence of beginMark and the next occurrence of
|
|
// endMark.
|
|
bool GetAfterBetween(const char *searchAfter, const char *beginMark, const char *endMark, CkString &outStr);
|
|
|
|
// Begin searching after the 1st occurrence of searchAfter is found, and then return the
|
|
// substring found between the next occurrence of beginMark and the next occurrence of
|
|
// endMark.
|
|
const char *getAfterBetween(const char *searchAfter, const char *beginMark, const char *endMark);
|
|
// Begin searching after the 1st occurrence of searchAfter is found, and then return the
|
|
// substring found between the next occurrence of beginMark and the next occurrence of
|
|
// endMark.
|
|
const char *afterBetween(const char *searchAfter, const char *beginMark, const char *endMark);
|
|
|
|
|
|
// Returns the substring found after the final occurrence of marker. If removeFlag is
|
|
// true, the marker and the content that follows is removed from this content.
|
|
//
|
|
// If the marker is not present, then the entire string is returned. In this case, if
|
|
// removeFlag is true, this object is also cleared.
|
|
//
|
|
bool GetAfterFinal(const char *marker, bool removeFlag, CkString &outStr);
|
|
|
|
// Returns the substring found after the final occurrence of marker. If removeFlag is
|
|
// true, the marker and the content that follows is removed from this content.
|
|
//
|
|
// If the marker is not present, then the entire string is returned. In this case, if
|
|
// removeFlag is true, this object is also cleared.
|
|
//
|
|
const char *getAfterFinal(const char *marker, bool removeFlag);
|
|
// Returns the substring found after the final occurrence of marker. If removeFlag is
|
|
// true, the marker and the content that follows is removed from this content.
|
|
//
|
|
// If the marker is not present, then the entire string is returned. In this case, if
|
|
// removeFlag is true, this object is also cleared.
|
|
//
|
|
const char *afterFinal(const char *marker, bool removeFlag);
|
|
|
|
|
|
// Returns the contents as a string.
|
|
bool GetAsString(CkString &outStr);
|
|
|
|
// Returns the contents as a string.
|
|
const char *getAsString(void);
|
|
// Returns the contents as a string.
|
|
const char *asString(void);
|
|
|
|
|
|
// Returns the substring found before the 1st occurrence of marker. If removeFlag is
|
|
// true, the content up to and including the marker is removed from this object's
|
|
// contents.
|
|
//
|
|
// If the marker is not present, then the entire string is returned. In this case, if
|
|
// removeFlag is true, this object is also cleared.
|
|
//
|
|
bool GetBefore(const char *marker, bool removeFlag, CkString &outStr);
|
|
|
|
// Returns the substring found before the 1st occurrence of marker. If removeFlag is
|
|
// true, the content up to and including the marker is removed from this object's
|
|
// contents.
|
|
//
|
|
// If the marker is not present, then the entire string is returned. In this case, if
|
|
// removeFlag is true, this object is also cleared.
|
|
//
|
|
const char *getBefore(const char *marker, bool removeFlag);
|
|
// Returns the substring found before the 1st occurrence of marker. If removeFlag is
|
|
// true, the content up to and including the marker is removed from this object's
|
|
// contents.
|
|
//
|
|
// If the marker is not present, then the entire string is returned. In this case, if
|
|
// removeFlag is true, this object is also cleared.
|
|
//
|
|
const char *before(const char *marker, bool removeFlag);
|
|
|
|
|
|
// Returns the substring found between the 1st occurrence of beginMark and the next
|
|
// occurrence of endMark.
|
|
bool GetBetween(const char *beginMark, const char *endMark, CkString &outStr);
|
|
|
|
// Returns the substring found between the 1st occurrence of beginMark and the next
|
|
// occurrence of endMark.
|
|
const char *getBetween(const char *beginMark, const char *endMark);
|
|
// Returns the substring found between the 1st occurrence of beginMark and the next
|
|
// occurrence of endMark.
|
|
const char *between(const char *beginMark, const char *endMark);
|
|
|
|
|
|
// Decodes and returns the decoded bytes. The encoding can be set to any of the
|
|
// following strings: base64 , hex , quoted-printable (or qp ), url , base32 , Q ,
|
|
// B , url_rc1738 , url_rfc2396 , url_rfc3986 , url_oauth , uu , modBase64 , or
|
|
// html (for HTML entity encoding). The full up-to-date list of supported binary
|
|
// encodings is available at the link entitled Supported Binary Encodings below.
|
|
bool GetDecoded(const char *encoding, CkByteData &outBytes);
|
|
|
|
|
|
// Returns the string contents encoded in an encoding such as base64, hex,
|
|
// quoted-printable, or URL-encoding. The encoding can be set to any of the following
|
|
// strings: base64 , hex , quoted-printable (or qp ), url , base32 , Q , B ,
|
|
// url_rc1738 , url_rfc2396 , url_rfc3986 , url_oauth , uu , modBase64 , or html
|
|
// (for HTML entity encoding). The full up-to-date list of supported binary
|
|
// encodings is available at the link entitled Supported Binary Encodings below.
|
|
//
|
|
// Note: The Encode method modifies the content of this object. The GetEncoded
|
|
// method leaves this object's content unmodified.
|
|
//
|
|
bool GetEncoded(const char *encoding, const char *charset, CkString &outStr);
|
|
|
|
// Returns the string contents encoded in an encoding such as base64, hex,
|
|
// quoted-printable, or URL-encoding. The encoding can be set to any of the following
|
|
// strings: base64 , hex , quoted-printable (or qp ), url , base32 , Q , B ,
|
|
// url_rc1738 , url_rfc2396 , url_rfc3986 , url_oauth , uu , modBase64 , or html
|
|
// (for HTML entity encoding). The full up-to-date list of supported binary
|
|
// encodings is available at the link entitled Supported Binary Encodings below.
|
|
//
|
|
// Note: The Encode method modifies the content of this object. The GetEncoded
|
|
// method leaves this object's content unmodified.
|
|
//
|
|
const char *getEncoded(const char *encoding, const char *charset);
|
|
// Returns the string contents encoded in an encoding such as base64, hex,
|
|
// quoted-printable, or URL-encoding. The encoding can be set to any of the following
|
|
// strings: base64 , hex , quoted-printable (or qp ), url , base32 , Q , B ,
|
|
// url_rc1738 , url_rfc2396 , url_rfc3986 , url_oauth , uu , modBase64 , or html
|
|
// (for HTML entity encoding). The full up-to-date list of supported binary
|
|
// encodings is available at the link entitled Supported Binary Encodings below.
|
|
//
|
|
// Note: The Encode method modifies the content of this object. The GetEncoded
|
|
// method leaves this object's content unmodified.
|
|
//
|
|
const char *encoded(const char *encoding, const char *charset);
|
|
|
|
|
|
// Returns the hash of the contents of this object. The algorithm is the hash algorithm,
|
|
// and can be sha1 , sha256 , sha384 , sha512 , sha3-224 , sha3-256 , sha3-384 ,
|
|
// sha3-512 , md2 , md5 , ripemd128 , ripemd160 , ripemd256 , or ripemd320 . The
|
|
// encoding can be base64 , modBase64 , base64Url , base32 , base58 , qp (for
|
|
// quoted-printable), url (for url-encoding), hex , hexLower , or any of the
|
|
// encodings found at Chilkat Binary Encodings List.
|
|
//
|
|
// The charset is the character encoding byte representation to hash. It is typically
|
|
// utf-8 . It can be any of the chacter encodings listed at Chilkat Character
|
|
// Encodings List.
|
|
//
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
// 2: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
|
|
bool GetHash(const char *algorithm, const char *encoding, const char *charset, CkString &outStr);
|
|
|
|
// Returns the hash of the contents of this object. The algorithm is the hash algorithm,
|
|
// and can be sha1 , sha256 , sha384 , sha512 , sha3-224 , sha3-256 , sha3-384 ,
|
|
// sha3-512 , md2 , md5 , ripemd128 , ripemd160 , ripemd256 , or ripemd320 . The
|
|
// encoding can be base64 , modBase64 , base64Url , base32 , base58 , qp (for
|
|
// quoted-printable), url (for url-encoding), hex , hexLower , or any of the
|
|
// encodings found at Chilkat Binary Encodings List.
|
|
//
|
|
// The charset is the character encoding byte representation to hash. It is typically
|
|
// utf-8 . It can be any of the chacter encodings listed at Chilkat Character
|
|
// Encodings List.
|
|
//
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
// 2: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
|
|
const char *getHash(const char *algorithm, const char *encoding, const char *charset);
|
|
// Returns the hash of the contents of this object. The algorithm is the hash algorithm,
|
|
// and can be sha1 , sha256 , sha384 , sha512 , sha3-224 , sha3-256 , sha3-384 ,
|
|
// sha3-512 , md2 , md5 , ripemd128 , ripemd160 , ripemd256 , or ripemd320 . The
|
|
// encoding can be base64 , modBase64 , base64Url , base32 , base58 , qp (for
|
|
// quoted-printable), url (for url-encoding), hex , hexLower , or any of the
|
|
// encodings found at Chilkat Binary Encodings List.
|
|
//
|
|
// The charset is the character encoding byte representation to hash. It is typically
|
|
// utf-8 . It can be any of the chacter encodings listed at Chilkat Character
|
|
// Encodings List.
|
|
//
|
|
//
|
|
// References:
|
|
// 1: https://www.chilkatsoft.com/binary_encodings.asp
|
|
// 2: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
|
|
const char *hash(const char *algorithm, const char *encoding, const char *charset);
|
|
|
|
|
|
// Returns the Nth substring in string that is a list delimted by delimiterChar. The first
|
|
// substring is at index 0. If exceptDoubleQuoted is true, then the delimiter char found
|
|
// between double quotes is not treated as a delimiter. If exceptEscaped is true, then an
|
|
// escaped (with a backslash) delimiter char is not treated as a delimiter.
|
|
bool GetNth(int index, const char *delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped, CkString &outStr);
|
|
|
|
// Returns the Nth substring in string that is a list delimted by delimiterChar. The first
|
|
// substring is at index 0. If exceptDoubleQuoted is true, then the delimiter char found
|
|
// between double quotes is not treated as a delimiter. If exceptEscaped is true, then an
|
|
// escaped (with a backslash) delimiter char is not treated as a delimiter.
|
|
const char *getNth(int index, const char *delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped);
|
|
// Returns the Nth substring in string that is a list delimted by delimiterChar. The first
|
|
// substring is at index 0. If exceptDoubleQuoted is true, then the delimiter char found
|
|
// between double quotes is not treated as a delimiter. If exceptEscaped is true, then an
|
|
// escaped (with a backslash) delimiter char is not treated as a delimiter.
|
|
const char *nth(int index, const char *delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped);
|
|
|
|
|
|
// Returns a string containing the specified range of characters from this
|
|
// instance. If removeFlag is true, then the range of chars is removed from this
|
|
// instance.
|
|
//
|
|
// Note: It was discovered that the range of chars was always removed regardless of
|
|
// the value of removeFlag. This is fixed in v9.5.0.89.
|
|
//
|
|
bool GetRange(int startIndex, int numChars, bool removeFlag, CkString &outStr);
|
|
|
|
// Returns a string containing the specified range of characters from this
|
|
// instance. If removeFlag is true, then the range of chars is removed from this
|
|
// instance.
|
|
//
|
|
// Note: It was discovered that the range of chars was always removed regardless of
|
|
// the value of removeFlag. This is fixed in v9.5.0.89.
|
|
//
|
|
const char *getRange(int startIndex, int numChars, bool removeFlag);
|
|
// Returns a string containing the specified range of characters from this
|
|
// instance. If removeFlag is true, then the range of chars is removed from this
|
|
// instance.
|
|
//
|
|
// Note: It was discovered that the range of chars was always removed regardless of
|
|
// the value of removeFlag. This is fixed in v9.5.0.89.
|
|
//
|
|
const char *range(int startIndex, int numChars, bool removeFlag);
|
|
|
|
|
|
// Appends to startIndex the specified range of characters from this instance. If removeFlag is
|
|
// true, then the range of chars is removed from this instance.
|
|
bool GetRangeSb(int startIndex, int numChars, bool removeFlag, CkStringBuilder &sb);
|
|
|
|
|
|
// Returns the last N lines of the text. If fewer than numLines lines exists, then all
|
|
// of the text is returned. If bCrlf is true, then the line endings of the
|
|
// returned string are converted to CRLF, otherwise the line endings are converted
|
|
// to LF-only.
|
|
bool LastNLines(int numLines, bool bCrlf, CkString &outStr);
|
|
|
|
// Returns the last N lines of the text. If fewer than numLines lines exists, then all
|
|
// of the text is returned. If bCrlf is true, then the line endings of the
|
|
// returned string are converted to CRLF, otherwise the line endings are converted
|
|
// to LF-only.
|
|
const char *lastNLines(int numLines, bool bCrlf);
|
|
|
|
// Loads the contents of a file.
|
|
bool LoadFile(const char *path, const char *charset);
|
|
|
|
|
|
// This method converts the Markdown content of this object to HTML, storing the
|
|
// result in sbHtml. It supports both streaming and full document conversion. options
|
|
// specifies conversion options, including a key streaming option. In streaming
|
|
// mode, generated HTML is appended to sbHtml. In non-streaming mode, sbHtml is fully
|
|
// replaced by the generated HTML. For further details, see the examples linked
|
|
// below.
|
|
//
|
|
// In streaming mode, only complete markdown lines are converted to HTML and
|
|
// removed from this object, leaving just the final partial line, if present. If
|
|
// this object contains only a partial markdown line, no HTML is emitted.
|
|
//
|
|
bool MarkdownToHtml(CkJsonObject &options, CkStringBuilder &sbHtml);
|
|
|
|
|
|
// This function masks the content inside single and/or double-quoted strings by
|
|
// replacing it with a specified mask character (maskChar). The content of each masked
|
|
// quoted string is saved to maskedStrings. The contents can be restored by calling
|
|
// RestoreMaskedStrings.
|
|
//
|
|
// quoteType determines which types of quoted strings are masked:
|
|
// 1. Both single and double quoted.
|
|
// 2. Only single quoted strings.
|
|
// 3. Only double quoted strings.
|
|
//
|
|
bool MaskQuotedStrings(const char *maskChar, int quoteType, CkStringTable &maskedStrings);
|
|
|
|
|
|
// Obfuscates the string. (The Unobfuscate method can be called to reverse the
|
|
// obfuscation to restore the original string.)
|
|
//
|
|
// The Chilkat string obfuscation algorithm works by taking the utf-8 bytes of the
|
|
// string, base64 encoding it, and then scrambling the letters of the base64
|
|
// encoded string. It is deterministic in that the same string will always
|
|
// obfuscate to the same result. It is NOT a secure way of encrypting a string. It
|
|
// is only meant to be a simple means of transforming a string into something
|
|
// unintelligible.
|
|
//
|
|
void Obfuscate(void);
|
|
|
|
|
|
// Prepends a copy of the specified string to this instance.
|
|
bool Prepend(const char *value);
|
|
|
|
|
|
// In-place decodes the string from punycode.
|
|
bool PunyDecode(void);
|
|
|
|
|
|
// In-place encodes the string to punycode.
|
|
bool PunyEncode(void);
|
|
|
|
|
|
// Searches the content of this object for substrings that match a regular
|
|
// expression pattern and returns the matches in json. Returns the number of
|
|
// matches or -1 for failure. timeoutMs is the maximum number of milliseconds of
|
|
// processing allowed before giving up. Pass 0 for an infinite amount of time.
|
|
// Failure information is also returned in json.
|
|
int RegexMatch(const char *pattern, CkJsonObject &json, int timeoutMs);
|
|
|
|
|
|
// Replaces the substrings of capture groups found in a previous call to
|
|
// RegexMatch.
|
|
bool RegexReplace(CkJsonObject &json);
|
|
|
|
|
|
// Removes the accents (diacritics) from European accented characters. This applies
|
|
// only to the accented characters found in the Windows-1252 (Latin alphabet) and
|
|
// Windows-1250 (Central European) charsets. Accent marks for characters in other
|
|
// languages will not be removed.
|
|
bool RemoveAccents(void);
|
|
|
|
|
|
// Removes the substring found after the final occurrence of the marker. Also removes
|
|
// the marker. Returns true if the marker was found and content was removed.
|
|
// Otherwise returns false.
|
|
bool RemoveAfterFinal(const char *marker);
|
|
|
|
|
|
// Removes the substring found before the 1st occurrence of the marker. Also removes
|
|
// the marker. Returns true if the marker was found and content was removed.
|
|
// Otherwise returns false.
|
|
bool RemoveBefore(const char *marker);
|
|
|
|
|
|
// Removes the specified range of characters from this instance.
|
|
bool RemoveCharsAt(int startIndex, int numChars);
|
|
|
|
|
|
// Removes all emoji characters from the string.
|
|
void RemoveEmojis(void);
|
|
|
|
|
|
// Replaces all occurrences of a specified string in this instance with another
|
|
// specified string. Returns the number of replacements.
|
|
int Replace(const char *value, const char *replacement);
|
|
|
|
|
|
// Replaces the content found after the final occurrence of marker with replacement.
|
|
bool ReplaceAfterFinal(const char *marker, const char *replacement);
|
|
|
|
|
|
// Replaces the first occurrence of ALL the content found between beginMark and endMark
|
|
// with replacement. The beginMark and endMark are included in what is replaced if replaceMarks is true.
|
|
bool ReplaceAllBetween(const char *beginMark, const char *endMark, const char *replacement, bool replaceMarks);
|
|
|
|
|
|
// Replaces all occurrences of value with replacement, but only where value is found between
|
|
// beginMark and endMark. Returns the number of replacements made.
|
|
int ReplaceBetween(const char *beginMark, const char *endMark, const char *value, const char *replacement);
|
|
|
|
|
|
// Replaces the first occurrence of a specified string in this instance with
|
|
// another string. Returns true if the value was found and replaced. Otherwise
|
|
// returns false.
|
|
bool ReplaceFirst(const char *value, const char *replacement);
|
|
|
|
|
|
// Replaces all occurrences of value with the decimal integer replacement. Returns the
|
|
// number of replacements.
|
|
int ReplaceI(const char *value, int replacement);
|
|
|
|
|
|
// Replaces all occurrences of value with replacement (case insensitive). Returns the
|
|
// number of replacements.
|
|
int ReplaceNoCase(const char *value, const char *replacement);
|
|
|
|
|
|
// Replaces all word occurrences of a specified string in this instance with
|
|
// another specified string. Returns the number of replacements made.
|
|
//
|
|
// Important: This method is limited to replacing whole words in strings that only
|
|
// contains characters in the Latin1 charset (i.e. iso-8859-1 or Windows-1252). A
|
|
// whole word can only contain alphanumeric chars where the alpha chars are
|
|
// restricted to those of the Latin1 alpha chars. (The underscore character is also
|
|
// considered part of a word.)
|
|
//
|
|
int ReplaceWord(const char *value, const char *replacement);
|
|
|
|
|
|
// Restores single and/or double-quoted strings previously masked by
|
|
// MaskQuotedStrings.
|
|
//
|
|
// quoteType determines which types of quoted strings are masked:
|
|
// 1. Both single and double quoted.
|
|
// 2. Only single quoted strings.
|
|
// 3. Only double quoted strings.
|
|
//
|
|
bool RestoreMaskedStrings(int quoteType, CkStringTable &maskedStrings);
|
|
|
|
|
|
// Removes all characters from the current StringBuilder instance, and write zero
|
|
// bytes to the allocated memory before deallocating.
|
|
void SecureClear(void);
|
|
|
|
|
|
// Sets the Nth substring in string in a list delimted by delimiterChar. The first substring
|
|
// is at index 0. If exceptDoubleQuoted is true, then the delimiter char found between double
|
|
// quotes is not treated as a delimiter. If exceptEscaped is true, then an escaped (with a
|
|
// backslash) delimiter char is not treated as a delimiter.
|
|
bool SetNth(int index, const char *value, const char *delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped);
|
|
|
|
|
|
// Sets this instance to a copy of the specified string.
|
|
bool SetString(const char *value);
|
|
|
|
|
|
// Shortens the string by removing the last numChars chars.
|
|
bool Shorten(int numChars);
|
|
|
|
|
|
// Returns true if the string starts with substr. Otherwise returns false. The
|
|
// comparison is case sensitive if caseSensitive is true, and case insensitive if caseSensitive is
|
|
// false.
|
|
bool StartsWith(const char *substr, bool caseSensitive);
|
|
|
|
|
|
// Converts line endings to CRLF (Windows) format.
|
|
bool ToCRLF(void);
|
|
|
|
|
|
// Converts line endings to LF-only (UNIX) format.
|
|
bool ToLF(void);
|
|
|
|
|
|
// Converts the contents to lowercase.
|
|
bool ToLowercase(void);
|
|
|
|
|
|
// Converts the contents to uppercase.
|
|
bool ToUppercase(void);
|
|
|
|
|
|
// Trims whitespace from both ends of the string.
|
|
bool Trim(void);
|
|
|
|
|
|
// Replaces all tabs, CR's, and LF's, with SPACE chars, and removes extra SPACE's
|
|
// so there are no occurances of more than one SPACE char in a row.
|
|
bool TrimInsideSpaces(void);
|
|
|
|
|
|
// Unobfuscates the string.
|
|
//
|
|
// The Chilkat string obfuscation algorithm works by taking the utf-8 bytes of the
|
|
// string, base64 encoding it, and then scrambling the letters of the base64
|
|
// encoded string. It is deterministic in that the same string will always
|
|
// obfuscate to the same result. It is not a secure way of encrypting a string. It
|
|
// is only meant to be a simple means of transforming a string into something
|
|
// unintelligible.
|
|
//
|
|
void Unobfuscate(void);
|
|
|
|
|
|
// Writes the contents to a file. If emitBom is true, then the BOM (also known as a
|
|
// preamble), is emitted for charsets that define a BOM (such as utf-8, utf-16,
|
|
// utf-32, etc.)
|
|
bool WriteFile(const char *path, const char *charset, bool emitBom);
|
|
|
|
|
|
// Writes the contents to a file, but only if it is a new file or if the contents
|
|
// are different than the existing file. If emitBom is true, then the BOM (also
|
|
// known as a preamble), is emitted for charsets that define a BOM (such as utf-8,
|
|
// utf-16, utf-32, etc.)
|
|
bool WriteFileIfModified(const char *path, const char *charset, bool emitBom);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// END PUBLIC INTERFACE
|
|
|
|
|
|
};
|
|
#if !defined(__sun__) && !defined(__sun)
|
|
#pragma pack (pop)
|
|
#endif
|
|
|
|
#endif
|