/* ***************************************************************************************** * Copyright (C) 1996-1999, International Business Machines * Corporation and others. All Rights Reserved. ***************************************************************************************** */ // FILE NAME : unicode.h // // CREATED // Wednesday, December 11, 1996 // // CREATED BY // Helena Shih // // CHANGES // Thursday, April 15, 1999 // Modified the definitions of all the functions // C++ Wrappers for Unicode // CHANGES BY // Madhu Katragadda // 5/20/99 Madhu Added the function getVersion() // 11/22/99 aliu Added MIN_RADIX, MAX_RADIX, digit, forDigit //******************************************************************************************** #ifndef UNICODE_H #define UNICODE_H #include "unicode/utypes.h" #include "unicode/uchar.h" /** * The Unicode class allows you to query the properties associated with individual * Unicode character values. *

* 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. */ 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. */ 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 */ 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 */ enum EUnicodeScript { kBasicLatin, 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 }; /** * This specifies the language directional property of a character set. */ 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 */ 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. */ 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. */ 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. */ 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. */ 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. */ 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. */ 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. */ 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. */ 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. */ 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.) */ 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 * @draft */ 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 * @draft */ 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 * @draft */ 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 * @draft */ 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 * @draft */ 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 * @draft */ 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 * @draft */ 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 * @draft */ 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 * @draft */ 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: *

* * @param ch the Unicode character. * @return TRUE if the character may start a Java identifier; * FALSE otherwise. * @see isJavaIdentifierPart * @see isLetter * @see isUnicodeIdentifierStart * @draft */ static inline UBool isJavaIdentifierStart(UChar32 ch); /** * A convenience method for determining if a Unicode character * may be part of a Java identifier other than the starting * character. *

* A character may be part of a Java identifier if and only if * it is one of the following: *

* * @param ch the Unicode character. * @return TRUE if the character may be part of a Unicode identifier; * FALSE otherwise. * @see isIdentifierIgnorable * @see isJavaIdentifierStart * @see isLetter * @see isDigit * @see isUnicodeIdentifierPart * @draft */ static inline UBool isJavaIdentifierPart(UChar32 ch); /** * A convenience method for determining if a Unicode character * is allowed to start in a Unicode identifier. * A character may start a Unicode identifier if and only if * it is a letter. * * @param ch the Unicode character. * @return TRUE if the character may start a Unicode identifier; * FALSE otherwise. * @see isJavaIdentifierStart * @see isLetter * @see isUnicodeIdentifierPart * @draft */ static inline UBool isUnicodeIdentifierStart(UChar32 ch); /** * A convenience method for determining if a Unicode character * may be part of a Unicode identifier other than the starting * character. *

* A character may be part of a Unicode identifier if and only if * it is one of the following: *

* * @param ch the Unicode character. * @return TRUE if the character may be part of a Unicode identifier; * FALSE otherwise. * @see isIdentifierIgnorable * @see isJavaIdentifierPart * @see isLetterOrDigit * @see isUnicodeIdentifierStart * @draft */ static inline UBool isUnicodeIdentifierPart(UChar32 ch); /** * A convenience method for determining if a Unicode character * should be regarded as an ignorable character in a Java * identifier or a Unicode identifier. *

* 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
* * @param ch the Unicode character. * @return TRUE if the character may be part of a Unicode identifier; * FALSE otherwise. * @see isJavaIdentifierPart * @see isUnicodeIdentifierPart * @draft */ static inline UBool isIdentifierIgnorable(UChar32 ch); /** * The given character is mapped to its lowercase equivalent according to * Unicode 2.1.2; if the character has no lowercase equivalent, the character * itself is returned. *

* 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 * @draft */ 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 * @draft */ 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 * @draft */ 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. * @draft */ 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. * @draft */ 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: *

* Note: This method corresponds to the Java method * java.lang.Character.isWhitespace(). * * @param ch the character to be tested. * @return true if the character is an ICU whitespace character; * false otherwise. * @see #isSpaceChar * @draft */ static inline UBool isWhitespace(UChar32 ch); /** * Returns a value indicating a character category according to Unicode * 2.1.2. * @param ch the character to be tested * @return a value of type int, the character category. * @see Unicode#UNASSIGNED * @see Unicode#UPPERCASE_LETTER * @see Unicode#LOWERCASE_LETTER * @see Unicode#TITLECASE_LETTER * @see Unicode#MODIFIER_LETTER * @see Unicode#OTHER_LETTER * @see Unicode#NON_SPACING_MARK * @see Unicode#ENCLOSING_MARK * @see Unicode#COMBINING_SPACING_MARK * @see Unicode#DECIMAL_DIGIT_NUMBER * @see Unicode#OTHER_NUMBER * @see Unicode#SPACE_SEPARATOR * @see Unicode#LINE_SEPARATOR * @see Unicode#PARAGRAPH_SEPARATOR * @see Unicode#CONTROL * @see Unicode#PRIVATE_USE * @see Unicode#SURROGATE * @see Unicode#DASH_PUNCTUATION * @see Unicode#OPEN_PUNCTUATION * @see Unicode#CLOSE_PUNCTUATION * @see Unicode#CONNECTOR_PUNCTUATION * @see Unicode#OTHER_PUNCTUATION * @see Unicode#LETTER_NUMBER * @see Unicode#MATH_SYMBOL * @see Unicode#CURRENCY_SYMBOL * @see Unicode#MODIFIER_SYMBOL * @see Unicode#OTHER_SYMBOL * @draft */ static inline int8_t getType(UChar32 ch); /** * Returns the combining class of the code point as specified in UnicodeData.txt. * * @param c the code point of the character * @return the combining class of the character * @draft */ static inline uint8_t getCombiningClass(UChar32 c); /** * Returns the linguistic direction property of a character. *

* Returns the linguistic direction property of a character. * For example, 0x0041 (letter A) has the LEFT_TO_RIGHT directional * property. * @see #EDirectionProperty * @draft */ 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 */ 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 */ 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. * @draft */ 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, "");
     *
* @draft */ 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 HSYS: use Unicode::digit instead. Remove after 2000-dec-31 */ 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: *

* * @param ch the character to be converted. * @param radix the radix. * @return the numeric value represented by the character in the * specified radix. * @see Unicode#MIN_RADIX * @see Unicode#MAX_RADIX * @see Unicode#forDigit * @see Unicode#digitValue * @see Unicode#isDigit * @draft */ static inline int8_t digit(UChar32 ch, int8_t radix); /** * Determines the character representation for a specific digit in * the specified radix. If the value of 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 * @draft */ 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 * @draft */ 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) { // ### TODO this should probably move to a C u_charDigitValueEx(ch, radix) and be called here int8_t value; if((uint8_t)(radix-MIN_RADIX)<=(MAX_RADIX-MIN_RADIX)) { value=(int8_t)u_charDigitValue(ch); if(value<0) { // ch is not a decimal digit, try latin letters if ((uint32_t)(ch-0x41)<26) { value=(int8_t)(ch-(0x41-10)); // A-Z, subtract A } else if ((uint32_t)(ch-0x61)<26) { value=(int8_t)(ch-(0x61-10)); // a-z, subtract a } else { return -1; // ch is not a digit character } } } else { return -1; // invalid radix } return (uint8_t)((value(MAX_RADIX-MIN_RADIX) || (uint32_t)digit>=(uint32_t)radix) { return 0; } else if(digit<10) { return (UChar32)(0x30+digit); } else { return (UChar32)((0x61-10)+digit); } } inline void Unicode::getUnicodeVersion(UVersionInfo versionArray) { u_getUnicodeVersion(versionArray); } #endif