Rudiments
Static Public Member Functions | List of all members
charstring Class Reference

Static Public Member Functions

static size_t length (const char *string)
 
static size_t size (const char *string)
 
static bool isNullOrEmpty (const char *string)
 
static bool isYes (const char *string)
 
static bool isNo (const char *string)
 
static void zero (char *str, size_t len)
 
static char * append (char *dest, const char *source)
 
static char * append (char *dest, const char *source, size_t len)
 
static char * append (char *dest, int64_t number)
 
static char * append (char *dest, uint64_t number)
 
static char * append (char *dest, double number)
 
static char * append (char *dest, double number, uint16_t scale)
 
static char * append (char *dest, double number, uint16_t precision, uint16_t scale)
 
static char * copy (char *dest, const char *source)
 
static char * copy (char *dest, const char *source, size_t len)
 
static char * copy (char *dest, size_t location, const char *source)
 
static char * copy (char *dest, size_t location, const char *source, size_t len)
 
static char * safeCopy (char *dest, size_t destlen, const char *source)
 
static char * safeCopy (char *dest, size_t destlen, const char *source, size_t sourcelen)
 
static int32_t compare (const char *str1, const char *str2)
 
static int32_t compare (const char *str1, const char *str2, size_t length)
 
static int32_t compareIgnoringCase (const char *str1, const char *str2)
 
static int32_t compareIgnoringCase (const char *str1, const char *str2, size_t len)
 
static bool inSet (const char *str, const char *const *set)
 
static bool inSetIgnoringCase (const char *str, const char *const *set)
 
static bool contains (const char *haystack, const char *needle)
 
static bool containsIgnoringCase (const char *haystack, const char *needle)
 
static bool contains (const char *haystack, char needle)
 
static bool containsIgnoringCase (const char *haystack, char needle)
 
static bool startsWith (const char *haystack, const char *needle)
 
static bool endsWith (const char *haystack, const char *needle)
 
static const char * findFirst (const char *haystack, const char *needle)
 
static const char * findFirstIgnoringCase (const char *haystack, const char *needle)
 
static const char * findFirst (const char *haystack, char needle)
 
static const char * findFirstIgnoringCase (const char *haystack, char needle)
 
static const char * findFirstOrEnd (const char *haystack, const char *needle)
 
static const char * findFirstOrEndIgnoringCase (const char *haystack, const char *needle)
 
static const char * findFirstOrEnd (const char *haystack, char needle)
 
static const char * findFirstOrEndIgnoringCase (const char *haystack, char needle)
 
static const char * findLast (const char *haystack, const char *needle)
 
static const char * findLastIgnoringCase (const char *haystack, const char *needle)
 
static const char * findLast (const char *haystack, char needle)
 
static const char * findLastIgnoringCase (const char *haystack, char needle)
 
static char * findFirst (char *haystack, const char *needle)
 
static char * findFirstIgnoringCase (char *haystack, const char *needle)
 
static char * findFirst (char *haystack, char needle)
 
static char * findFirstIgnoringCase (char *haystack, char needle)
 
static char * findFirstOrEnd (char *haystack, const char *needle)
 
static char * findFirstOrEndIgnoringCase (char *haystack, const char *needle)
 
static char * findLast (char *haystack, const char *needle)
 
static char * findLastIgnoringCase (char *haystack, const char *needle)
 
static char * findLast (char *haystack, char needle)
 
static char * findLastIgnoringCase (char *haystack, char needle)
 
static const char * findFirstOfSet (const char *haystack, const char *set)
 
static char * findFirstOfSet (char *haystack, const char *set)
 
static const char * findFirstOfSetOrEnd (const char *haystack, const char *set)
 
static char * findFirstOfSetOrEnd (char *haystack, const char *set)
 
static const char * findLastOfSet (const char *haystack, const char *set)
 
static char * findLastOfSet (char *haystack, const char *set)
 
static const char * findLastOfSetOrEnd (const char *haystack, const char *set)
 
static char * findLastOfSetOrEnd (char *haystack, const char *set)
 
static char * before (const char *str, const char *delimiter)
 
static char * between (const char *str, const char *start, const char *end)
 
static char * after (const char *str, const char *delimiter)
 
static size_t lengthContainingSet (const char *haystack, const char *set)
 
static size_t lengthNotContainingSet (const char *haystack, const char *set)
 
static char * duplicate (const char *str)
 
static char * duplicate (const char *str, size_t len)
 
static void upper (char *str)
 
static void lower (char *str)
 
static void capitalize (char *str)
 
static void rightTrim (char *str)
 
static void rightTrim (char *str, char character)
 
static void leftTrim (char *str)
 
static void leftTrim (char *str, char character)
 
static void bothTrim (char *str)
 
static void bothTrim (char *str, char character)
 
static bool strip (char *str, char character)
 
static bool strip (char *str1, const char *str2)
 
static bool stripSet (char *str1, const char *set)
 
static void replace (char *str, char oldchar, char newchar)
 
static void replace (char *str, const char *oldchars, char newchar)
 
static char * replace (const char *str, const char *oldstr, const char *newstr)
 
static char * replace (const char *str, const char *const *oldstrset, ssize_t *oldstrlen, const char *const *newstrset)
 
static char * replace (const char *str, regularexpression *from, const char *to, bool global)
 
static uint16_t integerLength (int16_t number)
 
static uint16_t integerLength (int32_t number)
 
static uint16_t integerLength (int64_t number)
 
static uint16_t integerLength (uint16_t number)
 
static uint16_t integerLength (uint32_t number)
 
static uint16_t integerLength (uint64_t number)
 
static bool isInteger (const char *val)
 
static bool isInteger (const char *val, int32_t len)
 
static bool isNumber (const char *val)
 
static bool isNumber (const char *val, int32_t len)
 
static char * parseNumber (int16_t number)
 
static char * parseNumber (uint16_t number)
 
static char * parseNumber (int16_t number, uint16_t zeropadding)
 
static char * parseNumber (uint16_t number, uint16_t zeropadding)
 
static char * parseNumber (int32_t number)
 
static char * parseNumber (uint32_t number)
 
static char * parseNumber (int32_t number, uint16_t zeropadding)
 
static char * parseNumber (uint32_t number, uint16_t zeropadding)
 
static char * parseNumber (int64_t number)
 
static char * parseNumber (uint64_t number)
 
static char * parseNumber (int64_t number, uint16_t zeropadding)
 
static char * parseNumber (uint64_t number, uint16_t zeropadding)
 
static char * parseNumber (float number)
 
static char * parseNumber (float number, uint16_t scale)
 
static char * parseNumber (float number, uint16_t precision, uint16_t scale)
 
static char * parseNumber (double number)
 
static char * parseNumber (double number, uint16_t scale)
 
static char * parseNumber (double number, uint16_t precision, uint16_t scale)
 
static char * parseNumber (long double number)
 
static char * parseNumber (long double number, uint16_t scale)
 
static char * parseNumber (long double number, uint16_t precision, uint16_t scale)
 
static int64_t toInteger (const char *string)
 
static int64_t toInteger (const char *string, const char **endptr)
 
static int64_t toInteger (const char *string, int32_t base)
 
static int64_t toInteger (const char *string, const char **endptr, int32_t base)
 
static uint64_t toUnsignedInteger (const char *string)
 
static uint64_t toUnsignedInteger (const char *string, const char **endptr)
 
static uint64_t toUnsignedInteger (const char *string, int32_t base)
 
static uint64_t toUnsignedInteger (const char *string, const char **endptr, int32_t base)
 
static long double toFloat (const char *string)
 
static long double toFloatC (const char *string)
 
static long double toFloat (const char *string, const char **endptr)
 
static int64_t convertAmount (const char *amount)
 
static char * convertAmount (int64_t amount)
 
static char * convertAmount (int64_t amount, uint16_t padding)
 
static char * httpEscape (const char *input)
 
static char * httpUnescape (const char *input)
 
static char * escape (const char *input, const char *characters)
 
static char * unescape (const char *input)
 
static void escape (const char *input, uint64_t inputlength, char **output, uint64_t *outputlength, const char *characters)
 
static void unescape (const char *input, uint64_t inputlength, char **output, uint64_t *outputlength)
 
static char * base64Encode (const unsigned char *input)
 
static char * base64Encode (const unsigned char *input, uint64_t inputsize)
 
static void base64Encode (const unsigned char *input, uint64_t inputsize, char **output, uint64_t *outputlength)
 
static unsigned char * base64Decode (const char *input)
 
static unsigned char * base64Decode (const char *input, uint64_t inputlength)
 
static void base64Decode (const char *input, uint64_t inputlength, unsigned char **output, uint64_t *outputsize)
 
static char * quotedPrintableEncode (const unsigned char *input)
 
static char * quotedPrintableEncode (const unsigned char *input, uint64_t inputsize)
 
static void quotedPrintableEncode (const unsigned char *input, uint64_t inputsize, char **output, uint64_t *outputlength)
 
static unsigned char * quotedPrintableDecode (const char *input)
 
static unsigned char * quotedPrintableDecode (const char *input, uint64_t inputlength)
 
static void quotedPrintableDecode (const char *input, uint64_t inputlength, unsigned char **output, uint64_t *outputsize)
 
static char * hexEncode (const unsigned char *input)
 
static char * hexEncode (const unsigned char *input, uint64_t inputsize)
 
static void hexEncode (const unsigned char *input, uint64_t inputsize, char **output, uint64_t *outputlength)
 
static unsigned char * hexDecode (const char *input)
 
static unsigned char * hexDecode (const char *input, uint64_t inputlength)
 
static void hexDecode (const char *input, uint64_t inputlength, unsigned char **output, uint64_t *outputsize)
 
static void obfuscate (char *str)
 
static void deobfuscate (char *str)
 
static void leftJustify (char *str, int32_t len)
 
static void rightJustify (char *str, int32_t len)
 
static void center (char *str, int32_t len)
 
static char * pad (const char *string, char padchar, int16_t direction, uint64_t totallength)
 
static void split (const char *string, ssize_t stringlength, const char *delimiter, ssize_t delimiterlength, bool collapse, char ***list, uint64_t *listlength)
 
static void split (const char *string, const char *delimiter, ssize_t delimiterlength, bool collapse, char ***list, uint64_t *listlength)
 
static void split (const char *string, ssize_t stringlength, const char *delimiter, bool collapse, char ***list, uint64_t *listlength)
 
static void split (const char *string, const char *delimiter, bool collapse, char ***list, uint64_t *listlength)
 
static char * subString (const char *str, size_t start, size_t end)
 
static char * subString (const char *str, size_t start)
 
static char * insertString (const char *dest, const char *src, uint64_t index)
 
static ssize_t printf (char *buffer, size_t len, const char *format,...)
 
static ssize_t printf (char *buffer, size_t len, const char *format, va_list *argp)
 
static ssize_t printf (char **buffer, const char *format,...)
 
static ssize_t printf (char **buffer, const char *format, va_list *argp)
 

Detailed Description

The charstring class provides static methods for manipulating C-style character strings.

In addition to some unique methods, analogs for the standard C string functions are provided. However, unlike the standard C string functions, the charstring methods are NULL safe. Your application will not crash if a NULL is passed in, and instead, will give intuitive results.

Member Function Documentation

◆ after()

static char* charstring::after ( const char *  str,
const char *  delimiter 
)
static

Returns the string from the "delimiter" until the end of the string. Note that this method allocates a buffer for the return value internally and returns it. The calling program must deallocate this buffer.

◆ append() [1/7]

static char* charstring::append ( char *  dest,
const char *  source 
)
static

Appends "source" to "dest". Assumes that there is enough room remaining in "dest" to accommodate the new string. Returns a pointer to "dest".

◆ append() [2/7]

static char* charstring::append ( char *  dest,
const char *  source,
size_t  len 
)
static

Appends "len" characters of "source" to "dest". Assumes that there is enough room remaining in "dest" to accommodate the new string. Returns a pointer to "dest".

◆ append() [3/7]

static char* charstring::append ( char *  dest,
double  number 
)
static

Converts "number" to a string and appends it to "dest". Assumes that there is enough room remaining in "dest" to accommodate the new string. Returns a pointer to "dest".

◆ append() [4/7]

static char* charstring::append ( char *  dest,
double  number,
uint16_t  precision,
uint16_t  scale 
)
static

Converts "number" to a string using "precision" and "scale" and appends it to "dest". Assumes that there is enough room remaining in "dest" to accommodate the new string. Returns a pointer to "dest".

◆ append() [5/7]

static char* charstring::append ( char *  dest,
double  number,
uint16_t  scale 
)
static

Converts "number" to a string using "scale" and appends it to "dest". Assumes that there is enough room remaining in "dest" to accommodate the new string. Returns a pointer to "dest".

◆ append() [6/7]

static char* charstring::append ( char *  dest,
int64_t  number 
)
static

Converts "number" to a string and appends it to "dest". Assumes that there is enough room remaining in "dest" to accommodate the new string. Returns a pointer to "dest".

◆ append() [7/7]

static char* charstring::append ( char *  dest,
uint64_t  number 
)
static

Converts "number" to a string and appends it to "dest". Assumes that there is enough room remaining in "dest" to accommodate the new string. Returns a pointer to "dest".

◆ base64Decode() [1/3]

static unsigned char* charstring::base64Decode ( const char *  input)
static

base64-decodes "input" and returns it in a buffer allocated inside the function. This buffer must be deleted by the calling program.

◆ base64Decode() [2/3]

static unsigned char* charstring::base64Decode ( const char *  input,
uint64_t  inputlength 
)
static

similar to base64Decode above but only decodes the first "inputlength" characters of "input"

◆ base64Decode() [3/3]

static void charstring::base64Decode ( const char *  input,
uint64_t  inputlength,
unsigned char **  output,
uint64_t *  outputsize 
)
static

similar to base64Decode() above, but returns the result in "output" and "outputsize" (in bytes) rather than in a return value

◆ base64Encode() [1/3]

static char* charstring::base64Encode ( const unsigned char *  input)
static

base64-encodes "input" and returns it in a buffer allocated inside the function. This buffer must be deleted by the calling program.

◆ base64Encode() [2/3]

static char* charstring::base64Encode ( const unsigned char *  input,
uint64_t  inputsize 
)
static

similar to base64Encode above but only encodes the first "inputsize" bytes of "input"

◆ base64Encode() [3/3]

static void charstring::base64Encode ( const unsigned char *  input,
uint64_t  inputsize,
char **  output,
uint64_t *  outputlength 
)
static

similar to base64Encode() above, but returns the result in "output" and "outputlength" (in characters) rather than in a return value

◆ before()

static char* charstring::before ( const char *  str,
const char *  delimiter 
)
static

Returns the string from the beginning of "str" until Note that this method allocates a buffer for the return value internally and returns it. The calling program must deallocate this buffer.

◆ between()

static char* charstring::between ( const char *  str,
const char *  start,
const char *  end 
)
static

Returns the string between "start" and "end". Note that this method allocates a buffer for the return value internally and returns it. The calling program must deallocate this buffer.

◆ bothTrim() [1/2]

static void charstring::bothTrim ( char *  str)
static

Trims all spaces off of both sides of "str".

◆ bothTrim() [2/2]

static void charstring::bothTrim ( char *  str,
char  character 
)
static

Trims all characters off of both sides of "str".

◆ capitalize()

static void charstring::capitalize ( char *  str)
static

Captitalizes "str", converting characters to upper or lower case as necessary.

◆ center()

static void charstring::center ( char *  str,
int32_t  len 
)
static

Centers the text of "str" for "len" characters.

Example: "hello " -> " hello "

◆ compare() [1/2]

static int32_t charstring::compare ( const char *  str1,
const char *  str2 
)
static

Returns -1,0 or 1 if "str1" is greater than, equal to or less than "str2".

◆ compare() [2/2]

static int32_t charstring::compare ( const char *  str1,
const char *  str2,
size_t  length 
)
static

Returns -1,0 or 1 if "length" characters of "str1" are greater than, equal to or less than "size" bytes of "str2".

◆ compareIgnoringCase() [1/2]

static int32_t charstring::compareIgnoringCase ( const char *  str1,
const char *  str2 
)
static

Returns -1,0 or 1 if "str1" is greater than, equal to or less than "str2", ignoring case.

◆ compareIgnoringCase() [2/2]

static int32_t charstring::compareIgnoringCase ( const char *  str1,
const char *  str2,
size_t  len 
)
static

Returns -1,0 or 1 if "len" characters of "str1" are greater than, equal to or less than "size" bytes of "str2", ignoring case.

◆ contains() [1/2]

static bool charstring::contains ( const char *  haystack,
char  needle 
)
static

Returns true if "haystack" contains "needle" or false otherwise.

◆ contains() [2/2]

static bool charstring::contains ( const char *  haystack,
const char *  needle 
)
static

Returns true if "haystack" contains "needle" or false otherwise.

◆ containsIgnoringCase() [1/2]

static bool charstring::containsIgnoringCase ( const char *  haystack,
char  needle 
)
static

Returns true if "haystack" contains "needle", ignoring case, or false otherwise.

◆ containsIgnoringCase() [2/2]

static bool charstring::containsIgnoringCase ( const char *  haystack,
const char *  needle 
)
static

Returns true if "haystack" contains "needle", ignoring case, or false otherwise.

◆ convertAmount() [1/3]

static int64_t charstring::convertAmount ( const char *  amount)
static

Converts "amount" which is assumed to be a dollar amount into pennies.

◆ convertAmount() [2/3]

static char* charstring::convertAmount ( int64_t  amount)
static

Converts "amount" which is assumed to be a number of pennies into a dollar amount string.

◆ convertAmount() [3/3]

static char* charstring::convertAmount ( int64_t  amount,
uint16_t  padding 
)
static

Converts "amount" which is assumed to be a number of pennies into a dollar amount string where there are "padding" places between the dollar sign and decimal point. These will be space padded if the amount is small enough not to fill them.

◆ copy() [1/4]

static char* charstring::copy ( char *  dest,
const char *  source 
)
static

Replaces "dest" with "source". Assumes that there is enough room in "dest" to accommodate "source". Returns a pointer to "dest".

◆ copy() [2/4]

static char* charstring::copy ( char *  dest,
const char *  source,
size_t  len 
)
static

Replaces the first "length" characters of "dest" with "source". Assumes that "dest" is at least "size" bytes long. Returns a pointer to "dest".

◆ copy() [3/4]

static char* charstring::copy ( char *  dest,
size_t  location,
const char *  source 
)
static

Replaces "dest" with "source", starting "location" bytes into "dest". Assumes that there is enough room in "dest" (after "location" bytes) to accommodate "source". Returns a pointer to "dest".

◆ copy() [4/4]

static char* charstring::copy ( char *  dest,
size_t  location,
const char *  source,
size_t  len 
)
static

Replaces "len" characters of "dest" with "source", starting "location" bytes into "dest". Assumes that there are "size" bytes in "dest" (after "location" bytes). Returns a pointer to "dest".

◆ deobfuscate()

static void charstring::deobfuscate ( char *  str)
static

Deobfuscates "str" which was obfusacted using the obfuscate method of this class.

◆ duplicate() [1/2]

static char* charstring::duplicate ( const char *  str)
static

Creates a duplicate of "str" and returns a pointer to it. Note that this method allocates a buffer for the duplicate string internally and returns it. The calling program must deallocate this buffer.

◆ duplicate() [2/2]

static char* charstring::duplicate ( const char *  str,
size_t  len 
)
static

Creates a duplicate of the first "len" characters of "str" and returns a pointer to it. Note that this method allocates a buffer for the duplicate string internally and returns it. The calling program must deallocate this buffer.

◆ endsWith()

static bool charstring::endsWith ( const char *  haystack,
const char *  needle 
)
static

Returns true if "haystack" ends with "needle" or false otherwise.

◆ escape() [1/2]

static char* charstring::escape ( const char *  input,
const char *  characters 
)
static

escapes all characters in "characters" found in "input" using \'s and returns it in a buffer allocated inside the function. This buffer must be deleted by the calling program.

◆ escape() [2/2]

static void charstring::escape ( const char *  input,
uint64_t  inputlength,
char **  output,
uint64_t *  outputlength,
const char *  characters 
)
static

similar to escape() above, but takes an "inputlength" parameter and returns the result in "output" and "outputlength" rather than in a return value

◆ findFirst() [1/4]

static char* charstring::findFirst ( char *  haystack,
char  needle 
)
static

Returns a pointer to the first occurrance of "needle" in "haystack" or NULL if not found.

◆ findFirst() [2/4]

static char* charstring::findFirst ( char *  haystack,
const char *  needle 
)
static

Returns a pointer to the first occurrance of "needle" in "haystack" or NULL if not found.

◆ findFirst() [3/4]

static const char* charstring::findFirst ( const char *  haystack,
char  needle 
)
static

Returns a pointer to the first occurrance of "needle" in "haystack" or NULL if not found.

◆ findFirst() [4/4]

static const char* charstring::findFirst ( const char *  haystack,
const char *  needle 
)
static

Returns a pointer to the first occurrance of "needle" in "haystack" or NULL if not found.

◆ findFirstIgnoringCase() [1/4]

static char* charstring::findFirstIgnoringCase ( char *  haystack,
char  needle 
)
static

Returns a pointer to the first occurrance of "needle" in "haystack", ignoring case, or NULL if not found.

◆ findFirstIgnoringCase() [2/4]

static char* charstring::findFirstIgnoringCase ( char *  haystack,
const char *  needle 
)
static

Returns a pointer to the first occurrance of "needle" in "haystack", ignoring case, or NULL if not found.

◆ findFirstIgnoringCase() [3/4]

static const char* charstring::findFirstIgnoringCase ( const char *  haystack,
char  needle 
)
static

Returns a pointer to the first occurrance of "needle" in "haystack", ignoring case, or NULL if not found.

◆ findFirstIgnoringCase() [4/4]

static const char* charstring::findFirstIgnoringCase ( const char *  haystack,
const char *  needle 
)
static

Returns a pointer to the first occurrance of "needle" in "haystack", ignoring case, or NULL if not found.

◆ findFirstOfSet() [1/2]

static char* charstring::findFirstOfSet ( char *  haystack,
const char *  set 
)
static

Returns a pointer to the first occurence in "haystack" of any of the characters in "set" or NULL if not found.

◆ findFirstOfSet() [2/2]

static const char* charstring::findFirstOfSet ( const char *  haystack,
const char *  set 
)
static

Returns a pointer to the first occurence in "haystack" of any of the characters in "set" or NULL if not found.

◆ findFirstOfSetOrEnd() [1/2]

static char* charstring::findFirstOfSetOrEnd ( char *  haystack,
const char *  set 
)
static

Returns a pointer to the first occurence in "haystack" of any of the characters in "set". or a pointer to the NULL terminator at the end of the string if not found.

◆ findFirstOfSetOrEnd() [2/2]

static const char* charstring::findFirstOfSetOrEnd ( const char *  haystack,
const char *  set 
)
static

Returns a pointer to the first occurence in "haystack" of any of the characters in "set" or a pointer to the NULL terminator at the end of the string if not found.

◆ findFirstOrEnd() [1/3]

static char* charstring::findFirstOrEnd ( char *  haystack,
const char *  needle 
)
static

Returns a pointer to the first occurrance of "needle" in "haystack" or a pointer to the NULL terminator at the end of the string if not found.

◆ findFirstOrEnd() [2/3]

static const char* charstring::findFirstOrEnd ( const char *  haystack,
char  needle 
)
static

Returns a pointer to the first occurrance of "needle" in "haystack" or a pointer to the NULL terminator at the end of the string if not found.

◆ findFirstOrEnd() [3/3]

static const char* charstring::findFirstOrEnd ( const char *  haystack,
const char *  needle 
)
static

Returns a pointer to the first occurrance of "needle" in "haystack" or a pointer to the NULL terminator at the end of the string if not found.

◆ findFirstOrEndIgnoringCase() [1/3]

static char* charstring::findFirstOrEndIgnoringCase ( char *  haystack,
const char *  needle 
)
static

Returns a pointer to the first occurrance of "needle" in "haystack", ignoring case, or a pointer to the NULL terminator at the end of the string if not found.

◆ findFirstOrEndIgnoringCase() [2/3]

static const char* charstring::findFirstOrEndIgnoringCase ( const char *  haystack,
char  needle 
)
static

Returns a pointer to the first occurrance of "needle" in "haystack", ignoring case, or a pointer to the NULL terminator at the end of the string if not found.

◆ findFirstOrEndIgnoringCase() [3/3]

static const char* charstring::findFirstOrEndIgnoringCase ( const char *  haystack,
const char *  needle 
)
static

Returns a pointer to the first occurrance of "needle" in "haystack", ignoring case, or a pointer to the NULL terminator at the end of the string if not found.

◆ findLast() [1/4]

static char* charstring::findLast ( char *  haystack,
char  needle 
)
static

Returns a pointer to the last occurrance of "needle" in "haystack" or NULL if not found.

◆ findLast() [2/4]

static char* charstring::findLast ( char *  haystack,
const char *  needle 
)
static

Returns a pointer to the last occurrance of "needle" in "haystack" or NULL if not found.

◆ findLast() [3/4]

static const char* charstring::findLast ( const char *  haystack,
char  needle 
)
static

Returns a pointer to the last occurrance of "needle" in "haystack" or NULL if not found.

◆ findLast() [4/4]

static const char* charstring::findLast ( const char *  haystack,
const char *  needle 
)
static

Returns a pointer to the last occurrance of "needle" in "haystack" or NULL if not found.

◆ findLastIgnoringCase() [1/4]

static char* charstring::findLastIgnoringCase ( char *  haystack,
char  needle 
)
static

Returns a pointer to the last occurrance of "needle" in "haystack", ignoring case, or NULL if not found.

◆ findLastIgnoringCase() [2/4]

static char* charstring::findLastIgnoringCase ( char *  haystack,
const char *  needle 
)
static

Returns a pointer to the last occurrance of "needle" in "haystack", ignoring case, or NULL if not found.

◆ findLastIgnoringCase() [3/4]

static const char* charstring::findLastIgnoringCase ( const char *  haystack,
char  needle 
)
static

Returns a pointer to the last occurrance of "needle" in "haystack", ignoring case, or NULL if not found.

◆ findLastIgnoringCase() [4/4]

static const char* charstring::findLastIgnoringCase ( const char *  haystack,
const char *  needle 
)
static

Returns a pointer to the last occurrance of "needle" in "haystack", ignoring case, or NULL if not found.

◆ findLastOfSet() [1/2]

static char* charstring::findLastOfSet ( char *  haystack,
const char *  set 
)
static

Returns a pointer to the last occurence in "haystack" of any of the characters in "set" or NULL if not found.

◆ findLastOfSet() [2/2]

static const char* charstring::findLastOfSet ( const char *  haystack,
const char *  set 
)
static

Returns a pointer to the last occurence in "haystack" of any of the characters in "set" or NULL if not found.

◆ findLastOfSetOrEnd() [1/2]

static char* charstring::findLastOfSetOrEnd ( char *  haystack,
const char *  set 
)
static

Returns a pointer to the last occurence in "haystack" of any of the characters in "set". or a pointer to the NULL terminator at the end of the string if not found.

◆ findLastOfSetOrEnd() [2/2]

static const char* charstring::findLastOfSetOrEnd ( const char *  haystack,
const char *  set 
)
static

Returns a pointer to the last occurence in "haystack" of any of the characters in "set" or a pointer to the NULL terminator at the end of the string if not found.

◆ hexDecode() [1/3]

static unsigned char* charstring::hexDecode ( const char *  input)
static

hex-decodes "input" and returns it in a buffer allocated inside the function. This buffer must be deleted by the calling program.

◆ hexDecode() [2/3]

static unsigned char* charstring::hexDecode ( const char *  input,
uint64_t  inputlength 
)
static

similar to hexDecode above but only decodes the first "inputlength" characters of "input"

◆ hexDecode() [3/3]

static void charstring::hexDecode ( const char *  input,
uint64_t  inputlength,
unsigned char **  output,
uint64_t *  outputsize 
)
static

similar to hexDecode() above, but returns the result in "output" and "outputsize" rather than in a return value

◆ hexEncode() [1/3]

static char* charstring::hexEncode ( const unsigned char *  input)
static

hex-encodes "input" and returns it in a buffer allocated inside the function. This buffer must be deleted by the calling program.

◆ hexEncode() [2/3]

static char* charstring::hexEncode ( const unsigned char *  input,
uint64_t  inputsize 
)
static

similar to hexEncode above but only encodes the first "inputsize" characters of "input"

◆ hexEncode() [3/3]

static void charstring::hexEncode ( const unsigned char *  input,
uint64_t  inputsize,
char **  output,
uint64_t *  outputlength 
)
static

similar to hexEncode() above, but returns the result in "output" and "outputsize" (in characters) rather than in a return value

◆ httpEscape()

static char* charstring::httpEscape ( const char *  input)
static

http escapes "input" and returns it in a buffer allocated inside the function. This buffer must be deleted by the calling program.

◆ httpUnescape()

static char* charstring::httpUnescape ( const char *  input)
static

http unescapes "input" and returns it in a buffer allocated inside the function. This buffer must be deleted by the calling program.

◆ insertString()

static char* charstring::insertString ( const char *  dest,
const char *  src,
uint64_t  index 
)
static

Creates a new string with "src" inserted into "dest" at "index".

◆ inSet()

static bool charstring::inSet ( const char *  str,
const char *const *  set 
)
static

Returns true if "str" is found among the values in the NULL-terminated array "set". Also returns true if "str" is NULL and set is NULL or contains only a NULL-terminator. Otherwise returns false.

◆ inSetIgnoringCase()

static bool charstring::inSetIgnoringCase ( const char *  str,
const char *const *  set 
)
static

Returns true if "str" is found among the values in the NULL-terminated array "set", ignoring case. Also returns true if "str" is NULL and set is NULL or contains only a NULL-terminator. Otherwise returns false.

◆ integerLength() [1/6]

static uint16_t charstring::integerLength ( int16_t  number)
static

Returns the number of characters needed to represent "number" as a string.

◆ integerLength() [2/6]

static uint16_t charstring::integerLength ( int32_t  number)
static

Returns the number of characters needed to represent "number" as a string.

◆ integerLength() [3/6]

static uint16_t charstring::integerLength ( int64_t  number)
static

Returns the number of characters needed to represent "number" as a string.

◆ integerLength() [4/6]

static uint16_t charstring::integerLength ( uint16_t  number)
static

Returns the number of characters needed to represent "number" as a string.

◆ integerLength() [5/6]

static uint16_t charstring::integerLength ( uint32_t  number)
static

Returns the number of characters needed to represent "number" as a string.

◆ integerLength() [6/6]

static uint16_t charstring::integerLength ( uint64_t  number)
static

Returns the number of characters needed to represent "number" as a string.

◆ isInteger() [1/2]

static bool charstring::isInteger ( const char *  val)
static

Returns true if the string "val" is an integer and false if it is not an integer.

◆ isInteger() [2/2]

static bool charstring::isInteger ( const char *  val,
int32_t  len 
)
static

Returns true if the string "val" is an integer and false if it is not an integer.

◆ isNo()

static bool charstring::isNo ( const char *  string)
static

Returns true if "string" starts with the standalone word: "No" (case-insensitive), "False" (case-insensitive), or "0" and false otherwise.

(Eg. returns true for "No,", "False ", and "0 1 2" but returns false for "Nothing", "Falsest", and "012")

◆ isNullOrEmpty()

static bool charstring::isNullOrEmpty ( const char *  string)
static

Returns true if "string" is NULL or the empty string.

◆ isNumber() [1/2]

static bool charstring::isNumber ( const char *  val)
static

Returns true the string "val" is a number and false if it is not a number

◆ isNumber() [2/2]

static bool charstring::isNumber ( const char *  val,
int32_t  len 
)
static

Returns true the string "val" is a number and false if it is not a number

◆ isYes()

static bool charstring::isYes ( const char *  string)
static

Returns true if "string" starts with the standalone "word": "Yes" (case-insensitive), "True" (case-insensitive), "Y" (case-insensitive), "T" (case-insensitive), or "1" and false otherwise.

(Eg. returns true for "Yes,", "True ", and "1 2 3" but returns false for "Yesterday", "Truest", and "123")

◆ leftJustify()

static void charstring::leftJustify ( char *  str,
int32_t  len 
)
static

Moves leading spaces to the end of "str" for "len" characters.

Example: " hello " -> "hello "

◆ leftTrim() [1/2]

static void charstring::leftTrim ( char *  str)
static

Trims all spaces off of the left hand side of "str".

◆ leftTrim() [2/2]

static void charstring::leftTrim ( char *  str,
char  character 
)
static

Trims all "character"'s off of the left hand side of "str".

◆ length()

static size_t charstring::length ( const char *  string)
static

Returns the number of characters in "string".

◆ lengthContainingSet()

static size_t charstring::lengthContainingSet ( const char *  haystack,
const char *  set 
)
static

Returns the number of characters, starting at the beginning of "haystack" which consists entirely of characters in "set".

◆ lengthNotContainingSet()

static size_t charstring::lengthNotContainingSet ( const char *  haystack,
const char *  set 
)
static

Returns the number of characters, starting at the beginning of "haystack" which consists entirely of characters not in "set".

◆ lower()

static void charstring::lower ( char *  str)
static

Converts "str" to lowercase.

◆ obfuscate()

static void charstring::obfuscate ( char *  str)
static

Obfuscates "str" by adding 128 to each character.

◆ pad()

static char* charstring::pad ( const char *  string,
char  padchar,
int16_t  direction,
uint64_t  totallength 
)
static

Returns a copy of "string", padded with "padchar" to a character length of "totallength". Set "direction" to -1 to left-pad, 0 to center-pad and 1 to right-pad. Note that this method allocates a buffer internally and returns it. The calling program must deallocate this buffer.

◆ parseNumber() [1/21]

static char* charstring::parseNumber ( double  number)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [2/21]

static char* charstring::parseNumber ( double  number,
uint16_t  precision,
uint16_t  scale 
)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [3/21]

static char* charstring::parseNumber ( double  number,
uint16_t  scale 
)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [4/21]

static char* charstring::parseNumber ( float  number)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [5/21]

static char* charstring::parseNumber ( float  number,
uint16_t  precision,
uint16_t  scale 
)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [6/21]

static char* charstring::parseNumber ( float  number,
uint16_t  scale 
)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [7/21]

static char* charstring::parseNumber ( int16_t  number)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [8/21]

static char* charstring::parseNumber ( int16_t  number,
uint16_t  zeropadding 
)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [9/21]

static char* charstring::parseNumber ( int32_t  number)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [10/21]

static char* charstring::parseNumber ( int32_t  number,
uint16_t  zeropadding 
)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [11/21]

static char* charstring::parseNumber ( int64_t  number)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [12/21]

static char* charstring::parseNumber ( int64_t  number,
uint16_t  zeropadding 
)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [13/21]

static char* charstring::parseNumber ( long double  number)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [14/21]

static char* charstring::parseNumber ( long double  number,
uint16_t  precision,
uint16_t  scale 
)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [15/21]

static char* charstring::parseNumber ( long double  number,
uint16_t  scale 
)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [16/21]

static char* charstring::parseNumber ( uint16_t  number)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [17/21]

static char* charstring::parseNumber ( uint16_t  number,
uint16_t  zeropadding 
)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [18/21]

static char* charstring::parseNumber ( uint32_t  number)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [19/21]

static char* charstring::parseNumber ( uint32_t  number,
uint16_t  zeropadding 
)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [20/21]

static char* charstring::parseNumber ( uint64_t  number)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ parseNumber() [21/21]

static char* charstring::parseNumber ( uint64_t  number,
uint16_t  zeropadding 
)
static

Returns a string representing "number". The string is allocated inside the function and must be deleted by the calling program.

◆ printf() [1/4]

static ssize_t charstring::printf ( char **  buffer,
const char *  format,
va_list *  argp 
)
static

Allocates "buffer" to sufficient size and writes "argp" to it using "format" which should comply with standard printf formatting rules.

Returns the number of characters written to "buffer" excluding the NULL terminator.

If "buffer" is NULL then nothing is written to "buffer" and 0 is returned.

Returns -1 if an error occurred.

◆ printf() [2/4]

static ssize_t charstring::printf ( char **  buffer,
const char *  format,
  ... 
)
static

Allocates "buffer" to sufficient size and writes "..." to it using "format" which should comply with standard printf formatting rules.

Returns the number of characters written to "buffer" excluding the NULL terminator.

If "buffer" is NULL then nothing is written to "buffer" and 0 is returned.

Returns -1 if an error occurred.

◆ printf() [3/4]

static ssize_t charstring::printf ( char *  buffer,
size_t  len,
const char *  format,
va_list *  argp 
)
static

Appends "argp" to "buffer" of character length "len" using "format" which should comply with standard printf formatting rules.

Note that argp is a pointer to a va_list, not just a va_list.

Returns the number of characters written to "buffer" excluding the NULL terminator. If "buffer" wasn't large enough to accommodate the data then it only writes "len" bytes to "buffer" but still returns the number of characters that would have been written had "buffer" been large enough.

If "buffer" is NULL or "len" is 0 then nothing is written to "buffer" but the number of characters that would have been written had "buffer" been large enough is still returned.

Returns -1 if an error occurred.

◆ printf() [4/4]

static ssize_t charstring::printf ( char *  buffer,
size_t  len,
const char *  format,
  ... 
)
static

Appends "..." to "buffer" of character length "len" using "format" which should comply with standard printf formatting rules.

Returns the number of characters written to "buffer" excluding the NULL terminator. If string wasn't large enough to accommodate the data then it only writes "len" bytes to "buffer" but still returns the number of characters that would have been written had "buffer" been large enough.

If "buffer" is NULL or "len" is 0 then nothing is written to "buffer" but the number of characters that would have been written had "buffer" been large enough is still returned.

Returns -1 if an error occurred.

◆ quotedPrintableDecode() [1/3]

static unsigned char* charstring::quotedPrintableDecode ( const char *  input)
static

Quoted-printable-decodes "input" and returns it in a buffer allocated inside the function. This buffer must be deleted by the calling program.

◆ quotedPrintableDecode() [2/3]

static unsigned char* charstring::quotedPrintableDecode ( const char *  input,
uint64_t  inputlength 
)
static

similar to quotedPrintableDecode above but only decodes the first "inputlength" characters of "input"

◆ quotedPrintableDecode() [3/3]

static void charstring::quotedPrintableDecode ( const char *  input,
uint64_t  inputlength,
unsigned char **  output,
uint64_t *  outputsize 
)
static

similar to quotedPrintableDecode() above, but returns the result in "output" and "outputsize" (in bytes) rather than in a return value

◆ quotedPrintableEncode() [1/3]

static char* charstring::quotedPrintableEncode ( const unsigned char *  input)
static

Quoted-printable-encodes "input" and returns it in a buffer allocated inside the function. This buffer must be deleted by the calling program.

◆ quotedPrintableEncode() [2/3]

static char* charstring::quotedPrintableEncode ( const unsigned char *  input,
uint64_t  inputsize 
)
static

similar to quotedPrintableEncode above but only encodes the first "inputsize" bytes of "input"

◆ quotedPrintableEncode() [3/3]

static void charstring::quotedPrintableEncode ( const unsigned char *  input,
uint64_t  inputsize,
char **  output,
uint64_t *  outputlength 
)
static

similar to quotedPrintableEncode() above, but returns the result in "output" and "outputlength" (in characters) rather than in a return value

◆ replace() [1/5]

static void charstring::replace ( char *  str,
char  oldchar,
char  newchar 
)
static

Replaces all instances of "oldchar" in "str" with "newchar"

◆ replace() [2/5]

static void charstring::replace ( char *  str,
const char *  oldchars,
char  newchar 
)
static

Replaces all instances of any of the characters in the set "oldchar" in "str" with "newchar"

◆ replace() [3/5]

static char* charstring::replace ( const char *  str,
const char *const *  oldstrset,
ssize_t *  oldstrlen,
const char *const *  newstrset 
)
static

Returns a new string which is a copy of "str" in which all instances of strings found in the NULL-terminated array "oldstrset", the number of characters of which are given by the array "oldstrlen", have been replaced with the commensurate string found in the NULL-terminated array "newstrset", which must have the same number of members as "oldstrset"

◆ replace() [4/5]

static char* charstring::replace ( const char *  str,
const char *  oldstr,
const char *  newstr 
)
static

Returns a new string which is a copy of "str" in which all instances of "oldstr" have been replaced with "newstr"

◆ replace() [5/5]

static char* charstring::replace ( const char *  str,
regularexpression from,
const char *  to,
bool  global 
)
static

Returns a new string which is a copy of "str" in which parts that match "from" have been replaced with "to".

If "global" is true then all matching parts are replaced. If "global" is false then only the first matching part is replaced.

◆ rightJustify()

static void charstring::rightJustify ( char *  str,
int32_t  len 
)
static

Moves trailing spaces to the beginning of "str" for "len" characters.

Example: " hello " -> " hello"

◆ rightTrim() [1/2]

static void charstring::rightTrim ( char *  str)
static

Trims all spaces off of the right hand side of "str".

◆ rightTrim() [2/2]

static void charstring::rightTrim ( char *  str,
char  character 
)
static

Trims all "character"'s off of the right hand side of "str".

◆ safeCopy() [1/2]

static char* charstring::safeCopy ( char *  dest,
size_t  destlen,
const char *  source 
)
static

Replaces "dest" with "source" unless the character length of "source" is greater than "destlen", in which case only "destlen" characters of "dest" will be replaced. Returns a pointer to "dest".

◆ safeCopy() [2/2]

static char* charstring::safeCopy ( char *  dest,
size_t  destlen,
const char *  source,
size_t  sourcelen 
)
static

Replaces "sourcelen" characters of "dest" with "source" unless "sourcelen" is greater than "destlen", in which case only "destlen" characters of "dest" will be replaced. Returns a pointer to "dest".

◆ size()

static size_t charstring::size ( const char *  string)
static

Returns the number of bytes in "string", including the null terminator.

◆ split() [1/4]

static void charstring::split ( const char *  string,
const char *  delimiter,
bool  collapse,
char ***  list,
uint64_t *  listlength 
)
static

Parses NULL-terminated "string" delimited by NULL-terminated "delimiter" and allocates "listlength" elements of "list" to return the parts. If "collapse" is true then multiple instances of the delimiter in a row will be interpreted as one instance of the delimiter. Each member of "list" and "list" itseslf must be deallocated by the calling program.

◆ split() [2/4]

static void charstring::split ( const char *  string,
const char *  delimiter,
ssize_t  delimiterlength,
bool  collapse,
char ***  list,
uint64_t *  listlength 
)
static

Parses NULL-terminated "string" delimited by "delimiter" of character length "delimiterlength" and allocates "listlength" elements of "list" to return the parts. If "collapse" is true then multiple instances of the delimiter in a row will be interpreted as one instance of the delimiter. Each member of "list" and "list" itseslf must be deallocated by the calling program.

◆ split() [3/4]

static void charstring::split ( const char *  string,
ssize_t  stringlength,
const char *  delimiter,
bool  collapse,
char ***  list,
uint64_t *  listlength 
)
static

Parses "string" of character length "stringlength" delimited by NULL-terminated "delimiter" and allocates "listlength" elements of "list" to return the parts. If "collapse" is true then multiple instances of the delimiter in a row will be interpreted as one instance of the delimiter. Each member of "list" and "list" itseslf must be deallocated by the calling program.

◆ split() [4/4]

static void charstring::split ( const char *  string,
ssize_t  stringlength,
const char *  delimiter,
ssize_t  delimiterlength,
bool  collapse,
char ***  list,
uint64_t *  listlength 
)
static

Parses "string" of character length "stringlength" delimited by "delimiter" of character length "delimiterlength" and allocates "listlength" elements of "list" to return the parts. If "collapse" is true then multiple instances of the delimiter in a row will be interpreted as one instance of the delimiter. Each member of "list" and "list" itseslf must be deallocated by the calling program.

◆ startsWith()

static bool charstring::startsWith ( const char *  haystack,
const char *  needle 
)
static

Returns true if "haystack" starts with "needle" or false otherwise.

◆ strip() [1/2]

static bool charstring::strip ( char *  str,
char  character 
)
static

Strips all instances of "character" from "str". Returns true if any characters were stripped and false if no characters were stripped.

◆ strip() [2/2]

static bool charstring::strip ( char *  str1,
const char *  str2 
)
static

Strips all instances of "str2" from "str1". Returns true if any characters were stripped and false if no characters were stripped.

◆ stripSet()

static bool charstring::stripSet ( char *  str1,
const char *  set 
)
static

Strips all instances of any character in "set" from "str1". Returns true if any characters were stripped and false if no characters were stripped.

◆ subString() [1/2]

static char* charstring::subString ( const char *  str,
size_t  start 
)
static

Returns a copy of the segment of "str" between string index "start" and the end of the string, inclusive.

◆ subString() [2/2]

static char* charstring::subString ( const char *  str,
size_t  start,
size_t  end 
)
static

Returns a copy of the segment of "str" between string indices "start" and "end", inclusive.

◆ toFloat() [1/2]

static long double charstring::toFloat ( const char *  string)
static

Converts "string" to a floating point number.

◆ toFloat() [2/2]

static long double charstring::toFloat ( const char *  string,
const char **  endptr 
)
static

Converts "string" to a floating point number. If non-NULL, endptr will be set to the first character in the string after the number.

◆ toFloatC()

static long double charstring::toFloatC ( const char *  string)
static

Converts "string" to a floating point number.

If "string" uses a "." as a decimal point (per the "C" locale) then the "." is first converted to the appropriate decimal-delimiter for the current locale.

(Currently only supported on linux/unix platforms that provide the locale.h header. On other platforms, it just falls through to toFloat().)

◆ toInteger() [1/4]

static int64_t charstring::toInteger ( const char *  string)
static

Converts "string" to a 64-bit integer.

◆ toInteger() [2/4]

static int64_t charstring::toInteger ( const char *  string,
const char **  endptr 
)
static

Converts "string" to a 64-bit integer. If non-NULL, endptr will be set to the first character in the string after the number.

◆ toInteger() [3/4]

static int64_t charstring::toInteger ( const char *  string,
const char **  endptr,
int32_t  base 
)
static

Converts "string" to a 64-bit integer of base "base". If non-NULL, endptr will be set to the first character in the string after the number.

◆ toInteger() [4/4]

static int64_t charstring::toInteger ( const char *  string,
int32_t  base 
)
static

Converts "string" to a 64-bit integer of base "base".

◆ toUnsignedInteger() [1/4]

static uint64_t charstring::toUnsignedInteger ( const char *  string)
static

Converts "string" to a 64-bit unsigned integer.

◆ toUnsignedInteger() [2/4]

static uint64_t charstring::toUnsignedInteger ( const char *  string,
const char **  endptr 
)
static

Converts "string" to a 64-bit unsigned integer. If non-NULL, endptr will be set to the first character in the string after the number.

◆ toUnsignedInteger() [3/4]

static uint64_t charstring::toUnsignedInteger ( const char *  string,
const char **  endptr,
int32_t  base 
)
static

Converts "string" to a 64-bit unsigned integer of base "base". If non-NULL, endptr will be set to the first character in the string after the number.

◆ toUnsignedInteger() [4/4]

static uint64_t charstring::toUnsignedInteger ( const char *  string,
int32_t  base 
)
static

Converts "string" to a 64-bit unsigned integer of base "base".

◆ unescape() [1/2]

static char* charstring::unescape ( const char *  input)
static

unescapes all -escaped characters found in "input" and returns the result in a buffer allocated inside the function. This buffer must be deleted by the calling program.

◆ unescape() [2/2]

static void charstring::unescape ( const char *  input,
uint64_t  inputlength,
char **  output,
uint64_t *  outputlength 
)
static

similar to unescape() above, but takes an "inputlength" parameter and returns the result in "output" and "outputlength" rather than in a return value

◆ upper()

static void charstring::upper ( char *  str)
static

Converts "str" to uppercase.

◆ zero()

static void charstring::zero ( char *  str,
size_t  len 
)
static

Sets "len" characters of "str" to NULL.