SUMMARY:  INNER | FIELD | CONSTR | METHOD | FRIEND DETAIL:  FIELD | CONSTR | METHOD | FRIEND


Namespace Platform::Str

namespace Platform::Str

Provides operations for manipulating native C strings (copying, comparison, conversion, formatting etc).

Inner Compounds, Typedefs, and Enumscollapse
enum Constants
          Constants used by the constructs within this namespace.

Method Summarycollapse
template <typename Type,
typename TypeX>
Int
compare(const Type* stringA, const TypeX* stringB)
          Compares two strings for order (total ordering relation).
template <typename Type,
typename TypeX>
Int
compare(const Type* stringA, const TypeX* stringB, Int length)
          Compares up to length characters in two strings for order (total ordering relation).
template <typename Type,
typename TypeX>
Int
compareIgnoreCase(const Type* stringA, const TypeX* stringB)
          Compares two strings for order, ignoring case differences (case insensitive total ordering relation).
template <typename Type,
typename TypeX>
Int
compareIgnoreCase(const Type* stringA, const TypeX* stringB, Int length)
          Compares up to length characters in two strings for order, ignoring case differences (case insensitive total ordering relation).
template <typename Type,
typename TypeX>
Void
copy(Type* destination, const TypeX* source)
          Copies the source string into destination buffer applying type conversion if necessary.
template <typename Type,
typename TypeX>
Void
copy(Type* destination, const TypeX* source, Int length)
          Copies up to length characters from the source string into destination buffer applying type conversion if necessary.
template <typename Type,
typename TypeX>
Bool
equal(const Type* stringA, const TypeX* stringB)
          Compares two strings for equality (equivalence relation).
template <typename Type,
typename TypeX>
Bool
equal(const Type* stringA, const TypeX* stringB, Int length)
          Compares up to length characters in two strings for equality (equivalence relation).
template <typename Type,
typename TypeX>
Bool
equalIgnoreCase(const Type* stringA, const TypeX* stringB)
          Compares two strings for equality, ignoring case differences (case insensitive equivalence relation).
template <typename Type,
typename TypeX>
Bool
equalIgnoreCase(const Type* stringA, const TypeX* stringB, Int length)
          Compares up to length characters in two strings for equality, ignoring case differences (case insensitive equivalence relation).
template <typename Type,
typename TypeX>
Void
fill(Type* string, TypeX c)
          Fills a string with the specified character.
template <typename Type,
typename TypeX>
Void
fill(Type* string, TypeX c, Int length)
          Fills up to length characters in a string with the specified character.
Int format(Char* result, const Char* string, ...)
          Formats the specified string according to format specification (see below) and places the result into the result buffer.
Int formatv(Char* result, const Char* string, va_list arguments)
          Formats the specified string according to format specification (see below) and places the result into the result buffer.
template <typename Type>
UInt
hashCodeIgnoreCaseOf(const Type* string)
          Computes the hash code of a string ignoring case differences.
template <typename Type>
UInt
hashCodeIgnoreCaseOf(const Type* string, Int length)
          Computes the hash code of a string ignoring case differences.
template <typename Type>
UInt
hashCodeOf(const Type* string)
          Computes the hash code of a string.
template <typename Type>
UInt
hashCodeOf(const Type* string, Int length)
          Computes the hash code of a string.
template <typename Type,
typename TypeX>
Int
indexOf(const Type* string, TypeX c, Int fromIndex)
          Finds the first occurance of the specified character in a string from the given offset.
template <typename Type,
typename TypeX,
typename EqualityTester>
Int
indexOf(const Type* string, TypeX c, Int fromIndex, EqualityTester equalFn)
          Finds the first occurance of the specified character in a string from the given offset using the specified equality tester function.
template <typename Type,
typename TypeX>
Int
indexOfSubString(const Type* source, const TypeX* target, Int fromIndex)
          Finds the first occurance of the specified target string in the source string starting the search from the given offset.
template <typename Type,
typename TypeX,
typename EqualityTester>
Int
indexOfSubString(const Type* source, const TypeX* target, Int fromIndex, EqualityTester equalFn)
          Finds the first occurance of the specified target string in the source string starting the search from the given offset using the specified equality tester function.
template <typename Type>
Bool
isEmpty(const Type* string)
          Tests whether the specified string is empty.
template <typename Type,
typename TypeX>
Int
lastIndexOf(const Type* string, TypeX c, Int fromIndex)
          Finds the last occurance of the specified character in a string from the given offset.
template <typename Type,
typename TypeX,
typename EqualityTester>
Int
lastIndexOf(const Type* string, TypeX c, Int fromIndex, EqualityTester equalFn)
          Finds the last occurance of the specified character in a string from the given offset using the specified equality tester function.
template <typename Type,
typename TypeX>
Int
lastIndexOfSubString(const Type* source, const TypeX* target, Int fromIndex)
          Finds the last occurance of the specified target string in the source string starting the search from the given offset.
template <typename Type,
typename TypeX,
typename EqualityTester>
Int
lastIndexOfSubString(const Type* source, const TypeX* target, Int fromIndex, EqualityTester equalFn)
          Finds the last occurance of the specified target string in the source string starting the search from the given offset using the specified equality tester function.
template <typename Type>
Int
lengthOf(const Type* string)
          Computes the length of a string.
template <typename Type>
Int
lengthOf(const Type* string, Int length)
          Computes the length of a string.
template <typename Type>
static Type
parseNumber(const Char* string, Int base, Int* outLength)
          Attempts to parse a string and convert the result into an integer number.
template <typename Type,
typename TypeX>
Void
replace(Type* string, TypeX oldChar, TypeX newChar)
          Replaces every occurance of the character oldChar with newChar in a given string.
template <typename Type,
typename TypeX,
typename EqualityTester>
Void
replace(Type* string, TypeX oldChar, TypeX newChar, EqualityTester equalFn)
          Replaces every occurance of the character oldChar with newChar in a given string using the specified equality tester function.
Bool toBool(const Char* string, Int* outLength = Null)
          Attempts to parse a string and convert the result into a boolean number.
Double toDouble(const Char* string, Int* outLength = Null)
          Attempts to parse a string and convert the result into a floating-point number.
Float toFloat(const Char* string, Int* outLength = Null)
          Attempts to parse a string and convert the result into a floating-point number.
template <typename Type>
Void
toFoldCase(Type* string)
          Converts a string to fold case.
Int toInt(const Char* string, Int* outLength = Null)
          Attempts to parse a string and convert the result into an integer number.
Long toLong(const Char* string, Int* outLength = Null)
          Attempts to parse a string and convert the result into an integer number.
template <typename Type>
Void
toLowerCase(Type* string)
          Converts a string to lower case.
template <typename Type>
Void
toTitleCase(Type* string)
          Converts a string to title case.
UInt toUInt(const Char* string, Int* outLength = Null)
          Attempts to parse a string and convert the result into an integer number.
ULong toULong(const Char* string, Int* outLength = Null)
          Attempts to parse a string and convert the result into an integer number.
template <typename Type>
Void
toUpperCase(Type* string)
          Converts a string to upper case.

 

Method Detail

compare[nothrow, inline]

template <typename Type, typename TypeX>
Int compare(const Type* stringA, const TypeX* stringB)

Compares two strings for order (total ordering relation).

Parameters:
stringA - first string
stringB - second string
Returns:
a signed integer number, result, indicating the relationship between stringA and stringB:
  • result < 0 if stringA < stringB
  • result == 0 if stringA == stringB
  • result > 0 if stringA > stringB

compare[nothrow, inline]

template <typename Type, typename TypeX>
Int compare(const Type* stringA, const TypeX* stringB, Int length)

Compares up to length characters in two strings for order (total ordering relation).

Parameters:
stringA - first string
stringB - second string
length - the maximum number of characters to compare
Returns:
a signed integer number, result, indicating the relationship between stringA and stringB:
  • result < 0 if stringA < stringB
  • result == 0 if stringA == stringB
  • result > 0 if stringA > stringB

compareIgnoreCase[nothrow, inline]

template <typename Type, typename TypeX>
Int compareIgnoreCase(const Type* stringA, const TypeX* stringB)

Compares two strings for order, ignoring case differences (case insensitive total ordering relation). Case considerations are erased by converting both characters to foldcase during comparison.

Parameters:
stringA - first string
stringB - second string
Returns:
a signed integer number, result, indicating the relationship between stringA and stringB:
  • result < 0 if stringA < stringB
  • result == 0 if stringA == stringB
  • result > 0 if stringA > stringB

compareIgnoreCase[nothrow, inline]

template <typename Type, typename TypeX>
Int compareIgnoreCase(const Type* stringA, const TypeX* stringB, Int length)

Compares up to length characters in two strings for order, ignoring case differences (case insensitive total ordering relation). Case considerations are erased by converting both characters to foldcase during comparison.

Parameters:
stringA - first string
stringB - second string
length - the maximum number of characters to compare
Returns:
a signed integer number, result, indicating the relationship between stringA and stringB:
  • result < 0 if stringA < stringB
  • result == 0 if stringA == stringB
  • result > 0 if stringA > stringB

copy[nothrow, inline]

template <typename Type, typename TypeX>
Void copy(Type* destination, const TypeX* source)

Copies the source string into destination buffer applying type conversion if necessary.

Parameters:
destination - the destination buffer
source - a string

copy[nothrow, inline]

template <typename Type, typename TypeX>
Void copy(Type* destination, const TypeX* source, Int length)

Copies up to length characters from the source string into destination buffer applying type conversion if necessary.

Parameters:
destination - the destination buffer
source - a string
length - the maximum number of characters to copy

equal[nothrow, inline]

template <typename Type, typename TypeX>
Bool equal(const Type* stringA, const TypeX* stringB)

Compares two strings for equality (equivalence relation).

Parameters:
stringA - first string
stringB - second string
Returns:
True if the strings are equal, False otherwise

equal[nothrow, inline]

template <typename Type, typename TypeX>
Bool equal(const Type* stringA, const TypeX* stringB, Int length)

Compares up to length characters in two strings for equality (equivalence relation).

Parameters:
stringA - first string
stringB - second string
length - the maximum number of characters to compare
Returns:
True if the strings are equal, False otherwise

equalIgnoreCase[nothrow, inline]

template <typename Type, typename TypeX>
Bool equalIgnoreCase(const Type* stringA, const TypeX* stringB)

Compares two strings for equality, ignoring case differences (case insensitive equivalence relation). Case considerations are erased by converting both characters to foldcase during comparison.

Parameters:
stringA - first string
stringB - second string
Returns:
True if the strings are equal ignoring case differences, False otherwise

equalIgnoreCase[nothrow, inline]

template <typename Type, typename TypeX>
Bool equalIgnoreCase(const Type* stringA, const TypeX* stringB, Int length)

Compares up to length characters in two strings for equality, ignoring case differences (case insensitive equivalence relation). Case considerations are erased by converting both characters to foldcase during comparison.

Parameters:
stringA - first string
stringB - second string
length - the maximum number of characters to compare
Returns:
True if the strings are equal ignoring case differences, False otherwise

fill[nothrow, inline]

template <typename Type, typename TypeX>
Void fill(Type* string, TypeX c)

Fills a string with the specified character.

Parameters:
string - a string
c - a character

fill[nothrow, inline]

template <typename Type, typename TypeX>
Void fill(Type* string, TypeX c, Int length)

Fills up to length characters in a string with the specified character.

Parameters:
string - a string
c - a character
length - the maximum number of characters to fill

format[nothrow]

Int format(Char* result, const Char* string, ...)

Formats the specified string according to format specification (see below) and places the result into the result buffer.

Parameters:
result - the buffer to hold the formatted string
string - the string containing format specification characters
... - zero or more optional arguments
Returns:
the number of characters placed into the result buffer
Format Specification:
    flag specifiers:
    ----------------
    '-'    - left adjust
    '+'    - force sign
    ' '    - pad with space
    '#'    - alternate
    '0'    - pad with zeroes
    '&'    - group digits (' ' separator)
    ','    - group digits (',' separator)
    '$'    - use ellipsis at the end of too long strings (eg strLen > precision)

    size specifiers:
    ----------------
    'h'    - Short (16-bit)
    'l'    - Int   (32-bit)
    'L'    - Long  (64-bit)

    type specifiers:
    ----------------
    'b'    - format argument as binary integer
    'B'    - format argument as Bool (True/False)
    'c'    - format argument as Char
    'C'    - expect argument to be of the opposite type to the current Char type
    'd'    - format argument as signed decimal integer
    'e'    - format argument as floating point (i.e. 3.14e+02 scientific representation)
    'E'    - format argument as floating point (i.e. 3.14E+02 scientific representation)
    'f'    - format argument as floating point (i.e. 314.1516 normal representation)
    'g'    - format argument as floating point (auto-chose between f and e)
    'G'    - format argument as floating point (auto-chose between f and E)
    'i'    - format argument as signed decimal integer
    'n'    - write to argument the number of characters written to buffer so far
    'o'    - format argument as octal integer
    'p'    - format argument as pointer (heximal lowercase)
    'P'    - format argument as pointer (heximal uppercase)
    's'    - format argument as string
    'S'    - expect argument to be of the opposite type to the current Char* type
    'u'    - format argument as unsigned decimal integer
    'x'    - format argument as heximal integer (lower case a..f)
    'X'    - format argument as heximal integer (upper case A..F)
    'y'    - expect argument to be LatinChar character
    'Y'    - expect argument to be UniChar character
    'z'    - expect argument to be LatinChar* string
    'Z'    - expect argument to be UniChar* string

    non-standard features:
    ----------------------
    'b' output binary number (e.g. 0x3e is formatted as 0b00111110)
    'B' output boolean number (True/False)
    'L' size specifier (actually semi-standard but not ISO C)
    'y' and 'Y' to format argument as Latin/Unicode Char
    'z' and 'Z' to format argument as Latin/Unicode string
    'z' type specifier behaves differently from Win32
    '&' and ',' new flag types supporting digit grouping
    '$'    new flag type supporting ellipsis at the end of long strings
Remarks:
formatting to Null returns the number of characters written without actually writing to buffer which is useful for computing the length of a formatted string prior to actual formatting into a buffer

formatv[nothrow]

Int formatv(Char* result, const Char* string, va_list arguments)

Formats the specified string according to format specification (see below) and places the result into the result buffer.

Parameters:
result - the buffer to hold the formatted string
string - the string containing format specification characters
arguments - pointer to argument list
Returns:
the number of characters placed into the result buffer
Format Specification:
    flag specifiers:
    ----------------
    '-'    - left adjust
    '+'    - force sign
    ' '    - pad with space
    '#'    - alternate
    '0'    - pad with zeroes
    '&'    - group digits (' ' separator)
    ','    - group digits (',' separator)
    '$'    - use ellipsis at the end of too long strings (eg strLen > precision)

    size specifiers:
    ----------------
    'h'    - Short (16-bit)
    'l'    - Int   (32-bit)
    'L'    - Long  (64-bit)

    type specifiers:
    ----------------
    'b'    - format argument as binary integer
    'B'    - format argument as Bool (True/False)
    'c'    - format argument as Char
    'C'    - expect argument to be of the opposite type to the current Char type
    'd'    - format argument as signed decimal integer
    'e'    - format argument as floating point (i.e. 3.14e+02 scientific representation)
    'E'    - format argument as floating point (i.e. 3.14E+02 scientific representation)
    'f'    - format argument as floating point (i.e. 314.1516 normal representation)
    'g'    - format argument as floating point (auto-chose between f and e)
    'G'    - format argument as floating point (auto-chose between f and E)
    'i'    - format argument as signed decimal integer
    'n'    - write to argument the number of characters written to buffer so far
    'o'    - format argument as octal integer
    'p'    - format argument as pointer (heximal lowercase)
    'P'    - format argument as pointer (heximal uppercase)
    's'    - format argument as string
    'S'    - expect argument to be of the opposite type to the current Char* type
    'u'    - format argument as unsigned decimal integer
    'x'    - format argument as heximal integer (lower case a..f)
    'X'    - format argument as heximal integer (upper case A..F)
    'y'    - expect argument to be LatinChar character
    'Y'    - expect argument to be UniChar character
    'z'    - expect argument to be LatinChar* string
    'Z'    - expect argument to be UniChar* string

    non-standard features:
    ----------------------
    'b' output binary number (e.g. 0x3e is formatted as 0b00111110)
    'B' output boolean number (True/False)
    'L' size specifier (actually semi-standard but not ISO C)
    'y' and 'Y' to format argument as Latin/Unicode Char
    'z' and 'Z' to format argument as Latin/Unicode string
    'z' type specifier behaves differently from Win32
    '&' and ',' new flag types supporting digit grouping
    '$'    new flag type supporting ellipsis at the end of long strings
Remarks:
formatting to Null returns the number of characters written without actually writing to buffer which is useful for computing the length of a formatted string prior to actual formatting into a buffer

hashCodeIgnoreCaseOf[nothrow, inline]

template <typename Type>
UInt hashCodeIgnoreCaseOf(const Type* string)

Computes the hash code of a string ignoring case differences.

Parameters:
string - a string
Returns:
the computed hash code
See Also:
Chr::hashCodeIgnoreCaseOf

hashCodeIgnoreCaseOf[nothrow, inline]

template <typename Type>
UInt hashCodeIgnoreCaseOf(const Type* string, Int length)

Computes the hash code of a string ignoring case differences.

Parameters:
string - a string
length - the maximum number of characters to compute hash code for
Returns:
the computed hash code
See Also:
Chr::hashCodeIgnoreCaseOf

hashCodeOf[nothrow, inline]

template <typename Type>
UInt hashCodeOf(const Type* string)

Computes the hash code of a string.

Parameters:
string - a string
Returns:
the computed hash code
See Also:
Chr::hashCodeOf

hashCodeOf[nothrow, inline]

template <typename Type>
UInt hashCodeOf(const Type* string, Int length)

Computes the hash code of a string.

Parameters:
string - a string
length - the maximum number of characters to compute hash code for
Returns:
the computed hash code
See Also:
Chr::hashCodeOf

indexOf[inline]

template <typename Type, typename TypeX>
Int indexOf(const Type* string, TypeX c, Int fromIndex)

Finds the first occurance of the specified character in a string from the given offset.

Parameters:
string - a string
c - the character to find
fromIndex - offset from the start of the string
Returns:
the index of the first occurance of character c or -1 if not found
Preconditions:
the value of fromIndex must not exceed the total length of the string as returned by Str::lengthOf(string)

indexOf[inline]

template <typename Type, typename TypeX, typename EqualityTester>
Int indexOf(const Type* string, TypeX c, Int fromIndex, EqualityTester equalFn)

Finds the first occurance of the specified character in a string from the given offset using the specified equality tester function.

Parameters:
string - a string
c - the character to find
fromIndex - offset from the start of the string
equalFn - equality tester function
Returns:
the index of the first occurance of character c or -1 if not found
Preconditions:
the value of fromIndex must not exceed the total length of the string as returned by Str::lengthOf(string)
See Also:
Lang::TypeActors::EqualityTester, Lang::TypeActors::CaseInsensitiveEqualityTester

indexOfSubString[inline]

template <typename Type, typename TypeX>
Int indexOfSubString(const Type* source, const TypeX* target, Int fromIndex)

Finds the first occurance of the specified target string in the source string starting the search from the given offset.

Parameters:
source - the source string
target - the string to find
fromIndex - offset from the start of the source string
Returns:
the index of the first occurance of target string c or -1 if not found
Preconditions:
the value of fromIndex must not exceed the total length of the source string as returned by Str::lengthOf(source)

indexOfSubString[inline]

template <typename Type, typename TypeX, typename EqualityTester>
Int indexOfSubString(const Type* source, const TypeX* target, Int fromIndex, EqualityTester equalFn)

Finds the first occurance of the specified target string in the source string starting the search from the given offset using the specified equality tester function.

Parameters:
source - the source string
target - the string to find
fromIndex - offset from the start of the source string
equalFn - equality tester function
Returns:
the index of the first occurance of target string c or -1 if not found
Preconditions:
the value of fromIndex must not exceed the total length of the source string as returned by Str::lengthOf(source)
See Also:
Lang::TypeActors::EqualityTester, Lang::TypeActors::CaseInsensitiveEqualityTester

isEmpty[nothrow, inline]

template <typename Type>
Bool isEmpty(const Type* string)

Tests whether the specified string is empty. That is if the string pointer is Null or points to a null character.

Parameters:
string - a string
Returns:
True if the string is empty, False otherwise

lastIndexOf[inline]

template <typename Type, typename TypeX>
Int lastIndexOf(const Type* string, TypeX c, Int fromIndex)

Finds the last occurance of the specified character in a string from the given offset.

Parameters:
string - a string
c - the character to find
fromIndex - offset from the end of the string
Returns:
the index of the last occurance of character c or -1 if not found
Preconditions:
the value of fromIndex must not exceed the total length of the string as returned by Str::lengthOf(string)

lastIndexOf[inline]

template <typename Type, typename TypeX, typename EqualityTester>
Int lastIndexOf(const Type* string, TypeX c, Int fromIndex, EqualityTester equalFn)

Finds the last occurance of the specified character in a string from the given offset using the specified equality tester function.

Parameters:
string - a string
c - the character to find
fromIndex - offset from the end of the string
equalFn - equality tester function
Returns:
the index of the last occurance of character c or -1 if not found
Preconditions:
the value of fromIndex must not exceed the total length of the string as returned by Str::lengthOf(string)
See Also:
Lang::TypeActors::EqualityTester, Lang::TypeActors::CaseInsensitiveEqualityTester

lastIndexOfSubString[inline]

template <typename Type, typename TypeX>
Int lastIndexOfSubString(const Type* source, const TypeX* target, Int fromIndex)

Finds the last occurance of the specified target string in the source string starting the search from the given offset.

Parameters:
source - the source string
target - the string to find
fromIndex - offset from the end of the source string
Returns:
the index of the last occurance of target string c or -1 if not found
Preconditions:
the value of fromIndex must not exceed the total length of the source string as returned by Str::lengthOf(source)

lastIndexOfSubString[inline]

template <typename Type, typename TypeX, typename EqualityTester>
Int lastIndexOfSubString(const Type* source, const TypeX* target, Int fromIndex, EqualityTester equalFn)

Finds the last occurance of the specified target string in the source string starting the search from the given offset using the specified equality tester function.

Parameters:
source - the source string
target - the string to find
fromIndex - offset from the end of the source string
equalFn - equality tester function
Returns:
the index of the last occurance of target string c or -1 if not found
Preconditions:
the value of fromIndex must not exceed the total length of the source string as returned by Str::lengthOf(source)
See Also:
Lang::TypeActors::EqualityTester, Lang::TypeActors::CaseInsensitiveEqualityTester

lengthOf[nothrow, inline]

template <typename Type>
Int lengthOf(const Type* string)

Computes the length of a string.

Parameters:
string - a string
Returns:
the number of characters in the string

lengthOf[nothrow, inline]

template <typename Type>
Int lengthOf(const Type* string, Int length)

Computes the length of a string.

Parameters:
string - a string
length - the maximum number of characters to count
Returns:
the number of characters in the string or length, whichever is smaller

parseNumber[nothrow, inline]

template <typename Type>
static Type parseNumber(const Char* string, Int base, Int* outLength)

Attempts to parse a string and convert the result into an integer number.

Parameters:
string - a string to parse
base - number base (radix)
outLength - if not Null, holds the number of characters parsed upon successful conversion or value 0 if the string did not contain a recognizable number format
Returns:
an integer number representing the result of the conversion or value 0 if the string did not contain a recognizable number format
Remarks:
this method does not attempt to recognize the radix from the string unlike other conversion methods this method increments the parsed length output parameter (if not Null), which must have been initialized prior to calling this function
See Also:
Chr::toNumber

replace

template <typename Type, typename TypeX>
Void replace(Type* string, TypeX oldChar, TypeX newChar)

Replaces every occurance of the character oldChar with newChar in a given string.

Parameters:
string - a string
oldChar - a character to replace
newChar - the replacement character

replace

template <typename Type, typename TypeX, typename EqualityTester>
Void replace(Type* string, TypeX oldChar, TypeX newChar, EqualityTester equalFn)

Replaces every occurance of the character oldChar with newChar in a given string using the specified equality tester function.

Parameters:
string - a string
oldChar - a character to replace
newChar - the replacement character
equalFn - equality tester function
See Also:
Lang::TypeActors::EqualityTester, Lang::TypeActors::CaseInsensitiveEqualityTester

toBool[nothrow]

Bool toBool(const Char* string, Int* outLength = Null)

Attempts to parse a string and convert the result into a boolean number.

Parameters:
string - a string to parse
outLength - if not Null, accumulates the number of characters parsed upon successful conversion or unchanged if the string did not contain a recognizable number format
Returns:
a boolean number representing the result of the conversion or value 0 if the string did not contain a recognizable number format
Number Format Specification:
    [Whitespace] {Value}

    Whitespace  = zero or more Whitespace characters
    Value       = one of "True", "False" (case insensitive)
See Also:
Chr::isWhiteSpace, Chr::isDigit, Chr::toNumber

toDouble[nothrow]

Double toDouble(const Char* string, Int* outLength = Null)

Attempts to parse a string and convert the result into a floating-point number.

Parameters:
string - a string to parse
outLength - if not Null, accumulates the number of characters parsed upon successful conversion or unchanged if the string did not contain a recognizable number format
Returns:
a floating-point number representing the result of the conversion or value 0 if the string did not contain a recognizable number format
Number Format Specification:
    [Whitespace] [Sign] {[Digits] [.Digits]} [Exponent [Sign] Digits] [Suffix]

    Whitespace  = zero or more Whitespace characters
    Sign        = one of '+' '-'
    Exponent    = one of 'e' 'E'
    Suffix      = one of 'f' 'F' 'd' 'D'
    Digits      = one or more characters convertible to decimal digits, e.g. for which Category_Number_DecimalDigit Unicode property is defined
See Also:
Chr::isWhiteSpace, Chr::isDigit, Chr::toNumber

toFloat[nothrow]

Float toFloat(const Char* string, Int* outLength = Null)

Attempts to parse a string and convert the result into a floating-point number.

Parameters:
string - a string to parse
outLength - if not Null, accumulates the number of characters parsed upon successful conversion or unchanged if the string did not contain a recognizable number format
Returns:
a floating-point number representing the result of the conversion or value 0 if the string did not contain a recognizable number format
Number Format Specification:
    [Whitespace] [Sign] {[Digits] [.Digits]} [Exponent [Sign] Digits] [Suffix]

    Whitespace  = zero or more Whitespace characters
    Sign        = one of '+' '-'
    Exponent    = one of 'e' 'E'
    Suffix      = one of 'f' 'F' 'd' 'D'
    Digits      = one or more characters convertible to decimal digits, e.g. for which Category_Number_DecimalDigit Unicode property is defined
See Also:
Chr::isWhiteSpace, Chr::isDigit, Chr::toNumber

toFoldCase[nothrow, inline]

template <typename Type>
Void toFoldCase(Type* string)

Converts a string to fold case.

Parameters:
string - a string
See Also:
Chr::toFoldCase

toInt[nothrow]

Int toInt(const Char* string, Int* outLength = Null)

Attempts to parse a string and convert the result into an integer number.

Parameters:
string - a string to parse
outLength - if not Null, accumulates the number of characters parsed upon successful conversion or unchanged if the string did not contain a recognizable number format
Returns:
an integer number representing the result of the conversion or value 0 if the string did not contain a recognizable number format
Number Format Specification:
    [Whitespace] [Sign] [Base] {Digits}

    Whitespace  = zero or more Whitespace characters
    Sign        = one of '+' '-'
    Base        = one of "0b" "0o" "0d" "0x" (case insensitive)
    Digits      = one or more characters convertible to decimal digits, e.g. for which Category_Number_DecimalDigit Unicode property is defined
See Also:
Chr::isWhiteSpace, Chr::isDigit, Chr::toNumber

toLong[nothrow]

Long toLong(const Char* string, Int* outLength = Null)

Attempts to parse a string and convert the result into an integer number.

Parameters:
string - a string to parse
outLength - if not Null, accumulates the number of characters parsed upon successful conversion or unchanged if the string did not contain a recognizable number format
Returns:
an integer number representing the result of the conversion or value 0 if the string did not contain a recognizable number format
Number Format Specification:
    [Whitespace] [Sign] [Base] {Digits}

    Whitespace  = zero or more Whitespace characters
    Sign        = one of '+' '-'
    Base        = one of "0b" "0o" "0d" "0x" (case insensitive)
    Digits      = one or more characters convertible to decimal digits, e.g. for which Category_Number_DecimalDigit Unicode property is defined
See Also:
Chr::isWhiteSpace, Chr::isDigit, Chr::toNumber

toLowerCase[nothrow, inline]

template <typename Type>
Void toLowerCase(Type* string)

Converts a string to lower case.

Parameters:
string - a string
See Also:
Chr::toLowerCase

toTitleCase[nothrow, inline]

template <typename Type>
Void toTitleCase(Type* string)

Converts a string to title case.

Parameters:
string - a string
See Also:
Chr::toTitleCase

toUInt[nothrow]

UInt toUInt(const Char* string, Int* outLength = Null)

Attempts to parse a string and convert the result into an integer number.

Parameters:
string - a string to parse
outLength - if not Null, accumulates the number of characters parsed upon successful conversion or unchanged if the string did not contain a recognizable number format
Returns:
an integer number representing the result of the conversion or value 0 if the string did not contain a recognizable number format
Number Format Specification:
    [Whitespace] [Sign] [Base] {Digits}

    Whitespace  = zero or more Whitespace characters
    Sign        = one of '+' '-'
    Base        = one of "0b" "0o" "0d" "0x" (case insensitive)
    Digits      = one or more characters convertible to decimal digits, e.g. for which Category_Number_DecimalDigit Unicode property is defined
See Also:
Chr::isWhiteSpace, Chr::isDigit, Chr::toNumber

toULong[nothrow]

ULong toULong(const Char* string, Int* outLength = Null)

Attempts to parse a string and convert the result into an integer number.

Parameters:
string - a string to parse
outLength - if not Null, accumulates the number of characters parsed upon successful conversion or unchanged if the string did not contain a recognizable number format
Returns:
an integer number representing the result of the conversion or value 0 if the string did not contain a recognizable number format
Number Format Specification:
    [Whitespace] [Sign] [Base] {Digits}

    Whitespace  = zero or more Whitespace characters
    Sign        = one of '+' '-'
    Base        = one of "0b" "0o" "0d" "0x" (case insensitive)
    Digits      = one or more characters convertible to decimal digits, e.g. for which Category_Number_DecimalDigit Unicode property is defined
See Also:
Chr::isWhiteSpace, Chr::isDigit, Chr::toNumber

toUpperCase[nothrow, inline]

template <typename Type>
Void toUpperCase(Type* string)

Converts a string to upper case.

Parameters:
string - a string
See Also:
Chr::toUpperCase


SUMMARY:  INNER | FIELD | CONSTR | METHOD | FRIEND DETAIL:  FIELD | CONSTR | METHOD | FRIEND