Static Public Member Functions
static size_t	getLength (const wchar_t *string)

static size_t	getSize (const wchar_t *string)

static bool	isNullOrEmpty (const wchar_t *string)

static bool	isYes (const wchar_t *string)

static bool	isNo (const wchar_t *string)

static void	zero (wchar_t *str, size_t len)

static wchar_t *	append (wchar_t dest, const wchar_t source)

static wchar_t *	append (wchar_t dest, const wchar_t source, size_t len)

static wchar_t *	append (wchar_t *dest, int64_t number)

static wchar_t *	append (wchar_t *dest, uint64_t number)

static wchar_t *	append (wchar_t *dest, double number)

static wchar_t *	append (wchar_t *dest, double number, uint16_t scale)

static wchar_t *	append (wchar_t *dest, double number, uint16_t precision, uint16_t scale)

static wchar_t *	copy (wchar_t dest, const wchar_t source)

static wchar_t *	copy (wchar_t dest, const wchar_t source, size_t len)

static wchar_t *	copy (wchar_t dest, size_t location, const wchar_t source)

static wchar_t *	copy (wchar_t dest, size_t location, const wchar_t source, size_t len)

static wchar_t *	safeCopy (wchar_t dest, size_t destlen, const wchar_t source)

static wchar_t *	safeCopy (wchar_t dest, size_t destlen, const wchar_t source, size_t sourcelen)

static int32_t	compare (const wchar_t str1, const wchar_t str2)

static int32_t	compare (const wchar_t str1, const wchar_t str2, size_t len)

static int32_t	compareIgnoringCase (const wchar_t str1, const wchar_t str2)

static int32_t	compareIgnoringCase (const wchar_t str1, const wchar_t str2, size_t len)

static int32_t	compareNatural (const wchar_t str1, const wchar_t str2)

static int32_t	compareNatural (const wchar_t str1, const wchar_t str2, const wchar_t *delimiters)

static int32_t	compareVersions (const wchar_t str1, const wchar_t str2)

static int32_t	compareVersions (const wchar_t str1, const wchar_t str2, const wchar_t *delimiters)

static bool	compareWithWildcards (const wchar_t string, size_t stringlength, const wchar_t pattern, size_t patternlength, wchar_t singlewildcard, wchar_t multiwildcard)

static bool	compareWithWildcards (const wchar_t string, const wchar_t pattern, size_t patternlength, wchar_t singlewildcard, wchar_t multiwildcard)

static bool	compareWithWildcards (const wchar_t string, size_t stringlength, const wchar_t pattern, wchar_t singlewildcard, wchar_t multiwildcard)

static bool	compareWithWildcards (const wchar_t string, const wchar_t pattern, wchar_t singlewildcard, wchar_t multiwildcard)

static bool	isInSet (const wchar_t str, const wchar_t const *set)

static bool	isInSetIgnoringCase (const wchar_t str, const wchar_t const *set)

static bool	contains (const wchar_t haystack, const wchar_t needle)

static bool	containsIgnoringCase (const wchar_t haystack, const wchar_t needle)

static bool	contains (const wchar_t *haystack, wchar_t needle)

static bool	containsIgnoringCase (const wchar_t *haystack, wchar_t needle)

static bool	startsWith (const wchar_t haystack, const wchar_t needle)

static bool	endsWith (const wchar_t haystack, const wchar_t needle)

static const wchar_t *	findFirst (const wchar_t haystack, const wchar_t needle)

static const wchar_t *	findFirstIgnoringCase (const wchar_t haystack, const wchar_t needle)

static const wchar_t *	findFirst (const wchar_t *haystack, wchar_t needle)

static const wchar_t *	findFirstIgnoringCase (const wchar_t *haystack, wchar_t needle)

static const wchar_t *	findFirstOrEnd (const wchar_t haystack, const wchar_t needle)

static const wchar_t *	findFirstOrEndIgnoringCase (const wchar_t haystack, const wchar_t needle)

static const wchar_t *	findFirstOrEnd (const wchar_t *haystack, wchar_t needle)

static const wchar_t *	findFirstOrEndIgnoringCase (const wchar_t *haystack, wchar_t needle)

static const wchar_t *	findLast (const wchar_t haystack, const wchar_t needle)

static const wchar_t *	findLast (const wchar_t *haystack, wchar_t needle)

static wchar_t *	findFirst (wchar_t haystack, const wchar_t needle)

static wchar_t *	findFirstIgnoringCase (wchar_t haystack, const wchar_t needle)

static wchar_t *	findFirst (wchar_t *haystack, wchar_t needle)

static wchar_t *	findFirstIgnoringCase (wchar_t *haystack, wchar_t needle)

static wchar_t *	findFirstOrEnd (wchar_t haystack, const wchar_t needle)

static wchar_t *	findFirstOrEndIgnoringCase (wchar_t haystack, const wchar_t needle)

static wchar_t *	findLast (wchar_t haystack, const wchar_t needle)

static const wchar_t *	findLastIgnoringCase (const wchar_t haystack, const wchar_t needle)

static wchar_t *	findLast (wchar_t *haystack, wchar_t needle)

static const wchar_t *	findLastIgnoringCase (const wchar_t *haystack, wchar_t needle)

static const wchar_t *	findFirstOfSet (const wchar_t haystack, const wchar_t set)

static wchar_t *	findFirstOfSet (wchar_t haystack, const wchar_t set)

static const wchar_t *	findFirstOfSetOrEnd (const wchar_t haystack, const wchar_t set)

static wchar_t *	findFirstOfSetOrEnd (wchar_t haystack, const wchar_t set)

static const wchar_t *	findLastOfSet (const wchar_t haystack, const wchar_t set)

static wchar_t *	findLastOfSet (wchar_t haystack, const wchar_t set)

static const wchar_t *	findLastOfSetOrEnd (const wchar_t haystack, const wchar_t set)

static wchar_t *	findLastOfSetOrEnd (wchar_t haystack, const wchar_t set)

static wchar_t *	isBefore (const wchar_t str, const wchar_t delimiter)

static wchar_t *	isBetween (const wchar_t str, const wchar_t start, const wchar_t *end)

static wchar_t *	isAfter (const wchar_t str, const wchar_t delimiter)

static size_t	getLengthContainingSet (const wchar_t haystack, const wchar_t set)

static size_t	getLengthNotContainingSet (const wchar_t haystack, const wchar_t set)

static wchar_t *	duplicate (const wchar_t *str)

static wchar_t *	duplicate (const wchar_t *str, size_t len)

static wchar_t *	duplicate (const char *str)

static wchar_t *	duplicate (const char *str, size_t len)

static wchar_t *	duplicateUcs2 (const ucs2_t *str)

static wchar_t *	duplicateUcs2 (const ucs2_t *str, size_t len)

static wchar_t *	duplicateUcs2 (const ucs2_t *str, bool bigendian)

static wchar_t *	duplicateUcs2 (const ucs2_t *str, size_t len, bool bigendian)

static wchar_t *	duplicateUcs2 (const ucs2_t *str, wchar_t replacement)

static wchar_t *	duplicateUcs2 (const ucs2_t *str, size_t len, wchar_t replacement)

static wchar_t *	duplicateUcs2 (const ucs2_t *str, wchar_t replacement, bool bigendian)

static wchar_t *	duplicateUcs2 (const ucs2_t *str, size_t len, wchar_t replacement, bool bigendian)

static void	upper (wchar_t *str)

static void	lower (wchar_t *str)

static void	capitalize (wchar_t *str)

static void	rightTrim (wchar_t *str)

static void	rightTrim (wchar_t *str, wchar_t character)

static void	leftTrim (wchar_t *str)

static void	leftTrim (wchar_t *str, wchar_t character)

static void	bothTrim (wchar_t *str)

static void	bothTrim (wchar_t *str, wchar_t character)

static bool	strip (wchar_t *str, wchar_t character)

static bool	strip (wchar_t str1, const wchar_t str2)

static bool	stripSet (wchar_t str1, const wchar_t set)

static void	replace (wchar_t *str, wchar_t oldchar, wchar_t newchar)

static void	replace (wchar_t str, const wchar_t oldchars, wchar_t newchar)

static wchar_t *	replace (const wchar_t str, const wchar_t oldstr, const wchar_t *newstr)

static wchar_t *	replace (const wchar_t str, const wchar_t const oldstrset, size_t oldstrlen, const wchar_t const newstrset)

static uint16_t	getIntegerLength (int16_t number)

static uint16_t	getIntegerLength (int32_t number)

static uint16_t	getIntegerLength (int64_t number)

static uint16_t	getIntegerLength (uint16_t number)

static uint16_t	getIntegerLength (uint32_t number)

static uint16_t	getIntegerLength (uint64_t number)

static bool	isInteger (const wchar_t *val)

static bool	isInteger (const wchar_t *val, int32_t len)

static bool	isNumber (const wchar_t *val)

static bool	isNumber (const wchar_t *val, int32_t len)

static wchar_t *	parseNumber (int16_t number)

static wchar_t *	parseNumber (uint16_t number)

static wchar_t *	parseNumber (int16_t number, uint16_t zeropadding)

static wchar_t *	parseNumber (uint16_t number, uint16_t zeropadding)

static wchar_t *	parseNumber (int32_t number)

static wchar_t *	parseNumber (uint32_t number)

static wchar_t *	parseNumber (int32_t number, uint16_t zeropadding)

static wchar_t *	parseNumber (uint32_t number, uint16_t zeropadding)

static wchar_t *	parseNumber (int64_t number)

static wchar_t *	parseNumber (uint64_t number)

static wchar_t *	parseNumber (int64_t number, uint16_t zeropadding)

static wchar_t *	parseNumber (uint64_t number, uint16_t zeropadding)

static wchar_t *	parseNumber (float number)

static wchar_t *	parseNumber (float number, uint16_t scale)

static wchar_t *	parseNumber (float number, uint16_t precision, uint16_t scale)

static wchar_t *	parseNumber (double number)

static wchar_t *	parseNumber (double number, uint16_t scale)

static wchar_t *	parseNumber (double number, uint16_t precision, uint16_t scale)

static wchar_t *	parseNumber (long double number)

static wchar_t *	parseNumber (long double number, uint16_t scale)

static wchar_t *	parseNumber (long double number, uint16_t precision, uint16_t scale)

static int64_t	convertToInteger (const wchar_t *string)

static int64_t	convertToInteger (const wchar_t string, const wchar_t *endptr)

static int64_t	convertToInteger (const wchar_t *string, int32_t base)

static int64_t	convertToInteger (const wchar_t string, const wchar_t *endptr, int32_t base)

static uint64_t	convertToUnsignedInteger (const wchar_t *string)

static uint64_t	convertToUnsignedInteger (const wchar_t string, const wchar_t *endptr)

static uint64_t	convertToUnsignedInteger (const wchar_t *string, int32_t base)

static uint64_t	convertToUnsignedInteger (const wchar_t string, const wchar_t *endptr, int32_t base)

static long double	convertToFloat (const wchar_t *string)

static long double	convertToFloatC (const wchar_t *string)

static long double	convertToFloat (const wchar_t string, const wchar_t *endptr)

static int64_t	convertAmount (const wchar_t *amount)

static wchar_t *	convertAmount (int64_t amount)

static wchar_t *	convertAmount (int64_t amount, uint16_t padding)

static wchar_t *	escape (const wchar_t input, const wchar_t characters)

static wchar_t *	unescape (const wchar_t *input)

static void	escape (const wchar_t input, uint64_t inputlen, wchar_t output, uint64_t outputlen, const wchar_t *characters)

static void	unescape (const wchar_t input, uint64_t inputlen, wchar_t output, uint64_t outputlen)

static void	leftJustify (wchar_t *str, int32_t len)

static void	rightJustify (wchar_t *str, int32_t len)

static void	center (wchar_t *str, int32_t len)

static wchar_t *	pad (const wchar_t *string, wchar_t padchar, int16_t direction, uint64_t totallength)

static void	split (const wchar_t string, size_t stringlength, const wchar_t delimiter, size_t delimiterlength, bool collapse, wchar_t **list, uint64_t listlength)

static void	split (const wchar_t string, const wchar_t delimiter, size_t delimiterlength, bool collapse, wchar_t **list, uint64_t listlength)

static void	split (const wchar_t string, size_t stringlength, const wchar_t delimiter, bool collapse, wchar_t **list, uint64_t listlength)

static void	split (const wchar_t string, const wchar_t delimiter, bool collapse, wchar_t **list, uint64_t listlength)

static wchar_t *	getSubString (const wchar_t *str, size_t start, size_t end)

static wchar_t *	getSubString (const wchar_t *str, size_t start)

static wchar_t *	insertString (const wchar_t dest, const wchar_t src, uint64_t index)

static wchar_t *	getHumanReadable (int64_t number)

static wchar_t *	getHumanReadable (int64_t number, bool onethousand)

static wchar_t *	getHumanReadable (uint64_t number)

static wchar_t *	getHumanReadable (uint64_t number, bool onethousand)

static wchar_t *	getHumanReadable (long double number)

static wchar_t *	getHumanReadable (long double number, bool onethousand)

static ssize_t	printf (wchar_t buffer, size_t len, const wchar_t format,...)

static ssize_t	printf (wchar_t buffer, size_t len, const wchar_t format, va_list *argp)

static ssize_t	printf (wchar_t *buffer, const wchar_t format,...)

static ssize_t	printf (wchar_t *buffer, const wchar_t format, va_list *argp)

static bool	supportsPrintf ()

Detailed Description

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

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

Member Function Documentation

◆ append() [1/7]

static wchar_t* wcharstring::append	(	wchar_t *	dest,
		const wchar_t *	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 wchar_t* wcharstring::append	(	wchar_t *	dest,
		const wchar_t *	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 wchar_t* wcharstring::append	(	wchar_t *	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 wchar_t* wcharstring::append	(	wchar_t *	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 wchar_t* wcharstring::append	(	wchar_t *	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 wchar_t* wcharstring::append	(	wchar_t *	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 wchar_t* wcharstring::append	(	wchar_t *	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".

◆ bothTrim() [1/2]

static void wcharstring::bothTrim ( wchar_t * str )

static

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

◆ bothTrim() [2/2]

static void wcharstring::bothTrim	(	wchar_t *	str,
		wchar_t	character
	)

static

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

◆ capitalize()

static void wcharstring::capitalize ( wchar_t * str )

static

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

◆ center()

static void wcharstring::center	(	wchar_t *	str,
		int32_t	len
	)

static

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

Example: "hello " -> " hello "

◆ compare() [1/2]

static int32_t wcharstring::compare	(	const wchar_t *	str1,
		const wchar_t *	str2
	)

static

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

◆ compare() [2/2]

static int32_t wcharstring::compare	(	const wchar_t *	str1,
		const wchar_t *	str2,
		size_t	len
	)

static

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

◆ compareIgnoringCase() [1/2]

static int32_t wcharstring::compareIgnoringCase	(	const wchar_t *	str1,
		const wchar_t *	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 wcharstring::compareIgnoringCase	(	const wchar_t *	str1,
		const wchar_t *	str2,
		size_t	len
	)

static

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

◆ compareNatural() [1/2]

static int32_t wcharstring::compareNatural	(	const wchar_t *	str1,
		const wchar_t *	str2
	)

static

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

Embedded (version) numbers will be interpreted "naturally" (eg. 12 > 8)

◆ compareNatural() [2/2]

static int32_t wcharstring::compareNatural	(	const wchar_t *	str1,
		const wchar_t *	str2,
		const wchar_t *	delimiters
	)

static

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

Embedded (version) numbers will be interpreted "naturally" (eg. 12 > 8)

"delimiters" should be set to the set of characters that will be interpreted as equivalent delimiters. Eg. "._" means that either .'s or _'s may be used to delimit numbers.

◆ compareVersions() [1/2]

static int32_t wcharstring::compareVersions	(	const wchar_t *	str1,
		const wchar_t *	str2
	)

static

Returns -1,0 or 1 if "str1" is greater than, equal to or less than "str2", where "str1" and "str2" are version numbers with arbitrary numbers of decimal delimiters.

◆ compareVersions() [2/2]

static int32_t wcharstring::compareVersions	(	const wchar_t *	str1,
		const wchar_t *	str2,
		const wchar_t *	delimiters
	)

static

Returns -1,0 or 1 if "str1" is greater than, equal to or less than "str2", where "str1" and "str2" are version numbers with arbitrary numbers of delimiters.

"delimiters" should be set to the set of characters that will be interpreted as equivalent delimiters. Eg. "._" means that either .'s or _'s may be used to delimiters numbers.

◆ compareWithWildcards() [1/4]

static bool wcharstring::compareWithWildcards	(	const wchar_t *	string,
		const wchar_t *	pattern,
		size_t	patternlength,
		wchar_t	singlewildcard,
		wchar_t	multiwildcard
	)

static

Compares "string" to the first "patternlength" characters of "pattern" which may contain instances of single-character wildcard markers "singlewildcard" or multi-character wildcard markers "multiwildcard".

If either "singlewildcard" or "multiwildcard" are '\0' then they are ignored.

Returns true if a match is found or false otherwise.

◆ compareWithWildcards() [2/4]

static bool wcharstring::compareWithWildcards	(	const wchar_t *	string,
		const wchar_t *	pattern,
		wchar_t	singlewildcard,
		wchar_t	multiwildcard
	)

static

Compares "string" to "pattern" which may contain instances of single-character wildcard markers "singlewildcard" or multi-character wildcard markers "multiwildcard".

If either "singlewildcard" or "multiwildcard" are '\0' then they are ignored.

Returns true if a match is found or false otherwise.

◆ compareWithWildcards() [3/4]

static bool wcharstring::compareWithWildcards	(	const wchar_t *	string,
		size_t	stringlength,
		const wchar_t *	pattern,
		size_t	patternlength,
		wchar_t	singlewildcard,
		wchar_t	multiwildcard
	)

static

Compares the first "stringlength" characters of "string" to the first "patternlength" characters of "pattern" which may contain instances of single-character wildcard markers "singlewildcard" or multi-character wildcard markers "multiwildcard".

If either "singlewildcard" or "multiwildcard" are '\0' then they are ignored.

Returns true if a match is found or false otherwise.

◆ compareWithWildcards() [4/4]

static bool wcharstring::compareWithWildcards	(	const wchar_t *	string,
		size_t	stringlength,
		const wchar_t *	pattern,
		wchar_t	singlewildcard,
		wchar_t	multiwildcard
	)

static

Compares the first "stringlength" characters of "string" to "pattern" which may contain instances of single-character wildcard markers "singlewildcard" or multi-character wildcard markers "multiwildcard".

If either "singlewildcard" or "multiwildcard" are '\0' then they are ignored.

Returns true if a match is found or false otherwise.

◆ contains() [1/2]

static bool wcharstring::contains	(	const wchar_t *	haystack,
		const wchar_t *	needle
	)

static

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

◆ contains() [2/2]

static bool wcharstring::contains	(	const wchar_t *	haystack,
		wchar_t	needle
	)

static

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

◆ containsIgnoringCase() [1/2]

static bool wcharstring::containsIgnoringCase	(	const wchar_t *	haystack,
		const wchar_t *	needle
	)

static

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

◆ containsIgnoringCase() [2/2]

static bool wcharstring::containsIgnoringCase	(	const wchar_t *	haystack,
		wchar_t	needle
	)

static

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

◆ convertAmount() [1/3]

static int64_t wcharstring::convertAmount ( const wchar_t * amount )

static

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

◆ convertAmount() [2/3]

static wchar_t* wcharstring::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 wchar_t* wcharstring::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.

◆ convertToFloat() [1/2]

static long double wcharstring::convertToFloat ( const wchar_t * string )

static

Converts "string" to a floating point number.

◆ convertToFloat() [2/2]

static long double wcharstring::convertToFloat	(	const wchar_t *	string,
		const wchar_t **	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.

◆ convertToFloatC()

static long double wcharstring::convertToFloatC ( const wchar_t * 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 convertToFloat().)

◆ convertToInteger() [1/4]

static int64_t wcharstring::convertToInteger ( const wchar_t * string )

static

Converts "string" to a 64-bit integer.

◆ convertToInteger() [2/4]

static int64_t wcharstring::convertToInteger	(	const wchar_t *	string,
		const wchar_t **	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.

◆ convertToInteger() [3/4]

static int64_t wcharstring::convertToInteger	(	const wchar_t *	string,
		const wchar_t **	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.

◆ convertToInteger() [4/4]

static int64_t wcharstring::convertToInteger	(	const wchar_t *	string,
		int32_t	base
	)

static

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

◆ convertToUnsignedInteger() [1/4]

static uint64_t wcharstring::convertToUnsignedInteger ( const wchar_t * string )

static

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

◆ convertToUnsignedInteger() [2/4]

static uint64_t wcharstring::convertToUnsignedInteger	(	const wchar_t *	string,
		const wchar_t **	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.

◆ convertToUnsignedInteger() [3/4]

static uint64_t wcharstring::convertToUnsignedInteger	(	const wchar_t *	string,
		const wchar_t **	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.

◆ convertToUnsignedInteger() [4/4]

static uint64_t wcharstring::convertToUnsignedInteger	(	const wchar_t *	string,
		int32_t	base
	)

static

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

◆ copy() [1/4]

static wchar_t* wcharstring::copy	(	wchar_t *	dest,
		const wchar_t *	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 wchar_t* wcharstring::copy	(	wchar_t *	dest,
		const wchar_t *	source,
		size_t	len
	)

static

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

◆ copy() [3/4]

static wchar_t* wcharstring::copy	(	wchar_t *	dest,
		size_t	location,
		const wchar_t *	source
	)

static

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

◆ copy() [4/4]

static wchar_t* wcharstring::copy	(	wchar_t *	dest,
		size_t	location,
		const wchar_t *	source,
		size_t	len
	)

static

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

◆ duplicate() [1/4]

static wchar_t* wcharstring::duplicate ( const char * str )

static

Creates a duplicate of "str", converts it to a wide string, 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/4]

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

static

Creates a duplicate of the first "len" characters of "str", converts it to a wide string, 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() [3/4]

static wchar_t* wcharstring::duplicate ( const wchar_t * 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() [4/4]

static wchar_t* wcharstring::duplicate	(	const wchar_t *	str,
		size_t	len
	)

static

Creates a duplicate of the first "len" wide 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.

◆ duplicateUcs2() [1/8]

static wchar_t* wcharstring::duplicateUcs2 ( const ucs2_t * str )

static

Creates a duplicate of "str", converting each UCS-2 character to a wide character, replacing characters that can't be represented as wide characters with a wide '?', and returns a pointer to it.

The UCS-2 characters in "str" are presumed to be in the byte-order of the system.

Note that this method allocates a buffer for the duplicate string internally and returns it. The calling program must deallocate this buffer.

◆ duplicateUcs2() [2/8]

static wchar_t* wcharstring::duplicateUcs2	(	const ucs2_t *	str,
		bool	bigendian
	)

static

Creates a duplicate of "str", converting each UCS-2 character to a wide character, replacing characters that can't be represented as wide characters with a wide '?', and returns a pointer to it.

If "bigendian" is true then "str" is presumed to be big endian. If "bigendian" is false, then "str" is presumed to be little endian.

Note that this method allocates a buffer for the duplicate string internally and returns it. The calling program must deallocate this buffer.

◆ duplicateUcs2() [3/8]

static wchar_t* wcharstring::duplicateUcs2	(	const ucs2_t *	str,
		size_t	len
	)

static

Creates a duplicate of the first "len" UCS-2 characters of "str", converting each UCS-2 character to a character per the character set of the current locale, replacing characters that can't be represented '?', and returns a pointer to it.

The UCS-2 characters in "str" are presumed to be in the byte-order of the system.

Note that this method allocates a buffer for the duplicate string internally and returns it. The calling program must deallocate this buffer.

◆ duplicateUcs2() [4/8]

static wchar_t* wcharstring::duplicateUcs2	(	const ucs2_t *	str,
		size_t	len,
		bool	bigendian
	)

static

Creates a duplicate of the first "len" UCS-2 characters of "str", converting each UCS-2 character to a character per the character set of the current locale, replacing characters that can't be represented '?', and returns a pointer to it.

If "bigendian" is true then "str" is presumed to be big endian. If "bigendian" is false, then "str" is presumed to be little endian.

Note that this method allocates a buffer for the duplicate string internally and returns it. The calling program must deallocate this buffer.

◆ duplicateUcs2() [5/8]

static wchar_t* wcharstring::duplicateUcs2	(	const ucs2_t *	str,
		size_t	len,
		wchar_t	replacement
	)

static

Creates a duplicate of the first "len" UCS-2 characters of "str", converting each UCS-2 character to a character per the character set of the current locale, replacing characters that can't be represented with "replacement", and returns a pointer to it.

The UCS-2 characters in "str" are presumed to be in the byte-order of the system.

Note that this method allocates a buffer for the duplicate string internally and returns it. The calling program must deallocate this buffer.

◆ duplicateUcs2() [6/8]

static wchar_t* wcharstring::duplicateUcs2	(	const ucs2_t *	str,
		size_t	len,
		wchar_t	replacement,
		bool	bigendian
	)

static

Creates a duplicate of the first "len" UCS-2 characters of "str", converting each UCS-2 character to a character per the character set of the current locale, replacing characters that can't be represented with "replacement", and returns a pointer to it.

If "bigendian" is true then "str" is presumed to be big endian. If "bigendian" is false, then "str" is presumed to be little endian.

Note that this method allocates a buffer for the duplicate string internally and returns it. The calling program must deallocate this buffer.

◆ duplicateUcs2() [7/8]

static wchar_t* wcharstring::duplicateUcs2	(	const ucs2_t *	str,
		wchar_t	replacement
	)

static

Creates a duplicate of "str", converting each UCS-2 character to a character per the character set of the current locale, replacing characters that can't be represented with "replacement", and returns a pointer to it.

The UCS-2 characters in "str" are presumed to be in the byte-order of the system.

Note that this method allocates a buffer for the duplicate string internally and returns it. The calling program must deallocate this buffer.

◆ duplicateUcs2() [8/8]

static wchar_t* wcharstring::duplicateUcs2	(	const ucs2_t *	str,
		wchar_t	replacement,
		bool	bigendian
	)

static

Creates a duplicate of "str", converting each UCS-2 character to a character per the character set of the current locale, replacing characters that can't be represented with "replacement", and returns a pointer to it.

If "bigendian" is true then "str" is presumed to be big endian. If "bigendian" is false, then "str" is presumed to be little endian.

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 wcharstring::endsWith	(	const wchar_t *	haystack,
		const wchar_t *	needle
	)

static

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

◆ escape() [1/2]

static wchar_t* wcharstring::escape	(	const wchar_t *	input,
		const wchar_t *	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 wcharstring::escape	(	const wchar_t *	input,
		uint64_t	inputlen,
		wchar_t **	output,
		uint64_t *	outputlen,
		const wchar_t *	characters
	)

static

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

◆ findFirst() [1/4]

static const wchar_t* wcharstring::findFirst	(	const wchar_t *	haystack,
		const wchar_t *	needle
	)

static

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

◆ findFirst() [2/4]

static const wchar_t* wcharstring::findFirst	(	const wchar_t *	haystack,
		wchar_t	needle
	)

static

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

◆ findFirst() [3/4]

static wchar_t* wcharstring::findFirst	(	wchar_t *	haystack,
		const wchar_t *	needle
	)

static

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

◆ findFirst() [4/4]

static wchar_t* wcharstring::findFirst	(	wchar_t *	haystack,
		wchar_t	needle
	)

static

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

◆ findFirstIgnoringCase() [1/4]

static const wchar_t* wcharstring::findFirstIgnoringCase	(	const wchar_t *	haystack,
		const wchar_t *	needle
	)

static

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

◆ findFirstIgnoringCase() [2/4]

static const wchar_t* wcharstring::findFirstIgnoringCase	(	const wchar_t *	haystack,
		wchar_t	needle
	)

static

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

◆ findFirstIgnoringCase() [3/4]

static wchar_t* wcharstring::findFirstIgnoringCase	(	wchar_t *	haystack,
		const wchar_t *	needle
	)

static

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

◆ findFirstIgnoringCase() [4/4]

static wchar_t* wcharstring::findFirstIgnoringCase	(	wchar_t *	haystack,
		wchar_t	needle
	)

static

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

◆ findFirstOfSet() [1/2]

static const wchar_t* wcharstring::findFirstOfSet	(	const wchar_t *	haystack,
		const wchar_t *	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 wchar_t* wcharstring::findFirstOfSet	(	wchar_t *	haystack,
		const wchar_t *	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 const wchar_t* wcharstring::findFirstOfSetOrEnd	(	const wchar_t *	haystack,
		const wchar_t *	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 wchar_t* wcharstring::findFirstOfSetOrEnd	(	wchar_t *	haystack,
		const wchar_t *	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 const wchar_t* wcharstring::findFirstOrEnd	(	const wchar_t *	haystack,
		const wchar_t *	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 wchar_t* wcharstring::findFirstOrEnd	(	const wchar_t *	haystack,
		wchar_t	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 wchar_t* wcharstring::findFirstOrEnd	(	wchar_t *	haystack,
		const wchar_t *	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 const wchar_t* wcharstring::findFirstOrEndIgnoringCase	(	const wchar_t *	haystack,
		const wchar_t *	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 wchar_t* wcharstring::findFirstOrEndIgnoringCase	(	const wchar_t *	haystack,
		wchar_t	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 wchar_t* wcharstring::findFirstOrEndIgnoringCase	(	wchar_t *	haystack,
		const wchar_t *	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 const wchar_t* wcharstring::findLast	(	const wchar_t *	haystack,
		const wchar_t *	needle
	)

static

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

◆ findLast() [2/4]

static const wchar_t* wcharstring::findLast	(	const wchar_t *	haystack,
		wchar_t	needle
	)

static

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

◆ findLast() [3/4]

static wchar_t* wcharstring::findLast	(	wchar_t *	haystack,
		const wchar_t *	needle
	)

static

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

◆ findLast() [4/4]

static wchar_t* wcharstring::findLast	(	wchar_t *	haystack,
		wchar_t	needle
	)

static

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

◆ findLastIgnoringCase() [1/2]

static const wchar_t* wcharstring::findLastIgnoringCase	(	const wchar_t *	haystack,
		const wchar_t *	needle
	)

static

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

◆ findLastIgnoringCase() [2/2]

static const wchar_t* wcharstring::findLastIgnoringCase	(	const wchar_t *	haystack,
		wchar_t	needle
	)

static

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

◆ findLastOfSet() [1/2]

static const wchar_t* wcharstring::findLastOfSet	(	const wchar_t *	haystack,
		const wchar_t *	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 wchar_t* wcharstring::findLastOfSet	(	wchar_t *	haystack,
		const wchar_t *	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 const wchar_t* wcharstring::findLastOfSetOrEnd	(	const wchar_t *	haystack,
		const wchar_t *	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 wchar_t* wcharstring::findLastOfSetOrEnd	(	wchar_t *	haystack,
		const wchar_t *	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.

◆ getHumanReadable() [1/6]

static wchar_t* wcharstring::getHumanReadable ( int64_t number )

static

Returns a human-readable version of the number.

Eg. 128, 1.2K, 2.4M, 3.5G, 4.6T, etc.

Where 1K = 1024.

◆ getHumanReadable() [2/6]

static wchar_t* wcharstring::getHumanReadable	(	int64_t	number,
		bool	onethousand
	)

static

Returns a human-readable version of the number.

Eg. 128, 1.2K, 2.4M, 3.5G, 4.6T, etc.

If "onethousand" = true then 1K = 1000, otherwise 1K = 1024.

◆ getHumanReadable() [3/6]

static wchar_t* wcharstring::getHumanReadable ( long double number )

static

Returns a human-readable version of the number.

Eg. 128, 1.2K, 2.4M, 3.5G, 4.6T, etc.

◆ getHumanReadable() [4/6]

static wchar_t* wcharstring::getHumanReadable	(	long double	number,
		bool	onethousand
	)

static

Returns a human-readable version of the number.

Eg. 128, 1.2K, 2.4M, 3.5G, 4.6T, etc.

If "onethousand" = true then 1K = 1000, otherwise 1K = 1024.

◆ getHumanReadable() [5/6]

static wchar_t* wcharstring::getHumanReadable ( uint64_t number )

static

Returns a human-readable version of the number.

Eg. 128, 1.2K, 2.4M, 3.5G, 4.6T, etc.

◆ getHumanReadable() [6/6]

static wchar_t* wcharstring::getHumanReadable	(	uint64_t	number,
		bool	onethousand
	)

static

Returns a human-readable version of the number.

Eg. 128, 1.2K, 2.4M, 3.5G, 4.6T, etc.

If "onethousand" = true then 1K = 1000, otherwise 1K = 1024.

◆ getIntegerLength() [1/6]

static uint16_t wcharstring::getIntegerLength ( int16_t number )

static

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

◆ getIntegerLength() [2/6]

static uint16_t wcharstring::getIntegerLength ( int32_t number )

static

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

◆ getIntegerLength() [3/6]

static uint16_t wcharstring::getIntegerLength ( int64_t number )

static

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

◆ getIntegerLength() [4/6]

static uint16_t wcharstring::getIntegerLength ( uint16_t number )

static

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

◆ getIntegerLength() [5/6]

static uint16_t wcharstring::getIntegerLength ( uint32_t number )

static

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

◆ getIntegerLength() [6/6]

static uint16_t wcharstring::getIntegerLength ( uint64_t number )

static

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

◆ getLength()

static size_t wcharstring::getLength ( const wchar_t * string )

static

Returns the number of characters in "string".

◆ getLengthContainingSet()

static size_t wcharstring::getLengthContainingSet	(	const wchar_t *	haystack,
		const wchar_t *	set
	)

static

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

◆ getLengthNotContainingSet()

static size_t wcharstring::getLengthNotContainingSet	(	const wchar_t *	haystack,
		const wchar_t *	set
	)

static

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

◆ getSize()

static size_t wcharstring::getSize ( const wchar_t * string )

static

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

◆ getSubString() [1/2]

static wchar_t* wcharstring::getSubString	(	const wchar_t *	str,
		size_t	start
	)

static

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

◆ getSubString() [2/2]

static wchar_t* wcharstring::getSubString	(	const wchar_t *	str,
		size_t	start,
		size_t	end
	)

static

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

◆ insertString()

static wchar_t* wcharstring::insertString	(	const wchar_t *	dest,
		const wchar_t *	src,
		uint64_t	index
	)

static

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

◆ isAfter()

static wchar_t* wcharstring::isAfter	(	const wchar_t *	str,
		const wchar_t *	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.

◆ isBefore()

static wchar_t* wcharstring::isBefore	(	const wchar_t *	str,
		const wchar_t *	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.

◆ isBetween()

static wchar_t* wcharstring::isBetween	(	const wchar_t *	str,
		const wchar_t *	start,
		const wchar_t *	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.

◆ isInSet()

static bool wcharstring::isInSet	(	const wchar_t *	str,
		const wchar_t 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.

◆ isInSetIgnoringCase()

static bool wcharstring::isInSetIgnoringCase	(	const wchar_t *	str,
		const wchar_t 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.

◆ isInteger() [1/2]

static bool wcharstring::isInteger ( const wchar_t * val )

static

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

◆ isInteger() [2/2]

static bool wcharstring::isInteger	(	const wchar_t *	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 wcharstring::isNo ( const wchar_t * 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 wcharstring::isNullOrEmpty ( const wchar_t * string )

static

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

◆ isNumber() [1/2]

static bool wcharstring::isNumber ( const wchar_t * val )

static

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

◆ isNumber() [2/2]

static bool wcharstring::isNumber	(	const wchar_t *	val,
		int32_t	len
	)

static

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

◆ isYes()

static bool wcharstring::isYes ( const wchar_t * 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 wcharstring::leftJustify	(	wchar_t *	str,
		int32_t	len
	)

static

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

Example: " hello " -> "hello "

◆ leftTrim() [1/2]

static void wcharstring::leftTrim ( wchar_t * str )

static

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

◆ leftTrim() [2/2]

static void wcharstring::leftTrim	(	wchar_t *	str,
		wchar_t	character
	)

static

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

◆ lower()

static void wcharstring::lower ( wchar_t * str )

static

Converts "str" to lowercase.

◆ pad()

static wchar_t* wcharstring::pad	(	const wchar_t *	string,
		wchar_t	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.