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


Namespace Platform::Chr

namespace Platform::Chr

Provides operations for manipulating characters (comparison, case transform, attribute examination etc).

Character information used by this implementation is based on the Unicode Standard version 5.0.0. The character data is extracted from UnicodeData, CaseFolding and BidiMirroring files maintained and published by the Unicode Consortium.

The Unicode Standard provides universal character encoding; it defines values in range U+0000 through U+10FFFF, known as code points, representing characters and their specific attributes.

Two fundamental types are used to represent Unicode characters: LatinChar (8-bit) and UniChar (16-bit or wider). The LatinChar type represents a subset of Unicode known as Basic Latin covering code points in range U+0000 through U+007F. The UniChar type represents a subset of Unicode known as the Basic Multilingual Plane (BMP) and covers code points in range U+0000 through U+FFFF.

Because the two ranges overlap (or more precisely, Basic Latin being a subset of BMP) there exists a 1:1 mapping between any valid LatinChar code point and the equivalent UniChar character. Any operation carried out on a valid LatinChar code point shall yield the same result as when performed on a UniChar character representing that same code point. The result of operation on LatinChar values outside of valid range is undefined.

For more information see:
See Also:
LatinChar, UniChar

Inner Compounds, Typedefs, and Enumscollapse
struct TypeConvertor
          Converts characters of one type to another.
struct TypeConvertor<LatinChar, LatinChar>
          Converts characters of type LatinChar to type LatinChar.
struct TypeConvertor<LatinChar, UniChar>
          Converts characters of type UniChar to type LatinChar.
struct TypeConvertor<UniChar, LatinChar>
          Converts characters of type LatinChar to type UniChar.
struct TypeConvertor<UniChar, UniChar>
          Converts characters of type UniChar to type UniChar.
enum Category
          Defines the Unicode general category of a character.
enum Directionality
          Defines the Unicode bidirectional category of a character.

Method Summarycollapse
Category categoryOf(LatinChar c)
          Retrieves the Unicode general category property for a given character.
Category categoryOf(UniChar c)
          Retrieves the Unicode general category property for a given character.
Int compare(LatinChar a, LatinChar b)
          Compares two characters for order (total ordering relation).
Int compare(LatinChar a, UniChar b)
          Compares two characters for order (total ordering relation).
Int compare(UniChar a, LatinChar b)
          Compares two characters for order (total ordering relation).
Int compare(UniChar a, UniChar b)
          Compares two characters for order (total ordering relation).
Int compareIgnoreCase(LatinChar a, LatinChar b)
          Compares two characters for order, ignoring case differences (case insensitive total ordering relation).
Int compareIgnoreCase(LatinChar a, UniChar b)
          Compares two characters for order, ignoring case differences (case insensitive total ordering relation).
Int compareIgnoreCase(UniChar a, LatinChar b)
          Compares two characters for order, ignoring case differences (case insensitive total ordering relation).
Int compareIgnoreCase(UniChar a, UniChar b)
          Compares two characters for order, ignoring case differences (case insensitive total ordering relation).
Directionality directionalityOf(LatinChar c)
          Retrieves the Unicode bidirectional category property for a given character.
Directionality directionalityOf(UniChar c)
          Retrieves the Unicode bidirectional category property for a given character.
Bool equal(LatinChar a, LatinChar b)
          Compares two characters for equality (equivalence relation).
Bool equal(LatinChar a, UniChar b)
          Compares two characters for equality (equivalence relation).
Bool equal(UniChar a, LatinChar b)
          Compares two characters for equality (equivalence relation).
Bool equal(UniChar a, UniChar b)
          Compares two characters for equality (equivalence relation).
Bool equalIgnoreCase(LatinChar a, LatinChar b)
          Compares two characters for equality, ignoring case differences (case insensitive equivalence relation).
Bool equalIgnoreCase(LatinChar a, UniChar b)
          Compares two characters for equality, ignoring case differences (case insensitive equivalence relation).
Bool equalIgnoreCase(UniChar a, LatinChar b)
          Compares two characters for equality, ignoring case differences (case insensitive equivalence relation).
Bool equalIgnoreCase(UniChar a, UniChar b)
          Compares two characters for equality, ignoring case differences (case insensitive equivalence relation).
UInt hashCodeIgnoreCaseOf(LatinChar c)
          Computes a hash code for the specified character, ignoring case differences.
UInt hashCodeIgnoreCaseOf(UniChar c)
          Computes a hash code for the specified character, ignoring case differences.
UInt hashCodeOf(LatinChar c)
          Computes a hash code for the specified character.
UInt hashCodeOf(UniChar c)
          Computes a hash code for the specified character.
Bool isControl(LatinChar c)
          Tests whether a character represents a control character.
Bool isControl(UniChar c)
          Tests whether a character represents a control character.
Bool isDefined(LatinChar c)
          Tests whether a character is defined in Unicode.
Bool isDefined(UniChar c)
          Tests whether a character is defined in Unicode.
Bool isDigit(LatinChar c)
          Tests whether a character represents a digit.
Bool isDigit(UniChar c)
          Tests whether a character represents a digit.
Bool isLetter(LatinChar c)
          Tests whether a character represents a letter.
Bool isLetter(UniChar c)
          Tests whether a character represents a letter.
Bool isLetterOrDigit(LatinChar c)
          Tests whether a character represents a letter or digit.
Bool isLetterOrDigit(UniChar c)
          Tests whether a character represents a letter or digit.
Bool isLowerCase(LatinChar c)
          Tests whether a character is a lowercase character.
Bool isLowerCase(UniChar c)
          Tests whether a character is a lowercase character.
Bool isMirrored(LatinChar c)
          Tests whether a character is mirrored according to the Unicode specification.
Bool isMirrored(UniChar c)
          Tests whether a character is mirrored according to the Unicode specification.
Bool isPunctuation(LatinChar c)
          Tests whether a character represents a punctuation character.
Bool isPunctuation(UniChar c)
          Tests whether a character represents a punctuation character.
Bool isSeparator(LatinChar c)
          Tests whether a character represents a separator character.
Bool isSeparator(UniChar c)
          Tests whether a character represents a separator character.
Bool isSurrogate(LatinChar c)
          Tests whether a character is a surrogate code point.
Bool isSurrogate(UniChar c)
          Tests whether a character is a surrogate code point.
Bool isSymbol(LatinChar c)
          Tests whether a character represents a symbol.
Bool isSymbol(UniChar c)
          Tests whether a character represents a symbol.
Bool isTitleCase(LatinChar c)
          Tests whether a character is a titlecase character.
Bool isTitleCase(UniChar c)
          Tests whether a character is a titlecase character.
Bool isUpperCase(LatinChar c)
          Tests whether a character is a uppercase character.
Bool isUpperCase(UniChar c)
          Tests whether a character is an uppercase character.
Bool isWhiteSpace(LatinChar c)
          Tests whether a character represents a whitespace character.
Bool isWhiteSpace(UniChar c)
          Tests whether a character represents a whitespace character.
LatinChar mirrorOf(LatinChar c)
          Retrieves a mirror of the specified character.
UniChar mirrorOf(UniChar c)
          Retrieves a mirror of the specified character.
LatinChar toFoldCase(LatinChar c)
          Converts the specified character to foldcase.
UniChar toFoldCase(UniChar c)
          Converts the specified character to foldcase.
LatinChar toLowerCase(LatinChar c)
          Converts the specified character to lowercase.
UniChar toLowerCase(UniChar c)
          Converts the specified character to lowercase.
Int toNumber(LatinChar c)
          Converts a character to a positive integer number.
Int toNumber(UniChar c)
          Converts a character to a positive integer number.
LatinChar toTitleCase(LatinChar c)
          Converts the specified character to titlecase.
UniChar toTitleCase(UniChar c)
          Converts the specified character to titlecase.
LatinChar toUpperCase(LatinChar c)
          Converts the specified character to uppercase.
UniChar toUpperCase(UniChar c)
          Converts the specified character to uppercase.

 

Method Detail

categoryOf[nothrow, inline]

Category categoryOf(LatinChar c)

Retrieves the Unicode general category property for a given character. If the value of character c is not within a valid range, U+0000 thru U+007F, the return value is Category_NotAssigned.

Parameters:
c - a character
Returns:
the general category property for character c
See Also:
Category

categoryOf[nothrow, inline]

Category categoryOf(UniChar c)

Retrieves the Unicode general category property for a given character. If the value of character c is not within a valid range, U+0000 thru U+FFFF, the return value is Category_NotAssigned.

Parameters:
c - a character
Returns:
the general category property for character c
See Also:
Category

compare[nothrow, inline]

Int compare(LatinChar a, LatinChar b)

Compares two characters for order (total ordering relation).

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

compare[nothrow, inline]

Int compare(LatinChar a, UniChar b)

Compares two characters for order (total ordering relation).

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

compare[nothrow, inline]

Int compare(UniChar a, LatinChar b)

Compares two characters for order (total ordering relation).

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

compare[nothrow, inline]

Int compare(UniChar a, UniChar b)

Compares two characters for order (total ordering relation).

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

compareIgnoreCase[nothrow, inline]

Int compareIgnoreCase(LatinChar a, LatinChar b)

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

Parameters:
a - first character
b - second character
Returns:
a signed integer number, result, indicating the relationship between a and b:
  • result < 0 if toFoldCase(a) < toFoldCase(b)
  • result == 0 if toFoldCase(a) == toFoldCase(b)
  • result > 0 if toFoldCase(a) > toFoldCase(b)
See Also:
toFoldCase

compareIgnoreCase[nothrow, inline]

Int compareIgnoreCase(LatinChar a, UniChar b)

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

Parameters:
a - first character
b - second character
Returns:
a signed integer number, result, indicating the relationship between a and b:
  • result < 0 if toFoldCase(a) < toFoldCase(b)
  • result == 0 if toFoldCase(a) == toFoldCase(b)
  • result > 0 if toFoldCase(a) > toFoldCase(b)
See Also:
toFoldCase

compareIgnoreCase[nothrow, inline]

Int compareIgnoreCase(UniChar a, LatinChar b)

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

Parameters:
a - first character
b - second character
Returns:
a signed integer number, result, indicating the relationship between a and b:
  • result < 0 if toFoldCase(a) < toFoldCase(b)
  • result == 0 if toFoldCase(a) == toFoldCase(b)
  • result > 0 if toFoldCase(a) > toFoldCase(b)
See Also:
toFoldCase

compareIgnoreCase[nothrow, inline]

Int compareIgnoreCase(UniChar a, UniChar b)

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

Parameters:
a - first character
b - second character
Returns:
a signed integer number, result, indicating the relationship between a and b:
  • result < 0 if toFoldCase(a) < toFoldCase(b)
  • result == 0 if toFoldCase(a) == toFoldCase(b)
  • result > 0 if toFoldCase(a) > toFoldCase(b)
See Also:
toFoldCase

directionalityOf[nothrow, inline]

Directionality directionalityOf(LatinChar c)

Retrieves the Unicode bidirectional category property for a given character. If the directionality of the specified character is not defined by the Unicode standard, or the value of character c is not within a valid range, U+0000 thru U+007F, the return value is Directionality_Undefined.

Parameters:
c - a character
Returns:
the bidirectional category property for character c
See Also:
Directionality

directionalityOf[nothrow, inline]

Directionality directionalityOf(UniChar c)

Retrieves the Unicode bidirectional category property for a given character. If the directionality of the specified character is not defined by the Unicode standard, or the value of character c is not within a valid range, U+0000 thru U+FFFF, the return value is Directionality_Undefined.

Parameters:
c - a character
Returns:
the bidirectional category property for character c
See Also:
Directionality

equal[nothrow, inline]

Bool equal(LatinChar a, LatinChar b)

Compares two characters for equality (equivalence relation).

Parameters:
a - first character
b - second character
Returns:
True if the characters are equal, False otherwise

equal[nothrow, inline]

Bool equal(LatinChar a, UniChar b)

Compares two characters for equality (equivalence relation).

Parameters:
a - first character
b - second character
Returns:
True if the characters are equal, False otherwise

equal[nothrow, inline]

Bool equal(UniChar a, LatinChar b)

Compares two characters for equality (equivalence relation).

Parameters:
a - first character
b - second character
Returns:
True if the characters are equal, False otherwise

equal[nothrow, inline]

Bool equal(UniChar a, UniChar b)

Compares two characters for equality (equivalence relation).

Parameters:
a - first character
b - second character
Returns:
True if the characters are equal, False otherwise

equalIgnoreCase[nothrow, inline]

Bool equalIgnoreCase(LatinChar a, LatinChar b)

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

Parameters:
a - first character
b - second character
Returns:
True if the characters are equal ignoring case, False otherwise
See Also:
toFoldCase

equalIgnoreCase[nothrow, inline]

Bool equalIgnoreCase(LatinChar a, UniChar b)

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

Parameters:
a - first character
b - second character
Returns:
True if the characters are equal ignoring case, False otherwise
See Also:
toFoldCase

equalIgnoreCase[nothrow, inline]

Bool equalIgnoreCase(UniChar a, LatinChar b)

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

Parameters:
a - first character
b - second character
Returns:
True if the characters are equal ignoring case, False otherwise
See Also:
toFoldCase

equalIgnoreCase[nothrow, inline]

Bool equalIgnoreCase(UniChar a, UniChar b)

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

Parameters:
a - first character
b - second character
Returns:
True if the characters are equal ignoring case, False otherwise
See Also:
toFoldCase

hashCodeIgnoreCaseOf[nothrow, inline]

UInt hashCodeIgnoreCaseOf(LatinChar c)

Computes a hash code for the specified character, ignoring case differences. Case considerations are erased by converting the character to foldcase prior to computation.

Parameters:
c - a character
Returns:
hash code for the specified character c converted to foldcase
See Also:
toFoldCase

hashCodeIgnoreCaseOf[nothrow, inline]

UInt hashCodeIgnoreCaseOf(UniChar c)

Computes a hash code for the specified character, ignoring case differences. Case considerations are erased by converting the character to foldcase prior to computation.

Parameters:
c - a character
Returns:
hash code for the specified character c converted to foldcase
See Also:
toFoldCase

hashCodeOf[nothrow, inline]

UInt hashCodeOf(LatinChar c)

Computes a hash code for the specified character.

Parameters:
c - a character
Returns:
hash code for the specified character c

hashCodeOf[nothrow, inline]

UInt hashCodeOf(UniChar c)

Computes a hash code for the specified character.

Parameters:
c - a character
Returns:
hash code for the specified character c

isControl[nothrow, inline]

Bool isControl(LatinChar c)

Tests whether a character represents a control character. A LatinChar character c is a control character if its general category property is Category_Other_Control.

Parameters:
c - a character
Returns:
True if the character c represents a control character, False otherwise
See Also:
Category::Category_Other_Control

isControl[nothrow, inline]

Bool isControl(UniChar c)

Tests whether a character represents a control character. A UniChar character c is a control character if its general category property is Category_Other_Control.

Parameters:
c - a character
Returns:
True if the character c represents a control character, False otherwise
See Also:
Category::Category_Other_Control

isDefined[nothrow, inline]

Bool isDefined(LatinChar c)

Tests whether a character is defined in Unicode. A LatinChar character c is defined if:
Parameters:
c - a character
Returns:
True if the character c has a defined meaning in Unicode, False otherwise

isDefined[nothrow, inline]

Bool isDefined(UniChar c)

Tests whether a character is defined in Unicode. A UniChar character c is defined if:
Parameters:
c - a character
Returns:
True if the character c has a defined meaning in Unicode, False otherwise

isDigit[nothrow, inline]

Bool isDigit(LatinChar c)

Tests whether a character represents a digit. A LatinChar character c is a digit if its value is any of the following: digit letters 0-9 (U+0030 through U+0039).

Parameters:
c - a character
Returns:
True if the character c represents a digit, False otherwise

isDigit[nothrow, inline]

Bool isDigit(UniChar c)

Tests whether a character represents a digit. A UniChar character c is a digit if its general category property is Category_Number_DecimalDigit.

Parameters:
c - a character
Returns:
True if the character c represents a digit, False otherwise
See Also:
Category::Category_Number_DecimalDigit

isLetter[nothrow, inline]

Bool isLetter(LatinChar c)

Tests whether a character represents a letter. A LatinChar character c is a letter if its value is any of the following:
Parameters:
c - a character
Returns:
True if the character c represents a letter, False otherwise

isLetter[nothrow, inline]

Bool isLetter(UniChar c)

Tests whether a character represents a letter. A UniChar character c is a letter if its general category property is any of the following:
Parameters:
c - a character
Returns:
True if the character c represents a letter, False otherwise
See Also:
Category::Category_Letter_LowerCase, Category::Category_Letter_UpperCase, Category::Category_Letter_TitleCase, Category::Category_Letter_Modifier, Category::Category_Letter_Other

isLetterOrDigit[nothrow, inline]

Bool isLetterOrDigit(LatinChar c)

Tests whether a character represents a letter or digit. A LatinChar character c is a letter or digit if its value is any of the following:
Parameters:
c - a character
Returns:
True if the character c represents a letter or digit, False otherwise

isLetterOrDigit[nothrow, inline]

Bool isLetterOrDigit(UniChar c)

Tests whether a character represents a letter or digit. A UniChar character c is a letter or digit if its general category property is any of the following:
Parameters:
c - a character
Returns:
True if the character c represents a letter or digit, False otherwise
See Also:
Category::Category_Letter_LowerCase, Category::Category_Letter_UpperCase, Category::Category_Letter_TitleCase, Category::Category_Letter_Modifier, Category::Category_Letter_Other, Category::Category_Number_DecimalDigit

isLowerCase[nothrow, inline]

Bool isLowerCase(LatinChar c)

Tests whether a character is a lowercase character. A LatinChar character c is a lowercase character if its value is any of the following: lowercase letters a-z (U+0061 through U+007A).

Parameters:
c - a character
Returns:
True if the character c is a lowercase character, False otherwise

isLowerCase[nothrow, inline]

Bool isLowerCase(UniChar c)

Tests whether a character is a lowercase character. A UniChar character c is a lowercase character if its general category property is Category_Letter_LowerCase.

Parameters:
c - a character
Returns:
True if the character c is a lowercase character, False otherwise
See Also:
Category::Category_Letter_LowerCase

isMirrored[nothrow, inline]

Bool isMirrored(LatinChar c)

Tests whether a character is mirrored according to the Unicode specification. Mirrored characters have their visual appearance horizontally mirrored when displayed in text that is right-to-left.

Parameters:
c - a character
Returns:
True if the character c is mirrored, False if the character is not mirrored or is not defined
See Also:
mirrorOf(LatinChar)

isMirrored[nothrow, inline]

Bool isMirrored(UniChar c)

Tests whether a character is mirrored according to the Unicode specification. Mirrored characters have their visual appearance horizontally mirrored when displayed in text that is right-to-left.

Parameters:
c - a character
Returns:
True if the character c is mirrored, False if the character is not mirrored or is not defined
See Also:
mirrorOf(UniChar)

isPunctuation[nothrow, inline]

Bool isPunctuation(LatinChar c)

Tests whether a character represents a punctuation character. A LatinChar character c is a punctuation character if its general category property is any of the following:
Parameters:
c - a character
Returns:
True if the character c represents a punctuation character, False otherwise
See Also:
Category::Category_Punctuation_Connector, Category::Category_Punctuation_Dash, Category::Category_Punctuation_Open, Category::Category_Punctuation_Close, Category::Category_Punctuation_InitialQuote, Category::Category_Punctuation_FinalQuote, Category::Category_Punctuation_Other

isPunctuation[nothrow, inline]

Bool isPunctuation(UniChar c)

Tests whether a character represents a punctuation character. A UniChar character c is a punctuation character if its general category property is any of the following:
Parameters:
c - a character
Returns:
True if the character c represents a punctuation character, False otherwise
See Also:
Category::Category_Punctuation_Connector, Category::Category_Punctuation_Dash, Category::Category_Punctuation_Open, Category::Category_Punctuation_Close, Category::Category_Punctuation_InitialQuote, Category::Category_Punctuation_FinalQuote, Category::Category_Punctuation_Other

isSeparator[nothrow, inline]

Bool isSeparator(LatinChar c)

Tests whether a character represents a separator character. A LatinChar character c is a separator character if its general category property is any of the following:
Parameters:
c - a character
Returns:
True if the character c represents a separator character, False otherwise
See Also:
Category::Category_Separator_Space, Category::Category_Separator_Line, Category::Category_Separator_Paragraph

isSeparator[nothrow, inline]

Bool isSeparator(UniChar c)

Tests whether a character represents a separator character. A UniChar character c is a separator character if its general category property is any of the following:
Parameters:
c - a character
Returns:
True if the character c represents a separator character, False otherwise
See Also:
Category::Category_Separator_Space, Category::Category_Separator_Line, Category::Category_Separator_Paragraph

isSurrogate[nothrow, inline]

Bool isSurrogate(LatinChar c)

Tests whether a character is a surrogate code point. A LatinChar character can never be a surrogate.

Parameters:
c - a character
Returns:
always False

isSurrogate[nothrow, inline]

Bool isSurrogate(UniChar c)

Tests whether a character is a surrogate code point. A UniChar character c is a surrogate if its general category property is Category_Other_Surrogate.

Parameters:
c - a character
Returns:
True if the character c is a surrogate code point, False otherwise
See Also:
Category::Category_Other_Surrogate

isSymbol[nothrow, inline]

Bool isSymbol(LatinChar c)

Tests whether a character represents a symbol. A LatinChar character c is a symbol if its general category property is any of the following:
Parameters:
c - a character
Returns:
True if the character c represents a symbol, False otherwise
See Also:
Category::Category_Symbol_Math, Category::Category_Symbol_Currency, Category::Category_Symbol_Modifier, Category::Category_Symbol_Other

isSymbol[nothrow, inline]

Bool isSymbol(UniChar c)

Tests whether a character represents a symbol. A UniChar character c is a symbol if its general category property is any of the following:
Parameters:
c - a character
Returns:
True if the character c represents a symbol, False otherwise
See Also:
Category::Category_Symbol_Math, Category::Category_Symbol_Currency, Category::Category_Symbol_Modifier, Category::Category_Symbol_Other

isTitleCase[nothrow, inline]

Bool isTitleCase(LatinChar c)

Tests whether a character is a titlecase character. A LatinChar character can never be a titlecase character.

Parameters:
c - a character
Returns:
always False

isTitleCase[nothrow, inline]

Bool isTitleCase(UniChar c)

Tests whether a character is a titlecase character. A UniChar character c is a titlecase character if its general category property is Category_Letter_TitleCase.

Parameters:
c - a character
Returns:
True if the character c is a titlecase character, False otherwise
See Also:
Category::Category_Letter_TitleCase

isUpperCase[nothrow, inline]

Bool isUpperCase(LatinChar c)

Tests whether a character is a uppercase character. A LatinChar character c is a uppercase character if its value is any of the following: uppercase letters A-Z (U+0041 through U+005A).

Parameters:
c - a character
Returns:
True if the character c is a uppercase character, False otherwise

isUpperCase[nothrow, inline]

Bool isUpperCase(UniChar c)

Tests whether a character is an uppercase character. A UniChar character c is an uppercase character if its general category property is Category_Letter_UpperCase.

Parameters:
c - a character
Returns:
True if the character c is an uppercase character, False otherwise
See Also:
Category::Category_Letter_UpperCase

isWhiteSpace[nothrow, inline]

Bool isWhiteSpace(LatinChar c)

Tests whether a character represents a whitespace character. A LatinChar character c is a whitespace character if its value is any of the following:
Parameters:
c - a character
Returns:
True if the character c represents a whitespace character, False otherwise

isWhiteSpace[nothrow, inline]

Bool isWhiteSpace(UniChar c)

Tests whether a character represents a whitespace character. A UniChar character c is a whitespace character if:
Parameters:
c - a character
Returns:
True if the character c represents a whitespace character, False otherwise
See Also:
Category::Category_Separator_Space, Category::Category_Separator_Line, Category::Category_Separator_Paragraph

mirrorOf[nothrow, inline]

LatinChar mirrorOf(LatinChar c)

Retrieves a mirror of the specified character. For example the mirror of character '{' U+007B is '}' U+007D and '(' U+0028 is mirrored by ')' U+0029. Use isMirrored(LatinChar) function to test whether a mirror for a character is defined. If no mirror exists for the specified character c the return value is c itself.

Parameters:
c - a character
Returns:
a mirror of character c
See Also:
isMirrored(LatinChar)

mirrorOf[nothrow, inline]

UniChar mirrorOf(UniChar c)

Retrieves a mirror of the specified character. For example the mirror of character '{' U+007B is '}' U+007D and '(' U+0028 is mirrored by ')' U+0029. Use isMirrored(UniChar) function to test whether a mirror for a character is defined. If no mirror exists for the specified character c the return value is c itself.

Parameters:
c - a character
Returns:
a mirror of character c
See Also:
isMirrored(UniChar)

toFoldCase[nothrow, inline]

LatinChar toFoldCase(LatinChar c)

Converts the specified character to foldcase. Foldcase is a special representation of characters intended to erase case differences for purposes such as case insensitive comparison. A character converted to foldcase no longer should be treated as a character (although it still represents a valid Unicode code point).

Parameters:
c - a character
Returns:
the foldcase equivalent of the character c

toFoldCase[nothrow, inline]

UniChar toFoldCase(UniChar c)

Converts the specified character to foldcase. Foldcase is a special representation of characters intended to erase case differences for purposes such as case insensitive comparison. A character converted to foldcase no longer should be treated as a character (although it still represents a valid Unicode code point).

Parameters:
c - a character
Returns:
the foldcase equivalent of the character c

toLowerCase[nothrow, inline]

LatinChar toLowerCase(LatinChar c)

Converts the specified character to lowercase. Note that Unicode does not guarantee round tripping of code point values during transformations such as case mapping. For an arbitrary character c the following may *not* hold true: toUpperCase(c) == toUpperCase(toLowerCase(c))!

Parameters:
c - a character
Returns:
the lowercase equivalent of the character c, if any, otherwise, the character itself

toLowerCase[nothrow, inline]

UniChar toLowerCase(UniChar c)

Converts the specified character to lowercase. Note that Unicode does not guarantee round tripping of code point values during transformations such as case mapping. For an arbitrary character c the following may *not* hold true: toUpperCase(c) == toUpperCase(toLowerCase(c))!

Parameters:
c - a character
Returns:
the lowercase equivalent of the character c, if any, otherwise, the character itself

toNumber[nothrow, inline]

Int toNumber(LatinChar c)

Converts a character to a positive integer number. If the character c can not be converted to a number because no numeric value is assigned to it by the Unicode standard, the result is -1. If c does have a numeric representation in Unicode, but the assigned numeric value is negative, or cannot be represented by an integer (e.g. a fraction), the result is -2.

A character c is considered to be convertible to a number if:
Parameters:
c - a character
Returns:
a positive integer number representing character c; -1 if c does not represent a number; -2 if c cannot be converted to a positive integer number

toNumber[nothrow, inline]

Int toNumber(UniChar c)

Converts a character to a positive integer number. If the character c can not be converted to a number because no numeric value is assigned to it by the Unicode standard, the result is -1. If c does have a numeric representation in Unicode, but the assigned numeric value is negative, or cannot be represented by an integer (e.g. a fraction), the result is -2.

A character c is considered to be convertible to a number if:
Parameters:
c - a character
Returns:
a positive integer number representing character c; -1 if c does not represent a number; -2 if c cannot be converted to a positive integer number

toTitleCase[nothrow, inline]

LatinChar toTitleCase(LatinChar c)

Converts the specified character to titlecase. Note that Unicode does not guarantee round tripping of code point values during transformations such as case mapping. For an arbitrary character c the following may *not* hold true: toUpperCase(c) == toUpperCase(toLowerCase(c))!

Parameters:
c - a character
Returns:
the titlecase equivalent of the character c, if any, otherwise, the character converted to uppercase

toTitleCase[nothrow, inline]

UniChar toTitleCase(UniChar c)

Converts the specified character to titlecase. Note that Unicode does not guarantee round tripping of code point values during transformations such as case mapping. For an arbitrary character c the following may *not* hold true: toUpperCase(c) == toUpperCase(toLowerCase(c))!

Parameters:
c - a character
Returns:
the titlecase equivalent of the character c, if any, otherwise, the character converted to uppercase

toUpperCase[nothrow, inline]

LatinChar toUpperCase(LatinChar c)

Converts the specified character to uppercase. Note that Unicode does not guarantee round tripping of code point values during transformations such as case mapping. For an arbitrary character c the following may *not* hold true: toUpperCase(c) == toUpperCase(toLowerCase(c))!

Parameters:
c - a character
Returns:
the uppercase equivalent of the character c, if any, otherwise, the character itself

toUpperCase[nothrow, inline]

UniChar toUpperCase(UniChar c)

Converts the specified character to uppercase. Note that Unicode does not guarantee round tripping of code point values during transformations such as case mapping. For an arbitrary character c the following may *not* hold true: toUpperCase(c) == toUpperCase(toLowerCase(c))!

Parameters:
c - a character
Returns:
the uppercase equivalent of the character c, if any, otherwise, the character itself


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