Google Git
Sign in
skia / external / github.com / unicode-org / icu / refs/tags/icu4j-release-2-0 / . / src / com / ibm / text / UCharacter.java
blob: 54f10d5bdb9c2c7569c598d5e2f0450a2edf826c [file] [log] [blame]
/**
*******************************************************************************
* Copyright (C) 1996-2001, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/icu4j/src/com/ibm/text/Attic/UCharacter.java,v $
* $Date: 2001/12/04 20:09:07 $
* $Revision: 1.20 $
*
*******************************************************************************
*/
package com.ibm.text;
import java.util.Locale;
import com.ibm.util.Utility;
/**
* <p>
* The UCharacter class provides extensions to the
* <a href=http://java.sun.com/j2se/1.3/docs/api/java/lang/Character.html>
* java.lang.Character</a> class. These extensions provide support for
* Unicode 3.1 properties and together with the <a href=UTF16.html>UTF16</a>
* class, provide support for supplementary characters (those with code
* points above U+FFFF).
* </p>
* <p>
* Code points are represented in these API using ints. While it would be
* more convenient in Java to have a separate primitive datatype for them,
* ints suffice in the meantime.
* </p>
* <p>
* To use this class please add the jar file name icu4j.jar to the
* class path, since it contains data files which supply the information used
* by this file.<br>
* E.g. In Windows <br>
* <code>set CLASSPATH=%CLASSPATH%;$JAR_FILE_PATH/ucharacter.jar</code>.<br>
* Otherwise, another method would be to copy the files uprops.dat and
* unames.dat from the icu4j source subdirectory
* <i>$ICU4J_SRC/src/com/ibm/text/resources</i> to your class directory
* <i>$ICU4J_CLASS/com/ibm/text/resources</i>.
* </p>
* <p>
* For more information about the data file format, please refer to
* <a href=http://oss.software.ibm.com/icu4j/doc/com/ibm/text/ReadMe.html>
* Read Me</a>.
* </p>
* <p>
* Aside from the additions for UTF-16 support, and the updated Unicode 3.1
* properties, the main differences between UCharacter and Character are:
* <ul>
* <li> UCharacter is not designed to be a char wrapper and does not have
* APIs to which involves management of that single char.<br>
* These include:
* <ul>
* <li> char charValue(),
* <li> int compareTo(java.lang.Character, java.lang.Character), etc.
* </ul>
* <li> UCharacter does not include Character APIs that are deprecated, not
* does it include the Java-specific character information, such as
* boolean isJavaIdentifierPart(char ch).
* <li> Character maps characters 'A' - 'Z' and 'a' - 'z' to the numeric
* values '10' - '35'. UCharacter also does this in digit and
* getNumericValue, to adhere to the java semantics of these
* methods. New methods unicodeDigit, and
* getUnicodeNumericValue do not treat the above code points
* as having numeric values. This is a semantic change from ICU4J 1.3.1.
* <li> For consistency with ICU4C's data, control code points below have their
* Unicode general category reset to the types below.
* <ul>
* <li> TAB 0x9 : U_SPACE_SEPARATOR
* <li> VT 0xb : U_SPACE_SEPARATOR
* <li> LF 0xa : U_PARAGRAPH_SEPARATOR
* <li> FF 0xc : U_LINE_SEPARATOR
* <li> CR 0xd : U_PARAGRAPH_SEPARATOR
* <li> FS 0x1c : U_PARAGRAPH_SEPARATOR
* <li> GS 0x1d : U_PARAGRAPH_SEPARATOR
* <li> RS 0x1e : U_PARAGRAPH_SEPARATOR
* <li> US 0x1f : U_SPACE_SEPARATOR
* <li> NL 0x85 : U_PARAGRAPH_SEPARATOR
* </ul>
* <p>
* Further detail differences can be determined from the program
* <a href = http://oss.software.ibm.com/developerworks/opensource/cvs/icu4j/~checkout~/icu4j/src/com/ibm/icu/test/text/UCharacterCompare.java>
* com.ibm.icu.test.text.UCharacterCompare</a>
* </p>
* @author Syn Wee Quek
* @since oct 06 2000
* @see com.ibm.text.UCharacterCategory
* @see com.ibm.text.UCharacterDirection
*/
public final class UCharacter
{
// public variables ==============================================
/**
* The lowest Unicode code point value. Code points are non-ne N_VALUE
*/
public static final int MIN_VALUE = 0;
/**
* The highest Unicode code point value (scalar value) according to the
* Unicode Standard.<br>
* This is a 21-bit value (21 bits, rounded up).<br>
* Up-to-date Unicode implementation of java.lang.Character.MIN_VALUE
*/
public static final int MAX_VALUE = 0x10ffff;
/**
* The minimum value for Supplementary code points
*/
public static final int SUPPLEMENTARY_MIN_VALUE = 0x10000;
/**
* Unicode value used when translating into Unicode encoding form and there
* is no existing character.
*/
public static final int REPLACEMENT_CHAR = '\uFFFD';
// constructor ====================================================
/**
* Private constructor to prevent instantiation
*/
private UCharacter()
{
}
// public methods ===================================================
/**
* Retrieves the numeric value of a decimal digit code point.
* <br>This method observes the semantics of
* <code>java.lang.Character.digit()</code>. Note that this
* will return positive values for code points for which isDigit
* returns false, just like java.lang.Character.
* <br><em>Semantic Change:</em> In release 1.3.1 and
* prior, this did not treat the European letters as having a
* digit value, and also treated numeric letters and other numbers as
* digits.
* This has been changed to conform to the java semantics.
* <br>A code point is a valid digit if and only if:
* <ul>
* <li>ch is a decimal digit or one of the european letters, and
* <li>the value of ch is less than the specified radix.
* </ul>
* @param ch the code point to query
* @param radix the radix
* @return the numeric value represented by the code point in the
* specified radix, or -1 if the code point is not a decimal digit
* or if its value is too large for the radix
*/
public static int digit(int ch, int radix)
{
int props = getProps(ch);
int result = -1;
// if props == 0, it will just fall through and return -1
if (!UCharacterPropertyDB.isExceptionIndicator(props)) {
// not contained in exception data
if (UCharacterPropertyDB.getPropType(props) ==
UCharacterCategory.DECIMAL_DIGIT_NUMBER) {
result = UCharacterPropertyDB.getSignedValue(props);
}
}
if (result < 0 && radix > 10) {
result = getEuropeanDigit(ch);
}
if (result < 0 || result >= radix) {
return -1;
}
return result;
}
private static boolean isEuropeanDigit(int ch) {
return (ch <= 0x7a && ((ch >= 0x41 && ch <= 0x5a) || ch >= 0x61)) ||
(ch >= 0xff21 && (ch <= 0xff3a || (ch >= 0xff41 && ch <= 0xff5a)));
}
private static int getEuropeanDigit(int ch) {
if (ch <= 0x7a) {
if (ch >= 0x41 && ch <= 0x5a) {
return ch + 10 - 0x41;
} else if (ch >= 0x61) {
return ch + 10 - 0x61;
}
} else if (ch >= 0xff21) {
if (ch <= 0xff3a) {
return ch + 10 - 0xff21;
} else if (ch >= 0xff41 && ch <= 0xff5a) {
return ch + 10 - 0xff41;
}
}
return -1;
}
/**
* Retrieves the numeric value of a decimal digit code point.
* <br>This is a convenience overload of <code>digit(int, int)</code>
* that provides a decimal radix.
* <br><em>Semantic Change:</em> In release 1.3.1 and prior, this
* treated numeric letters and other numbers as digits. This has
* been changed to conform to the java semantics.
* @param ch the code point to query
* @return the numeric value represented by the code point,
* or -1 if the code point is not a decimal digit or if its
* value is too large for a decimal radix
*/
public static int digit(int ch)
{
return digit(ch, DECIMAL_RADIX_);
}
/**
* Returns the Unicode numeric value of the code point as a nonnegative
* integer.
* <br>If the code point does not have a numeric value, then -1 is returned.
* <br>
* If the code point has a numeric value that cannot be represented as a
* nonnegative integer (for example, a fractional value), then -2 is
* returned.
* <br><em>Semantic Change:</em> In release 1.3.1 and
* prior, this returned -1 for ASCII letters and their
* fullwidth counterparts. This has been changed to
* conform to the java semantics.
* @param ch the code point to query
* @return the numeric value of the code point, or -1 if it has no numeric
* value, or -2 if it has a numeric value that cannot be represented as a
* nonnegative integer
*/
public static int getNumericValue(int ch)
{
return getNumericValueInternal(ch, true);
}
/**
* Returns the Unicode numeric value of the code point as a nonnegative
* integer.
* <br>If the code point does not have a numeric value, then -1 is returned. <br>
* If the code point has a numeric value that cannot be represented as a
* nonnegative integer (for example, a fractional value), then -2 is
* returned.
* This returns values other than -1 for all and only those code points
* whose type is a numeric type.
* @param ch the code point to query
* @return the numeric value of the code point, or -1 if it has no numeric
* value, or -2 if it has a numeric value that cannot be represented as a
* nonnegative integer
*/
public static int getUnicodeNumericValue(int ch)
{
return getNumericValueInternal(ch, false);
}
private static int getNumericValueInternal(int ch, boolean useEuropean)
{
int props = getProps(ch);
int type = UCharacterPropertyDB.getPropType(props);
// if props == 0, it will just fall through and return -1
if (type != UCharacterCategory.DECIMAL_DIGIT_NUMBER &&
type != UCharacterCategory.LETTER_NUMBER &&
type != UCharacterCategory.OTHER_NUMBER) {
return useEuropean ? getEuropeanDigit(ch) : -1;
}
int result = -1;
if (!UCharacterPropertyDB.isExceptionIndicator(props)) {
// not contained in exception data
result = UCharacterPropertyDB.getSignedValue(props);
}
else {
// contained in exception data
int index = UCharacterPropertyDB.getExceptionIndex(props);
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_DIGIT_VALUE_)) {
result = PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_DIGIT_VALUE_) &
LAST_CHAR_MASK_;
}
else {
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_DENOMINATOR_VALUE_)) {
return -2;
}
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_NUMERIC_VALUE_)) {
result = PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_NUMERIC_VALUE_);
}
}
}
return result;
}
/**
* Returns a value indicating a code point's Unicode category.<br>
* Up-to-date Unicode implementation of java.lang.Character.getType() except
* for the above mentioned code points that had their category changed.<br>
* Return results are constants from the interface
* <a href=UCharacterCategory.html>UCharacterCategory</a>
* @param ch code point whose type is to be determined
* @return category which is a value of UCharacterCategory
*/
public static int getType(int ch)
{
return UCharacterPropertyDB.getPropType(getProps(ch));
}
/**
* Determines if a code point has a defined meaning in the up-to-date Unicode
* standard.<br>
* E.g. supplementary code points though allocated space are not defined in
* Unicode yet.<br>
* Up-to-date Unicode implementation of java.lang.Character.isDefined()
* @param ch code point to be determined if it is defined in the most current
* version of Unicode
* @return true if this code point is defined in unicode
*/
public static boolean isDefined(int ch)
{
return getProps(ch) != 0;
}
/**
* Determines if a code point is a Java digit.
* <br>This method observes the semantics of
* <code>java.lang.Character.isDigit()</code>. It returns true for
* decimal digits only.
* <br><em>Semantic Change:</em> In release 1.3.1 and prior, this
* treated numeric letters and other numbers as digits. This has
* been changed to conform to the java semantics.
* @param ch code point to query
* @return true if this code point is a digit */
public static boolean isDigit(int ch)
{
return getType(ch) == UCharacterCategory.DECIMAL_DIGIT_NUMBER;
}
/**
* Determines if the specified code point is an ISO control character.<br>
* A code point is considered to be an ISO control character if it is in the
* range &#92u0000 through &#92u001F or in the range &#92u007F through
* &#92u009F.<br>
* Up-to-date Unicode implementation of java.lang.Character.isISOControl()
* @param ch code point to determine if it is an ISO control character
* @return true if code point is a ISO control character
*/
public static boolean isISOControl(int ch)
{
return ch >= 0 && ch <= APPLICATION_PROGRAM_COMMAND_ &&
((ch <= UNIT_SEPERATOR_) || (ch >= DELETE_));
}
/**
* Determines if the specified code point is a letter.<br>
* Up-to-date Unicode implementation of java.lang.Character.isLetter()
* @param ch code point to determine if it is a letter
* @return true if code point is a letter
*/
public static boolean isLetter(int ch)
{
int cat = getType(ch);
// if props == 0, it will just fall through and return false
return cat == UCharacterCategory.UPPERCASE_LETTER ||
cat == UCharacterCategory.LOWERCASE_LETTER ||
cat == UCharacterCategory.TITLECASE_LETTER ||
cat == UCharacterCategory.MODIFIER_LETTER ||
cat == UCharacterCategory.OTHER_LETTER;
}
/**
* Determines if the specified code point is a letter or digit.<br>
* Note this method, unlike java.lang.Character does not regard the ascii
* characters 'A' - 'Z' and 'a' - 'z' as digits.
* @param ch code point to determine if it is a letter or a digit
* @return true if code point is a letter or a digit
*/
public static boolean isLetterOrDigit(int ch)
{
return isDigit(ch) || isLetter(ch);
}
/**
* Determines if the specified code point is a lowercase character.<br>
* UnicodeData only contains case mappings for code points where they are
* one-to-one mappings; it also omits information about context-sensitive
* case mappings.<br> For more information about Unicode case mapping please
* refer to the <a href=http://www.unicode.org/unicode/reports/tr21/>
* Technical report #21</a>.<br>
* Up-to-date Unicode implementation of java.lang.Character.isLowerCase()
* @param ch code point to determine if it is in lowercase
* @return true if code point is a lowercase character
*/
public static boolean isLowerCase(int ch)
{
// if props == 0, it will just fall through and return false
return getType(ch) == UCharacterCategory.LOWERCASE_LETTER;
}
/**
* Determines if the specified code point is a white space character.<br>
* A code point is considered to be an whitespace character if and only
* if it satisfies one of the following criteria:
* <ul>
* <li> It is a Unicode space separator (category "Zs"), but is not
* a no-break space (&#92u00A0 or &#92u202F or &#92uFEFF).
* <li> It is a Unicode line separator (category "Zl").
* <li> It is a Unicode paragraph separator (category "Zp").
* </ul>
* Up-to-date Unicode implementation of java.lang.Character.isWhitespace().
* @param ch code point to determine if it is a white space
* @return true if the specified code point is a white space character
*/
public static boolean isWhitespace(int ch)
{
int cat = getType(ch);
// exclude no-break spaces
// if props == 0, it will just fall through and return false
return (cat == UCharacterCategory.SPACE_SEPARATOR ||
cat == UCharacterCategory.LINE_SEPARATOR ||
cat == UCharacterCategory.PARAGRAPH_SEPARATOR) &&
(ch != NO_BREAK_SPACE_) && (ch != NARROW_NO_BREAK_SPACE_) &&
(ch != ZERO_WIDTH_NO_BREAK_SPACE_);
}
/**
* Determines if the specified code point is a Unicode specified space
* character, ie if code point is in the category Zs, Zl and Zp.<br>
* Up-to-date Unicode implementation of java.lang.Character.isSpaceChar().
* @param ch code point to determine if it is a space
* @return true if the specified code point is a space character
*/
public static boolean isSpaceChar(int ch)
{
int cat = getType(ch);
// if props == 0, it will just fall through and return false
return cat == UCharacterCategory.SPACE_SEPARATOR ||
cat == UCharacterCategory.LINE_SEPARATOR ||
cat == UCharacterCategory.PARAGRAPH_SEPARATOR;
}
/**
* Determines if the specified code point is a titlecase character.<br>
* UnicodeData only contains case mappings for code points where they are
* one-to-one mappings; it also omits information about context-sensitive
* case mappings.<br>
* For more information about Unicode case mapping please refer to the
* <a href=http://www.unicode.org/unicode/reports/tr21/>
* Technical report #21</a>.<br>
* Up-to-date Unicode implementation of java.lang.Character.isTitleCase().
* @param ch code point to determine if it is in title case
* @return true if the specified code point is a titlecase character
*/
public static boolean isTitleCase(int ch)
{
int cat = getType(ch);
// if props == 0, it will just fall through and return false
return cat == UCharacterCategory.TITLECASE_LETTER;
}
/**
* Determines if the specified code point may be any part of a Unicode
* identifier other than the starting character.<br>
* A code point may be part of a Unicode identifier if and only if it is one
* of the following:
* <ul>
* <li> Lu Uppercase letter
* <li> Ll Lowercase letter
* <li> Lt Titlecase letter
* <li> Lm Modifier letter
* <li> Lo Other letter
* <li> Nl Letter number
* <li> Pc Connecting punctuation character
* <li> Nd decimal number
* <li> Mc Spacing combining mark
* <li> Mn Non-spacing mark
* <li> Cf formatting code
* </ul>
* Up-to-date Unicode implementation of
* java.lang.Character.isUnicodeIdentifierPart().<br>
* See <a href=http://www.unicode.org/unicode/reports/tr8/>UTR #8</a>.
* @param ch code point to determine if is can be part of a Unicode identifier
* @return true if code point is any character belonging a unicode identifier
* suffix after the first character
*/
public static boolean isUnicodeIdentifierPart(int ch)
{
int cat = getType(ch);
// if props == 0, it will just fall through and return false
return cat == UCharacterCategory.UPPERCASE_LETTER ||
cat == UCharacterCategory.LOWERCASE_LETTER ||
cat == UCharacterCategory.TITLECASE_LETTER ||
cat == UCharacterCategory.MODIFIER_LETTER ||
cat == UCharacterCategory.OTHER_LETTER ||
cat == UCharacterCategory.LETTER_NUMBER ||
cat == UCharacterCategory.CONNECTOR_PUNCTUATION ||
cat == UCharacterCategory.DECIMAL_DIGIT_NUMBER ||
cat == UCharacterCategory.COMBINING_SPACING_MARK ||
cat == UCharacterCategory.NON_SPACING_MARK ||
// cat == UCharacterCategory.FORMAT;
isIdentifierIgnorable(ch);
}
/**
* Determines if the specified code point is permissible as the first
* character in a Unicode identifier.<br>
* A code point may start a Unicode identifier if it is of type either
* <ul>
* <li> Lu Uppercase letter
* <li> Ll Lowercase letter
* <li> Lt Titlecase letter
* <li> Lm Modifier letter
* <li> Lo Other letter
* <li> Nl Letter number
* </ul>
* Up-to-date Unicode implementation of
* java.lang.Character.isUnicodeIdentifierStart().<br>
* See <a href=http://www.unicode.org/unicode/reports/tr8/>UTR #8</a>.
* @param ch code point to determine if it can start a Unicode identifier
* @return true if code point is the first character belonging a unicode
* identifier
*/
public static boolean isUnicodeIdentifierStart(int ch)
{
int cat = getType(ch);
// if props == 0, it will just fall through and return false
return cat == UCharacterCategory.UPPERCASE_LETTER ||
cat == UCharacterCategory.LOWERCASE_LETTER ||
cat == UCharacterCategory.TITLECASE_LETTER ||
cat == UCharacterCategory.MODIFIER_LETTER ||
cat == UCharacterCategory.OTHER_LETTER ||
cat == UCharacterCategory.LETTER_NUMBER;
}
/**
* Determines if the specified code point should be regarded as an ignorable
* character in a Unicode identifier.<br>
* A character is ignorable in the Unicode standard if it is of the type Cf,
* Formatting code.<br>
* Up-to-date Unicode implementation of
* java.lang.Character.isIdentifierIgnorable().<br>
* See <a href=http://www.unicode.org/unicode/reports/tr8/>UTR #8</a>.
* @param ch code point to be determined if it can be ignored in a Unicode
* identifier.
* @return true if the code point is ignorable
*/
public static boolean isIdentifierIgnorable(int ch)
{
/*
int cat = getType(ch);
// if props == 0, it will just fall through and return false
return cat == UCharacterCategory.FORMAT;
*/
// see java.lang.Character.isIdentifierIgnorable() on range of
// ignorable characters.
return ch <= 8 || (ch >= 0xe && ch <= 0x1b) ||
(ch >= 0x7f && ch <= 0x9f) ||
getType(ch) == UCharacterCategory.FORMAT;
}
/**
* Determines if the specified code point is an uppercase character.<br>
* UnicodeData only contains case mappings for code point where they are
* one-to-one mappings; it also omits information about context-sensitive
* case mappings.<br>
* For language specific case conversion behavior, use
* toUpperCase(locale, str). <br>
* For example, the case conversion for dot-less i and dotted I in Turkish,
* or for final sigma in Greek.
* For more information about Unicode case mapping please refer to the
* <a href=http://www.unicode.org/unicode/reports/tr21/>
* Technical report #21</a>.<br>
* Up-to-date Unicode implementation of java.lang.Character.isUpperCase().
* @param ch code point to determine if it is in uppercase
* @return true if the code point is an uppercase character
*/
public static boolean isUpperCase(int ch)
{
int cat = getType(ch);
// if props == 0, it will just fall through and return false
return cat == UCharacterCategory.UPPERCASE_LETTER;
}
/**
* The given code point is mapped to its lowercase equivalent; if the code
* point has no lowercase equivalent, the code point itself is returned.<br>
* UnicodeData only contains case mappings for code point where they are
* one-to-one mappings; it also omits information about context-sensitive
* case mappings.<br>
* For language specific case conversion behavior, use
* toLowerCase(locale, str). <br>
* For example, the case conversion for dot-less i and dotted I in Turkish,
* or for final sigma in Greek.
* For more information about Unicode case mapping please refer to the
* <a href=http://www.unicode.org/unicode/reports/tr21/>
* Technical report #21</a>.<br>
* Up-to-date Unicode implementation of java.lang.Character.toLowerCase()
* @param ch code point whose lowercase equivalent is to be retrieved
* @return the lowercase equivalent code point
*/
public static int toLowerCase(int ch)
{
int props = getProps(ch);
// if props == 0, it will just fall through and return itself
if(!UCharacterPropertyDB.isExceptionIndicator(props)) {
int cat = UCharacterPropertyDB.getPropType(props);
if (cat == UCharacterCategory.UPPERCASE_LETTER ||
cat == UCharacterCategory.TITLECASE_LETTER) {
return ch + UCharacterPropertyDB.getSignedValue(props);
}
}
else
{
int index = UCharacterPropertyDB.getExceptionIndex(props);
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_LOWERCASE_)) {
return PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_LOWERCASE_);
}
}
return ch;
}
/**
* Converts argument code point and returns a String object representing the
* code point's value in UTF16 format.<br>
* The result is a string whose length is 1 for non-supplementary code points,
* 2 otherwise.<br>
* com.ibm.ibm.icu.UTF16 can be used to parse Strings generated by this
* function.<br>
* Up-to-date Unicode implementation of java.lang.Character.toString()
* @param ch code point
* @return string representation of the code point, null if code point is not
* defined in unicode
*/
public static String toString(int ch)
{
if (ch < MIN_VALUE || ch > MAX_VALUE) {
return null;
}
if (ch < UCharacter.SUPPLEMENTARY_MIN_VALUE) {
return String.valueOf((char)ch);
}
char result[] = new char[2];
result[0] = (char)UTF16.getLeadSurrogate(ch);
result[1] = (char)UTF16.getTrailSurrogate(ch);
return new String(result);
}
/**
* Converts the code point argument to titlecase.<br>
* UnicodeData only contains case mappings for code points where they are
* one-to-one mappings; it also omits information about context-sensitive
* case mappings.<br>
* There are only four Unicode characters that are truly titlecase forms
* that are distinct from uppercase forms.
* For more information about Unicode case mapping please refer
* to the <a href=http://www.unicode.org/unicode/reports/tr21/>
* Technical report #21</a>.<br>
* If no titlecase is available, the uppercase is returned. If no uppercase
* is available, the code point itself is returned.<br>
* Up-to-date Unicode implementation of java.lang.Character.toTitleCase()
* @param ch code point whose title case is to be retrieved
* @return titlecase code point
*/
public static int toTitleCase(int ch)
{
int props = getProps(ch);
// if props == 0, it will just fall through and return itself
if (!UCharacterPropertyDB.isExceptionIndicator(props)) {
if (UCharacterPropertyDB.getPropType(props) ==
UCharacterCategory.LOWERCASE_LETTER) {
// here, titlecase is same as uppercase
return ch - UCharacterPropertyDB.getSignedValue(props);
}
}
else {
int index = UCharacterPropertyDB.getExceptionIndex(props);
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_TITLECASE_)) {
return PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_TITLECASE_);
}
else {
// here, titlecase is same as uppercase
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_UPPERCASE_)) {
return PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_UPPERCASE_);
}
}
}
return ch; // no mapping - return c itself
}
/**
* Converts the character argument to uppercase.<br>
* UnicodeData only contains case mappings for characters where they are
* one-to-one mappings; it also omits information about context-sensitive
* case mappings.<br>
* For more information about Unicode case mapping please refer
* to the <a href=http://www.unicode.org/unicode/reports/tr21/>
* Technical report #21</a>.<br>
* If no uppercase is available, the character itself is returned.<br>
* Up-to-date Unicode implementation of java.lang.Character.toUpperCase()
* @param ch code point whose uppercase is to be retrieved
* @return uppercase code point
*/
public static int toUpperCase(int ch)
{
int props = getProps(ch);
// if props == 0, it will just fall through and return itself
if (!UCharacterPropertyDB.isExceptionIndicator(props)) {
if (UCharacterPropertyDB.getPropType(props) ==
UCharacterCategory.LOWERCASE_LETTER) {
// here, titlecase is same as uppercase */
return ch - UCharacterPropertyDB.getSignedValue(props);
}
}
else
{
int index = UCharacterPropertyDB.getExceptionIndex(props);
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_UPPERCASE_)) {
return PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_UPPERCASE_);
}
}
return ch; // no mapping - return c itself
}
// extra methods not in java.lang.Character ===========================
/**
* Determines if the code point is a supplementary character.<br>
* A code point is a supplementary character if and only if it is greater than
* <a href=#SUPPLEMENTARY_MIN_VALUE>SUPPLEMENTARY_MIN_VALUE</a>
* @param ch code point to be determined if it is in the supplementary plane
* @return true if code point is a supplementary character
*/
public static boolean isSupplementary(int ch)
{
return ch >= UCharacter.SUPPLEMENTARY_MIN_VALUE &&
ch <= UCharacter.MAX_VALUE;
}
/**
* Determines if the code point is in the BMP plane.<br>
* @param ch code point to be determined if it is not a supplementary
* character
* @return true if code point is not a supplementary character
*/
public static boolean isBMP(int ch)
{
return (ch >= 0 && ch < LAST_CHAR_MASK_);
}
/**
* Determines whether the specified code point is a printable character
* according to the Unicode standard.
* @param ch code point to be determined if it is printable
* @return true if the code point is a printable character
*/
public static boolean isPrintable(int ch)
{
if (isISOControl(ch)) {
return false;
}
int cat = getType(ch);
// if props == 0, it will just fall through and return false
return (cat != UCharacterCategory.UNASSIGNED &&
cat != UCharacterCategory.CONTROL &&
cat != UCharacterCategory.FORMAT &&
cat != UCharacterCategory.PRIVATE_USE &&
cat != UCharacterCategory.SURROGATE &&
cat != UCharacterCategory.GENERAL_OTHER_TYPES);
}
/**
* Determines whether the specified code point is of base form.<br>
* A code point of base form does not graphically combine with preceding
* characters, and is neither a control nor a format character.
* @param ch code point to be determined if it is of base form
* @return true if the code point is of base form
*/
public static boolean isBaseForm(int ch)
{
int cat = getType(ch);
// if props == 0, it will just fall through and return false
return cat == UCharacterCategory.DECIMAL_DIGIT_NUMBER ||
cat == UCharacterCategory.OTHER_NUMBER ||
cat == UCharacterCategory.LETTER_NUMBER ||
cat == UCharacterCategory.UPPERCASE_LETTER ||
cat == UCharacterCategory.LOWERCASE_LETTER ||
cat == UCharacterCategory.TITLECASE_LETTER ||
cat == UCharacterCategory.MODIFIER_LETTER ||
cat == UCharacterCategory.OTHER_LETTER ||
cat == UCharacterCategory.NON_SPACING_MARK ||
cat == UCharacterCategory.ENCLOSING_MARK ||
cat == UCharacterCategory.COMBINING_SPACING_MARK;
}
/**
* Returns the Bidirection property of a code point.<br>
* For example, 0x0041 (letter A) has the LEFT_TO_RIGHT directional
* property.<br>
* Result returned belongs to the interface
* <a href=UCharacterDirection.html>UCharacterDirection</a>
* @param ch the code point to be determined its direction
* @return direction constant from UCharacterDirection. Otherwise is
* character is not defined, UCharacterDirection.BOUNDARY_NEUTRAL
* will be returned.
*/
public static int getDirection(int ch)
{
int props = getProps(ch);
if (props != 0) {
return UCharacterPropertyDB.getDirection(props);
}
return UCharacterDirection.LEFT_TO_RIGHT;
}
/**
* Determines whether the code point has the "mirrored" property.<br>
* 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 ch code point whose mirror is to be determined
* @return true if the code point has the "mirrored" property
*/
public static boolean isMirrored(int ch)
{
int props = getProps(ch);
// if props == 0, it will just fall through and return false
return UCharacterPropertyDB.isMirrored(props);
}
/**
* Maps the specified code point to a "mirror-image" code point.<br>
* For code points with the "mirrored" property, implementations sometimes
* need a "poor man's" mapping to another code point such that the default
* glyph may serve as the mirror-image of the default glyph of the specified
* code point.<br>
* This is useful for text conversion to and from codepages with visual
* order, and for displays without glyph selection capabilities.
* @param ch code point whose mirror is to be retrieved
* @return another code point that may serve as a mirror-image substitute, or
* ch itself if there is no such mapping or ch does not have the
* "mirrored" property
*/
public static int getMirror(int ch)
{
int props = getProps(ch);
// mirrored - the value is a mirror offset
// if props == 0, it will just fall through and return false
if (UCharacterPropertyDB.isMirrored(props)) {
if(!UCharacterPropertyDB.isExceptionIndicator(props)) {
return ch + UCharacterPropertyDB.getSignedValue(props);
}
else
{
int index = UCharacterPropertyDB.getExceptionIndex(props);
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_MIRROR_MAPPING_))
return PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_MIRROR_MAPPING_);
}
}
return ch;
}
/**
* Gets the combining class of the argument codepoint
* @param ch code point whose combining is to be retrieved
* @return the combining class of the codepoint
*/
public static int getCombiningClass(int ch)
{
int props = getProps(ch);
if(!UCharacterPropertyDB.isExceptionIndicator(props)) {
if (UCharacterPropertyDB.getPropType(props) ==
UCharacterCategory.NON_SPACING_MARK) {
return PROPERTY_DB_.getUnsignedValue(props);
}
else {
return 0;
}
}
else {
// the combining class is in bits 23..16 of the first exception value
return (PROPERTY_DB_.getException(
PROPERTY_DB_.getExceptionIndex(props),
UCharacterPropertyDB.EXC_COMBINING_CLASS_)
>> SHIFT_16_) & LAST_BYTE_MASK_;
}
}
/**
* A code point is illegal if and only if
* <ul>
* <li> Out of bounds, less than 0 or greater than UCharacter.MAX_VALUE
* <li> A surrogate value, 0xD800 to 0xDFFF
* <li> Not-a-character, having the form 0x xxFFFF or 0x xxFFFE
* </ul>
* Note: legal does not mean that it is assigned in this version of Unicode.
* @param ch code point to determine if it is a legal code point by itself
* @return true if and only if legal.
*/
public static boolean isLegal(int ch)
{
if (ch < MIN_VALUE) {
return false;
}
if (ch < SURROGATE_MIN_VALUE_) {
return true;
}
if (ch <= SURROGATE_MAX_VALUE_) {
return false;
}
if (isNonCharacter(ch)) {
return false;
}
return (ch <= MAX_VALUE);
}
/**
* A string is legal iff all its code points are legal.
* A code point is illegal if and only if
* <ul>
* <li> Out of bounds, less than 0 or greater than UCharacter.MAX_VALUE
* <li> A surrogate value, 0xD800 to 0xDFFF
* <li> Not-a-character, having the form 0x xxFFFF or 0x xxFFFE
* </ul>
* Note: legal does not mean that it is assigned in this version of Unicode.
* @param ch code point to determine if it is a legal code point by itself
* @return true if and only if legal.
*/
public static boolean isLegal(String str)
{
int size = str.length();
int codepoint;
for (int i = 0; i < size; i ++)
{
codepoint = UTF16.charAt(str, i);
if (!isLegal(codepoint)) {
return false;
}
if (isSupplementary(codepoint)) {
i ++;
}
}
return true;
}
/**
* Gets the version of Unicode data used.
* @return the unicode version number used
*/
public static String getUnicodeVersion()
{
return PROPERTY_DB_.m_unicodeversion_;
}
/**
* Retrieve the most current Unicode name of the argument code point, or
* null if the character is unassigned or outside the range
* UCharacter.MIN_VALUE and UCharacter.MAX_VALUE.<br>
* Note calling any methods related to code point names, e.g. get*Name*()
* incurs a one-time initialisation cost to construct the name tables.
* @param ch the code point for which to get the name
* @return most current Unicode name
*/
public static String getName(int ch)
{
return UCharacterName.getName(ch,
UCharacterNameChoice.U_UNICODE_CHAR_NAME);
}
/**
* Retrieve the earlier version 1.0 Unicode name of the argument code point,
* or null if the character is unassigned or outside the range
* UCharacter.MIN_VALUE and UCharacter.MAX_VALUE.<br>
* <br>
* Note calling any methods related to code point names, e.g. get*Name*()
* incurs a one-time initialisation cost to construct the name tables.
* @param ch the code point for which to get the name
* @return version 1.0 Unicode name
*/
public static String getName1_0(int ch)
{
return UCharacterName.getName(ch,
UCharacterNameChoice.U_UNICODE_10_CHAR_NAME);
}
/**
* Find a Unicode code point by its most current Unicode name and return its
* code point value.<br>
* Note calling any methods related to code point names, e.g. get*Name*()
* incurs a one-time initialisation cost to construct the name tables.
* @param name most current Unicode character name whose code point is to be
* returned
* @return code point or -1 if name is not found
*/
public static int getCharFromName(String name)
{
return UCharacterName.getCharFromName(
UCharacterNameChoice.U_UNICODE_CHAR_NAME, name);
}
/**
* Find a Unicode character by its version 1.0 Unicode name and return its
* code point value.<br>
* Note calling any methods related to code point names, e.g. get*Name*()
* incurs a one-time initialisation cost to construct the name tables.
* @param name Unicode 1.0 code point name whose code point is to
* returned
* @return code point or -1 if name is not found
*/
public static int getCharFromName1_0(String name)
{
return UCharacterName.getCharFromName(
UCharacterNameChoice.U_UNICODE_10_CHAR_NAME, name);
}
/**
* Returns a code pointcorresponding to the two UTF16 characters.<br>
* If the argument lead is not a high surrogate character or trail is not a
* low surrogate character, UCharacter.REPLACEMENT_CHAR is returned.
* @param lead the lead char
* @param trail the trail char
* @return code point or UCharacter.REPLACEMENT_CHAR if surrogate characters
* are invalid.
*/
public static int getCodePoint(char lead, char trail)
{
if (UTF16.isLeadSurrogate(lead) && UTF16.isTrailSurrogate(trail)) {
return getRawSupplementary(lead, trail);
}
return UCharacter.REPLACEMENT_CHAR;
}
/**
* Returns the code point corresponding to the UTF16 character.<br>
* If argument char16 is a surrogate character, UCharacter.REPLACEMENT_CHAR
* is returned
* @param char16 the UTF16 character
* @return code point or UCharacter.REPLACEMENT_CHAR if argument is not a
* invalid character.
* @exception IllegalArgumentException thrown when char16 is not a valid
* codepoint
*/
public static int getCodePoint(char char16)
{
if (UCharacter.isLegal(char16)) {
return char16;
}
throw new IllegalArgumentException("Illegal codepoint");
}
/**
* Gets uppercase version of the argument string.
* Casing is dependent on the default locale and context-sensitive.
* @param str source string to be performed on
* @return uppercase version of the argument string
*/
public static String toUpperCase(String str)
{
return toUpperCase(Locale.getDefault(), str);
}
/**
* Gets lowercase version of the argument string.
* Casing is dependent on the default locale and context-sensitive
* @param str source string to be performed on
* @return lowercase version of the argument string
*/
public static String toLowerCase(String str)
{
return toLowerCase(Locale.getDefault(), str);
}
/**
* Gets uppercase version of the argument string.
* Casing is dependent on the argument locale and context-sensitive.
* @param locale which string is to be converted in
* @param str source string to be performed on
* @return uppercase version of the argument string
*/
public static String toUpperCase(Locale locale, String str)
{
int size = str.length();
StringBuffer result = new StringBuffer(size); // initial buffer
int offset = 0;
while (offset < size)
{
int ch = UTF16.charAt(str, offset);
int chsize = UTF16.getCharCount(ch);
int props = PROPERTY_DB_.getProperty(ch);
if (!UCharacterPropertyDB.isExceptionIndicator(props))
{
if (UCharacterPropertyDB.getPropType(props) ==
UCharacterCategory.LOWERCASE_LETTER) {
ch -= UCharacterPropertyDB.getSignedValue(props);
}
UTF16.append(result, ch);
}
else
{
int index = UCharacterPropertyDB.getExceptionIndex(props);
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_SPECIAL_CASING_)) {
getSpecialUpperCase(ch, index, result, str, offset,
locale);
}
else {
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_UPPERCASE_)) {
ch = PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_UPPERCASE_);
}
UTF16.append(result, ch);
}
}
offset += chsize;
}
return result.toString();
}
/**
* Gets lowercase version of the argument string.
* Casing is dependent on the argument locale and context-sensitive
* @param locale which string is to be converted in
* @param str source string to be performed on
* @return lowercase version of the argument string
*/
public static String toLowerCase(Locale locale, String str)
{
// case mapping loop
int offset = 0;
int length = str.length();
StringBuffer result = new StringBuffer(length);
while (offset < length) {
int ch = UTF16.charAt(str, offset);
int chsize = UTF16.getCharCount(ch);
int props = PROPERTY_DB_.getProperty(ch);
if (!UCharacterPropertyDB.isExceptionIndicator(props)) {
int type = UCharacterPropertyDB.getPropType(props);
if (type == UCharacterCategory.UPPERCASE_LETTER ||
type == UCharacterCategory.TITLECASE_LETTER) {
ch += UCharacterPropertyDB.getSignedValue(props);
}
UTF16.append(result, ch);
}
else {
int index = UCharacterPropertyDB.getExceptionIndex(props);
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_SPECIAL_CASING_)) {
getSpecialLowerCase(ch, index, result, str, offset,
locale);
}
else {
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_LOWERCASE_)) {
ch = PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_LOWERCASE_);
}
UTF16.append(result, ch);
}
}
offset += chsize;
}
return result.toString();
}
// TODO: Make public API
/**
* returns the maximum amount that a single character will expand in
* upper, lower, title, or fold case operations
*/
static int getMaxCaseExpansion() {
return 10;
}
// TODO: Make public API?
/**
* produces the result of converting a single (possibly surrogate)
* character in a string.
* @param result
* @return length of returned value IF there is a change. -1 otherwise.
*/
static int toLowerCase(Locale locale, String str, int offset, char[] result) {
// NOTE: we have to keep the original string around, because it is used
// for the context
int ch = UTF16.charAt(str, offset);
int props = PROPERTY_DB_.getProperty(ch);
if (!UCharacterPropertyDB.isExceptionIndicator(props)) {
int type = UCharacterPropertyDB.getPropType(props);
if (type == UCharacterCategory.UPPERCASE_LETTER ||
type == UCharacterCategory.TITLECASE_LETTER) {
int chDelta = UCharacterPropertyDB.getSignedValue(props);
if (chDelta == 0) return -1;
int len = str.length();
return UTF16.append(result, 0, ch + chDelta);
}
} else {
int index = UCharacterPropertyDB.getExceptionIndex(props);
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_SPECIAL_CASING_)) {
// TODO: avoid StringBuffer, put directly into array?
StringBuffer buf = new StringBuffer();
getSpecialLowerCase(ch, index, buf, str, offset,
locale);
Utility.getChars(buf, 0, buf.length(), result, 0);
return buf.length();
} else if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_LOWERCASE_)) {
return UTF16.append(result, 0, PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_LOWERCASE_));
}
}
return -1;
}
// TODO: Make public API?
/**
* produces the result of converting a single (possibly surrogate)
* character in a string.
* @param result
* @return length of returned value IF there is a change. -1 otherwise.
*/
static int toUpperCase(Locale locale, String str, int offset, char[] result) {
// NOTE: we have to keep the original string around, because it is used
// for the context
int ch = UTF16.charAt(str, offset);
int props = PROPERTY_DB_.getProperty(ch);
if (!UCharacterPropertyDB.isExceptionIndicator(props)) {
int type = UCharacterPropertyDB.getPropType(props);
if (type == UCharacterCategory.LOWERCASE_LETTER ||
type == UCharacterCategory.TITLECASE_LETTER) {
int chDelta = UCharacterPropertyDB.getSignedValue(props);
if (chDelta == 0) return -1;
int len = str.length();
return UTF16.append(result, 0, ch - chDelta);
}
} else {
int index = UCharacterPropertyDB.getExceptionIndex(props);
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_SPECIAL_CASING_)) {
// TODO: avoid StringBuffer, put directly into array?
StringBuffer buf = new StringBuffer();
getSpecialUpperCase(ch, index, buf, str, offset,
locale);
Utility.getChars(buf, 0, buf.length(), result, 0);
return buf.length();
} else if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_UPPERCASE_)) {
return UTF16.append(result, 0, PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_UPPERCASE_));
}
}
return -1;
}
// TODO: Make public API?
/**
* produces the result of converting a single (possibly surrogate)
* character in a string.
* @param result
* @return length of returned value IF there is a change. -1 otherwise.
*/
static int toTitleCase(Locale locale, String str, int offset, char[] result) {
// NOTE: we have to keep the original string around, because it is used
// for the context
// TODO: simplify code by checking for the few special titlecases,
// and just jump to uppercase for the rest.
int ch = UTF16.charAt(str, offset);
int props = PROPERTY_DB_.getProperty(ch);
if (!UCharacterPropertyDB.isExceptionIndicator(props)) {
int type = UCharacterPropertyDB.getPropType(props);
if (type == UCharacterCategory.LOWERCASE_LETTER) {
// here, titlecase is same as uppercase
int chDelta = UCharacterPropertyDB.getSignedValue(props);
if (chDelta == 0) return -1;
int len = str.length();
return UTF16.append(result, 0, ch - chDelta);
}
} else {
int index = UCharacterPropertyDB.getExceptionIndex(props);
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_TITLECASE_)) {
return UTF16.append(result, 0, PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_TITLECASE_));
} else if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_SPECIAL_CASING_)) {
// TODO: avoid StringBuffer, put directly into array?
StringBuffer buf = new StringBuffer();
getSpecialUpperCase(ch, index, buf, str, offset,
locale);
Utility.getChars(buf, 0, buf.length(), result, 0);
return buf.length();
} else if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_UPPERCASE_)) {
return UTF16.append(result, 0, PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_UPPERCASE_));
}
}
return -1;
}
/**
* 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.
* For "full", multiple-code point mappings use the API
* foldCase(String str, boolean defaultmapping).
* @param ch the character to be converted
* @param defaultmapping Indicates if all mappings defined in CaseFolding.txt
* is to be used, otherwise the mappings for dotted I
* and dotless i marked with 'I' in CaseFolding.txt will
* be skipped.
* @return the case folding equivalent of the character, if any;
* otherwise the character itself.
* @see #foldCase(String, boolean)
*/
public static int foldCase(int ch, boolean defaultmapping)
{
int props = PROPERTY_DB_.getProperty(ch);
if (!UCharacterPropertyDB.isExceptionIndicator(props)) {
int type = UCharacterPropertyDB.getPropType(props);
if (type == UCharacterCategory.UPPERCASE_LETTER ||
type == UCharacterCategory.TITLECASE_LETTER) {
return ch + UCharacterPropertyDB.getSignedValue(props);
}
}
else {
int index = UCharacterPropertyDB.getExceptionIndex(props);
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_CASE_FOLDING_)) {
int exception = PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_CASE_FOLDING_);
if (exception != 0) {
int foldedcasech =
PROPERTY_DB_.getFoldCase(exception & LAST_CHAR_MASK_);
if (foldedcasech != 0){
return foldedcasech;
}
}
else {
// special case folding mappings, hardcoded
if (defaultmapping &&
(ch == LATIN_SMALL_LETTER_DOTLESS_I_ ||
ch == LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE_)) {
// map dotted I and dotless i to U+0069 small i
return LATIN_SMALL_LETTER_I_;
}
// return ch itself because it is excluded from case folding
return ch;
}
}
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_LOWERCASE_)) {
// not else! - allow to fall through from above
return PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_LOWERCASE_);
}
}
return ch; // no mapping - return the character itself
}
/**
* The given string is mapped to its case folding equivalent according to
* UnicodeData.txt and CaseFolding.txt; if any character has no case folding
* equivalent, the character itself is returned.
* "Full", multiple-code point case folding mappings are returned here.
* For "simple" single-code point mappings use the API
* foldCase(int ch, boolean defaultmapping).
* @param str the String to be converted
* @param defaultmapping Indicates if all mappings defined in CaseFolding.txt
* is to be used, otherwise the mappings for dotted I
* and dotless i marked with 'I' in CaseFolding.txt will
* be skipped.
* @return the case folding equivalent of the character, if any;
* otherwise the character itself.
* @see #foldCase(int, boolean)
*/
public static String foldCase(String str, boolean defaultmapping)
{
int size = str.length();
StringBuffer result = new StringBuffer(size);
int offset = 0;
int ch;
// case mapping loop
while (offset < size) {
ch = UTF16.charAt(str, offset);
offset += UTF16.getCharCount(ch);
int props = PROPERTY_DB_.getProperty(ch);
if (!UCharacterPropertyDB.isExceptionIndicator(props)) {
int type = UCharacterPropertyDB.getPropType(props);
if (type == UCharacterCategory.UPPERCASE_LETTER ||
type == UCharacterCategory.TITLECASE_LETTER) {
ch += UCharacterPropertyDB.getSignedValue(props);
}
}
else {
int index = UCharacterPropertyDB.getExceptionIndex(props);
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_CASE_FOLDING_)) {
int exception = PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_CASE_FOLDING_);
if (exception != 0) {
PROPERTY_DB_.getFoldCase(exception & LAST_CHAR_MASK_,
exception >> SHIFT_24_, result);
}
else {
// special case folding mappings, hardcoded
if (defaultmapping &&
(ch == LATIN_SMALL_LETTER_DOTLESS_I_ ||
ch == LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE_)) {
// map dotted I and dotless i to U+0069 small i
result.append(LATIN_SMALL_LETTER_I_);
}
else {
// output c itself because it is excluded from
// case folding
UTF16.append(result, ch);
}
}
// do not fall through to the output of c
continue;
}
else {
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_LOWERCASE_)) {
ch = PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_LOWERCASE_);
}
}
}
// handle 1:1 code point mappings from UnicodeData.txt
UTF16.append(result, ch);
}
return result.toString();
}
/**
* Return numeric value of Han code points.
* <br> This returns the value of Han 'numeric' code points,
* including those for zero, ten, hundred, thousand, ten thousand,
* and hundred million. Unicode does not consider these to be
* numeric. This includes both the standard and 'checkwriting'
* characters, the 'big circle' zero character, and the standard
* zero character.
* @draft
* @param ch code point to query
* @return value if it is a Han 'numeric character,' otherwise return -1.
*/
public static int getHanNumericValue(int ch)
{
switch(ch)
{
case IDEOGRAPHIC_NUMBER_ZERO_ :
case CJK_IDEOGRAPH_COMPLEX_ZERO_ :
return 0; // Han Zero
case CJK_IDEOGRAPH_FIRST_ :
case CJK_IDEOGRAPH_COMPLEX_ONE_ :
return 1; // Han One
case CJK_IDEOGRAPH_SECOND_ :
case CJK_IDEOGRAPH_COMPLEX_TWO_ :
return 2; // Han Two
case CJK_IDEOGRAPH_THIRD_ :
case CJK_IDEOGRAPH_COMPLEX_THREE_ :
return 3; // Han Three
case CJK_IDEOGRAPH_FOURTH_ :
case CJK_IDEOGRAPH_COMPLEX_FOUR_ :
return 4; // Han Four
case CJK_IDEOGRAPH_FIFTH_ :
case CJK_IDEOGRAPH_COMPLEX_FIVE_ :
return 5; // Han Five
case CJK_IDEOGRAPH_SIXTH_ :
case CJK_IDEOGRAPH_COMPLEX_SIX_ :
return 6; // Han Six
case CJK_IDEOGRAPH_SEVENTH_ :
case CJK_IDEOGRAPH_COMPLEX_SEVEN_ :
return 7; // Han Seven
case CJK_IDEOGRAPH_EIGHTH_ :
case CJK_IDEOGRAPH_COMPLEX_EIGHT_ :
return 8; // Han Eight
case CJK_IDEOGRAPH_NINETH_ :
case CJK_IDEOGRAPH_COMPLEX_NINE_ :
return 9; // Han Nine
case CJK_IDEOGRAPH_TEN_ :
case CJK_IDEOGRAPH_COMPLEX_TEN_ :
return 10;
case CJK_IDEOGRAPH_HUNDRED_ :
case CJK_IDEOGRAPH_COMPLEX_HUNDRED_ :
return 100;
case CJK_IDEOGRAPH_THOUSAND_ :
case CJK_IDEOGRAPH_COMPLEX_THOUSAND_ :
return 1000;
case CJK_IDEOGRAPH_TEN_THOUSAND_ :
return 10000;
case CJK_IDEOGRAPH_HUNDRED_MILLION_ :
return 100000000;
}
return -1; // no value
}
// protected variables ===================================
/**
* Shift and mask value for surrogates
*/
protected static final int LEAD_SURROGATE_SHIFT_ = 10;
protected static final int TRAIL_SURROGATE_MASK_ = 0x3FF;
// protected methods ====================================================
/**
* Forms a supplementary code point from the argument character<br>
* Note this is for internal use hence no checks for the validity of the
* surrogate characters are done
* @param lead lead surrogate character
* @param trail trailing surrogate character
* @return code point of the supplementary character
*/
protected static int getRawSupplementary(char lead, char trail)
{
return (lead << LEAD_SURROGATE_SHIFT_) + trail + SURROGATE_OFFSET_;
}
// private variables =====================================
/**
* Database storing the sets of character property
*/
private static final UCharacterPropertyDB PROPERTY_DB_;
/**
* Initialization of the UCharacterPropertyDB instance.
* RuntimeException thrown when data is missing or data has been corrupted.
*/
static
{
try
{
PROPERTY_DB_ = new UCharacterPropertyDB();
}
catch (Exception e)
{
throw new RuntimeException(e.getMessage());
}
}
/**
* Offset to add to combined surrogate pair to avoid msking.
*/
private static final int SURROGATE_OFFSET_ =
SUPPLEMENTARY_MIN_VALUE - (0xD800 << LEAD_SURROGATE_SHIFT_) - 0xDC00;
/**
* Surrogate code point values
*/
private static final int SURROGATE_MIN_VALUE_ = 0xD800;
private static final int SURROGATE_MAX_VALUE_ = 0xDFFF;
/**
* To get the last character out from a data type
*/
private static final int LAST_CHAR_MASK_ = 0xFFFF;
/**
* To get the last byte out from a data type
*/
private static final int LAST_BYTE_MASK_ = 0xFF;
/**
* Shift 16 bits
*/
private static final int SHIFT_16_ = 16;
/**
* Shift 24 bits
*/
private static final int SHIFT_24_ = 24;
/**
* Minimum suffix value that indicates if a character is non character.
* Unicode 3.0 non characters
*/
private static final int NON_CHARACTER_SUFFIX_MIN_3_0_ = 0xFFFE;
/**
* New minimum non character in Unicode 3.1
*/
private static final int NON_CHARACTER_MIN_3_1_ = 0xFDD0;
/**
* New non character range in Unicode 3.1
*/
private static final int NON_CHARACTER_RANGE_3_1_ =
0xFDEF - NON_CHARACTER_MIN_3_1_;
/**
* Decimal radix
*/
private static final int DECIMAL_RADIX_ = 10;
/**
* No break space code point
*/
private static final int NO_BREAK_SPACE_ = 0xA0;
/**
* Narrow no break space code point
*/
private static final int NARROW_NO_BREAK_SPACE_ = 0x202F;
/**
* Zero width no break space code point
*/
private static final int ZERO_WIDTH_NO_BREAK_SPACE_ = 0xFEFF;
/**
* Ideographic number zero code point
*/
private static final int IDEOGRAPHIC_NUMBER_ZERO_ = 0x3007;
/**
* CJK Ideograph, First code point
*/
private static final int CJK_IDEOGRAPH_FIRST_ = 0x4e00;
/**
* CJK Ideograph, Second code point
*/
private static final int CJK_IDEOGRAPH_SECOND_ = 0x4e8c;
/**
* CJK Ideograph, Third code point
*/
private static final int CJK_IDEOGRAPH_THIRD_ = 0x4e09;
/**
* CJK Ideograph, Fourth code point
*/
private static final int CJK_IDEOGRAPH_FOURTH_ = 0x56d8;
/**
* CJK Ideograph, FIFTH code point
*/
private static final int CJK_IDEOGRAPH_FIFTH_ = 0x4e94;
/**
* CJK Ideograph, Sixth code point
*/
private static final int CJK_IDEOGRAPH_SIXTH_ = 0x516d;
/**
* CJK Ideograph, Seventh code point
*/
private static final int CJK_IDEOGRAPH_SEVENTH_ = 0x4e03;
/**
* CJK Ideograph, Eighth code point
*/
private static final int CJK_IDEOGRAPH_EIGHTH_ = 0x516b;
/**
* CJK Ideograph, Nineth code point
*/
private static final int CJK_IDEOGRAPH_NINETH_ = 0x4e5d;
/**
* Application Program command code point
*/
private static final int APPLICATION_PROGRAM_COMMAND_ = 0x009F;
/**
* Unit seperator code point
*/
private static final int UNIT_SEPERATOR_ = 0x001F;
/**
* Delete code point
*/
private static final int DELETE_ = 0x007F;
/**
* Turkish ISO 639 2 character code
*/
private static final String TURKISH_ = "tr";
/**
* Azerbaijani ISO 639 2 character code
*/
private static final String AZERBAIJANI_ = "az";
/**
* Lithuanian ISO 639 2 character code
*/
private static final String LITHUANIAN_ = "lt";
/**
* Latin owercase i
*/
private static final char LATIN_SMALL_LETTER_I_ = 0x69;
/**
* Latin uppercase I
*/
private static final char LATIN_CAPITAL_LETTER_I_ = 0x49;
/**
* Latin capital letter i with dot above
*/
private static final char LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE_ = 0x130;
/**
* Latin small letter i with dot above
*/
private static final char LATIN_SMALL_LETTER_DOTLESS_I_ = 0x131;
/**
* Combining dot above
*/
private static final char COMBINING_DOT_ABOVE_ = 0x307;
/**
* Greek capital letter sigma
*/
private static final char GREEK_CAPITAL_LETTER_SIGMA_ = 0x3a3;
/**
* Greek small letter sigma
*/
private static final char GREEK_SMALL_LETTER_SIGMA_ = 0x3c3;
/**
* Greek small letter rho
*/
private static final char GREEK_SMALL_LETTER_RHO_ = 0x3c2;
/**
* ISO control character first range upper limit 0x0 - 0x1F
*/
private static final int ISO_CONTROL_FIRST_RANGE_MAX_ = 0x1F;
/**
* Han digit characters
*/
private static final int CJK_IDEOGRAPH_COMPLEX_ZERO_ = 0x96f6;
private static final int CJK_IDEOGRAPH_COMPLEX_ONE_ = 0x58f9;
private static final int CJK_IDEOGRAPH_COMPLEX_TWO_ = 0x8cb3;
private static final int CJK_IDEOGRAPH_COMPLEX_THREE_ = 0x53c3;
private static final int CJK_IDEOGRAPH_COMPLEX_FOUR_ = 0x8086;
private static final int CJK_IDEOGRAPH_COMPLEX_FIVE_ = 0x4f0d;
private static final int CJK_IDEOGRAPH_COMPLEX_SIX_ = 0x9678;
private static final int CJK_IDEOGRAPH_COMPLEX_SEVEN_ = 0x67d2;
private static final int CJK_IDEOGRAPH_COMPLEX_EIGHT_ = 0x634c;
private static final int CJK_IDEOGRAPH_COMPLEX_NINE_ = 0x7396;
private static final int CJK_IDEOGRAPH_TEN_ = 0x5341;
private static final int CJK_IDEOGRAPH_COMPLEX_TEN_ = 0x62fe;
private static final int CJK_IDEOGRAPH_HUNDRED_ = 0x767e;
private static final int CJK_IDEOGRAPH_COMPLEX_HUNDRED_ = 0x4f70;
private static final int CJK_IDEOGRAPH_THOUSAND_ = 0x5343;
private static final int CJK_IDEOGRAPH_COMPLEX_THOUSAND_ = 0x4edf;
private static final int CJK_IDEOGRAPH_TEN_THOUSAND_ = 0x824c;
private static final int CJK_IDEOGRAPH_HUNDRED_MILLION_ = 0x5104;
/**
* Hyphens
*/
private static final int HYPHEN_ = 0x2010;
private static final int SOFT_HYPHEN_ = 0xAD;
/**
* LATIN SMALL LETTER J
*/
private static final int LATIN_SMALL_LETTER_J_ = 0x6a;
/**
* LATIN SMALL LETTER I WITH OGONEK
*/
private static final int LATIN_SMALL_LETTER_I_WITH_OGONEK_ = 0x12f;
/**
* LATIN SMALL LETTER I WITH TILDE BELOW
*/
private static final int LATIN_SMALL_LETTER_I_WITH_TILDE_BELOW_ = 0x1e2d;
/**
* LATIN SMALL LETTER I WITH DOT BELOW
*/
private static final int LATIN_SMALL_LETTER_I_WITH_DOT_BELOW_ = 0x1ecb;
/**
* Combining class for combining mark above
*/
private static final int COMBINING_MARK_ABOVE_CLASS_ = 230;
/**
* LATIN CAPITAL LETTER J
*/
private static final int LATIN_CAPITAL_LETTER_J_ = 0x4a;
/**
* LATIN CAPITAL LETTER I WITH OGONEK
*/
private static final int LATIN_CAPITAL_I_WITH_OGONEK_ = 0x12e;
/**
* LATIN CAPITAL LETTER I WITH TILDE
*/
private static final int LATIN_CAPITAL_I_WITH_TILDE_ = 0x128;
/**
* LATIN CAPITAL LETTER I WITH GRAVE
*/
private static final int LATIN_CAPITAL_I_WITH_GRAVE_ = 0xcc;
/**
* LATIN CAPITAL LETTER I WITH ACUTE
*/
private static final int LATIN_CAPITAL_I_WITH_ACUTE_ = 0xcd;
/**
* COMBINING GRAVE ACCENT
*/
private static final int COMBINING_GRAVE_ACCENT_ = 0x300;
/**
* COMBINING ACUTE ACCENT
*/
private static final int COMBINING_ACUTE_ACCENT_ = 0x301;
/**
* COMBINING TILDE
*/
private static final int COMBINING_TILDE_ = 0x303;
// private methods ==============================================
/**
* Gets the correct property information from UCharacterPropertyDB
* @param ch character whose information is to be retrieved
* @return a 32 bit information, returns 0 if no data is found.
*/
private static int getProps(int ch)
{
if (ch >= UCharacter.MIN_VALUE & ch <= UCharacter.MAX_VALUE) {
return PROPERTY_DB_.getProperty(ch);
}
return 0;
}
/**
* Getting the locales used for case mapping
* @param locale to work with
* @return locale which the actual case mapping works with
*/
private static Locale getCaseLocale(Locale locale)
{
String language = locale.getLanguage();
// the locale can have no language
if (language.length() != 2) {
return locale;
}
if (language.equals(TURKISH_) || language.equals(AZERBAIJANI_)) {
return new Locale("tr", "TR");
}
if (language.equals(LITHUANIAN_)) {
return new Locale("lt", "LT");
}
return locale;
}
/**
* In Unicode 3.1.1, an ignorable sequence is a sequence of *zero* or more
* characters from the set {HYPHEN, SOFT HYPHEN, general category = Mn}.
* (Expected to change!)
* @param ch codepoint
* @param cat category of the argument codepoint
* @return true if ch is case ignorable.
*/
private static boolean isIgnorable(int ch, int cat)
{
return cat == UCharacterCategory.NON_SPACING_MARK || ch == HYPHEN_ ||
ch == SOFT_HYPHEN_;
}
/**
* Determines if offset is not followed by a sequence consisting of
* an ignorable sequence and then a cased letter {Ll, Lu, Lt}.
* @param str string to determine
* @param offset offset in string to check
* @return false if any character after index in src is a cased letter
* @see SpecialCasing.txt
*/
private static boolean isCFINAL(String str, int offset)
{
int length = str.length();
offset += UTF16.getCharCount(UTF16.charAt(str, offset));
while (offset < length) {
int ch = UTF16.charAt(str, offset);
int cat = getType(ch);
if (cat == UCharacterCategory.LOWERCASE_LETTER ||
cat == UCharacterCategory.UPPERCASE_LETTER ||
cat == UCharacterCategory.TITLECASE_LETTER) {
return false; // followed by cased letter
}
if (!isIgnorable(ch, cat)) {
return true; // not ignorable
}
offset += UTF16.getCharCount(ch);
}
return true;
}
/**
* Determines if offset is not preceded by a sequence consisting of a cased
* letter {Ll, Lu, Lt} and an ignorable sequence.
* @param str string to determine
* @param offset offset in string to check
* @return true if any character before index in src is a cased letter
* @see SpecialCasing.txt
*/
private static boolean isNotCINITIAL(String str, int offset)
{
offset --;
while (offset >= 0) {
int ch = UTF16.charAt(str, offset);
int cat = getType(ch);
if (cat == UCharacterCategory.LOWERCASE_LETTER ||
cat == UCharacterCategory.UPPERCASE_LETTER ||
cat == UCharacterCategory.TITLECASE_LETTER) {
return true; // preceded by cased letter
}
if (!isIgnorable(ch, cat)) {
return false; // not ignorable
}
offset -= UTF16.getCharCount(ch);
}
return false;
}
/**
* Determines if a string at offset is preceded by any base characters
* { 'i', 'j', U+012f, U+1e2d, U+1ecb } with no intervening character with
* combining class = 230
* @param str string to be determined
* @param offset offset in string to check
* @return true if some characters preceding the offset index belongs to
* the set { 'i', 'j', U+012f, U+1e2d, U+1ecb }
* @see SpecialCasing.txt
*/
private static boolean isAFTER_i(String str, int offset)
{
offset --;
while (offset >= 0) {
int ch = UTF16.charAt(str, offset);
if (ch == LATIN_SMALL_LETTER_I_ || ch == LATIN_SMALL_LETTER_J_ ||
ch == LATIN_SMALL_LETTER_I_WITH_OGONEK_ ||
ch == LATIN_SMALL_LETTER_I_WITH_TILDE_BELOW_ ||
ch == LATIN_SMALL_LETTER_I_WITH_DOT_BELOW_) {
return true; // preceded by TYPE_i
}
int cc = getCombiningClass(ch);
if (cc == 0 || cc == COMBINING_MARK_ABOVE_CLASS_) {
// preceded by different base character not TYPE_i), or
// intervening cc == 230
return false;
}
offset -= UTF16.getCharCount(ch);
}
return false; // not preceded by TYPE_i
}
/**
* Determines if a string at offset is preceded by base characters 'I' with
* no intervening combining class = 230
* @param str string to be determined
* @param offset offset in string to check
* @return true if some characters preceding the offset index is the
* character 'I' with no intervening combining class = 230
* @see SpecialCasing.txt
*/
private static boolean isAFTER_I(String str, int offset)
{
offset --;
while (offset >= 0) {
int ch = UTF16.charAt(str, offset);
if (ch == LATIN_CAPITAL_LETTER_I_) {
return true; // preceded by I
}
int cc = getCombiningClass(ch);
if (cc == 0 || cc == COMBINING_MARK_ABOVE_CLASS_) {
// preceded by different base character (not I), or
// intervening cc == 230
return false;
}
offset -= UTF16.getCharCount(ch);
}
return false; // not preceded by I
}
/**
* Determines if a string at offset is followed by one or more characters
* of combining class = 230.
* @param str string to be determined
* @param offset offset in string to check
* @return true if a string at offset is followed by one or more characters
* of combining class = 230.
* @see SpecialCasing.txt
*/
private static boolean isFollowedByMOREABOVE(String str, int offset)
{
int length = str.length();
offset += UTF16.getCharCount(UTF16.charAt(str, 0));
while (offset < length) {
int ch = UTF16.charAt(str, offset);
int cc = getCombiningClass(ch);
if (cc == COMBINING_MARK_ABOVE_CLASS_) {
return true; // at least one cc==230 following
}
if (cc == 0) {
return false; // next base character, no more cc==230 following
}
offset += UTF16.getCharCount(ch);
}
return false; // no more cc == 230 following
}
/**
* Determines if a string at offset is followed by a dot above
* with no characters of combining class == 230 in between
* @param str string to be determined
* @param offset offset in string to check
* @return true if a string at offset is followed by oa dot above
* with no characters of combining class == 230 in between
* @see SpecialCasing.txt
*/
private static boolean isFollowedByDotAbove(String str, int offset)
{
int length = str.length();
offset += UTF16.getCharCount(UTF16.charAt(str, 0));
while (offset < length) {
int ch = UTF16.charAt(str, offset);
if (ch == COMBINING_DOT_ABOVE_) {
return true;
}
int cc = getCombiningClass(ch);
if (cc == 0 || cc == COMBINING_MARK_ABOVE_CLASS_) {
return false; // next base character or cc==230 in between
}
offset += UTF16.getCharCount(ch);
}
return false; // no dot above following
}
/**
* Special casing uppercase management
* @param ch code point to convert
* @param index of exception containing special case information
* @param buffer to add uppercase
* @param str original string
* @param offset index of ch in str
* @param tr_az if uppercase is to be made with TURKISH or AZERBAIJANI
* in mind
* @param lt if uppercase is to be made with LITHUANIAN in mind
*/
private static void getSpecialUpperCase(int ch, int index,
StringBuffer buffer, String str,
int offset, Locale locale)
{
int exception = PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_SPECIAL_CASING_);
if (exception < 0) {
String language = locale.getLanguage();
// use hardcoded conditions and mappings
if ((language.equals(TURKISH_) || language.equals(AZERBAIJANI_))
&& ch == LATIN_SMALL_LETTER_I_) {
// turkish: i maps to dotted I
buffer.append(LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE_);
}
else {
if (language.equals(LITHUANIAN_) && ch == COMBINING_DOT_ABOVE_
&& isAFTER_i(str, offset)) {
// lithuanian: remove DOT ABOVE after U+0069 "i" with
// upper or titlecase
return; // remove the dot (continue without output)
}
else {
// no known conditional special case mapping, use a normal
// mapping
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_UPPERCASE_)) {
UTF16.append(buffer, PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_UPPERCASE_));
}
else {
UTF16.append(buffer, ch);
}
}
}
}
else {
// get the special case mapping string from the data file
index = exception & LAST_CHAR_MASK_;
PROPERTY_DB_.getUpperCase(index, buffer);
}
}
/**
* Special casing lowercase management
* @param ch code point to convert
* @param index of exception containing special case information
* @param buffer to add lowercase
* @param str original string
* @param offset index of ch in str
* @param locale current locale
*/
private static void getSpecialLowerCase(int ch, int index,
StringBuffer buffer, String str,
int offset, Locale locale)
{
int exception = PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_SPECIAL_CASING_);
if (exception < 0) {
// fill u and i with the case mapping result string
// use hardcoded conditions and mappings
if (locale.getLanguage().equals(LITHUANIAN_) &&
// base characters, find accents above
(((ch == LATIN_CAPITAL_LETTER_I_ ||
ch == LATIN_CAPITAL_LETTER_J_ ||
ch == LATIN_CAPITAL_I_WITH_OGONEK_) &&
isFollowedByMOREABOVE(str, offset)) ||
// precomposed with accent above, no need to find one
(ch == LATIN_CAPITAL_I_WITH_GRAVE_ ||
ch == LATIN_CAPITAL_I_WITH_ACUTE_ ||
ch == LATIN_CAPITAL_I_WITH_TILDE_))) {
// lithuanian: add a dot above if there are more accents
// above (to always have the dot)
switch(ch) {
case LATIN_CAPITAL_LETTER_I_:
buffer.append((char)LATIN_SMALL_LETTER_I_);
buffer.append((char)COMBINING_DOT_ABOVE_);
break;
case LATIN_CAPITAL_LETTER_J_:
buffer.append((char)LATIN_SMALL_LETTER_J_);
buffer.append((char)COMBINING_DOT_ABOVE_);
break;
case LATIN_CAPITAL_I_WITH_OGONEK_:
buffer.append((char)LATIN_SMALL_LETTER_I_WITH_OGONEK_);
buffer.append((char)COMBINING_DOT_ABOVE_);
break;
case LATIN_CAPITAL_I_WITH_GRAVE_:
buffer.append((char)LATIN_SMALL_LETTER_I_);
buffer.append((char)COMBINING_DOT_ABOVE_);
buffer.append((char)COMBINING_GRAVE_ACCENT_);
break;
case LATIN_CAPITAL_I_WITH_ACUTE_:
buffer.append((char)LATIN_SMALL_LETTER_I_);
buffer.append((char)COMBINING_DOT_ABOVE_);
buffer.append((char)COMBINING_ACUTE_ACCENT_);
break;
case LATIN_CAPITAL_I_WITH_TILDE_:
buffer.append((char)LATIN_SMALL_LETTER_I_);
buffer.append((char)COMBINING_DOT_ABOVE_);
buffer.append((char)COMBINING_TILDE_);
break;
}
/*
Note: This handling of I and of dot above differs from
Unicode 3.1.1's SpecialCasing-5.txt because the AFTER_i
condition there does not work for decomposed I+dot above.
This fix is being proposed to the UTC.
*/
}
else {
String language = locale.getLanguage();
if ((language.equals(TURKISH_) ||
language.equals(AZERBAIJANI_)) &&
ch == LATIN_CAPITAL_LETTER_I_ &&
!isFollowedByDotAbove(str, offset)) {
// turkish: I maps to dotless i
// other languages or turkish with decomposed I+dot above:
// I maps to i
buffer.append(LATIN_SMALL_LETTER_DOTLESS_I_);
}
else {
if (ch == COMBINING_DOT_ABOVE_ &&
isAFTER_I(str, offset) &&
!isFollowedByMOREABOVE(str, offset)) {
// decomposed I+dot above becomes i (see handling of
// U+0049 for turkish) and removes the dot above
return; // remove the dot (continue without output)
}
else {
if (ch == GREEK_CAPITAL_LETTER_SIGMA_ &&
isCFINAL(str, offset) &&
isNotCINITIAL(str, offset)) {
// greek capital sigma maps depending on
// surrounding cased letters
buffer.append(GREEK_SMALL_LETTER_RHO_);
}
else {
// no known conditional special case mapping, use
// a normal mapping
if (PROPERTY_DB_.hasExceptionValue(index,
UCharacterPropertyDB.EXC_LOWERCASE_)) {
UTF16.append(buffer,
PROPERTY_DB_.getException(index,
UCharacterPropertyDB.EXC_LOWERCASE_));
}
else {
UTF16.append(buffer, ch);
}
}
}
}
}
}
else {
// get the special case mapping string from the data file
index = exception & LAST_CHAR_MASK_;
PROPERTY_DB_.getLowerCase(index, buffer);
}
}
/**
* Determines if codepoint is a non character
* @param ch codepoint
* @return true if codepoint is a non character false otherwise
*/
private static boolean isNonCharacter(int ch)
{
if ((ch & LAST_CHAR_MASK_) >= NON_CHARACTER_SUFFIX_MIN_3_0_) {
return true;
}
int difference = ch - NON_CHARACTER_MIN_3_1_;
return difference >= 0 && difference <= NON_CHARACTER_RANGE_3_1_;
}
}