* The Unicode character information, provided implicitly by the * Unicode Standard, * includes information about the sript * (for example, symbols or control characters) to which the character belongs, * as well as semantic information such as whether a character is a digit or * uppercase, lowercase, or uncased. *
*
* @subclassing Do not subclass.
* @deprecated To be removed after 2002-sep-30; use the C API, see uchar.h and utf.h.
*/
class U_COMMON_API Unicode
{
public:
/*
* In C++, static const members actually take up memory and need to be accessed.
* enum values are more like C #define's.
* The following is a collection of constants, not an enumeration type.
*
* @deprecated See the Unicode class description.
*/
enum {
/** The lowest Unicode code point value. Code points are non-negative. */
MIN_VALUE=0,
/**
* The highest Unicode code point value (scalar value) according to
* The Unicode Standard. This is a 21-bit value (20.1 bits, rounded up).
* For a single character, UChar32 is a simple type that can hold any code point value.
*/
MAX_VALUE=0x10ffff,
/**
* The maximum number of code units (UChar's) per code point (UChar32).
* This depends on the default UTF that the ICU library is compiled for.
* Currently, the only natively supported UTF is UTF-16, which means that
* UChar is 16 bits wide and this value is 2 (for surrogate pairs).
* This may change in the future.
*/
MAX_CHAR_LENGTH=UTF_MAX_CHAR_LENGTH,
/**
* The minimum radix available for conversion to and from Strings.
* The constant value of this field is the smallest value permitted
* for the radix argument in radix-conversion methods such as the
* digit method and the forDigit
* method.
*
* @see Unicode#digit
* @see Unicode#forDigit
*/
MIN_RADIX=2,
/**
* The maximum radix available for conversion to and from Strings.
* The constant value of this field is the largest value permitted
* for the radix argument in radix-conversion methods such as the
* digit method and the forDigit
* method.
*
* @see Unicode#digit
* @see Unicode#forDigit
*/
MAX_RADIX=36
};
/**
* Public data for enumerated Unicode general category types
*
* @deprecated See the Unicode class description.
*/
enum EUnicodeGeneralTypes
{
UNASSIGNED = 0,
UPPERCASE_LETTER = 1,
LOWERCASE_LETTER = 2,
TITLECASE_LETTER = 3,
MODIFIER_LETTER = 4,
OTHER_LETTER = 5,
NON_SPACING_MARK = 6,
ENCLOSING_MARK = 7,
COMBINING_SPACING_MARK = 8,
DECIMAL_DIGIT_NUMBER = 9,
LETTER_NUMBER = 10,
OTHER_NUMBER = 11,
SPACE_SEPARATOR = 12,
LINE_SEPARATOR = 13,
PARAGRAPH_SEPARATOR = 14,
CONTROL = 15,
FORMAT = 16,
PRIVATE_USE = 17,
SURROGATE = 18,
DASH_PUNCTUATION = 19,
START_PUNCTUATION = 20,
END_PUNCTUATION = 21,
CONNECTOR_PUNCTUATION = 22,
OTHER_PUNCTUATION = 23,
MATH_SYMBOL = 24,
CURRENCY_SYMBOL = 25,
MODIFIER_SYMBOL = 26,
OTHER_SYMBOL = 27,
INITIAL_PUNCTUATION = 28,
FINAL_PUNCTUATION = 29,
GENERAL_TYPES_COUNT = 30
};
/* Please keep these values in sync with UCharScript */
/**
* These are the same values as uchar.h::UCharScript
*
* @deprecated See the Unicode class description.
*/
enum EUnicodeScript
{
kBasicLatin=UBLOCK_BASIC_LATIN,
kLatin1Supplement,
kLatinExtendedA,
kLatinExtendedB,
kIPAExtension,
kSpacingModifier,
kCombiningDiacritical,
kGreek,
kCyrillic,
kArmenian,
kHebrew,
kArabic,
kSyriac,
kThaana,
kDevanagari,
kBengali,
kGurmukhi,
kGujarati,
kOriya,
kTamil,
kTelugu,
kKannada,
kMalayalam,
kSinhala,
kThai,
kLao,
kTibetan,
kMyanmar,
kGeorgian,
kHangulJamo,
kEthiopic,
kCherokee,
kUnifiedCanadianAboriginalSyllabics,
kogham,
kRunic,
kKhmer,
kMongolian,
kLatinExtendedAdditional,
kGreekExtended,
kGeneralPunctuation,
kSuperSubScript,
kCurrencySymbolScript,
kSymbolCombiningMark,
kLetterlikeSymbol,
kNumberForm,
kArrow,
kMathOperator,
kMiscTechnical,
kControlPicture,
kOpticalCharacter,
kEnclosedAlphanumeric,
kBoxDrawing,
kBlockElement,
kGeometricShape,
kMiscSymbol,
kDingbat,
kBraillePatterns,
kCJKRadicalsSupplement,
kKangxiRadicals,
kIdeographicDescriptionCharacters,
kCJKSymbolPunctuation,
kHiragana,
kKatakana,
kBopomofo,
kHangulCompatibilityJamo,
kKanbun,
kBopomofoExtended,
kEnclosedCJKLetterMonth,
kCJKCompatibility,
kCJKUnifiedIdeographExtensionA,
kCJKUnifiedIdeograph,
kYiSyllables,
kYiRadicals,
kHangulSyllable,
kHighSurrogate,
kHighPrivateUseSurrogate,
kLowSurrogate,
kPrivateUse,
kCJKCompatibilityIdeograph,
kAlphabeticPresentation,
kArabicPresentationA,
kCombiningHalfMark,
kCJKCompatibilityForm,
kSmallFormVariant,
kArabicPresentationB,
kNoScript,
kHalfwidthFullwidthForm,
kScriptCount=UBLOCK_COUNT
};
/**
* This specifies the language directional property of a character set.
*
* @deprecated See the Unicode class description.
*/
enum EDirectionProperty {
LEFT_TO_RIGHT = 0,
RIGHT_TO_LEFT = 1,
EUROPEAN_NUMBER = 2,
EUROPEAN_NUMBER_SEPARATOR = 3,
EUROPEAN_NUMBER_TERMINATOR = 4,
ARABIC_NUMBER = 5,
COMMON_NUMBER_SEPARATOR = 6,
BLOCK_SEPARATOR = 7,
SEGMENT_SEPARATOR = 8,
WHITE_SPACE_NEUTRAL = 9,
OTHER_NEUTRAL = 10,
LEFT_TO_RIGHT_EMBEDDING = 11,
LEFT_TO_RIGHT_OVERRIDE = 12,
RIGHT_TO_LEFT_ARABIC = 13,
RIGHT_TO_LEFT_EMBEDDING = 14,
RIGHT_TO_LEFT_OVERRIDE = 15,
POP_DIRECTIONAL_FORMAT = 16,
DIR_NON_SPACING_MARK = 17,
BOUNDARY_NEUTRAL = 18
};
/**
* Values returned by the getCellWidth() function.
* @see Unicode#getCellWidth
*
* @deprecated See the Unicode class description.
*/
enum ECellWidths
{
ZERO_WIDTH = 0,
HALF_WIDTH = 1,
FULL_WIDTH = 2,
NEUTRAL = 3
};
/**
* Does this code unit alone represent a Unicode code point?
* If so, then the code point value is the same as the code unit value,
* or (UChar32)c.
* Being a single, lead, or trail unit are mutually exclusive properties.
*
* @param c The code unit to be tested.
* @return Boolean value.
*
* @deprecated See the Unicode class description.
*/
static inline UBool isSingle(UChar c);
/**
* Is this code unit the first of a multiple-unit sequence?
* Being a single, lead, or trail unit are mutually exclusive properties.
*
* @param c The code unit to be tested.
* @return Boolean value.
*
* @deprecated See the Unicode class description.
*/
static inline UBool isLead(UChar c);
/**
* Is this code unit one of, but not the first, of a multiple-unit sequence?
* Being a single, lead, or trail unit are mutually exclusive properties.
*
* @param c The code unit to be tested.
* @return Boolean value.
*
* @deprecated See the Unicode class description.
*/
static inline UBool isTrail(UChar c);
/**
* Is this code point a surrogate character?
* Surrogates are not characters; they are reserved for
* use in UTF-16 strings as leading and trailing code units
* of multiple-unit sequences for single code points.
*
* @param c The code point to be tested.
* @return Boolean value.
*
* @deprecated See the Unicode class description.
*/
static inline UBool isSurrogate(UChar32 c);
/**
* Is this code point a Unicode character?
* The value range for Unicode characters is limited to
* 0x10ffff==MAX_VALUE, and some values within this
* range are reserved and not characters, too.
* Those are the surrogate values and all values where the least
* significant 16 bits are either 0xfffe or 0xffff.
*
* @param c The code point to be tested.
* @return Boolean value.
*
* @deprecated See the Unicode class description.
*/
static inline UBool isUnicodeChar(UChar32 c);
/**
* Is this code point an error value?
* In ICU, code point access with macros or functions does not result
* in a UErrorCode to be set if a code unit sequence is illegal
* or irregular, but instead the resulting code point will be
* one of few special error values. This function tests for one of those.
*
* @param c The code point to be tested.
* @return Boolean value.
*
* @deprecated See the Unicode class description.
*/
static inline UBool isError(UChar32 c);
/**
* Is this code point a Unicode character, and not an error value?
* This is an efficient combination of
* isUnicodeChar(c) && !isError(c).
*
* @param c The code point to be tested.
* @return Boolean value.
*
* @deprecated See the Unicode class description.
*/
static inline UBool isValid(UChar32 c);
/**
* When writing code units for a given code point, is more than one
* code unit necessary?
* If not, then a single UChar value of (UChar)c can
* be written to a UChar array. Otherwise, multiple code units need to be
* calculated and written.
*
* @param c The code point to be tested.
* @return Boolean value.
*
* @deprecated See the Unicode class description.
*/
static inline UBool needMultipleUChar(UChar32 c);
/**
* When writing code units for a given code point, how many
* code units are necessary?
*
* @param c The code point to be tested.
* @return Boolean value.
*
* @deprecated See the Unicode class description.
*/
static inline int32_t charLength(UChar32 c);
/**
* This function returns an average size of a UChar array compared to the
* size that it would need to hold similar text if UTF-16 were used.
* With UTF-16, this always returns its argument.
* With UTF-8, the number returned will be larger, with UTF-32, smaller.
* It will typically be less than size*MAX_CHAR_LENGTH.
*
* @param size The size of the array if UTF-16 were used.
* @return An average size necessary for the UTF that ICU was compiled for.
* (Only UTF-16 is supported right now, therefore,
* this will always be size itself. This may change in the future.)
*
* @deprecated See the Unicode class description.
*/
static inline int32_t arraySize(int32_t size);
/**
* Determines whether the specified UChar is a lowercase character
* according to Unicode 2.1.2.
*
* @param ch the character to be tested
* @return true if the character is lowercase; false otherwise.
*
* @see Unicode#isUpperCase
* @see Unicode#isTitleCase
* @see Unicode#toLowerCase
*
* @deprecated See the Unicode class description.
*/
static inline UBool isLowerCase(UChar32 ch);
/**
* Determines whether the specified character is an uppercase character
* according to Unicode 2.1.2.
*
* @param ch the character to be tested
* @return true if the character is uppercase; false otherwise.
* @see Unicode#isLowerCase
* @see Unicode#isTitleCase
* @see Unicode#toUpperCase
*
* @deprecated See the Unicode class description.
*/
static inline UBool isUpperCase(UChar32 ch);
/**
* Determines whether the specified character is a titlecase character
* according to Unicode 2.1.2.
*
* @param ch the character to be tested
* @return true if the character is titlecase; false otherwise.
* @see Unicode#isUpperCase
* @see Unicode#isLowerCase
* @see Unicode#toTitleCase
*
* @deprecated See the Unicode class description.
*/
static inline UBool isTitleCase(UChar32 ch);
/**
* Determines whether the specified character is a digit according to Unicode
* 2.1.2.
*
* @param ch the character to be tested
* @return true if the character is a digit; false otherwise.
* @see Unicode#digit
* @see Unicode#forDigit
* @see Unicode#digitValue
*
* @deprecated See the Unicode class description.
*/
static inline UBool isDigit(UChar32 ch);
/**
* Determines whether the specified numeric value is actually a defined character
* according to Unicode 2.1.2.
*
* @param ch the character to be tested
* @return true if the character has a defined Unicode meaning; false otherwise.
*
* @see Unicode#isDigit
* @see Unicode#isLetter
* @see Unicode#isLetterOrDigit
* @see Unicode#isUpperCase
* @see Unicode#isLowerCase
* @see Unicode#isTitleCase
*
* @deprecated See the Unicode class description.
*/
static inline UBool isDefined(UChar32 ch);
/**
* Determines whether the specified character is a control character according
* to Unicode 2.1.2.
*
* @param ch the character to be tested
* @return true if the Unicode character is a control character; false otherwise.
*
* @see Unicode#isPrintable
*
* @deprecated See the Unicode class description.
*/
static inline UBool isControl(UChar32 ch);
/**
* Determines whether the specified character is a printable character according
* to Unicode 2.1.2.
*
* @param ch the character to be tested
* @return true if the Unicode character is a printable character; false otherwise.
*
* @see Unicode#isControl
*
* @deprecated See the Unicode class description.
*/
static inline UBool isPrintable(UChar32 ch);
/**
* Determines whether the specified character is of the base form according
* to Unicode 2.1.2.
*
* @param ch the character to be tested
* @return true if the Unicode character is of the base form; false otherwise.
*
* @see Unicode#isLetter
* @see Unicode#isDigit
*
* @deprecated See the Unicode class description.
*/
static inline UBool isBaseForm(UChar32 ch);
/**
* Determines whether the specified character is a letter
* according to Unicode 2.1.2.
*
* @param ch the character to be tested
* @return true if the character is a letter; false otherwise.
*
*
* @see Unicode#isDigit
* @see Unicode#isLetterOrDigit
* @see Unicode#isUpperCase
* @see Unicode#isLowerCase
* @see Unicode#isTitleCase
*
* @deprecated See the Unicode class description.
*/
static inline UBool isLetter(UChar32 ch);
/**
* A convenience method for determining if a Unicode character
* is allowed as the first character in a Java identifier.
*
* A character may start a Java identifier if and only if * it is one of the following: *
* A character may be part of a Java identifier if and only if * it is one of the following: *
* A character may be part of a Unicode identifier if and only if * it is one of the following: *
* The following Unicode characters are ignorable in a Java identifier * or a Unicode identifier: *
| 0x0000 through 0x0008, | *ISO control characters that |
| 0x000E through 0x001B, | are not whitespace |
| and 0x007F through 0x009F | |
| 0x200C through 0x200F | join controls |
| 0x200A through 0x200E | bidirectional controls |
| 0x206A through 0x206F | format controls |
| 0xFEFF | zero-width no-break space |
* A character has a lowercase equivalent if and only if a lowercase mapping * is specified for the character in the Unicode 2.0 attribute table. *
* Unicode::toLowerCase() only deals with the general letter case conversion. * For language specific case conversion behavior, use UnicodeString::toLower(). * For example, the case conversion for dot-less i and dotted I in Turkish, * or for final sigma in Greek. * * @param ch the character to be converted * @return the lowercase equivalent of the character, if any; * otherwise the character itself. * * @see UnicodeString#toLower * @see Unicode#isLowerCase * @see Unicode#isUpperCase * @see Unicode#toUpperCase * @see Unicode#toTitleCase * * @deprecated See the Unicode class description. */ static inline UChar32 toLowerCase(UChar32 ch); /** * The given character is mapped to its uppercase equivalent according to Unicode * 2.1.2; if the character has no uppercase equivalent, the character itself is * returned. *
* Unicode::toUpperCase() only deals with the general letter case conversion. * For language specific case conversion behavior, use UnicodeString::toUpper(). * For example, the case conversion for dot-less i and dotted I in Turkish, * or ess-zed (i.e., "sharp S") in German. * * @param ch the character to be converted * @return the uppercase equivalent of the character, if any; * otherwise the character itself. * * @see UnicodeString#toUpper * @see Unicode#isUpperCase * @see Unicode#isLowerCase * @see Unicode#toLowerCase * @see Unicode#toTitleCase * * @deprecated See the Unicode class description. */ static inline UChar32 toUpperCase(UChar32 ch); /** * The given character is mapped to its titlecase equivalent according to Unicode * 2.1.2. There are only four Unicode characters that are truly titlecase forms * that are distinct from uppercase forms. As a rule, if a character has no * true titlecase equivalent, its uppercase equivalent is returned. *
* A character has a titlecase equivalent if and only if a titlecase mapping * is specified for the character in the Unicode 2.1.2 data. * * @param ch the character to be converted * @return the titlecase equivalent of the character, if any; * otherwise the character itself. * @see Unicode#isTitleCase * @see Unicode#toUpperCase * @see Unicode#toLowerCase * * @deprecated See the Unicode class description. */ static inline UChar32 toTitleCase(UChar32 ch); /** * The given character is mapped to its case folding equivalent according to * UnicodeData.txt and CaseFolding.txt; if the character has no case folding equivalent, the character * itself is returned. * Only "simple", single-code point case folding mappings are used. * "Full" mappings are used by UnicodeString::foldCase(). * * @param c the character to be converted * @param options Either U_FOLD_CASE_DEFAULT or U_FOLD_CASE_EXCLUDE_SPECIAL_I * @return the case folding equivalent of the character, if any; * otherwise the character itself. * * @deprecated See the Unicode class description. */ static inline UChar32 foldCase(UChar32 c, uint32_t options); /** * Determines if the specified character is a Unicode space character * according to Unicode 2.1.2. * * @param ch the character to be tested * @return true if the character is a space character; false otherwise. * * @deprecated See the Unicode class description. */ static inline UBool isSpaceChar(UChar32 ch); /** * Determines if the specified character is white space according to ICU. * A character is considered to be an ICU whitespace character if and only * if it satisfies one of the following criteria: *
* Returns the linguistic direction property of a character. * For example, 0x0041 (letter A) has the LEFT_TO_RIGHT directional * property. * @see #EDirectionProperty * * @deprecated See the Unicode class description. */ static inline EDirectionProperty characterDirection(UChar32 ch); /** * Determines whether the character has the "mirrored" property. * This property is set for characters that are commonly used in * Right-To-Left contexts and need to be displayed with a "mirrored" * glyph. * * @param c the character (code point, Unicode scalar value) to be tested * @return TRUE if the character has the "mirrored" property * * @deprecated See the Unicode class description. */ static inline UBool isMirrored(UChar32 c); /** * Maps the specified character to a "mirror-image" character. * For characters with the "mirrored" property, implementations * sometimes need a "poor man's" mapping to another Unicode * character (code point) such that the default glyph may serve * as the mirror-image of the default glyph of the specified * character. This is useful for text conversion to and from * codepages with visual order, and for displays without glyph * selecetion capabilities. * * @param c the character (code point, Unicode scalar value) to be mapped * @return another Unicode code point that may serve as a mirror-image * substitute, or c itself if there is no such mapping or c * does not have the "mirrored" property * * @deprecated See the Unicode class description. */ static inline UChar32 charMirror(UChar32 c); /** * Returns the script associated with a character. * @see #EUnicodeScript * @draft */ static inline EUnicodeScript getScript(UChar32 ch); /** * Returns a value indicating the display-cell width of the character * when used in Asian text, according to the Unicode standard (see p. 6-130 * of The Unicode Standard, Version 2.0). The results for various characters * are as follows: *
* ZERO_WIDTH: Characters which are considered to take up no display-cell space: * control characters * format characters * line and paragraph separators * non-spacing marks * combining Hangul jungseong * combining Hangul jongseong * unassigned Unicode values *
* HALF_WIDTH: Characters which take up half a cell in standard Asian text: * all characters in the General Scripts Area except combining Hangul choseong * and the characters called out specifically above as ZERO_WIDTH * alphabetic and Arabic presentation forms * halfwidth CJK punctuation * halfwidth Katakana * halfwidth Hangul Jamo * halfwidth forms, arrows, and shapes *
* FULL_WIDTH: Characters which take up a full cell in standard Asian text: * combining Hangul choseong * all characters in the CJK Phonetics and Symbols Area * all characters in the CJK Ideographs Area * all characters in the Hangul Syllables Area * CJK compatibility ideographs * CJK compatibility forms * small form variants * fullwidth ASCII * fullwidth punctuation and currency signs *
* NEUTRAL: Characters whose cell width is context-dependent: * all characters in the Symbols Area, except those specifically called out above * all characters in the Surrogates Area * all charcaters in the Private Use Area *
* For Korean text, this algorithm should work properly with properly normalized Korean
* text. Precomposed Hangul syllables and non-combining jamo are all considered full-
* width characters. For combining jamo, we treat we treat choseong (initial consonants)
* as double-width characters and junseong (vowels) and jongseong (final consonants)
* as non-spacing marks. This will work right in text that uses the precomposed
* choseong characters instead of teo choseong characters in a row, and which uses the
* choseong filler character at the beginning of syllables that don't have an initial
* consonant. The results may be slightly off with Korean text following different
* conventions.
*
* @deprecated See the Unicode class description.
*/
static inline uint16_t getCellWidth(UChar32 ch);
/**
* Retrieve the name of a Unicode character.
* Depending on nameChoice, the character name written
* into the buffer is the "modern" name or the name that was defined
* in Unicode version 1.0.
* The name contains only "invariant" characters
* like A-Z, 0-9, space, and '-'.
*
* @param code The character (code point) for which to get the name.
* It must be 0<=code<0x10ffff.
* @param buffer Destination address for copying the name.
* @param bufferLength ==sizeof(buffer)
* @param nameChoice Selector for which name to get.
*
* @see UCharNameChoice
*
* Example:
*
* char buffer[100];
* UTextOffset length=Unicode::getCharName(
* 0x284, buffer, sizeof(buffer));
*
* // use invariant-character conversion to Unicode
* UnicodeString name(buffer, length, "");
*
*
* @deprecated See the Unicode class description.
*/
static inline UTextOffset
getCharName(uint32_t code,
char *buffer, UTextOffset bufferLength,
UCharNameChoice nameChoice=U_UNICODE_CHAR_NAME);
/**
* Retrives the decimal numeric value of a digit character.
* @param ch the digit character for which to get the numeric value
* @return the numeric value of ch in decimal radix. This method returns
* -1 if ch is not a valid digit character.
* @see Unicode#digit
* @see Unicode#forDigit
* @see Unicode#isDigit
*
* @deprecated See the Unicode class description.
*/
static inline int32_t digitValue(UChar32 ch);
/**
* Returns the numeric value of the character ch in the
* specified radix.
*
* If the radix is not in the range MIN_RADIX <=
* radix <= MAX_RADIX or if the
* value of ch is not a valid digit in the specified
* radix, -1 is returned. A character is a valid digit
* if at least one of the following is true:
*
isDigit is true of the character
* and the Unicode decimal digit value of the character (or its
* single-character decomposition) is less than the specified radix.
* In this case the decimal digit value is returned.
* 'A' through 'Z' and its code is less than
* radix + 'A' - 10.
* In this case, ch - 'A' + 10
* is returned.
* 'a' through 'z' and its code is less than
* radix + 'a' - 10.
* In this case, ch - 'a' + 10
* is returned.
* radix is not a
* valid radix, or the value of digit is not a valid
* digit in the specified radix, the null character
* (U+0000) is returned.
*
* The radix argument is valid if it is greater than or
* equal to MIN_RADIX and less than or equal to
* MAX_RADIX. The digit argument is valid if
* 0 <= digit <= radix.
*
* If the digit is less than 10, then
* '0' + digit is returned. Otherwise, the value
* 'a' + digit - 10 is returned.
*
* @param digit the number to convert to a character.
* @param radix the radix.
* @return the char representation of the specified digit
* in the specified radix.
* @see Unicode#MIN_RADIX
* @see Unicode#MAX_RADIX
* @see Unicode#digit
* @see Unicode#digitValue
* @see Unicode#isDigit
*
* @deprecated See the Unicode class description.
*/
static inline UChar32 forDigit(int32_t digit, int8_t radix);
/**
* Retrieves the Unicode Standard Version number that is used
* @param info the version # information, the result will be filled in
*
* @deprecated See the Unicode class description.
*/
static void getUnicodeVersion(UVersionInfo info);
protected:
// These constructors, destructor, and assignment operator must
// be protected (not private, as they semantically are) to make
// various UNIX compilers happy. [LIU]
// They should be private to prevent anyone from instantiating or
// subclassing Unicode.
Unicode();
Unicode(const Unicode &other);
~Unicode();
const Unicode &operator=(const Unicode &other);
};
/* inline implementations --------------------------------------------------- */
inline UBool
Unicode::isSingle(UChar c) {
return UTF_IS_SINGLE(c);
}
inline UBool
Unicode::isLead(UChar c) {
return UTF_IS_LEAD(c);
}
inline UBool
Unicode::isTrail(UChar c) {
return UTF_IS_TRAIL(c);
}
inline UBool
Unicode::isSurrogate(UChar32 c) {
return UTF_IS_SURROGATE(c);
}
inline UBool
Unicode::isUnicodeChar(UChar32 c) {
return UTF_IS_UNICODE_CHAR(c);
}
inline UBool
Unicode::isError(UChar32 c) {
return UTF_IS_ERROR(c);
}
inline UBool
Unicode::isValid(UChar32 c) {
return UTF_IS_VALID(c);
}
inline UBool
Unicode::needMultipleUChar(UChar32 c) {
return UTF_NEED_MULTIPLE_UCHAR(c);
}
inline int32_t
Unicode::charLength(UChar32 c) {
return UTF_CHAR_LENGTH(c);
}
inline int32_t
Unicode::arraySize(int32_t size) {
return UTF_ARRAY_SIZE(size);
}
// Checks if ch is a lower case letter.
inline UBool
Unicode::isLowerCase(UChar32 ch) {
return u_islower(ch);
}
// Checks if ch is a upper case letter.
inline UBool
Unicode::isUpperCase(UChar32 ch) {
return u_isupper(ch);
}
// Checks if ch is a title case letter; usually upper case letters.
inline UBool
Unicode::isTitleCase(UChar32 ch) {
return u_istitle(ch);
}
// Checks if ch is a decimal digit.
inline UBool
Unicode::isDigit(UChar32 ch) {
return u_isdigit(ch);
}
// Checks if ch is a unicode character with assigned character type.
inline UBool
Unicode::isDefined(UChar32 ch) {
return u_isdefined(ch);
}
// Checks if the Unicode character is a control character.
inline UBool
Unicode::isControl(UChar32 ch) {
return u_iscntrl(ch);
}
// Checks if the Unicode character is printable.
inline UBool
Unicode::isPrintable(UChar32 ch) {
return u_isprint(ch);
}
// Checks if the Unicode character is a base form character that can take a diacritic.
inline UBool
Unicode::isBaseForm(UChar32 ch) {
return u_isbase(ch);
}
// Checks if the Unicode character is a letter.
inline UBool
Unicode::isLetter(UChar32 ch) {
return u_isalpha(ch);
}
// Checks if the Unicode character can start a Java identifier.
inline UBool
Unicode::isJavaIdentifierStart(UChar32 ch) {
return u_isJavaIDStart(ch);
}
// Checks if the Unicode character can be a Java identifier part other than starting the
// identifier.
inline UBool
Unicode::isJavaIdentifierPart(UChar32 ch) {
return u_isJavaIDPart(ch);
}
// Checks if the Unicode character can start a Unicode identifier.
inline UBool
Unicode::isUnicodeIdentifierStart(UChar32 ch) {
return u_isIDStart(ch);
}
// Checks if the Unicode character can be a Unicode identifier part other than starting the
// identifier.
inline UBool
Unicode::isUnicodeIdentifierPart(UChar32 ch) {
return u_isIDPart(ch);
}
// Checks if the Unicode character can be ignorable in a Java or Unicode identifier.
inline UBool
Unicode::isIdentifierIgnorable(UChar32 ch) {
return u_isIDIgnorable(ch);
}
// Transforms the Unicode character to its lower case equivalent.
inline UChar32
Unicode::toLowerCase(UChar32 ch) {
return u_tolower(ch);
}
// Transforms the Unicode character to its upper case equivalent.
inline UChar32
Unicode::toUpperCase(UChar32 ch) {
return u_toupper(ch);
}
// Transforms the Unicode character to its title case equivalent.
inline UChar32
Unicode::toTitleCase(UChar32 ch) {
return u_totitle(ch);
}
// Transforms the Unicode character to its case folded equivalent.
inline UChar32
Unicode::foldCase(UChar32 ch, uint32_t options) {
return u_foldCase(ch, options);
}
// Checks if the Unicode character is a space character.
inline UBool
Unicode::isSpaceChar(UChar32 ch) {
return u_isspace(ch);
}
// Determines if the specified character is white space according to ICU.
inline UBool
Unicode::isWhitespace(UChar32 ch) {
return u_isWhitespace(ch);
}
// Gets if the Unicode character's character property.
inline int8_t
Unicode::getType(UChar32 ch) {
return u_charType(ch);
}
inline uint8_t
Unicode::getCombiningClass(UChar32 c) {
return u_getCombiningClass(c);
}
// Gets the character's linguistic directionality.
inline Unicode::EDirectionProperty
Unicode::characterDirection(UChar32 ch) {
return (EDirectionProperty)u_charDirection(ch);
}
// Determines if the character has the "mirrored" property.
inline UBool
Unicode::isMirrored(UChar32 ch) {
return u_isMirrored(ch);
}
// Maps the character to a "mirror-image" character, or to itself.
inline UChar32
Unicode::charMirror(UChar32 ch) {
return u_charMirror(ch);
}
// Get the script associated with the character
inline Unicode::EUnicodeScript
Unicode::getScript(UChar32 ch) {
return (EUnicodeScript) u_charScript(ch);
}
// Gets table cell width of the Unicode character.
inline uint16_t
Unicode::getCellWidth(UChar32 ch) {
return u_charCellWidth(ch);
}
inline UTextOffset
Unicode::getCharName(uint32_t code,
char *buffer, UTextOffset bufferLength,
UCharNameChoice nameChoice) {
UErrorCode errorCode=U_ZERO_ERROR;
UTextOffset length=u_charName(code, nameChoice, buffer, bufferLength, &errorCode);
return U_SUCCESS(errorCode) ? length : 0;
}
inline int32_t
Unicode::digitValue(UChar32 ch) {
return u_charDigitValue(ch);
}
inline int8_t
Unicode::digit(UChar32 ch, int8_t radix) {
return u_digit(ch, radix);
}
inline UChar32
Unicode::forDigit(int32_t digit, int8_t radix) {
return u_forDigit(digit, radix);
}
inline void
Unicode::getUnicodeVersion(UVersionInfo versionArray) {
u_getUnicodeVersion(versionArray);
}
U_NAMESPACE_END
#endif