--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/lang/Character.java Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,4502 @@
+/*
+ * Copyright 2002-2006 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package java.lang;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Locale;
+
+/**
+ * The <code>Character</code> class wraps a value of the primitive
+ * type <code>char</code> in an object. An object of type
+ * <code>Character</code> contains a single field whose type is
+ * <code>char</code>.
+ * <p>
+ * In addition, this class provides several methods for determining
+ * a character's category (lowercase letter, digit, etc.) and for converting
+ * characters from uppercase to lowercase and vice versa.
+ * <p>
+ * Character information is based on the Unicode Standard, version 4.0.
+ * <p>
+ * The methods and data of class <code>Character</code> are defined by
+ * the information in the <i>UnicodeData</i> file that is part of the
+ * Unicode Character Database maintained by the Unicode
+ * Consortium. This file specifies various properties including name
+ * and general category for every defined Unicode code point or
+ * character range.
+ * <p>
+ * The file and its description are available from the Unicode Consortium at:
+ * <ul>
+ * <li><a href="http://www.unicode.org">http://www.unicode.org</a>
+ * </ul>
+ *
+ * <h4><a name="unicode">Unicode Character Representations</a></h4>
+ *
+ * <p>The <code>char</code> data type (and therefore the value that a
+ * <code>Character</code> object encapsulates) are based on the
+ * original Unicode specification, which defined characters as
+ * fixed-width 16-bit entities. The Unicode standard has since been
+ * changed to allow for characters whose representation requires more
+ * than 16 bits. The range of legal <em>code point</em>s is now
+ * U+0000 to U+10FFFF, known as <em>Unicode scalar value</em>.
+ * (Refer to the <a
+ * href="http://www.unicode.org/reports/tr27/#notation"><i>
+ * definition</i></a> of the U+<i>n</i> notation in the Unicode
+ * standard.)
+ *
+ * <p>The set of characters from U+0000 to U+FFFF is sometimes
+ * referred to as the <em>Basic Multilingual Plane (BMP)</em>. <a
+ * name="supplementary">Characters</a> whose code points are greater
+ * than U+FFFF are called <em>supplementary character</em>s. The Java
+ * 2 platform uses the UTF-16 representation in <code>char</code>
+ * arrays and in the <code>String</code> and <code>StringBuffer</code>
+ * classes. In this representation, supplementary characters are
+ * represented as a pair of <code>char</code> values, the first from
+ * the <em>high-surrogates</em> range, (\uD800-\uDBFF), the
+ * second from the <em>low-surrogates</em> range
+ * (\uDC00-\uDFFF).
+ *
+ * <p>A <code>char</code> value, therefore, represents Basic
+ * Multilingual Plane (BMP) code points, including the surrogate
+ * code points, or code units of the UTF-16 encoding. An
+ * <code>int</code> value represents all Unicode code points,
+ * including supplementary code points. The lower (least significant)
+ * 21 bits of <code>int</code> are used to represent Unicode code
+ * points and the upper (most significant) 11 bits must be zero.
+ * Unless otherwise specified, the behavior with respect to
+ * supplementary characters and surrogate <code>char</code> values is
+ * as follows:
+ *
+ * <ul>
+ * <li>The methods that only accept a <code>char</code> value cannot support
+ * supplementary characters. They treat <code>char</code> values from the
+ * surrogate ranges as undefined characters. For example,
+ * <code>Character.isLetter('\uD840')</code> returns <code>false</code>, even though
+ * this specific value if followed by any low-surrogate value in a string
+ * would represent a letter.
+ *
+ * <li>The methods that accept an <code>int</code> value support all
+ * Unicode characters, including supplementary characters. For
+ * example, <code>Character.isLetter(0x2F81A)</code> returns
+ * <code>true</code> because the code point value represents a letter
+ * (a CJK ideograph).
+ * </ul>
+ *
+ * <p>In the Java SE API documentation, <em>Unicode code point</em> is
+ * used for character values in the range between U+0000 and U+10FFFF,
+ * and <em>Unicode code unit</em> is used for 16-bit
+ * <code>char</code> values that are code units of the <em>UTF-16</em>
+ * encoding. For more information on Unicode terminology, refer to the
+ * <a href="http://www.unicode.org/glossary/">Unicode Glossary</a>.
+ *
+ * @author Lee Boynton
+ * @author Guy Steele
+ * @author Akira Tanaka
+ * @since 1.0
+ */
+public final
+class Character extends Object implements java.io.Serializable, Comparable<Character> {
+ /**
+ * 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
+ * <code>digit</code> method, the <code>forDigit</code>
+ * method, and the <code>toString</code> method of class
+ * <code>Integer</code>.
+ *
+ * @see java.lang.Character#digit(char, int)
+ * @see java.lang.Character#forDigit(int, int)
+ * @see java.lang.Integer#toString(int, int)
+ * @see java.lang.Integer#valueOf(java.lang.String)
+ */
+ public static final int 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
+ * <code>digit</code> method, the <code>forDigit</code>
+ * method, and the <code>toString</code> method of class
+ * <code>Integer</code>.
+ *
+ * @see java.lang.Character#digit(char, int)
+ * @see java.lang.Character#forDigit(int, int)
+ * @see java.lang.Integer#toString(int, int)
+ * @see java.lang.Integer#valueOf(java.lang.String)
+ */
+ public static final int MAX_RADIX = 36;
+
+ /**
+ * The constant value of this field is the smallest value of type
+ * <code>char</code>, <code>'\u0000'</code>.
+ *
+ * @since 1.0.2
+ */
+ public static final char MIN_VALUE = '\u0000';
+
+ /**
+ * The constant value of this field is the largest value of type
+ * <code>char</code>, <code>'\uFFFF'</code>.
+ *
+ * @since 1.0.2
+ */
+ public static final char MAX_VALUE = '\uffff';
+
+ /**
+ * The <code>Class</code> instance representing the primitive type
+ * <code>char</code>.
+ *
+ * @since 1.1
+ */
+ public static final Class<Character> TYPE = Class.getPrimitiveClass("char");
+
+ /*
+ * Normative general types
+ */
+
+ /*
+ * General character types
+ */
+
+ /**
+ * General category "Cn" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ UNASSIGNED = 0;
+
+ /**
+ * General category "Lu" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ UPPERCASE_LETTER = 1;
+
+ /**
+ * General category "Ll" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ LOWERCASE_LETTER = 2;
+
+ /**
+ * General category "Lt" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ TITLECASE_LETTER = 3;
+
+ /**
+ * General category "Lm" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ MODIFIER_LETTER = 4;
+
+ /**
+ * General category "Lo" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ OTHER_LETTER = 5;
+
+ /**
+ * General category "Mn" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ NON_SPACING_MARK = 6;
+
+ /**
+ * General category "Me" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ ENCLOSING_MARK = 7;
+
+ /**
+ * General category "Mc" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ COMBINING_SPACING_MARK = 8;
+
+ /**
+ * General category "Nd" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ DECIMAL_DIGIT_NUMBER = 9;
+
+ /**
+ * General category "Nl" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ LETTER_NUMBER = 10;
+
+ /**
+ * General category "No" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ OTHER_NUMBER = 11;
+
+ /**
+ * General category "Zs" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ SPACE_SEPARATOR = 12;
+
+ /**
+ * General category "Zl" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ LINE_SEPARATOR = 13;
+
+ /**
+ * General category "Zp" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ PARAGRAPH_SEPARATOR = 14;
+
+ /**
+ * General category "Cc" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ CONTROL = 15;
+
+ /**
+ * General category "Cf" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ FORMAT = 16;
+
+ /**
+ * General category "Co" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ PRIVATE_USE = 18;
+
+ /**
+ * General category "Cs" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ SURROGATE = 19;
+
+ /**
+ * General category "Pd" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ DASH_PUNCTUATION = 20;
+
+ /**
+ * General category "Ps" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ START_PUNCTUATION = 21;
+
+ /**
+ * General category "Pe" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ END_PUNCTUATION = 22;
+
+ /**
+ * General category "Pc" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ CONNECTOR_PUNCTUATION = 23;
+
+ /**
+ * General category "Po" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ OTHER_PUNCTUATION = 24;
+
+ /**
+ * General category "Sm" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ MATH_SYMBOL = 25;
+
+ /**
+ * General category "Sc" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ CURRENCY_SYMBOL = 26;
+
+ /**
+ * General category "Sk" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ MODIFIER_SYMBOL = 27;
+
+ /**
+ * General category "So" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte
+ OTHER_SYMBOL = 28;
+
+ /**
+ * General category "Pi" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte
+ INITIAL_QUOTE_PUNCTUATION = 29;
+
+ /**
+ * General category "Pf" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte
+ FINAL_QUOTE_PUNCTUATION = 30;
+
+ /**
+ * Error flag. Use int (code point) to avoid confusion with U+FFFF.
+ */
+ static final int ERROR = 0xFFFFFFFF;
+
+
+ /**
+ * Undefined bidirectional character type. Undefined <code>char</code>
+ * values have undefined directionality in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_UNDEFINED = -1;
+
+ /**
+ * Strong bidirectional character type "L" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_LEFT_TO_RIGHT = 0;
+
+ /**
+ * Strong bidirectional character type "R" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_RIGHT_TO_LEFT = 1;
+
+ /**
+ * Strong bidirectional character type "AL" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC = 2;
+
+ /**
+ * Weak bidirectional character type "EN" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_EUROPEAN_NUMBER = 3;
+
+ /**
+ * Weak bidirectional character type "ES" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR = 4;
+
+ /**
+ * Weak bidirectional character type "ET" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR = 5;
+
+ /**
+ * Weak bidirectional character type "AN" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_ARABIC_NUMBER = 6;
+
+ /**
+ * Weak bidirectional character type "CS" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR = 7;
+
+ /**
+ * Weak bidirectional character type "NSM" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_NONSPACING_MARK = 8;
+
+ /**
+ * Weak bidirectional character type "BN" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_BOUNDARY_NEUTRAL = 9;
+
+ /**
+ * Neutral bidirectional character type "B" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_PARAGRAPH_SEPARATOR = 10;
+
+ /**
+ * Neutral bidirectional character type "S" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_SEGMENT_SEPARATOR = 11;
+
+ /**
+ * Neutral bidirectional character type "WS" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_WHITESPACE = 12;
+
+ /**
+ * Neutral bidirectional character type "ON" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_OTHER_NEUTRALS = 13;
+
+ /**
+ * Strong bidirectional character type "LRE" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING = 14;
+
+ /**
+ * Strong bidirectional character type "LRO" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE = 15;
+
+ /**
+ * Strong bidirectional character type "RLE" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING = 16;
+
+ /**
+ * Strong bidirectional character type "RLO" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE = 17;
+
+ /**
+ * Weak bidirectional character type "PDF" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT = 18;
+
+ /**
+ * The minimum value of a Unicode high-surrogate code unit in the
+ * UTF-16 encoding. A high-surrogate is also known as a
+ * <i>leading-surrogate</i>.
+ *
+ * @since 1.5
+ */
+ public static final char MIN_HIGH_SURROGATE = '\uD800';
+
+ /**
+ * The maximum value of a Unicode high-surrogate code unit in the
+ * UTF-16 encoding. A high-surrogate is also known as a
+ * <i>leading-surrogate</i>.
+ *
+ * @since 1.5
+ */
+ public static final char MAX_HIGH_SURROGATE = '\uDBFF';
+
+ /**
+ * The minimum value of a Unicode low-surrogate code unit in the
+ * UTF-16 encoding. A low-surrogate is also known as a
+ * <i>trailing-surrogate</i>.
+ *
+ * @since 1.5
+ */
+ public static final char MIN_LOW_SURROGATE = '\uDC00';
+
+ /**
+ * The maximum value of a Unicode low-surrogate code unit in the
+ * UTF-16 encoding. A low-surrogate is also known as a
+ * <i>trailing-surrogate</i>.
+ *
+ * @since 1.5
+ */
+ public static final char MAX_LOW_SURROGATE = '\uDFFF';
+
+ /**
+ * The minimum value of a Unicode surrogate code unit in the UTF-16 encoding.
+ *
+ * @since 1.5
+ */
+ public static final char MIN_SURROGATE = MIN_HIGH_SURROGATE;
+
+ /**
+ * The maximum value of a Unicode surrogate code unit in the UTF-16 encoding.
+ *
+ * @since 1.5
+ */
+ public static final char MAX_SURROGATE = MAX_LOW_SURROGATE;
+
+ /**
+ * The minimum value of a supplementary code point.
+ *
+ * @since 1.5
+ */
+ public static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x010000;
+
+ /**
+ * The minimum value of a Unicode code point.
+ *
+ * @since 1.5
+ */
+ public static final int MIN_CODE_POINT = 0x000000;
+
+ /**
+ * The maximum value of a Unicode code point.
+ *
+ * @since 1.5
+ */
+ public static final int MAX_CODE_POINT = 0x10ffff;
+
+
+ /**
+ * Instances of this class represent particular subsets of the Unicode
+ * character set. The only family of subsets defined in the
+ * <code>Character</code> class is <code>{@link Character.UnicodeBlock
+ * UnicodeBlock}</code>. Other portions of the Java API may define other
+ * subsets for their own purposes.
+ *
+ * @since 1.2
+ */
+ public static class Subset {
+
+ private String name;
+
+ /**
+ * Constructs a new <code>Subset</code> instance.
+ *
+ * @exception NullPointerException if name is <code>null</code>
+ * @param name The name of this subset
+ */
+ protected Subset(String name) {
+ if (name == null) {
+ throw new NullPointerException("name");
+ }
+ this.name = name;
+ }
+
+ /**
+ * Compares two <code>Subset</code> objects for equality.
+ * This method returns <code>true</code> if and only if
+ * <code>this</code> and the argument refer to the same
+ * object; since this method is <code>final</code>, this
+ * guarantee holds for all subclasses.
+ */
+ public final boolean equals(Object obj) {
+ return (this == obj);
+ }
+
+ /**
+ * Returns the standard hash code as defined by the
+ * <code>{@link Object#hashCode}</code> method. This method
+ * is <code>final</code> in order to ensure that the
+ * <code>equals</code> and <code>hashCode</code> methods will
+ * be consistent in all subclasses.
+ */
+ public final int hashCode() {
+ return super.hashCode();
+ }
+
+ /**
+ * Returns the name of this subset.
+ */
+ public final String toString() {
+ return name;
+ }
+ }
+
+ /**
+ * A family of character subsets representing the character blocks in the
+ * Unicode specification. Character blocks generally define characters
+ * used for a specific script or purpose. A character is contained by
+ * at most one Unicode block.
+ *
+ * @since 1.2
+ */
+ public static final class UnicodeBlock extends Subset {
+
+ private static Map map = new HashMap();
+
+ /**
+ * Create a UnicodeBlock with the given identifier name.
+ * This name must be the same as the block identifier.
+ */
+ private UnicodeBlock(String idName) {
+ super(idName);
+ map.put(idName.toUpperCase(Locale.US), this);
+ }
+
+ /**
+ * Create a UnicodeBlock with the given identifier name and
+ * alias name.
+ */
+ private UnicodeBlock(String idName, String alias) {
+ this(idName);
+ map.put(alias.toUpperCase(Locale.US), this);
+ }
+
+ /**
+ * Create a UnicodeBlock with the given identifier name and
+ * alias names.
+ */
+ private UnicodeBlock(String idName, String[] aliasName) {
+ this(idName);
+ if (aliasName != null) {
+ for(int x=0; x<aliasName.length; ++x) {
+ map.put(aliasName[x].toUpperCase(Locale.US), this);
+ }
+ }
+ }
+
+ /**
+ * Constant for the "Basic Latin" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock BASIC_LATIN =
+ new UnicodeBlock("BASIC_LATIN", new String[] {"Basic Latin", "BasicLatin" });
+
+ /**
+ * Constant for the "Latin-1 Supplement" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock LATIN_1_SUPPLEMENT =
+ new UnicodeBlock("LATIN_1_SUPPLEMENT", new String[]{ "Latin-1 Supplement", "Latin-1Supplement"});
+
+ /**
+ * Constant for the "Latin Extended-A" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock LATIN_EXTENDED_A =
+ new UnicodeBlock("LATIN_EXTENDED_A", new String[]{ "Latin Extended-A", "LatinExtended-A"});
+
+ /**
+ * Constant for the "Latin Extended-B" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock LATIN_EXTENDED_B =
+ new UnicodeBlock("LATIN_EXTENDED_B", new String[] {"Latin Extended-B", "LatinExtended-B"});
+
+ /**
+ * Constant for the "IPA Extensions" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock IPA_EXTENSIONS =
+ new UnicodeBlock("IPA_EXTENSIONS", new String[] {"IPA Extensions", "IPAExtensions"});
+
+ /**
+ * Constant for the "Spacing Modifier Letters" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock SPACING_MODIFIER_LETTERS =
+ new UnicodeBlock("SPACING_MODIFIER_LETTERS", new String[] { "Spacing Modifier Letters",
+ "SpacingModifierLetters"});
+
+ /**
+ * Constant for the "Combining Diacritical Marks" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock COMBINING_DIACRITICAL_MARKS =
+ new UnicodeBlock("COMBINING_DIACRITICAL_MARKS", new String[] {"Combining Diacritical Marks",
+ "CombiningDiacriticalMarks" });
+
+ /**
+ * Constant for the "Greek and Coptic" Unicode character block.
+ * <p>
+ * This block was previously known as the "Greek" block.
+ *
+ * @since 1.2
+ */
+ public static final UnicodeBlock GREEK
+ = new UnicodeBlock("GREEK", new String[] {"Greek and Coptic", "GreekandCoptic"});
+
+ /**
+ * Constant for the "Cyrillic" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CYRILLIC =
+ new UnicodeBlock("CYRILLIC");
+
+ /**
+ * Constant for the "Armenian" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ARMENIAN =
+ new UnicodeBlock("ARMENIAN");
+
+ /**
+ * Constant for the "Hebrew" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock HEBREW =
+ new UnicodeBlock("HEBREW");
+
+ /**
+ * Constant for the "Arabic" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ARABIC =
+ new UnicodeBlock("ARABIC");
+
+ /**
+ * Constant for the "Devanagari" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock DEVANAGARI =
+ new UnicodeBlock("DEVANAGARI");
+
+ /**
+ * Constant for the "Bengali" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock BENGALI =
+ new UnicodeBlock("BENGALI");
+
+ /**
+ * Constant for the "Gurmukhi" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock GURMUKHI =
+ new UnicodeBlock("GURMUKHI");
+
+ /**
+ * Constant for the "Gujarati" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock GUJARATI =
+ new UnicodeBlock("GUJARATI");
+
+ /**
+ * Constant for the "Oriya" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ORIYA =
+ new UnicodeBlock("ORIYA");
+
+ /**
+ * Constant for the "Tamil" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock TAMIL =
+ new UnicodeBlock("TAMIL");
+
+ /**
+ * Constant for the "Telugu" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock TELUGU =
+ new UnicodeBlock("TELUGU");
+
+ /**
+ * Constant for the "Kannada" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock KANNADA =
+ new UnicodeBlock("KANNADA");
+
+ /**
+ * Constant for the "Malayalam" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock MALAYALAM =
+ new UnicodeBlock("MALAYALAM");
+
+ /**
+ * Constant for the "Thai" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock THAI =
+ new UnicodeBlock("THAI");
+
+ /**
+ * Constant for the "Lao" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock LAO =
+ new UnicodeBlock("LAO");
+
+ /**
+ * Constant for the "Tibetan" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock TIBETAN =
+ new UnicodeBlock("TIBETAN");
+
+ /**
+ * Constant for the "Georgian" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock GEORGIAN =
+ new UnicodeBlock("GEORGIAN");
+
+ /**
+ * Constant for the "Hangul Jamo" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock HANGUL_JAMO =
+ new UnicodeBlock("HANGUL_JAMO", new String[] {"Hangul Jamo", "HangulJamo"});
+
+ /**
+ * Constant for the "Latin Extended Additional" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock LATIN_EXTENDED_ADDITIONAL =
+ new UnicodeBlock("LATIN_EXTENDED_ADDITIONAL", new String[] {"Latin Extended Additional",
+ "LatinExtendedAdditional"});
+
+ /**
+ * Constant for the "Greek Extended" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock GREEK_EXTENDED =
+ new UnicodeBlock("GREEK_EXTENDED", new String[] {"Greek Extended", "GreekExtended"});
+
+ /**
+ * Constant for the "General Punctuation" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock GENERAL_PUNCTUATION =
+ new UnicodeBlock("GENERAL_PUNCTUATION", new String[] {"General Punctuation", "GeneralPunctuation"});
+
+ /**
+ * Constant for the "Superscripts and Subscripts" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock SUPERSCRIPTS_AND_SUBSCRIPTS =
+ new UnicodeBlock("SUPERSCRIPTS_AND_SUBSCRIPTS", new String[] {"Superscripts and Subscripts",
+ "SuperscriptsandSubscripts" });
+
+ /**
+ * Constant for the "Currency Symbols" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CURRENCY_SYMBOLS =
+ new UnicodeBlock("CURRENCY_SYMBOLS", new String[] { "Currency Symbols", "CurrencySymbols"});
+
+ /**
+ * Constant for the "Combining Diacritical Marks for Symbols" Unicode character block.
+ * <p>
+ * This block was previously known as "Combining Marks for Symbols".
+ * @since 1.2
+ */
+ public static final UnicodeBlock COMBINING_MARKS_FOR_SYMBOLS =
+ new UnicodeBlock("COMBINING_MARKS_FOR_SYMBOLS", new String[] {"Combining Diacritical Marks for Symbols",
+ "CombiningDiacriticalMarksforSymbols",
+ "Combining Marks for Symbols",
+ "CombiningMarksforSymbols" });
+
+ /**
+ * Constant for the "Letterlike Symbols" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock LETTERLIKE_SYMBOLS =
+ new UnicodeBlock("LETTERLIKE_SYMBOLS", new String[] { "Letterlike Symbols", "LetterlikeSymbols"});
+
+ /**
+ * Constant for the "Number Forms" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock NUMBER_FORMS =
+ new UnicodeBlock("NUMBER_FORMS", new String[] {"Number Forms", "NumberForms"});
+
+ /**
+ * Constant for the "Arrows" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ARROWS =
+ new UnicodeBlock("ARROWS");
+
+ /**
+ * Constant for the "Mathematical Operators" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock MATHEMATICAL_OPERATORS =
+ new UnicodeBlock("MATHEMATICAL_OPERATORS", new String[] {"Mathematical Operators",
+ "MathematicalOperators"});
+
+ /**
+ * Constant for the "Miscellaneous Technical" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock MISCELLANEOUS_TECHNICAL =
+ new UnicodeBlock("MISCELLANEOUS_TECHNICAL", new String[] {"Miscellaneous Technical",
+ "MiscellaneousTechnical"});
+
+ /**
+ * Constant for the "Control Pictures" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CONTROL_PICTURES =
+ new UnicodeBlock("CONTROL_PICTURES", new String[] {"Control Pictures", "ControlPictures"});
+
+ /**
+ * Constant for the "Optical Character Recognition" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock OPTICAL_CHARACTER_RECOGNITION =
+ new UnicodeBlock("OPTICAL_CHARACTER_RECOGNITION", new String[] {"Optical Character Recognition",
+ "OpticalCharacterRecognition"});
+
+ /**
+ * Constant for the "Enclosed Alphanumerics" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ENCLOSED_ALPHANUMERICS =
+ new UnicodeBlock("ENCLOSED_ALPHANUMERICS", new String[] {"Enclosed Alphanumerics",
+ "EnclosedAlphanumerics"});
+
+ /**
+ * Constant for the "Box Drawing" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock BOX_DRAWING =
+ new UnicodeBlock("BOX_DRAWING", new String[] {"Box Drawing", "BoxDrawing"});
+
+ /**
+ * Constant for the "Block Elements" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock BLOCK_ELEMENTS =
+ new UnicodeBlock("BLOCK_ELEMENTS", new String[] {"Block Elements", "BlockElements"});
+
+ /**
+ * Constant for the "Geometric Shapes" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock GEOMETRIC_SHAPES =
+ new UnicodeBlock("GEOMETRIC_SHAPES", new String[] {"Geometric Shapes", "GeometricShapes"});
+
+ /**
+ * Constant for the "Miscellaneous Symbols" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock MISCELLANEOUS_SYMBOLS =
+ new UnicodeBlock("MISCELLANEOUS_SYMBOLS", new String[] {"Miscellaneous Symbols",
+ "MiscellaneousSymbols"});
+
+ /**
+ * Constant for the "Dingbats" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock DINGBATS =
+ new UnicodeBlock("DINGBATS");
+
+ /**
+ * Constant for the "CJK Symbols and Punctuation" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CJK_SYMBOLS_AND_PUNCTUATION =
+ new UnicodeBlock("CJK_SYMBOLS_AND_PUNCTUATION", new String[] {"CJK Symbols and Punctuation",
+ "CJKSymbolsandPunctuation"});
+
+ /**
+ * Constant for the "Hiragana" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock HIRAGANA =
+ new UnicodeBlock("HIRAGANA");
+
+ /**
+ * Constant for the "Katakana" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock KATAKANA =
+ new UnicodeBlock("KATAKANA");
+
+ /**
+ * Constant for the "Bopomofo" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock BOPOMOFO =
+ new UnicodeBlock("BOPOMOFO");
+
+ /**
+ * Constant for the "Hangul Compatibility Jamo" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock HANGUL_COMPATIBILITY_JAMO =
+ new UnicodeBlock("HANGUL_COMPATIBILITY_JAMO", new String[] {"Hangul Compatibility Jamo",
+ "HangulCompatibilityJamo"});
+
+ /**
+ * Constant for the "Kanbun" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock KANBUN =
+ new UnicodeBlock("KANBUN");
+
+ /**
+ * Constant for the "Enclosed CJK Letters and Months" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ENCLOSED_CJK_LETTERS_AND_MONTHS =
+ new UnicodeBlock("ENCLOSED_CJK_LETTERS_AND_MONTHS", new String[] {"Enclosed CJK Letters and Months",
+ "EnclosedCJKLettersandMonths"});
+
+ /**
+ * Constant for the "CJK Compatibility" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CJK_COMPATIBILITY =
+ new UnicodeBlock("CJK_COMPATIBILITY", new String[] {"CJK Compatibility", "CJKCompatibility"});
+
+ /**
+ * Constant for the "CJK Unified Ideographs" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS =
+ new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS", new String[] {"CJK Unified Ideographs",
+ "CJKUnifiedIdeographs"});
+
+ /**
+ * Constant for the "Hangul Syllables" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock HANGUL_SYLLABLES =
+ new UnicodeBlock("HANGUL_SYLLABLES", new String[] {"Hangul Syllables", "HangulSyllables"});
+
+ /**
+ * Constant for the "Private Use Area" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock PRIVATE_USE_AREA =
+ new UnicodeBlock("PRIVATE_USE_AREA", new String[] {"Private Use Area", "PrivateUseArea"});
+
+ /**
+ * Constant for the "CJK Compatibility Ideographs" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CJK_COMPATIBILITY_IDEOGRAPHS =
+ new UnicodeBlock("CJK_COMPATIBILITY_IDEOGRAPHS",
+ new String[] {"CJK Compatibility Ideographs",
+ "CJKCompatibilityIdeographs"});
+
+ /**
+ * Constant for the "Alphabetic Presentation Forms" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ALPHABETIC_PRESENTATION_FORMS =
+ new UnicodeBlock("ALPHABETIC_PRESENTATION_FORMS", new String[] {"Alphabetic Presentation Forms",
+ "AlphabeticPresentationForms"});
+
+ /**
+ * Constant for the "Arabic Presentation Forms-A" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ARABIC_PRESENTATION_FORMS_A =
+ new UnicodeBlock("ARABIC_PRESENTATION_FORMS_A", new String[] {"Arabic Presentation Forms-A",
+ "ArabicPresentationForms-A"});
+
+ /**
+ * Constant for the "Combining Half Marks" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock COMBINING_HALF_MARKS =
+ new UnicodeBlock("COMBINING_HALF_MARKS", new String[] {"Combining Half Marks",
+ "CombiningHalfMarks"});
+
+ /**
+ * Constant for the "CJK Compatibility Forms" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CJK_COMPATIBILITY_FORMS =
+ new UnicodeBlock("CJK_COMPATIBILITY_FORMS", new String[] {"CJK Compatibility Forms",
+ "CJKCompatibilityForms"});
+
+ /**
+ * Constant for the "Small Form Variants" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock SMALL_FORM_VARIANTS =
+ new UnicodeBlock("SMALL_FORM_VARIANTS", new String[] {"Small Form Variants",
+ "SmallFormVariants"});
+
+ /**
+ * Constant for the "Arabic Presentation Forms-B" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ARABIC_PRESENTATION_FORMS_B =
+ new UnicodeBlock("ARABIC_PRESENTATION_FORMS_B", new String[] {"Arabic Presentation Forms-B",
+ "ArabicPresentationForms-B"});
+
+ /**
+ * Constant for the "Halfwidth and Fullwidth Forms" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock HALFWIDTH_AND_FULLWIDTH_FORMS =
+ new UnicodeBlock("HALFWIDTH_AND_FULLWIDTH_FORMS",
+ new String[] {"Halfwidth and Fullwidth Forms",
+ "HalfwidthandFullwidthForms"});
+
+ /**
+ * Constant for the "Specials" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock SPECIALS =
+ new UnicodeBlock("SPECIALS");
+
+ /**
+ * @deprecated As of J2SE 5, use {@link #HIGH_SURROGATES},
+ * {@link #HIGH_PRIVATE_USE_SURROGATES}, and
+ * {@link #LOW_SURROGATES}. These new constants match
+ * the block definitions of the Unicode Standard.
+ * The {@link #of(char)} and {@link #of(int)} methods
+ * return the new constants, not SURROGATES_AREA.
+ */
+ @Deprecated
+ public static final UnicodeBlock SURROGATES_AREA =
+ new UnicodeBlock("SURROGATES_AREA");
+
+ /**
+ * Constant for the "Syriac" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock SYRIAC =
+ new UnicodeBlock("SYRIAC");
+
+ /**
+ * Constant for the "Thaana" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock THAANA =
+ new UnicodeBlock("THAANA");
+
+ /**
+ * Constant for the "Sinhala" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock SINHALA =
+ new UnicodeBlock("SINHALA");
+
+ /**
+ * Constant for the "Myanmar" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock MYANMAR =
+ new UnicodeBlock("MYANMAR");
+
+ /**
+ * Constant for the "Ethiopic" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock ETHIOPIC =
+ new UnicodeBlock("ETHIOPIC");
+
+ /**
+ * Constant for the "Cherokee" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock CHEROKEE =
+ new UnicodeBlock("CHEROKEE");
+
+ /**
+ * Constant for the "Unified Canadian Aboriginal Syllabics" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS =
+ new UnicodeBlock("UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS",
+ new String[] {"Unified Canadian Aboriginal Syllabics",
+ "UnifiedCanadianAboriginalSyllabics"});
+
+ /**
+ * Constant for the "Ogham" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock OGHAM =
+ new UnicodeBlock("OGHAM");
+
+ /**
+ * Constant for the "Runic" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock RUNIC =
+ new UnicodeBlock("RUNIC");
+
+ /**
+ * Constant for the "Khmer" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock KHMER =
+ new UnicodeBlock("KHMER");
+
+ /**
+ * Constant for the "Mongolian" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock MONGOLIAN =
+ new UnicodeBlock("MONGOLIAN");
+
+ /**
+ * Constant for the "Braille Patterns" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock BRAILLE_PATTERNS =
+ new UnicodeBlock("BRAILLE_PATTERNS", new String[] {"Braille Patterns",
+ "BraillePatterns"});
+
+ /**
+ * Constant for the "CJK Radicals Supplement" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock CJK_RADICALS_SUPPLEMENT =
+ new UnicodeBlock("CJK_RADICALS_SUPPLEMENT", new String[] {"CJK Radicals Supplement",
+ "CJKRadicalsSupplement"});
+
+ /**
+ * Constant for the "Kangxi Radicals" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock KANGXI_RADICALS =
+ new UnicodeBlock("KANGXI_RADICALS", new String[] {"Kangxi Radicals", "KangxiRadicals"});
+
+ /**
+ * Constant for the "Ideographic Description Characters" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock IDEOGRAPHIC_DESCRIPTION_CHARACTERS =
+ new UnicodeBlock("IDEOGRAPHIC_DESCRIPTION_CHARACTERS", new String[] {"Ideographic Description Characters",
+ "IdeographicDescriptionCharacters"});
+
+ /**
+ * Constant for the "Bopomofo Extended" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock BOPOMOFO_EXTENDED =
+ new UnicodeBlock("BOPOMOFO_EXTENDED", new String[] {"Bopomofo Extended",
+ "BopomofoExtended"});
+
+ /**
+ * Constant for the "CJK Unified Ideographs Extension A" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A =
+ new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A", new String[] {"CJK Unified Ideographs Extension A",
+ "CJKUnifiedIdeographsExtensionA"});
+
+ /**
+ * Constant for the "Yi Syllables" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock YI_SYLLABLES =
+ new UnicodeBlock("YI_SYLLABLES", new String[] {"Yi Syllables", "YiSyllables"});
+
+ /**
+ * Constant for the "Yi Radicals" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock YI_RADICALS =
+ new UnicodeBlock("YI_RADICALS", new String[] {"Yi Radicals", "YiRadicals"});
+
+
+ /**
+ * Constant for the "Cyrillic Supplementary" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock CYRILLIC_SUPPLEMENTARY =
+ new UnicodeBlock("CYRILLIC_SUPPLEMENTARY", new String[] {"Cyrillic Supplementary",
+ "CyrillicSupplementary"});
+
+ /**
+ * Constant for the "Tagalog" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock TAGALOG =
+ new UnicodeBlock("TAGALOG");
+
+ /**
+ * Constant for the "Hanunoo" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock HANUNOO =
+ new UnicodeBlock("HANUNOO");
+
+ /**
+ * Constant for the "Buhid" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock BUHID =
+ new UnicodeBlock("BUHID");
+
+ /**
+ * Constant for the "Tagbanwa" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock TAGBANWA =
+ new UnicodeBlock("TAGBANWA");
+
+ /**
+ * Constant for the "Limbu" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock LIMBU =
+ new UnicodeBlock("LIMBU");
+
+ /**
+ * Constant for the "Tai Le" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock TAI_LE =
+ new UnicodeBlock("TAI_LE", new String[] {"Tai Le", "TaiLe"});
+
+ /**
+ * Constant for the "Khmer Symbols" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock KHMER_SYMBOLS =
+ new UnicodeBlock("KHMER_SYMBOLS", new String[] {"Khmer Symbols", "KhmerSymbols"});
+
+ /**
+ * Constant for the "Phonetic Extensions" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock PHONETIC_EXTENSIONS =
+ new UnicodeBlock("PHONETIC_EXTENSIONS", new String[] {"Phonetic Extensions", "PhoneticExtensions"});
+
+ /**
+ * Constant for the "Miscellaneous Mathematical Symbols-A" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A =
+ new UnicodeBlock("MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A",
+ new String[]{"Miscellaneous Mathematical Symbols-A",
+ "MiscellaneousMathematicalSymbols-A"});
+
+ /**
+ * Constant for the "Supplemental Arrows-A" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock SUPPLEMENTAL_ARROWS_A =
+ new UnicodeBlock("SUPPLEMENTAL_ARROWS_A", new String[] {"Supplemental Arrows-A",
+ "SupplementalArrows-A"});
+
+ /**
+ * Constant for the "Supplemental Arrows-B" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock SUPPLEMENTAL_ARROWS_B =
+ new UnicodeBlock("SUPPLEMENTAL_ARROWS_B", new String[] {"Supplemental Arrows-B",
+ "SupplementalArrows-B"});
+
+ /**
+ * Constant for the "Miscellaneous Mathematical Symbols-B" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B
+ = new UnicodeBlock("MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B",
+ new String[] {"Miscellaneous Mathematical Symbols-B",
+ "MiscellaneousMathematicalSymbols-B"});
+
+ /**
+ * Constant for the "Supplemental Mathematical Operators" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock SUPPLEMENTAL_MATHEMATICAL_OPERATORS =
+ new UnicodeBlock("SUPPLEMENTAL_MATHEMATICAL_OPERATORS",
+ new String[]{"Supplemental Mathematical Operators",
+ "SupplementalMathematicalOperators"} );
+
+ /**
+ * Constant for the "Miscellaneous Symbols and Arrows" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock MISCELLANEOUS_SYMBOLS_AND_ARROWS =
+ new UnicodeBlock("MISCELLANEOUS_SYMBOLS_AND_ARROWS", new String[] {"Miscellaneous Symbols and Arrows",
+ "MiscellaneousSymbolsandArrows"});
+
+ /**
+ * Constant for the "Katakana Phonetic Extensions" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock KATAKANA_PHONETIC_EXTENSIONS =
+ new UnicodeBlock("KATAKANA_PHONETIC_EXTENSIONS", new String[] {"Katakana Phonetic Extensions",
+ "KatakanaPhoneticExtensions"});
+
+ /**
+ * Constant for the "Yijing Hexagram Symbols" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock YIJING_HEXAGRAM_SYMBOLS =
+ new UnicodeBlock("YIJING_HEXAGRAM_SYMBOLS", new String[] {"Yijing Hexagram Symbols",
+ "YijingHexagramSymbols"});
+
+ /**
+ * Constant for the "Variation Selectors" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock VARIATION_SELECTORS =
+ new UnicodeBlock("VARIATION_SELECTORS", new String[] {"Variation Selectors", "VariationSelectors"});
+
+ /**
+ * Constant for the "Linear B Syllabary" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock LINEAR_B_SYLLABARY =
+ new UnicodeBlock("LINEAR_B_SYLLABARY", new String[] {"Linear B Syllabary", "LinearBSyllabary"});
+
+ /**
+ * Constant for the "Linear B Ideograms" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock LINEAR_B_IDEOGRAMS =
+ new UnicodeBlock("LINEAR_B_IDEOGRAMS", new String[] {"Linear B Ideograms", "LinearBIdeograms"});
+
+ /**
+ * Constant for the "Aegean Numbers" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock AEGEAN_NUMBERS =
+ new UnicodeBlock("AEGEAN_NUMBERS", new String[] {"Aegean Numbers", "AegeanNumbers"});
+
+ /**
+ * Constant for the "Old Italic" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock OLD_ITALIC =
+ new UnicodeBlock("OLD_ITALIC", new String[] {"Old Italic", "OldItalic"});
+
+ /**
+ * Constant for the "Gothic" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock GOTHIC = new UnicodeBlock("GOTHIC");
+
+ /**
+ * Constant for the "Ugaritic" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock UGARITIC = new UnicodeBlock("UGARITIC");
+
+ /**
+ * Constant for the "Deseret" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock DESERET = new UnicodeBlock("DESERET");
+
+ /**
+ * Constant for the "Shavian" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock SHAVIAN = new UnicodeBlock("SHAVIAN");
+
+ /**
+ * Constant for the "Osmanya" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock OSMANYA = new UnicodeBlock("OSMANYA");
+
+ /**
+ * Constant for the "Cypriot Syllabary" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock CYPRIOT_SYLLABARY =
+ new UnicodeBlock("CYPRIOT_SYLLABARY", new String[] {"Cypriot Syllabary", "CypriotSyllabary"});
+
+ /**
+ * Constant for the "Byzantine Musical Symbols" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock BYZANTINE_MUSICAL_SYMBOLS =
+ new UnicodeBlock("BYZANTINE_MUSICAL_SYMBOLS", new String[] {"Byzantine Musical Symbols",
+ "ByzantineMusicalSymbols"});
+
+ /**
+ * Constant for the "Musical Symbols" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock MUSICAL_SYMBOLS =
+ new UnicodeBlock("MUSICAL_SYMBOLS", new String[] {"Musical Symbols", "MusicalSymbols"});
+
+ /**
+ * Constant for the "Tai Xuan Jing Symbols" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock TAI_XUAN_JING_SYMBOLS =
+ new UnicodeBlock("TAI_XUAN_JING_SYMBOLS", new String[] {"Tai Xuan Jing Symbols",
+ "TaiXuanJingSymbols"});
+
+ /**
+ * Constant for the "Mathematical Alphanumeric Symbols" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock MATHEMATICAL_ALPHANUMERIC_SYMBOLS =
+ new UnicodeBlock("MATHEMATICAL_ALPHANUMERIC_SYMBOLS",
+ new String[] {"Mathematical Alphanumeric Symbols", "MathematicalAlphanumericSymbols"});
+
+ /**
+ * Constant for the "CJK Unified Ideographs Extension B" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B =
+ new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B",
+ new String[] {"CJK Unified Ideographs Extension B", "CJKUnifiedIdeographsExtensionB"});
+
+ /**
+ * Constant for the "CJK Compatibility Ideographs Supplement" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT =
+ new UnicodeBlock("CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT",
+ new String[]{"CJK Compatibility Ideographs Supplement",
+ "CJKCompatibilityIdeographsSupplement"});
+
+ /**
+ * Constant for the "Tags" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock TAGS = new UnicodeBlock("TAGS");
+
+ /**
+ * Constant for the "Variation Selectors Supplement" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock VARIATION_SELECTORS_SUPPLEMENT =
+ new UnicodeBlock("VARIATION_SELECTORS_SUPPLEMENT", new String[] {"Variation Selectors Supplement",
+ "VariationSelectorsSupplement"});
+
+ /**
+ * Constant for the "Supplementary Private Use Area-A" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock SUPPLEMENTARY_PRIVATE_USE_AREA_A =
+ new UnicodeBlock("SUPPLEMENTARY_PRIVATE_USE_AREA_A",
+ new String[] {"Supplementary Private Use Area-A",
+ "SupplementaryPrivateUseArea-A"});
+
+ /**
+ * Constant for the "Supplementary Private Use Area-B" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock SUPPLEMENTARY_PRIVATE_USE_AREA_B =
+ new UnicodeBlock("SUPPLEMENTARY_PRIVATE_USE_AREA_B",
+ new String[] {"Supplementary Private Use Area-B",
+ "SupplementaryPrivateUseArea-B"});
+
+ /**
+ * Constant for the "High Surrogates" Unicode character block.
+ * This block represents codepoint values in the high surrogate
+ * range: 0xD800 through 0xDB7F
+ *
+ * @since 1.5
+ */
+ public static final UnicodeBlock HIGH_SURROGATES =
+ new UnicodeBlock("HIGH_SURROGATES", new String[] {"High Surrogates", "HighSurrogates"});
+
+ /**
+ * Constant for the "High Private Use Surrogates" Unicode character block.
+ * This block represents codepoint values in the high surrogate
+ * range: 0xDB80 through 0xDBFF
+ *
+ * @since 1.5
+ */
+ public static final UnicodeBlock HIGH_PRIVATE_USE_SURROGATES =
+ new UnicodeBlock("HIGH_PRIVATE_USE_SURROGATES", new String[] { "High Private Use Surrogates",
+ "HighPrivateUseSurrogates"});
+
+ /**
+ * Constant for the "Low Surrogates" Unicode character block.
+ * This block represents codepoint values in the high surrogate
+ * range: 0xDC00 through 0xDFFF
+ *
+ * @since 1.5
+ */
+ public static final UnicodeBlock LOW_SURROGATES =
+ new UnicodeBlock("LOW_SURROGATES", new String[] {"Low Surrogates", "LowSurrogates"});
+
+ private static final int blockStarts[] = {
+ 0x0000, // Basic Latin
+ 0x0080, // Latin-1 Supplement
+ 0x0100, // Latin Extended-A
+ 0x0180, // Latin Extended-B
+ 0x0250, // IPA Extensions
+ 0x02B0, // Spacing Modifier Letters
+ 0x0300, // Combining Diacritical Marks
+ 0x0370, // Greek and Coptic
+ 0x0400, // Cyrillic
+ 0x0500, // Cyrillic Supplementary
+ 0x0530, // Armenian
+ 0x0590, // Hebrew
+ 0x0600, // Arabic
+ 0x0700, // Syriac
+ 0x0750, // unassigned
+ 0x0780, // Thaana
+ 0x07C0, // unassigned
+ 0x0900, // Devanagari
+ 0x0980, // Bengali
+ 0x0A00, // Gurmukhi
+ 0x0A80, // Gujarati
+ 0x0B00, // Oriya
+ 0x0B80, // Tamil
+ 0x0C00, // Telugu
+ 0x0C80, // Kannada
+ 0x0D00, // Malayalam
+ 0x0D80, // Sinhala
+ 0x0E00, // Thai
+ 0x0E80, // Lao
+ 0x0F00, // Tibetan
+ 0x1000, // Myanmar
+ 0x10A0, // Georgian
+ 0x1100, // Hangul Jamo
+ 0x1200, // Ethiopic
+ 0x1380, // unassigned
+ 0x13A0, // Cherokee
+ 0x1400, // Unified Canadian Aboriginal Syllabics
+ 0x1680, // Ogham
+ 0x16A0, // Runic
+ 0x1700, // Tagalog
+ 0x1720, // Hanunoo
+ 0x1740, // Buhid
+ 0x1760, // Tagbanwa
+ 0x1780, // Khmer
+ 0x1800, // Mongolian
+ 0x18B0, // unassigned
+ 0x1900, // Limbu
+ 0x1950, // Tai Le
+ 0x1980, // unassigned
+ 0x19E0, // Khmer Symbols
+ 0x1A00, // unassigned
+ 0x1D00, // Phonetic Extensions
+ 0x1D80, // unassigned
+ 0x1E00, // Latin Extended Additional
+ 0x1F00, // Greek Extended
+ 0x2000, // General Punctuation
+ 0x2070, // Superscripts and Subscripts
+ 0x20A0, // Currency Symbols
+ 0x20D0, // Combining Diacritical Marks for Symbols
+ 0x2100, // Letterlike Symbols
+ 0x2150, // Number Forms
+ 0x2190, // Arrows
+ 0x2200, // Mathematical Operators
+ 0x2300, // Miscellaneous Technical
+ 0x2400, // Control Pictures
+ 0x2440, // Optical Character Recognition
+ 0x2460, // Enclosed Alphanumerics
+ 0x2500, // Box Drawing
+ 0x2580, // Block Elements
+ 0x25A0, // Geometric Shapes
+ 0x2600, // Miscellaneous Symbols
+ 0x2700, // Dingbats
+ 0x27C0, // Miscellaneous Mathematical Symbols-A
+ 0x27F0, // Supplemental Arrows-A
+ 0x2800, // Braille Patterns
+ 0x2900, // Supplemental Arrows-B
+ 0x2980, // Miscellaneous Mathematical Symbols-B
+ 0x2A00, // Supplemental Mathematical Operators
+ 0x2B00, // Miscellaneous Symbols and Arrows
+ 0x2C00, // unassigned
+ 0x2E80, // CJK Radicals Supplement
+ 0x2F00, // Kangxi Radicals
+ 0x2FE0, // unassigned
+ 0x2FF0, // Ideographic Description Characters
+ 0x3000, // CJK Symbols and Punctuation
+ 0x3040, // Hiragana
+ 0x30A0, // Katakana
+ 0x3100, // Bopomofo
+ 0x3130, // Hangul Compatibility Jamo
+ 0x3190, // Kanbun
+ 0x31A0, // Bopomofo Extended
+ 0x31C0, // unassigned
+ 0x31F0, // Katakana Phonetic Extensions
+ 0x3200, // Enclosed CJK Letters and Months
+ 0x3300, // CJK Compatibility
+ 0x3400, // CJK Unified Ideographs Extension A
+ 0x4DC0, // Yijing Hexagram Symbols
+ 0x4E00, // CJK Unified Ideographs
+ 0xA000, // Yi Syllables
+ 0xA490, // Yi Radicals
+ 0xA4D0, // unassigned
+ 0xAC00, // Hangul Syllables
+ 0xD7B0, // unassigned
+ 0xD800, // High Surrogates
+ 0xDB80, // High Private Use Surrogates
+ 0xDC00, // Low Surrogates
+ 0xE000, // Private Use
+ 0xF900, // CJK Compatibility Ideographs
+ 0xFB00, // Alphabetic Presentation Forms
+ 0xFB50, // Arabic Presentation Forms-A
+ 0xFE00, // Variation Selectors
+ 0xFE10, // unassigned
+ 0xFE20, // Combining Half Marks
+ 0xFE30, // CJK Compatibility Forms
+ 0xFE50, // Small Form Variants
+ 0xFE70, // Arabic Presentation Forms-B
+ 0xFF00, // Halfwidth and Fullwidth Forms
+ 0xFFF0, // Specials
+ 0x10000, // Linear B Syllabary
+ 0x10080, // Linear B Ideograms
+ 0x10100, // Aegean Numbers
+ 0x10140, // unassigned
+ 0x10300, // Old Italic
+ 0x10330, // Gothic
+ 0x10350, // unassigned
+ 0x10380, // Ugaritic
+ 0x103A0, // unassigned
+ 0x10400, // Deseret
+ 0x10450, // Shavian
+ 0x10480, // Osmanya
+ 0x104B0, // unassigned
+ 0x10800, // Cypriot Syllabary
+ 0x10840, // unassigned
+ 0x1D000, // Byzantine Musical Symbols
+ 0x1D100, // Musical Symbols
+ 0x1D200, // unassigned
+ 0x1D300, // Tai Xuan Jing Symbols
+ 0x1D360, // unassigned
+ 0x1D400, // Mathematical Alphanumeric Symbols
+ 0x1D800, // unassigned
+ 0x20000, // CJK Unified Ideographs Extension B
+ 0x2A6E0, // unassigned
+ 0x2F800, // CJK Compatibility Ideographs Supplement
+ 0x2FA20, // unassigned
+ 0xE0000, // Tags
+ 0xE0080, // unassigned
+ 0xE0100, // Variation Selectors Supplement
+ 0xE01F0, // unassigned
+ 0xF0000, // Supplementary Private Use Area-A
+ 0x100000, // Supplementary Private Use Area-B
+ };
+
+ private static final UnicodeBlock[] blocks = {
+ BASIC_LATIN,
+ LATIN_1_SUPPLEMENT,
+ LATIN_EXTENDED_A,
+ LATIN_EXTENDED_B,
+ IPA_EXTENSIONS,
+ SPACING_MODIFIER_LETTERS,
+ COMBINING_DIACRITICAL_MARKS,
+ GREEK,
+ CYRILLIC,
+ CYRILLIC_SUPPLEMENTARY,
+ ARMENIAN,
+ HEBREW,
+ ARABIC,
+ SYRIAC,
+ null,
+ THAANA,
+ null,
+ DEVANAGARI,
+ BENGALI,
+ GURMUKHI,
+ GUJARATI,
+ ORIYA,
+ TAMIL,
+ TELUGU,
+ KANNADA,
+ MALAYALAM,
+ SINHALA,
+ THAI,
+ LAO,
+ TIBETAN,
+ MYANMAR,
+ GEORGIAN,
+ HANGUL_JAMO,
+ ETHIOPIC,
+ null,
+ CHEROKEE,
+ UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS,
+ OGHAM,
+ RUNIC,
+ TAGALOG,
+ HANUNOO,
+ BUHID,
+ TAGBANWA,
+ KHMER,
+ MONGOLIAN,
+ null,
+ LIMBU,
+ TAI_LE,
+ null,
+ KHMER_SYMBOLS,
+ null,
+ PHONETIC_EXTENSIONS,
+ null,
+ LATIN_EXTENDED_ADDITIONAL,
+ GREEK_EXTENDED,
+ GENERAL_PUNCTUATION,
+ SUPERSCRIPTS_AND_SUBSCRIPTS,
+ CURRENCY_SYMBOLS,
+ COMBINING_MARKS_FOR_SYMBOLS,
+ LETTERLIKE_SYMBOLS,
+ NUMBER_FORMS,
+ ARROWS,
+ MATHEMATICAL_OPERATORS,
+ MISCELLANEOUS_TECHNICAL,
+ CONTROL_PICTURES,
+ OPTICAL_CHARACTER_RECOGNITION,
+ ENCLOSED_ALPHANUMERICS,
+ BOX_DRAWING,
+ BLOCK_ELEMENTS,
+ GEOMETRIC_SHAPES,
+ MISCELLANEOUS_SYMBOLS,
+ DINGBATS,
+ MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A,
+ SUPPLEMENTAL_ARROWS_A,
+ BRAILLE_PATTERNS,
+ SUPPLEMENTAL_ARROWS_B,
+ MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B,
+ SUPPLEMENTAL_MATHEMATICAL_OPERATORS,
+ MISCELLANEOUS_SYMBOLS_AND_ARROWS,
+ null,
+ CJK_RADICALS_SUPPLEMENT,
+ KANGXI_RADICALS,
+ null,
+ IDEOGRAPHIC_DESCRIPTION_CHARACTERS,
+ CJK_SYMBOLS_AND_PUNCTUATION,
+ HIRAGANA,
+ KATAKANA,
+ BOPOMOFO,
+ HANGUL_COMPATIBILITY_JAMO,
+ KANBUN,
+ BOPOMOFO_EXTENDED,
+ null,
+ KATAKANA_PHONETIC_EXTENSIONS,
+ ENCLOSED_CJK_LETTERS_AND_MONTHS,
+ CJK_COMPATIBILITY,
+ CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A,
+ YIJING_HEXAGRAM_SYMBOLS,
+ CJK_UNIFIED_IDEOGRAPHS,
+ YI_SYLLABLES,
+ YI_RADICALS,
+ null,
+ HANGUL_SYLLABLES,
+ null,
+ HIGH_SURROGATES,
+ HIGH_PRIVATE_USE_SURROGATES,
+ LOW_SURROGATES,
+ PRIVATE_USE_AREA,
+ CJK_COMPATIBILITY_IDEOGRAPHS,
+ ALPHABETIC_PRESENTATION_FORMS,
+ ARABIC_PRESENTATION_FORMS_A,
+ VARIATION_SELECTORS,
+ null,
+ COMBINING_HALF_MARKS,
+ CJK_COMPATIBILITY_FORMS,
+ SMALL_FORM_VARIANTS,
+ ARABIC_PRESENTATION_FORMS_B,
+ HALFWIDTH_AND_FULLWIDTH_FORMS,
+ SPECIALS,
+ LINEAR_B_SYLLABARY,
+ LINEAR_B_IDEOGRAMS,
+ AEGEAN_NUMBERS,
+ null,
+ OLD_ITALIC,
+ GOTHIC,
+ null,
+ UGARITIC,
+ null,
+ DESERET,
+ SHAVIAN,
+ OSMANYA,
+ null,
+ CYPRIOT_SYLLABARY,
+ null,
+ BYZANTINE_MUSICAL_SYMBOLS,
+ MUSICAL_SYMBOLS,
+ null,
+ TAI_XUAN_JING_SYMBOLS,
+ null,
+ MATHEMATICAL_ALPHANUMERIC_SYMBOLS,
+ null,
+ CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B,
+ null,
+ CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT,
+ null,
+ TAGS,
+ null,
+ VARIATION_SELECTORS_SUPPLEMENT,
+ null,
+ SUPPLEMENTARY_PRIVATE_USE_AREA_A,
+ SUPPLEMENTARY_PRIVATE_USE_AREA_B
+ };
+
+
+ /**
+ * Returns the object representing the Unicode block containing the
+ * given character, or <code>null</code> if the character is not a
+ * member of a defined block.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="Character.html#supplementary"> supplementary
+ * characters</a>. To support all Unicode characters,
+ * including supplementary characters, use the {@link
+ * #of(int)} method.
+ *
+ * @param c The character in question
+ * @return The <code>UnicodeBlock</code> instance representing the
+ * Unicode block of which this character is a member, or
+ * <code>null</code> if the character is not a member of any
+ * Unicode block
+ */
+ public static UnicodeBlock of(char c) {
+ return of((int)c);
+ }
+
+
+ /**
+ * Returns the object representing the Unicode block
+ * containing the given character (Unicode code point), or
+ * <code>null</code> if the character is not a member of a
+ * defined block.
+ *
+ * @param codePoint the character (Unicode code point) in question.
+ * @return The <code>UnicodeBlock</code> instance representing the
+ * Unicode block of which this character is a member, or
+ * <code>null</code> if the character is not a member of any
+ * Unicode block
+ * @exception IllegalArgumentException if the specified
+ * <code>codePoint</code> is an invalid Unicode code point.
+ * @see Character#isValidCodePoint(int)
+ * @since 1.5
+ */
+ public static UnicodeBlock of(int codePoint) {
+ if (!isValidCodePoint(codePoint)) {
+ throw new IllegalArgumentException();
+ }
+
+ int top, bottom, current;
+ bottom = 0;
+ top = blockStarts.length;
+ current = top/2;
+
+ // invariant: top > current >= bottom && codePoint >= unicodeBlockStarts[bottom]
+ while (top - bottom > 1) {
+ if (codePoint >= blockStarts[current]) {
+ bottom = current;
+ } else {
+ top = current;
+ }
+ current = (top + bottom) / 2;
+ }
+ return blocks[current];
+ }
+
+ /**
+ * Returns the UnicodeBlock with the given name. Block
+ * names are determined by The Unicode Standard. The file
+ * Blocks-<version>.txt defines blocks for a particular
+ * version of the standard. The {@link Character} class specifies
+ * the version of the standard that it supports.
+ * <p>
+ * This method accepts block names in the following forms:
+ * <ol>
+ * <li> Canonical block names as defined by the Unicode Standard.
+ * For example, the standard defines a "Basic Latin" block. Therefore, this
+ * method accepts "Basic Latin" as a valid block name. The documentation of
+ * each UnicodeBlock provides the canonical name.
+ * <li>Canonical block names with all spaces removed. For example, "BasicLatin"
+ * is a valid block name for the "Basic Latin" block.
+ * <li>The text representation of each constant UnicodeBlock identifier.
+ * For example, this method will return the {@link #BASIC_LATIN} block if
+ * provided with the "BASIC_LATIN" name. This form replaces all spaces and
+ * hyphens in the canonical name with underscores.
+ * </ol>
+ * Finally, character case is ignored for all of the valid block name forms.
+ * For example, "BASIC_LATIN" and "basic_latin" are both valid block names.
+ * The en_US locale's case mapping rules are used to provide case-insensitive
+ * string comparisons for block name validation.
+ * <p>
+ * If the Unicode Standard changes block names, both the previous and
+ * current names will be accepted.
+ *
+ * @param blockName A <code>UnicodeBlock</code> name.
+ * @return The <code>UnicodeBlock</code> instance identified
+ * by <code>blockName</code>
+ * @throws IllegalArgumentException if <code>blockName</code> is an
+ * invalid name
+ * @throws NullPointerException if <code>blockName</code> is null
+ * @since 1.5
+ */
+ public static final UnicodeBlock forName(String blockName) {
+ UnicodeBlock block = (UnicodeBlock)map.get(blockName.toUpperCase(Locale.US));
+ if (block == null) {
+ throw new IllegalArgumentException();
+ }
+ return block;
+ }
+ }
+
+
+ /**
+ * The value of the <code>Character</code>.
+ *
+ * @serial
+ */
+ private final char value;
+
+ /** use serialVersionUID from JDK 1.0.2 for interoperability */
+ private static final long serialVersionUID = 3786198910865385080L;
+
+ /**
+ * Constructs a newly allocated <code>Character</code> object that
+ * represents the specified <code>char</code> value.
+ *
+ * @param value the value to be represented by the
+ * <code>Character</code> object.
+ */
+ public Character(char value) {
+ this.value = value;
+ }
+
+ private static class CharacterCache {
+ private CharacterCache(){}
+
+ static final Character cache[] = new Character[127 + 1];
+
+ static {
+ for(int i = 0; i < cache.length; i++)
+ cache[i] = new Character((char)i);
+ }
+ }
+
+ /**
+ * Returns a <tt>Character</tt> instance representing the specified
+ * <tt>char</tt> value.
+ * If a new <tt>Character</tt> instance is not required, this method
+ * should generally be used in preference to the constructor
+ * {@link #Character(char)}, as this method is likely to yield
+ * significantly better space and time performance by caching
+ * frequently requested values.
+ *
+ * @param c a char value.
+ * @return a <tt>Character</tt> instance representing <tt>c</tt>.
+ * @since 1.5
+ */
+ public static Character valueOf(char c) {
+ if(c <= 127) { // must cache
+ return CharacterCache.cache[(int)c];
+ }
+ return new Character(c);
+ }
+
+ /**
+ * Returns the value of this <code>Character</code> object.
+ * @return the primitive <code>char</code> value represented by
+ * this object.
+ */
+ public char charValue() {
+ return value;
+ }
+
+ /**
+ * Returns a hash code for this <code>Character</code>.
+ * @return a hash code value for this object.
+ */
+ public int hashCode() {
+ return (int)value;
+ }
+
+ /**
+ * Compares this object against the specified object.
+ * The result is <code>true</code> if and only if the argument is not
+ * <code>null</code> and is a <code>Character</code> object that
+ * represents the same <code>char</code> value as this object.
+ *
+ * @param obj the object to compare with.
+ * @return <code>true</code> if the objects are the same;
+ * <code>false</code> otherwise.
+ */
+ public boolean equals(Object obj) {
+ if (obj instanceof Character) {
+ return value == ((Character)obj).charValue();
+ }
+ return false;
+ }
+
+ /**
+ * Returns a <code>String</code> object representing this
+ * <code>Character</code>'s value. The result is a string of
+ * length 1 whose sole component is the primitive
+ * <code>char</code> value represented by this
+ * <code>Character</code> object.
+ *
+ * @return a string representation of this object.
+ */
+ public String toString() {
+ char buf[] = {value};
+ return String.valueOf(buf);
+ }
+
+ /**
+ * Returns a <code>String</code> object representing the
+ * specified <code>char</code>. The result is a string of length
+ * 1 consisting solely of the specified <code>char</code>.
+ *
+ * @param c the <code>char</code> to be converted
+ * @return the string representation of the specified <code>char</code>
+ * @since 1.4
+ */
+ public static String toString(char c) {
+ return String.valueOf(c);
+ }
+
+ /**
+ * Determines whether the specified code point is a valid Unicode
+ * code point value in the range of <code>0x0000</code> to
+ * <code>0x10FFFF</code> inclusive. This method is equivalent to
+ * the expression:
+ *
+ * <blockquote><pre>
+ * codePoint >= 0x0000 && codePoint <= 0x10FFFF
+ * </pre></blockquote>
+ *
+ * @param codePoint the Unicode code point to be tested
+ * @return <code>true</code> if the specified code point value
+ * is a valid code point value;
+ * <code>false</code> otherwise.
+ * @since 1.5
+ */
+ public static boolean isValidCodePoint(int codePoint) {
+ return codePoint >= MIN_CODE_POINT && codePoint <= MAX_CODE_POINT;
+ }
+
+ /**
+ * Determines whether the specified character (Unicode code point)
+ * is in the supplementary character range. The method call is
+ * equivalent to the expression:
+ * <blockquote><pre>
+ * codePoint >= 0x10000 && codePoint <= 0x10FFFF
+ * </pre></blockquote>
+ *
+ * @param codePoint the character (Unicode code point) to be tested
+ * @return <code>true</code> if the specified character is in the Unicode
+ * supplementary character range; <code>false</code> otherwise.
+ * @since 1.5
+ */
+ public static boolean isSupplementaryCodePoint(int codePoint) {
+ return codePoint >= MIN_SUPPLEMENTARY_CODE_POINT
+ && codePoint <= MAX_CODE_POINT;
+ }
+
+ /**
+ * Determines if the given <code>char</code> value is a
+ * high-surrogate code unit (also known as <i>leading-surrogate
+ * code unit</i>). Such values do not represent characters by
+ * themselves, but are used in the representation of <a
+ * href="#supplementary">supplementary characters</a> in the
+ * UTF-16 encoding.
+ *
+ * <p>This method returns <code>true</code> if and only if
+ * <blockquote><pre>ch >= '\uD800' && ch <= '\uDBFF'
+ * </pre></blockquote>
+ * is <code>true</code>.
+ *
+ * @param ch the <code>char</code> value to be tested.
+ * @return <code>true</code> if the <code>char</code> value
+ * is between '\uD800' and '\uDBFF' inclusive;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isLowSurrogate(char)
+ * @see Character.UnicodeBlock#of(int)
+ * @since 1.5
+ */
+ public static boolean isHighSurrogate(char ch) {
+ return ch >= MIN_HIGH_SURROGATE && ch <= MAX_HIGH_SURROGATE;
+ }
+
+ /**
+ * Determines if the given <code>char</code> value is a
+ * low-surrogate code unit (also known as <i>trailing-surrogate code
+ * unit</i>). Such values do not represent characters by themselves,
+ * but are used in the representation of <a
+ * href="#supplementary">supplementary characters</a> in the UTF-16 encoding.
+ *
+ * <p> This method returns <code>true</code> if and only if
+ * <blockquote><pre>ch >= '\uDC00' && ch <= '\uDFFF'
+ * </pre></blockquote> is <code>true</code>.
+ *
+ * @param ch the <code>char</code> value to be tested.
+ * @return <code>true</code> if the <code>char</code> value
+ * is between '\uDC00' and '\uDFFF' inclusive;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isHighSurrogate(char)
+ * @since 1.5
+ */
+ public static boolean isLowSurrogate(char ch) {
+ return ch >= MIN_LOW_SURROGATE && ch <= MAX_LOW_SURROGATE;
+ }
+
+ /**
+ * Determines whether the specified pair of <code>char</code>
+ * values is a valid surrogate pair. This method is equivalent to
+ * the expression:
+ * <blockquote><pre>
+ * isHighSurrogate(high) && isLowSurrogate(low)
+ * </pre></blockquote>
+ *
+ * @param high the high-surrogate code value to be tested
+ * @param low the low-surrogate code value to be tested
+ * @return <code>true</code> if the specified high and
+ * low-surrogate code values represent a valid surrogate pair;
+ * <code>false</code> otherwise.
+ * @since 1.5
+ */
+ public static boolean isSurrogatePair(char high, char low) {
+ return isHighSurrogate(high) && isLowSurrogate(low);
+ }
+
+ /**
+ * Determines the number of <code>char</code> values needed to
+ * represent the specified character (Unicode code point). If the
+ * specified character is equal to or greater than 0x10000, then
+ * the method returns 2. Otherwise, the method returns 1.
+ *
+ * <p>This method doesn't validate the specified character to be a
+ * valid Unicode code point. The caller must validate the
+ * character value using {@link #isValidCodePoint(int) isValidCodePoint}
+ * if necessary.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return 2 if the character is a valid supplementary character; 1 otherwise.
+ * @see #isSupplementaryCodePoint(int)
+ * @since 1.5
+ */
+ public static int charCount(int codePoint) {
+ return codePoint >= MIN_SUPPLEMENTARY_CODE_POINT? 2 : 1;
+ }
+
+ /**
+ * Converts the specified surrogate pair to its supplementary code
+ * point value. This method does not validate the specified
+ * surrogate pair. The caller must validate it using {@link
+ * #isSurrogatePair(char, char) isSurrogatePair} if necessary.
+ *
+ * @param high the high-surrogate code unit
+ * @param low the low-surrogate code unit
+ * @return the supplementary code point composed from the
+ * specified surrogate pair.
+ * @since 1.5
+ */
+ public static int toCodePoint(char high, char low) {
+ return ((high - MIN_HIGH_SURROGATE) << 10)
+ + (low - MIN_LOW_SURROGATE) + MIN_SUPPLEMENTARY_CODE_POINT;
+ }
+
+ /**
+ * Returns the code point at the given index of the
+ * <code>CharSequence</code>. If the <code>char</code> value at
+ * the given index in the <code>CharSequence</code> is in the
+ * high-surrogate range, the following index is less than the
+ * length of the <code>CharSequence</code>, and the
+ * <code>char</code> value at the following index is in the
+ * low-surrogate range, then the supplementary code point
+ * corresponding to this surrogate pair is returned. Otherwise,
+ * the <code>char</code> value at the given index is returned.
+ *
+ * @param seq a sequence of <code>char</code> values (Unicode code
+ * units)
+ * @param index the index to the <code>char</code> values (Unicode
+ * code units) in <code>seq</code> to be converted
+ * @return the Unicode code point at the given index
+ * @exception NullPointerException if <code>seq</code> is null.
+ * @exception IndexOutOfBoundsException if the value
+ * <code>index</code> is negative or not less than
+ * {@link CharSequence#length() seq.length()}.
+ * @since 1.5
+ */
+ public static int codePointAt(CharSequence seq, int index) {
+ char c1 = seq.charAt(index++);
+ if (isHighSurrogate(c1)) {
+ if (index < seq.length()) {
+ char c2 = seq.charAt(index);
+ if (isLowSurrogate(c2)) {
+ return toCodePoint(c1, c2);
+ }
+ }
+ }
+ return c1;
+ }
+
+ /**
+ * Returns the code point at the given index of the
+ * <code>char</code> array. If the <code>char</code> value at
+ * the given index in the <code>char</code> array is in the
+ * high-surrogate range, the following index is less than the
+ * length of the <code>char</code> array, and the
+ * <code>char</code> value at the following index is in the
+ * low-surrogate range, then the supplementary code point
+ * corresponding to this surrogate pair is returned. Otherwise,
+ * the <code>char</code> value at the given index is returned.
+ *
+ * @param a the <code>char</code> array
+ * @param index the index to the <code>char</code> values (Unicode
+ * code units) in the <code>char</code> array to be converted
+ * @return the Unicode code point at the given index
+ * @exception NullPointerException if <code>a</code> is null.
+ * @exception IndexOutOfBoundsException if the value
+ * <code>index</code> is negative or not less than
+ * the length of the <code>char</code> array.
+ * @since 1.5
+ */
+ public static int codePointAt(char[] a, int index) {
+ return codePointAtImpl(a, index, a.length);
+ }
+
+ /**
+ * Returns the code point at the given index of the
+ * <code>char</code> array, where only array elements with
+ * <code>index</code> less than <code>limit</code> can be used. If
+ * the <code>char</code> value at the given index in the
+ * <code>char</code> array is in the high-surrogate range, the
+ * following index is less than the <code>limit</code>, and the
+ * <code>char</code> value at the following index is in the
+ * low-surrogate range, then the supplementary code point
+ * corresponding to this surrogate pair is returned. Otherwise,
+ * the <code>char</code> value at the given index is returned.
+ *
+ * @param a the <code>char</code> array
+ * @param index the index to the <code>char</code> values (Unicode
+ * code units) in the <code>char</code> array to be converted
+ * @param limit the index after the last array element that can be used in the
+ * <code>char</code> array
+ * @return the Unicode code point at the given index
+ * @exception NullPointerException if <code>a</code> is null.
+ * @exception IndexOutOfBoundsException if the <code>index</code>
+ * argument is negative or not less than the <code>limit</code>
+ * argument, or if the <code>limit</code> argument is negative or
+ * greater than the length of the <code>char</code> array.
+ * @since 1.5
+ */
+ public static int codePointAt(char[] a, int index, int limit) {
+ if (index >= limit || limit < 0 || limit > a.length) {
+ throw new IndexOutOfBoundsException();
+ }
+ return codePointAtImpl(a, index, limit);
+ }
+
+ static int codePointAtImpl(char[] a, int index, int limit) {
+ char c1 = a[index++];
+ if (isHighSurrogate(c1)) {
+ if (index < limit) {
+ char c2 = a[index];
+ if (isLowSurrogate(c2)) {
+ return toCodePoint(c1, c2);
+ }
+ }
+ }
+ return c1;
+ }
+
+ /**
+ * Returns the code point preceding the given index of the
+ * <code>CharSequence</code>. If the <code>char</code> value at
+ * <code>(index - 1)</code> in the <code>CharSequence</code> is in
+ * the low-surrogate range, <code>(index - 2)</code> is not
+ * negative, and the <code>char</code> value at <code>(index -
+ * 2)</code> in the <code>CharSequence</code> is in the
+ * high-surrogate range, then the supplementary code point
+ * corresponding to this surrogate pair is returned. Otherwise,
+ * the <code>char</code> value at <code>(index - 1)</code> is
+ * returned.
+ *
+ * @param seq the <code>CharSequence</code> instance
+ * @param index the index following the code point that should be returned
+ * @return the Unicode code point value before the given index.
+ * @exception NullPointerException if <code>seq</code> is null.
+ * @exception IndexOutOfBoundsException if the <code>index</code>
+ * argument is less than 1 or greater than {@link
+ * CharSequence#length() seq.length()}.
+ * @since 1.5
+ */
+ public static int codePointBefore(CharSequence seq, int index) {
+ char c2 = seq.charAt(--index);
+ if (isLowSurrogate(c2)) {
+ if (index > 0) {
+ char c1 = seq.charAt(--index);
+ if (isHighSurrogate(c1)) {
+ return toCodePoint(c1, c2);
+ }
+ }
+ }
+ return c2;
+ }
+
+ /**
+ * Returns the code point preceding the given index of the
+ * <code>char</code> array. If the <code>char</code> value at
+ * <code>(index - 1)</code> in the <code>char</code> array is in
+ * the low-surrogate range, <code>(index - 2)</code> is not
+ * negative, and the <code>char</code> value at <code>(index -
+ * 2)</code> in the <code>char</code> array is in the
+ * high-surrogate range, then the supplementary code point
+ * corresponding to this surrogate pair is returned. Otherwise,
+ * the <code>char</code> value at <code>(index - 1)</code> is
+ * returned.
+ *
+ * @param a the <code>char</code> array
+ * @param index the index following the code point that should be returned
+ * @return the Unicode code point value before the given index.
+ * @exception NullPointerException if <code>a</code> is null.
+ * @exception IndexOutOfBoundsException if the <code>index</code>
+ * argument is less than 1 or greater than the length of the
+ * <code>char</code> array
+ * @since 1.5
+ */
+ public static int codePointBefore(char[] a, int index) {
+ return codePointBeforeImpl(a, index, 0);
+ }
+
+ /**
+ * Returns the code point preceding the given index of the
+ * <code>char</code> array, where only array elements with
+ * <code>index</code> greater than or equal to <code>start</code>
+ * can be used. If the <code>char</code> value at <code>(index -
+ * 1)</code> in the <code>char</code> array is in the
+ * low-surrogate range, <code>(index - 2)</code> is not less than
+ * <code>start</code>, and the <code>char</code> value at
+ * <code>(index - 2)</code> in the <code>char</code> array is in
+ * the high-surrogate range, then the supplementary code point
+ * corresponding to this surrogate pair is returned. Otherwise,
+ * the <code>char</code> value at <code>(index - 1)</code> is
+ * returned.
+ *
+ * @param a the <code>char</code> array
+ * @param index the index following the code point that should be returned
+ * @param start the index of the first array element in the
+ * <code>char</code> array
+ * @return the Unicode code point value before the given index.
+ * @exception NullPointerException if <code>a</code> is null.
+ * @exception IndexOutOfBoundsException if the <code>index</code>
+ * argument is not greater than the <code>start</code> argument or
+ * is greater than the length of the <code>char</code> array, or
+ * if the <code>start</code> argument is negative or not less than
+ * the length of the <code>char</code> array.
+ * @since 1.5
+ */
+ public static int codePointBefore(char[] a, int index, int start) {
+ if (index <= start || start < 0 || start >= a.length) {
+ throw new IndexOutOfBoundsException();
+ }
+ return codePointBeforeImpl(a, index, start);
+ }
+
+ static int codePointBeforeImpl(char[] a, int index, int start) {
+ char c2 = a[--index];
+ if (isLowSurrogate(c2)) {
+ if (index > start) {
+ char c1 = a[--index];
+ if (isHighSurrogate(c1)) {
+ return toCodePoint(c1, c2);
+ }
+ }
+ }
+ return c2;
+ }
+
+ /**
+ * Converts the specified character (Unicode code point) to its
+ * UTF-16 representation. If the specified code point is a BMP
+ * (Basic Multilingual Plane or Plane 0) value, the same value is
+ * stored in <code>dst[dstIndex]</code>, and 1 is returned. If the
+ * specified code point is a supplementary character, its
+ * surrogate values are stored in <code>dst[dstIndex]</code>
+ * (high-surrogate) and <code>dst[dstIndex+1]</code>
+ * (low-surrogate), and 2 is returned.
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @param dst an array of <code>char</code> in which the
+ * <code>codePoint</code>'s UTF-16 value is stored.
+ * @param dstIndex the start index into the <code>dst</code>
+ * array where the converted value is stored.
+ * @return 1 if the code point is a BMP code point, 2 if the
+ * code point is a supplementary code point.
+ * @exception IllegalArgumentException if the specified
+ * <code>codePoint</code> is not a valid Unicode code point.
+ * @exception NullPointerException if the specified <code>dst</code> is null.
+ * @exception IndexOutOfBoundsException if <code>dstIndex</code>
+ * is negative or not less than <code>dst.length</code>, or if
+ * <code>dst</code> at <code>dstIndex</code> doesn't have enough
+ * array element(s) to store the resulting <code>char</code>
+ * value(s). (If <code>dstIndex</code> is equal to
+ * <code>dst.length-1</code> and the specified
+ * <code>codePoint</code> is a supplementary character, the
+ * high-surrogate value is not stored in
+ * <code>dst[dstIndex]</code>.)
+ * @since 1.5
+ */
+ public static int toChars(int codePoint, char[] dst, int dstIndex) {
+ if (codePoint < 0 || codePoint > MAX_CODE_POINT) {
+ throw new IllegalArgumentException();
+ }
+ if (codePoint < MIN_SUPPLEMENTARY_CODE_POINT) {
+ dst[dstIndex] = (char) codePoint;
+ return 1;
+ }
+ toSurrogates(codePoint, dst, dstIndex);
+ return 2;
+ }
+
+ /**
+ * Converts the specified character (Unicode code point) to its
+ * UTF-16 representation stored in a <code>char</code> array. If
+ * the specified code point is a BMP (Basic Multilingual Plane or
+ * Plane 0) value, the resulting <code>char</code> array has
+ * the same value as <code>codePoint</code>. If the specified code
+ * point is a supplementary code point, the resulting
+ * <code>char</code> array has the corresponding surrogate pair.
+ *
+ * @param codePoint a Unicode code point
+ * @return a <code>char</code> array having
+ * <code>codePoint</code>'s UTF-16 representation.
+ * @exception IllegalArgumentException if the specified
+ * <code>codePoint</code> is not a valid Unicode code point.
+ * @since 1.5
+ */
+ public static char[] toChars(int codePoint) {
+ if (codePoint < 0 || codePoint > MAX_CODE_POINT) {
+ throw new IllegalArgumentException();
+ }
+ if (codePoint < MIN_SUPPLEMENTARY_CODE_POINT) {
+ return new char[] { (char) codePoint };
+ }
+ char[] result = new char[2];
+ toSurrogates(codePoint, result, 0);
+ return result;
+ }
+
+ static void toSurrogates(int codePoint, char[] dst, int index) {
+ int offset = codePoint - MIN_SUPPLEMENTARY_CODE_POINT;
+ dst[index+1] = (char)((offset & 0x3ff) + MIN_LOW_SURROGATE);
+ dst[index] = (char)((offset >>> 10) + MIN_HIGH_SURROGATE);
+ }
+
+ /**
+ * Returns the number of Unicode code points in the text range of
+ * the specified char sequence. The text range begins at the
+ * specified <code>beginIndex</code> and extends to the
+ * <code>char</code> at index <code>endIndex - 1</code>. Thus the
+ * length (in <code>char</code>s) of the text range is
+ * <code>endIndex-beginIndex</code>. Unpaired surrogates within
+ * the text range count as one code point each.
+ *
+ * @param seq the char sequence
+ * @param beginIndex the index to the first <code>char</code> of
+ * the text range.
+ * @param endIndex the index after the last <code>char</code> of
+ * the text range.
+ * @return the number of Unicode code points in the specified text
+ * range
+ * @exception NullPointerException if <code>seq</code> is null.
+ * @exception IndexOutOfBoundsException if the
+ * <code>beginIndex</code> is negative, or <code>endIndex</code>
+ * is larger than the length of the given sequence, or
+ * <code>beginIndex</code> is larger than <code>endIndex</code>.
+ * @since 1.5
+ */
+ public static int codePointCount(CharSequence seq, int beginIndex, int endIndex) {
+ int length = seq.length();
+ if (beginIndex < 0 || endIndex > length || beginIndex > endIndex) {
+ throw new IndexOutOfBoundsException();
+ }
+ int n = 0;
+ for (int i = beginIndex; i < endIndex; ) {
+ n++;
+ if (isHighSurrogate(seq.charAt(i++))) {
+ if (i < endIndex && isLowSurrogate(seq.charAt(i))) {
+ i++;
+ }
+ }
+ }
+ return n;
+ }
+
+ /**
+ * Returns the number of Unicode code points in a subarray of the
+ * <code>char</code> array argument. The <code>offset</code>
+ * argument is the index of the first <code>char</code> of the
+ * subarray and the <code>count</code> argument specifies the
+ * length of the subarray in <code>char</code>s. Unpaired
+ * surrogates within the subarray count as one code point each.
+ *
+ * @param a the <code>char</code> array
+ * @param offset the index of the first <code>char</code> in the
+ * given <code>char</code> array
+ * @param count the length of the subarray in <code>char</code>s
+ * @return the number of Unicode code points in the specified subarray
+ * @exception NullPointerException if <code>a</code> is null.
+ * @exception IndexOutOfBoundsException if <code>offset</code> or
+ * <code>count</code> is negative, or if <code>offset +
+ * count</code> is larger than the length of the given array.
+ * @since 1.5
+ */
+ public static int codePointCount(char[] a, int offset, int count) {
+ if (count > a.length - offset || offset < 0 || count < 0) {
+ throw new IndexOutOfBoundsException();
+ }
+ return codePointCountImpl(a, offset, count);
+ }
+
+ static int codePointCountImpl(char[] a, int offset, int count) {
+ int endIndex = offset + count;
+ int n = 0;
+ for (int i = offset; i < endIndex; ) {
+ n++;
+ if (isHighSurrogate(a[i++])) {
+ if (i < endIndex && isLowSurrogate(a[i])) {
+ i++;
+ }
+ }
+ }
+ return n;
+ }
+
+ /**
+ * Returns the index within the given char sequence that is offset
+ * from the given <code>index</code> by <code>codePointOffset</code>
+ * code points. Unpaired surrogates within the text range given by
+ * <code>index</code> and <code>codePointOffset</code> count as
+ * one code point each.
+ *
+ * @param seq the char sequence
+ * @param index the index to be offset
+ * @param codePointOffset the offset in code points
+ * @return the index within the char sequence
+ * @exception NullPointerException if <code>seq</code> is null.
+ * @exception IndexOutOfBoundsException if <code>index</code>
+ * is negative or larger then the length of the char sequence,
+ * or if <code>codePointOffset</code> is positive and the
+ * subsequence starting with <code>index</code> has fewer than
+ * <code>codePointOffset</code> code points, or if
+ * <code>codePointOffset</code> is negative and the subsequence
+ * before <code>index</code> has fewer than the absolute value
+ * of <code>codePointOffset</code> code points.
+ * @since 1.5
+ */
+ public static int offsetByCodePoints(CharSequence seq, int index,
+ int codePointOffset) {
+ int length = seq.length();
+ if (index < 0 || index > length) {
+ throw new IndexOutOfBoundsException();
+ }
+
+ int x = index;
+ if (codePointOffset >= 0) {
+ int i;
+ for (i = 0; x < length && i < codePointOffset; i++) {
+ if (isHighSurrogate(seq.charAt(x++))) {
+ if (x < length && isLowSurrogate(seq.charAt(x))) {
+ x++;
+ }
+ }
+ }
+ if (i < codePointOffset) {
+ throw new IndexOutOfBoundsException();
+ }
+ } else {
+ int i;
+ for (i = codePointOffset; x > 0 && i < 0; i++) {
+ if (isLowSurrogate(seq.charAt(--x))) {
+ if (x > 0 && isHighSurrogate(seq.charAt(x-1))) {
+ x--;
+ }
+ }
+ }
+ if (i < 0) {
+ throw new IndexOutOfBoundsException();
+ }
+ }
+ return x;
+ }
+
+ /**
+ * Returns the index within the given <code>char</code> subarray
+ * that is offset from the given <code>index</code> by
+ * <code>codePointOffset</code> code points. The
+ * <code>start</code> and <code>count</code> arguments specify a
+ * subarray of the <code>char</code> array. Unpaired surrogates
+ * within the text range given by <code>index</code> and
+ * <code>codePointOffset</code> count as one code point each.
+ *
+ * @param a the <code>char</code> array
+ * @param start the index of the first <code>char</code> of the
+ * subarray
+ * @param count the length of the subarray in <code>char</code>s
+ * @param index the index to be offset
+ * @param codePointOffset the offset in code points
+ * @return the index within the subarray
+ * @exception NullPointerException if <code>a</code> is null.
+ * @exception IndexOutOfBoundsException
+ * if <code>start</code> or <code>count</code> is negative,
+ * or if <code>start + count</code> is larger than the length of
+ * the given array,
+ * or if <code>index</code> is less than <code>start</code> or
+ * larger then <code>start + count</code>,
+ * or if <code>codePointOffset</code> is positive and the text range
+ * starting with <code>index</code> and ending with <code>start
+ * + count - 1</code> has fewer than <code>codePointOffset</code> code
+ * points,
+ * or if <code>codePointOffset</code> is negative and the text range
+ * starting with <code>start</code> and ending with <code>index
+ * - 1</code> has fewer than the absolute value of
+ * <code>codePointOffset</code> code points.
+ * @since 1.5
+ */
+ public static int offsetByCodePoints(char[] a, int start, int count,
+ int index, int codePointOffset) {
+ if (count > a.length-start || start < 0 || count < 0
+ || index < start || index > start+count) {
+ throw new IndexOutOfBoundsException();
+ }
+ return offsetByCodePointsImpl(a, start, count, index, codePointOffset);
+ }
+
+ static int offsetByCodePointsImpl(char[]a, int start, int count,
+ int index, int codePointOffset) {
+ int x = index;
+ if (codePointOffset >= 0) {
+ int limit = start + count;
+ int i;
+ for (i = 0; x < limit && i < codePointOffset; i++) {
+ if (isHighSurrogate(a[x++])) {
+ if (x < limit && isLowSurrogate(a[x])) {
+ x++;
+ }
+ }
+ }
+ if (i < codePointOffset) {
+ throw new IndexOutOfBoundsException();
+ }
+ } else {
+ int i;
+ for (i = codePointOffset; x > start && i < 0; i++) {
+ if (isLowSurrogate(a[--x])) {
+ if (x > start && isHighSurrogate(a[x-1])) {
+ x--;
+ }
+ }
+ }
+ if (i < 0) {
+ throw new IndexOutOfBoundsException();
+ }
+ }
+ return x;
+ }
+
+ /**
+ * Determines if the specified character is a lowercase character.
+ * <p>
+ * A character is lowercase if its general category type, provided
+ * by <code>Character.getType(ch)</code>, is
+ * <code>LOWERCASE_LETTER</code>.
+ * <p>
+ * The following are examples of lowercase characters:
+ * <p><blockquote><pre>
+ * a b c d e f g h i j k l m n o p q r s t u v w x y z
+ * '\u00DF' '\u00E0' '\u00E1' '\u00E2' '\u00E3' '\u00E4' '\u00E5' '\u00E6'
+ * '\u00E7' '\u00E8' '\u00E9' '\u00EA' '\u00EB' '\u00EC' '\u00ED' '\u00EE'
+ * '\u00EF' '\u00F0' '\u00F1' '\u00F2' '\u00F3' '\u00F4' '\u00F5' '\u00F6'
+ * '\u00F8' '\u00F9' '\u00FA' '\u00FB' '\u00FC' '\u00FD' '\u00FE' '\u00FF'
+ * </pre></blockquote>
+ * <p> Many other Unicode characters are lowercase too.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isLowerCase(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character is lowercase;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isLowerCase(char)
+ * @see java.lang.Character#isTitleCase(char)
+ * @see java.lang.Character#toLowerCase(char)
+ * @see java.lang.Character#getType(char)
+ */
+ public static boolean isLowerCase(char ch) {
+ return isLowerCase((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is a
+ * lowercase character.
+ * <p>
+ * A character is lowercase if its general category type, provided
+ * by {@link Character#getType getType(codePoint)}, is
+ * <code>LOWERCASE_LETTER</code>.
+ * <p>
+ * The following are examples of lowercase characters:
+ * <p><blockquote><pre>
+ * a b c d e f g h i j k l m n o p q r s t u v w x y z
+ * '\u00DF' '\u00E0' '\u00E1' '\u00E2' '\u00E3' '\u00E4' '\u00E5' '\u00E6'
+ * '\u00E7' '\u00E8' '\u00E9' '\u00EA' '\u00EB' '\u00EC' '\u00ED' '\u00EE'
+ * '\u00EF' '\u00F0' '\u00F1' '\u00F2' '\u00F3' '\u00F4' '\u00F5' '\u00F6'
+ * '\u00F8' '\u00F9' '\u00FA' '\u00FB' '\u00FC' '\u00FD' '\u00FE' '\u00FF'
+ * </pre></blockquote>
+ * <p> Many other Unicode characters are lowercase too.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character is lowercase;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isLowerCase(int)
+ * @see java.lang.Character#isTitleCase(int)
+ * @see java.lang.Character#toLowerCase(int)
+ * @see java.lang.Character#getType(int)
+ * @since 1.5
+ */
+ public static boolean isLowerCase(int codePoint) {
+ return getType(codePoint) == Character.LOWERCASE_LETTER;
+ }
+
+ /**
+ * Determines if the specified character is an uppercase character.
+ * <p>
+ * A character is uppercase if its general category type, provided by
+ * <code>Character.getType(ch)</code>, is <code>UPPERCASE_LETTER</code>.
+ * <p>
+ * The following are examples of uppercase characters:
+ * <p><blockquote><pre>
+ * A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+ * '\u00C0' '\u00C1' '\u00C2' '\u00C3' '\u00C4' '\u00C5' '\u00C6' '\u00C7'
+ * '\u00C8' '\u00C9' '\u00CA' '\u00CB' '\u00CC' '\u00CD' '\u00CE' '\u00CF'
+ * '\u00D0' '\u00D1' '\u00D2' '\u00D3' '\u00D4' '\u00D5' '\u00D6' '\u00D8'
+ * '\u00D9' '\u00DA' '\u00DB' '\u00DC' '\u00DD' '\u00DE'
+ * </pre></blockquote>
+ * <p> Many other Unicode characters are uppercase too.<p>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isUpperCase(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character is uppercase;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isLowerCase(char)
+ * @see java.lang.Character#isTitleCase(char)
+ * @see java.lang.Character#toUpperCase(char)
+ * @see java.lang.Character#getType(char)
+ * @since 1.0
+ */
+ public static boolean isUpperCase(char ch) {
+ return isUpperCase((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is an uppercase character.
+ * <p>
+ * A character is uppercase if its general category type, provided by
+ * {@link Character#getType(int) getType(codePoint)}, is <code>UPPERCASE_LETTER</code>.
+ * <p>
+ * The following are examples of uppercase characters:
+ * <p><blockquote><pre>
+ * A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+ * '\u00C0' '\u00C1' '\u00C2' '\u00C3' '\u00C4' '\u00C5' '\u00C6' '\u00C7'
+ * '\u00C8' '\u00C9' '\u00CA' '\u00CB' '\u00CC' '\u00CD' '\u00CE' '\u00CF'
+ * '\u00D0' '\u00D1' '\u00D2' '\u00D3' '\u00D4' '\u00D5' '\u00D6' '\u00D8'
+ * '\u00D9' '\u00DA' '\u00DB' '\u00DC' '\u00DD' '\u00DE'
+ * </pre></blockquote>
+ * <p> Many other Unicode characters are uppercase too.<p>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character is uppercase;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isLowerCase(int)
+ * @see java.lang.Character#isTitleCase(int)
+ * @see java.lang.Character#toUpperCase(int)
+ * @see java.lang.Character#getType(int)
+ * @since 1.5
+ */
+ public static boolean isUpperCase(int codePoint) {
+ return getType(codePoint) == Character.UPPERCASE_LETTER;
+ }
+
+ /**
+ * Determines if the specified character is a titlecase character.
+ * <p>
+ * A character is a titlecase character if its general
+ * category type, provided by <code>Character.getType(ch)</code>,
+ * is <code>TITLECASE_LETTER</code>.
+ * <p>
+ * Some characters look like pairs of Latin letters. For example, there
+ * is an uppercase letter that looks like "LJ" and has a corresponding
+ * lowercase letter that looks like "lj". A third form, which looks like "Lj",
+ * is the appropriate form to use when rendering a word in lowercase
+ * with initial capitals, as for a book title.
+ * <p>
+ * These are some of the Unicode characters for which this method returns
+ * <code>true</code>:
+ * <ul>
+ * <li><code>LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON</code>
+ * <li><code>LATIN CAPITAL LETTER L WITH SMALL LETTER J</code>
+ * <li><code>LATIN CAPITAL LETTER N WITH SMALL LETTER J</code>
+ * <li><code>LATIN CAPITAL LETTER D WITH SMALL LETTER Z</code>
+ * </ul>
+ * <p> Many other Unicode characters are titlecase too.<p>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isTitleCase(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character is titlecase;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isLowerCase(char)
+ * @see java.lang.Character#isUpperCase(char)
+ * @see java.lang.Character#toTitleCase(char)
+ * @see java.lang.Character#getType(char)
+ * @since 1.0.2
+ */
+ public static boolean isTitleCase(char ch) {
+ return isTitleCase((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is a titlecase character.
+ * <p>
+ * A character is a titlecase character if its general
+ * category type, provided by {@link Character#getType(int) getType(codePoint)},
+ * is <code>TITLECASE_LETTER</code>.
+ * <p>
+ * Some characters look like pairs of Latin letters. For example, there
+ * is an uppercase letter that looks like "LJ" and has a corresponding
+ * lowercase letter that looks like "lj". A third form, which looks like "Lj",
+ * is the appropriate form to use when rendering a word in lowercase
+ * with initial capitals, as for a book title.
+ * <p>
+ * These are some of the Unicode characters for which this method returns
+ * <code>true</code>:
+ * <ul>
+ * <li><code>LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON</code>
+ * <li><code>LATIN CAPITAL LETTER L WITH SMALL LETTER J</code>
+ * <li><code>LATIN CAPITAL LETTER N WITH SMALL LETTER J</code>
+ * <li><code>LATIN CAPITAL LETTER D WITH SMALL LETTER Z</code>
+ * </ul>
+ * <p> Many other Unicode characters are titlecase too.<p>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character is titlecase;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isLowerCase(int)
+ * @see java.lang.Character#isUpperCase(int)
+ * @see java.lang.Character#toTitleCase(int)
+ * @see java.lang.Character#getType(int)
+ * @since 1.5
+ */
+ public static boolean isTitleCase(int codePoint) {
+ return getType(codePoint) == Character.TITLECASE_LETTER;
+ }
+
+ /**
+ * Determines if the specified character is a digit.
+ * <p>
+ * A character is a digit if its general category type, provided
+ * by <code>Character.getType(ch)</code>, is
+ * <code>DECIMAL_DIGIT_NUMBER</code>.
+ * <p>
+ * Some Unicode character ranges that contain digits:
+ * <ul>
+ * <li><code>'\u0030'</code> through <code>'\u0039'</code>,
+ * ISO-LATIN-1 digits (<code>'0'</code> through <code>'9'</code>)
+ * <li><code>'\u0660'</code> through <code>'\u0669'</code>,
+ * Arabic-Indic digits
+ * <li><code>'\u06F0'</code> through <code>'\u06F9'</code>,
+ * Extended Arabic-Indic digits
+ * <li><code>'\u0966'</code> through <code>'\u096F'</code>,
+ * Devanagari digits
+ * <li><code>'\uFF10'</code> through <code>'\uFF19'</code>,
+ * Fullwidth digits
+ * </ul>
+ *
+ * Many other character ranges contain digits as well.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isDigit(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character is a digit;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#digit(char, int)
+ * @see java.lang.Character#forDigit(int, int)
+ * @see java.lang.Character#getType(char)
+ */
+ public static boolean isDigit(char ch) {
+ return isDigit((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is a digit.
+ * <p>
+ * A character is a digit if its general category type, provided
+ * by {@link Character#getType(int) getType(codePoint)}, is
+ * <code>DECIMAL_DIGIT_NUMBER</code>.
+ * <p>
+ * Some Unicode character ranges that contain digits:
+ * <ul>
+ * <li><code>'\u0030'</code> through <code>'\u0039'</code>,
+ * ISO-LATIN-1 digits (<code>'0'</code> through <code>'9'</code>)
+ * <li><code>'\u0660'</code> through <code>'\u0669'</code>,
+ * Arabic-Indic digits
+ * <li><code>'\u06F0'</code> through <code>'\u06F9'</code>,
+ * Extended Arabic-Indic digits
+ * <li><code>'\u0966'</code> through <code>'\u096F'</code>,
+ * Devanagari digits
+ * <li><code>'\uFF10'</code> through <code>'\uFF19'</code>,
+ * Fullwidth digits
+ * </ul>
+ *
+ * Many other character ranges contain digits as well.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character is a digit;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#forDigit(int, int)
+ * @see java.lang.Character#getType(int)
+ * @since 1.5
+ */
+ public static boolean isDigit(int codePoint) {
+ return getType(codePoint) == Character.DECIMAL_DIGIT_NUMBER;
+ }
+
+ /**
+ * Determines if a character is defined in Unicode.
+ * <p>
+ * A character is defined if at least one of the following is true:
+ * <ul>
+ * <li>It has an entry in the UnicodeData file.
+ * <li>It has a value in a range defined by the UnicodeData file.
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isDefined(int)} method.
+ *
+ * @param ch the character to be tested
+ * @return <code>true</code> if the character has a defined meaning
+ * in Unicode; <code>false</code> otherwise.
+ * @see java.lang.Character#isDigit(char)
+ * @see java.lang.Character#isLetter(char)
+ * @see java.lang.Character#isLetterOrDigit(char)
+ * @see java.lang.Character#isLowerCase(char)
+ * @see java.lang.Character#isTitleCase(char)
+ * @see java.lang.Character#isUpperCase(char)
+ * @since 1.0.2
+ */
+ public static boolean isDefined(char ch) {
+ return isDefined((int)ch);
+ }
+
+ /**
+ * Determines if a character (Unicode code point) is defined in Unicode.
+ * <p>
+ * A character is defined if at least one of the following is true:
+ * <ul>
+ * <li>It has an entry in the UnicodeData file.
+ * <li>It has a value in a range defined by the UnicodeData file.
+ * </ul>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character has a defined meaning
+ * in Unicode; <code>false</code> otherwise.
+ * @see java.lang.Character#isDigit(int)
+ * @see java.lang.Character#isLetter(int)
+ * @see java.lang.Character#isLetterOrDigit(int)
+ * @see java.lang.Character#isLowerCase(int)
+ * @see java.lang.Character#isTitleCase(int)
+ * @see java.lang.Character#isUpperCase(int)
+ * @since 1.5
+ */
+ public static boolean isDefined(int codePoint) {
+ return getType(codePoint) != Character.UNASSIGNED;
+ }
+
+ /**
+ * Determines if the specified character is a letter.
+ * <p>
+ * A character is considered to be a letter if its general
+ * category type, provided by <code>Character.getType(ch)</code>,
+ * is any of the following:
+ * <ul>
+ * <li> <code>UPPERCASE_LETTER</code>
+ * <li> <code>LOWERCASE_LETTER</code>
+ * <li> <code>TITLECASE_LETTER</code>
+ * <li> <code>MODIFIER_LETTER</code>
+ * <li> <code>OTHER_LETTER</code>
+ * </ul>
+ *
+ * Not all letters have case. Many characters are
+ * letters but are neither uppercase nor lowercase nor titlecase.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isLetter(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character is a letter;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isDigit(char)
+ * @see java.lang.Character#isJavaIdentifierStart(char)
+ * @see java.lang.Character#isJavaLetter(char)
+ * @see java.lang.Character#isJavaLetterOrDigit(char)
+ * @see java.lang.Character#isLetterOrDigit(char)
+ * @see java.lang.Character#isLowerCase(char)
+ * @see java.lang.Character#isTitleCase(char)
+ * @see java.lang.Character#isUnicodeIdentifierStart(char)
+ * @see java.lang.Character#isUpperCase(char)
+ */
+ public static boolean isLetter(char ch) {
+ return isLetter((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is a letter.
+ * <p>
+ * A character is considered to be a letter if its general
+ * category type, provided by {@link Character#getType(int) getType(codePoint)},
+ * is any of the following:
+ * <ul>
+ * <li> <code>UPPERCASE_LETTER</code>
+ * <li> <code>LOWERCASE_LETTER</code>
+ * <li> <code>TITLECASE_LETTER</code>
+ * <li> <code>MODIFIER_LETTER</code>
+ * <li> <code>OTHER_LETTER</code>
+ * </ul>
+ *
+ * Not all letters have case. Many characters are
+ * letters but are neither uppercase nor lowercase nor titlecase.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character is a letter;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isDigit(int)
+ * @see java.lang.Character#isJavaIdentifierStart(int)
+ * @see java.lang.Character#isLetterOrDigit(int)
+ * @see java.lang.Character#isLowerCase(int)
+ * @see java.lang.Character#isTitleCase(int)
+ * @see java.lang.Character#isUnicodeIdentifierStart(int)
+ * @see java.lang.Character#isUpperCase(int)
+ * @since 1.5
+ */
+ public static boolean isLetter(int codePoint) {
+ return ((((1 << Character.UPPERCASE_LETTER) |
+ (1 << Character.LOWERCASE_LETTER) |
+ (1 << Character.TITLECASE_LETTER) |
+ (1 << Character.MODIFIER_LETTER) |
+ (1 << Character.OTHER_LETTER)) >> getType(codePoint)) & 1)
+ != 0;
+ }
+
+ /**
+ * Determines if the specified character is a letter or digit.
+ * <p>
+ * A character is considered to be a letter or digit if either
+ * <code>Character.isLetter(char ch)</code> or
+ * <code>Character.isDigit(char ch)</code> returns
+ * <code>true</code> for the character.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isLetterOrDigit(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character is a letter or digit;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isDigit(char)
+ * @see java.lang.Character#isJavaIdentifierPart(char)
+ * @see java.lang.Character#isJavaLetter(char)
+ * @see java.lang.Character#isJavaLetterOrDigit(char)
+ * @see java.lang.Character#isLetter(char)
+ * @see java.lang.Character#isUnicodeIdentifierPart(char)
+ * @since 1.0.2
+ */
+ public static boolean isLetterOrDigit(char ch) {
+ return isLetterOrDigit((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is a letter or digit.
+ * <p>
+ * A character is considered to be a letter or digit if either
+ * {@link #isLetter(int) isLetter(codePoint)} or
+ * {@link #isDigit(int) isDigit(codePoint)} returns
+ * <code>true</code> for the character.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character is a letter or digit;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isDigit(int)
+ * @see java.lang.Character#isJavaIdentifierPart(int)
+ * @see java.lang.Character#isLetter(int)
+ * @see java.lang.Character#isUnicodeIdentifierPart(int)
+ * @since 1.5
+ */
+ public static boolean isLetterOrDigit(int codePoint) {
+ return ((((1 << Character.UPPERCASE_LETTER) |
+ (1 << Character.LOWERCASE_LETTER) |
+ (1 << Character.TITLECASE_LETTER) |
+ (1 << Character.MODIFIER_LETTER) |
+ (1 << Character.OTHER_LETTER) |
+ (1 << Character.DECIMAL_DIGIT_NUMBER)) >> getType(codePoint)) & 1)
+ != 0;
+ }
+
+ /**
+ * Determines if the specified character is permissible as the first
+ * character in a Java identifier.
+ * <p>
+ * A character may start a Java identifier if and only if
+ * one of the following is true:
+ * <ul>
+ * <li> {@link #isLetter(char) isLetter(ch)} returns <code>true</code>
+ * <li> {@link #getType(char) getType(ch)} returns <code>LETTER_NUMBER</code>
+ * <li> ch is a currency symbol (such as "$")
+ * <li> ch is a connecting punctuation character (such as "_").
+ * </ul>
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character may start a Java
+ * identifier; <code>false</code> otherwise.
+ * @see java.lang.Character#isJavaLetterOrDigit(char)
+ * @see java.lang.Character#isJavaIdentifierStart(char)
+ * @see java.lang.Character#isJavaIdentifierPart(char)
+ * @see java.lang.Character#isLetter(char)
+ * @see java.lang.Character#isLetterOrDigit(char)
+ * @see java.lang.Character#isUnicodeIdentifierStart(char)
+ * @since 1.02
+ * @deprecated Replaced by isJavaIdentifierStart(char).
+ */
+ @Deprecated
+ public static boolean isJavaLetter(char ch) {
+ return isJavaIdentifierStart(ch);
+ }
+
+ /**
+ * Determines if the specified character may be part of a Java
+ * identifier as other than the first character.
+ * <p>
+ * A character may be part of a Java identifier if and only if any
+ * of the following are true:
+ * <ul>
+ * <li> it is a letter
+ * <li> it is a currency symbol (such as <code>'$'</code>)
+ * <li> it is a connecting punctuation character (such as <code>'_'</code>)
+ * <li> it is a digit
+ * <li> it is a numeric letter (such as a Roman numeral character)
+ * <li> it is a combining mark
+ * <li> it is a non-spacing mark
+ * <li> <code>isIdentifierIgnorable</code> returns
+ * <code>true</code> for the character.
+ * </ul>
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character may be part of a
+ * Java identifier; <code>false</code> otherwise.
+ * @see java.lang.Character#isJavaLetter(char)
+ * @see java.lang.Character#isJavaIdentifierStart(char)
+ * @see java.lang.Character#isJavaIdentifierPart(char)
+ * @see java.lang.Character#isLetter(char)
+ * @see java.lang.Character#isLetterOrDigit(char)
+ * @see java.lang.Character#isUnicodeIdentifierPart(char)
+ * @see java.lang.Character#isIdentifierIgnorable(char)
+ * @since 1.02
+ * @deprecated Replaced by isJavaIdentifierPart(char).
+ */
+ @Deprecated
+ public static boolean isJavaLetterOrDigit(char ch) {
+ return isJavaIdentifierPart(ch);
+ }
+
+ /**
+ * Determines if the specified character is
+ * permissible as the first character in a Java identifier.
+ * <p>
+ * A character may start a Java identifier if and only if
+ * one of the following conditions is true:
+ * <ul>
+ * <li> {@link #isLetter(char) isLetter(ch)} returns <code>true</code>
+ * <li> {@link #getType(char) getType(ch)} returns <code>LETTER_NUMBER</code>
+ * <li> ch is a currency symbol (such as "$")
+ * <li> ch is a connecting punctuation character (such as "_").
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isJavaIdentifierStart(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character may start a Java identifier;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isJavaIdentifierPart(char)
+ * @see java.lang.Character#isLetter(char)
+ * @see java.lang.Character#isUnicodeIdentifierStart(char)
+ * @see javax.lang.model.SourceVersion#isIdentifier(CharSequence)
+ * @since 1.1
+ */
+ public static boolean isJavaIdentifierStart(char ch) {
+ return isJavaIdentifierStart((int)ch);
+ }
+
+ /**
+ * Determines if the character (Unicode code point) is
+ * permissible as the first character in a Java identifier.
+ * <p>
+ * A character may start a Java identifier if and only if
+ * one of the following conditions is true:
+ * <ul>
+ * <li> {@link #isLetter(int) isLetter(codePoint)}
+ * returns <code>true</code>
+ * <li> {@link #getType(int) getType(codePoint)}
+ * returns <code>LETTER_NUMBER</code>
+ * <li> the referenced character is a currency symbol (such as "$")
+ * <li> the referenced character is a connecting punctuation character
+ * (such as "_").
+ * </ul>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character may start a Java identifier;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isJavaIdentifierPart(int)
+ * @see java.lang.Character#isLetter(int)
+ * @see java.lang.Character#isUnicodeIdentifierStart(int)
+ * @see javax.lang.model.SourceVersion#isIdentifier(CharSequence)
+ * @since 1.5
+ */
+ public static boolean isJavaIdentifierStart(int codePoint) {
+ return CharacterData.of(codePoint).isJavaIdentifierStart(codePoint);
+ }
+
+ /**
+ * Determines if the specified character may be part of a Java
+ * identifier as other than the first character.
+ * <p>
+ * A character may be part of a Java identifier if any of the following
+ * are true:
+ * <ul>
+ * <li> it is a letter
+ * <li> it is a currency symbol (such as <code>'$'</code>)
+ * <li> it is a connecting punctuation character (such as <code>'_'</code>)
+ * <li> it is a digit
+ * <li> it is a numeric letter (such as a Roman numeral character)
+ * <li> it is a combining mark
+ * <li> it is a non-spacing mark
+ * <li> <code>isIdentifierIgnorable</code> returns
+ * <code>true</code> for the character
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isJavaIdentifierPart(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character may be part of a
+ * Java identifier; <code>false</code> otherwise.
+ * @see java.lang.Character#isIdentifierIgnorable(char)
+ * @see java.lang.Character#isJavaIdentifierStart(char)
+ * @see java.lang.Character#isLetterOrDigit(char)
+ * @see java.lang.Character#isUnicodeIdentifierPart(char)
+ * @see javax.lang.model.SourceVersion#isIdentifier(CharSequence)
+ * @since 1.1
+ */
+ public static boolean isJavaIdentifierPart(char ch) {
+ return isJavaIdentifierPart((int)ch);
+ }
+
+ /**
+ * Determines if the character (Unicode code point) may be part of a Java
+ * identifier as other than the first character.
+ * <p>
+ * A character may be part of a Java identifier if any of the following
+ * are true:
+ * <ul>
+ * <li> it is a letter
+ * <li> it is a currency symbol (such as <code>'$'</code>)
+ * <li> it is a connecting punctuation character (such as <code>'_'</code>)
+ * <li> it is a digit
+ * <li> it is a numeric letter (such as a Roman numeral character)
+ * <li> it is a combining mark
+ * <li> it is a non-spacing mark
+ * <li> {@link #isIdentifierIgnorable(int)
+ * isIdentifierIgnorable(codePoint)} returns <code>true</code> for
+ * the character
+ * </ul>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character may be part of a
+ * Java identifier; <code>false</code> otherwise.
+ * @see java.lang.Character#isIdentifierIgnorable(int)
+ * @see java.lang.Character#isJavaIdentifierStart(int)
+ * @see java.lang.Character#isLetterOrDigit(int)
+ * @see java.lang.Character#isUnicodeIdentifierPart(int)
+ * @see javax.lang.model.SourceVersion#isIdentifier(CharSequence)
+ * @since 1.5
+ */
+ public static boolean isJavaIdentifierPart(int codePoint) {
+ return CharacterData.of(codePoint).isJavaIdentifierPart(codePoint);
+ }
+
+ /**
+ * Determines if the specified character is permissible as the
+ * first character in a Unicode identifier.
+ * <p>
+ * A character may start a Unicode identifier if and only if
+ * one of the following conditions is true:
+ * <ul>
+ * <li> {@link #isLetter(char) isLetter(ch)} returns <code>true</code>
+ * <li> {@link #getType(char) getType(ch)} returns
+ * <code>LETTER_NUMBER</code>.
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isUnicodeIdentifierStart(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character may start a Unicode
+ * identifier; <code>false</code> otherwise.
+ * @see java.lang.Character#isJavaIdentifierStart(char)
+ * @see java.lang.Character#isLetter(char)
+ * @see java.lang.Character#isUnicodeIdentifierPart(char)
+ * @since 1.1
+ */
+ public static boolean isUnicodeIdentifierStart(char ch) {
+ return isUnicodeIdentifierStart((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is permissible as the
+ * first character in a Unicode identifier.
+ * <p>
+ * A character may start a Unicode identifier if and only if
+ * one of the following conditions is true:
+ * <ul>
+ * <li> {@link #isLetter(int) isLetter(codePoint)}
+ * returns <code>true</code>
+ * <li> {@link #getType(int) getType(codePoint)}
+ * returns <code>LETTER_NUMBER</code>.
+ * </ul>
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character may start a Unicode
+ * identifier; <code>false</code> otherwise.
+ * @see java.lang.Character#isJavaIdentifierStart(int)
+ * @see java.lang.Character#isLetter(int)
+ * @see java.lang.Character#isUnicodeIdentifierPart(int)
+ * @since 1.5
+ */
+ public static boolean isUnicodeIdentifierStart(int codePoint) {
+ return CharacterData.of(codePoint).isUnicodeIdentifierStart(codePoint);
+ }
+
+ /**
+ * Determines if the specified character may be part of a Unicode
+ * identifier as other than the first character.
+ * <p>
+ * A character may be part of a Unicode identifier if and only if
+ * one of the following statements is true:
+ * <ul>
+ * <li> it is a letter
+ * <li> it is a connecting punctuation character (such as <code>'_'</code>)
+ * <li> it is a digit
+ * <li> it is a numeric letter (such as a Roman numeral character)
+ * <li> it is a combining mark
+ * <li> it is a non-spacing mark
+ * <li> <code>isIdentifierIgnorable</code> returns
+ * <code>true</code> for this character.
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isUnicodeIdentifierPart(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character may be part of a
+ * Unicode identifier; <code>false</code> otherwise.
+ * @see java.lang.Character#isIdentifierIgnorable(char)
+ * @see java.lang.Character#isJavaIdentifierPart(char)
+ * @see java.lang.Character#isLetterOrDigit(char)
+ * @see java.lang.Character#isUnicodeIdentifierStart(char)
+ * @since 1.1
+ */
+ public static boolean isUnicodeIdentifierPart(char ch) {
+ return isUnicodeIdentifierPart((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) may be part of a Unicode
+ * identifier as other than the first character.
+ * <p>
+ * A character may be part of a Unicode identifier if and only if
+ * one of the following statements is true:
+ * <ul>
+ * <li> it is a letter
+ * <li> it is a connecting punctuation character (such as <code>'_'</code>)
+ * <li> it is a digit
+ * <li> it is a numeric letter (such as a Roman numeral character)
+ * <li> it is a combining mark
+ * <li> it is a non-spacing mark
+ * <li> <code>isIdentifierIgnorable</code> returns
+ * <code>true</code> for this character.
+ * </ul>
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character may be part of a
+ * Unicode identifier; <code>false</code> otherwise.
+ * @see java.lang.Character#isIdentifierIgnorable(int)
+ * @see java.lang.Character#isJavaIdentifierPart(int)
+ * @see java.lang.Character#isLetterOrDigit(int)
+ * @see java.lang.Character#isUnicodeIdentifierStart(int)
+ * @since 1.5
+ */
+ public static boolean isUnicodeIdentifierPart(int codePoint) {
+ return CharacterData.of(codePoint).isUnicodeIdentifierPart(codePoint);
+ }
+
+ /**
+ * Determines if the specified character should be regarded as
+ * an ignorable character in a Java identifier or a Unicode identifier.
+ * <p>
+ * The following Unicode characters are ignorable in a Java identifier
+ * or a Unicode identifier:
+ * <ul>
+ * <li>ISO control characters that are not whitespace
+ * <ul>
+ * <li><code>'\u0000'</code> through <code>'\u0008'</code>
+ * <li><code>'\u000E'</code> through <code>'\u001B'</code>
+ * <li><code>'\u007F'</code> through <code>'\u009F'</code>
+ * </ul>
+ *
+ * <li>all characters that have the <code>FORMAT</code> general
+ * category value
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isIdentifierIgnorable(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character is an ignorable control
+ * character that may be part of a Java or Unicode identifier;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isJavaIdentifierPart(char)
+ * @see java.lang.Character#isUnicodeIdentifierPart(char)
+ * @since 1.1
+ */
+ public static boolean isIdentifierIgnorable(char ch) {
+ return isIdentifierIgnorable((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) should be regarded as
+ * an ignorable character in a Java identifier or a Unicode identifier.
+ * <p>
+ * The following Unicode characters are ignorable in a Java identifier
+ * or a Unicode identifier:
+ * <ul>
+ * <li>ISO control characters that are not whitespace
+ * <ul>
+ * <li><code>'\u0000'</code> through <code>'\u0008'</code>
+ * <li><code>'\u000E'</code> through <code>'\u001B'</code>
+ * <li><code>'\u007F'</code> through <code>'\u009F'</code>
+ * </ul>
+ *
+ * <li>all characters that have the <code>FORMAT</code> general
+ * category value
+ * </ul>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character is an ignorable control
+ * character that may be part of a Java or Unicode identifier;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isJavaIdentifierPart(int)
+ * @see java.lang.Character#isUnicodeIdentifierPart(int)
+ * @since 1.5
+ */
+ public static boolean isIdentifierIgnorable(int codePoint) {
+ return CharacterData.of(codePoint).isIdentifierIgnorable(codePoint);
+ }
+
+ /**
+ * Converts the character argument to lowercase using case
+ * mapping information from the UnicodeData file.
+ * <p>
+ * Note that
+ * <code>Character.isLowerCase(Character.toLowerCase(ch))</code>
+ * does not always return <code>true</code> for some ranges of
+ * characters, particularly those that are symbols or ideographs.
+ *
+ * <p>In general, {@link java.lang.String#toLowerCase()} should be used to map
+ * characters to lowercase. <code>String</code> case mapping methods
+ * have several benefits over <code>Character</code> case mapping methods.
+ * <code>String</code> case mapping methods can perform locale-sensitive
+ * mappings, context-sensitive mappings, and 1:M character mappings, whereas
+ * the <code>Character</code> case mapping methods cannot.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #toLowerCase(int)} method.
+ *
+ * @param ch the character to be converted.
+ * @return the lowercase equivalent of the character, if any;
+ * otherwise, the character itself.
+ * @see java.lang.Character#isLowerCase(char)
+ * @see java.lang.String#toLowerCase()
+ */
+ public static char toLowerCase(char ch) {
+ return (char)toLowerCase((int)ch);
+ }
+
+ /**
+ * Converts the character (Unicode code point) argument to
+ * lowercase using case mapping information from the UnicodeData
+ * file.
+ *
+ * <p> Note that
+ * <code>Character.isLowerCase(Character.toLowerCase(codePoint))</code>
+ * does not always return <code>true</code> for some ranges of
+ * characters, particularly those that are symbols or ideographs.
+ *
+ * <p>In general, {@link java.lang.String#toLowerCase()} should be used to map
+ * characters to lowercase. <code>String</code> case mapping methods
+ * have several benefits over <code>Character</code> case mapping methods.
+ * <code>String</code> case mapping methods can perform locale-sensitive
+ * mappings, context-sensitive mappings, and 1:M character mappings, whereas
+ * the <code>Character</code> case mapping methods cannot.
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @return the lowercase equivalent of the character (Unicode code
+ * point), if any; otherwise, the character itself.
+ * @see java.lang.Character#isLowerCase(int)
+ * @see java.lang.String#toLowerCase()
+ *
+ * @since 1.5
+ */
+ public static int toLowerCase(int codePoint) {
+ return CharacterData.of(codePoint).toLowerCase(codePoint);
+ }
+
+ /**
+ * Converts the character argument to uppercase using case mapping
+ * information from the UnicodeData file.
+ * <p>
+ * Note that
+ * <code>Character.isUpperCase(Character.toUpperCase(ch))</code>
+ * does not always return <code>true</code> for some ranges of
+ * characters, particularly those that are symbols or ideographs.
+ *
+ * <p>In general, {@link java.lang.String#toUpperCase()} should be used to map
+ * characters to uppercase. <code>String</code> case mapping methods
+ * have several benefits over <code>Character</code> case mapping methods.
+ * <code>String</code> case mapping methods can perform locale-sensitive
+ * mappings, context-sensitive mappings, and 1:M character mappings, whereas
+ * the <code>Character</code> case mapping methods cannot.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #toUpperCase(int)} method.
+ *
+ * @param ch the character to be converted.
+ * @return the uppercase equivalent of the character, if any;
+ * otherwise, the character itself.
+ * @see java.lang.Character#isUpperCase(char)
+ * @see java.lang.String#toUpperCase()
+ */
+ public static char toUpperCase(char ch) {
+ return (char)toUpperCase((int)ch);
+ }
+
+ /**
+ * Converts the character (Unicode code point) argument to
+ * uppercase using case mapping information from the UnicodeData
+ * file.
+ *
+ * <p>Note that
+ * <code>Character.isUpperCase(Character.toUpperCase(codePoint))</code>
+ * does not always return <code>true</code> for some ranges of
+ * characters, particularly those that are symbols or ideographs.
+ *
+ * <p>In general, {@link java.lang.String#toUpperCase()} should be used to map
+ * characters to uppercase. <code>String</code> case mapping methods
+ * have several benefits over <code>Character</code> case mapping methods.
+ * <code>String</code> case mapping methods can perform locale-sensitive
+ * mappings, context-sensitive mappings, and 1:M character mappings, whereas
+ * the <code>Character</code> case mapping methods cannot.
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @return the uppercase equivalent of the character, if any;
+ * otherwise, the character itself.
+ * @see java.lang.Character#isUpperCase(int)
+ * @see java.lang.String#toUpperCase()
+ *
+ * @since 1.5
+ */
+ public static int toUpperCase(int codePoint) {
+ return CharacterData.of(codePoint).toUpperCase(codePoint);
+ }
+
+ /**
+ * Converts the character argument to titlecase using case mapping
+ * information from the UnicodeData file. If a character has no
+ * explicit titlecase mapping and is not itself a titlecase char
+ * according to UnicodeData, then the uppercase mapping is
+ * returned as an equivalent titlecase mapping. If the
+ * <code>char</code> argument is already a titlecase
+ * <code>char</code>, the same <code>char</code> value will be
+ * returned.
+ * <p>
+ * Note that
+ * <code>Character.isTitleCase(Character.toTitleCase(ch))</code>
+ * does not always return <code>true</code> for some ranges of
+ * characters.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #toTitleCase(int)} method.
+ *
+ * @param ch the character to be converted.
+ * @return the titlecase equivalent of the character, if any;
+ * otherwise, the character itself.
+ * @see java.lang.Character#isTitleCase(char)
+ * @see java.lang.Character#toLowerCase(char)
+ * @see java.lang.Character#toUpperCase(char)
+ * @since 1.0.2
+ */
+ public static char toTitleCase(char ch) {
+ return (char)toTitleCase((int)ch);
+ }
+
+ /**
+ * Converts the character (Unicode code point) argument to titlecase using case mapping
+ * information from the UnicodeData file. If a character has no
+ * explicit titlecase mapping and is not itself a titlecase char
+ * according to UnicodeData, then the uppercase mapping is
+ * returned as an equivalent titlecase mapping. If the
+ * character argument is already a titlecase
+ * character, the same character value will be
+ * returned.
+ *
+ * <p>Note that
+ * <code>Character.isTitleCase(Character.toTitleCase(codePoint))</code>
+ * does not always return <code>true</code> for some ranges of
+ * characters.
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @return the titlecase equivalent of the character, if any;
+ * otherwise, the character itself.
+ * @see java.lang.Character#isTitleCase(int)
+ * @see java.lang.Character#toLowerCase(int)
+ * @see java.lang.Character#toUpperCase(int)
+ * @since 1.5
+ */
+ public static int toTitleCase(int codePoint) {
+ return CharacterData.of(codePoint).toTitleCase(codePoint);
+ }
+
+ /**
+ * Returns the numeric value of the character <code>ch</code> in the
+ * specified radix.
+ * <p>
+ * If the radix is not in the range <code>MIN_RADIX</code> <=
+ * <code>radix</code> <= <code>MAX_RADIX</code> or if the
+ * value of <code>ch</code> is not a valid digit in the specified
+ * radix, <code>-1</code> is returned. A character is a valid digit
+ * if at least one of the following is true:
+ * <ul>
+ * <li>The method <code>isDigit</code> is <code>true</code> of the character
+ * and the Unicode decimal digit value of the character (or its
+ * single-character decomposition) is less than the specified radix.
+ * In this case the decimal digit value is returned.
+ * <li>The character is one of the uppercase Latin letters
+ * <code>'A'</code> through <code>'Z'</code> and its code is less than
+ * <code>radix + 'A' - 10</code>.
+ * In this case, <code>ch - 'A' + 10</code>
+ * is returned.
+ * <li>The character is one of the lowercase Latin letters
+ * <code>'a'</code> through <code>'z'</code> and its code is less than
+ * <code>radix + 'a' - 10</code>.
+ * In this case, <code>ch - 'a' + 10</code>
+ * is returned.
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #digit(int, int)} method.
+ *
+ * @param ch the character to be converted.
+ * @param radix the radix.
+ * @return the numeric value represented by the character in the
+ * specified radix.
+ * @see java.lang.Character#forDigit(int, int)
+ * @see java.lang.Character#isDigit(char)
+ */
+ public static int digit(char ch, int radix) {
+ return digit((int)ch, radix);
+ }
+
+ /**
+ * Returns the numeric value of the specified character (Unicode
+ * code point) in the specified radix.
+ *
+ * <p>If the radix is not in the range <code>MIN_RADIX</code> <=
+ * <code>radix</code> <= <code>MAX_RADIX</code> or if the
+ * character is not a valid digit in the specified
+ * radix, <code>-1</code> is returned. A character is a valid digit
+ * if at least one of the following is true:
+ * <ul>
+ * <li>The method {@link #isDigit(int) isDigit(codePoint)} is <code>true</code> of the character
+ * and the Unicode decimal digit value of the character (or its
+ * single-character decomposition) is less than the specified radix.
+ * In this case the decimal digit value is returned.
+ * <li>The character is one of the uppercase Latin letters
+ * <code>'A'</code> through <code>'Z'</code> and its code is less than
+ * <code>radix + 'A' - 10</code>.
+ * In this case, <code>ch - 'A' + 10</code>
+ * is returned.
+ * <li>The character is one of the lowercase Latin letters
+ * <code>'a'</code> through <code>'z'</code> and its code is less than
+ * <code>radix + 'a' - 10</code>.
+ * In this case, <code>ch - 'a' + 10</code>
+ * is returned.
+ * </ul>
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @param radix the radix.
+ * @return the numeric value represented by the character in the
+ * specified radix.
+ * @see java.lang.Character#forDigit(int, int)
+ * @see java.lang.Character#isDigit(int)
+ * @since 1.5
+ */
+ public static int digit(int codePoint, int radix) {
+ return CharacterData.of(codePoint).digit(codePoint, radix);
+ }
+
+ /**
+ * Returns the <code>int</code> value that the specified Unicode
+ * character represents. For example, the character
+ * <code>'\u216C'</code> (the roman numeral fifty) will return
+ * an int with a value of 50.
+ * <p>
+ * The letters A-Z in their uppercase (<code>'\u0041'</code> through
+ * <code>'\u005A'</code>), lowercase
+ * (<code>'\u0061'</code> through <code>'\u007A'</code>), and
+ * full width variant (<code>'\uFF21'</code> through
+ * <code>'\uFF3A'</code> and <code>'\uFF41'</code> through
+ * <code>'\uFF5A'</code>) forms have numeric values from 10
+ * through 35. This is independent of the Unicode specification,
+ * which does not assign numeric values to these <code>char</code>
+ * values.
+ * <p>
+ * If the character does not have a numeric value, then -1 is returned.
+ * If the character has a numeric value that cannot be represented as a
+ * nonnegative integer (for example, a fractional value), then -2
+ * is returned.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #getNumericValue(int)} method.
+ *
+ * @param ch the character to be converted.
+ * @return the numeric value of the character, as a nonnegative <code>int</code>
+ * value; -2 if the character has a numeric value that is not a
+ * nonnegative integer; -1 if the character has no numeric value.
+ * @see java.lang.Character#forDigit(int, int)
+ * @see java.lang.Character#isDigit(char)
+ * @since 1.1
+ */
+ public static int getNumericValue(char ch) {
+ return getNumericValue((int)ch);
+ }
+
+ /**
+ * Returns the <code>int</code> value that the specified
+ * character (Unicode code point) represents. For example, the character
+ * <code>'\u216C'</code> (the Roman numeral fifty) will return
+ * an <code>int</code> with a value of 50.
+ * <p>
+ * The letters A-Z in their uppercase (<code>'\u0041'</code> through
+ * <code>'\u005A'</code>), lowercase
+ * (<code>'\u0061'</code> through <code>'\u007A'</code>), and
+ * full width variant (<code>'\uFF21'</code> through
+ * <code>'\uFF3A'</code> and <code>'\uFF41'</code> through
+ * <code>'\uFF5A'</code>) forms have numeric values from 10
+ * through 35. This is independent of the Unicode specification,
+ * which does not assign numeric values to these <code>char</code>
+ * values.
+ * <p>
+ * If the character does not have a numeric value, then -1 is returned.
+ * If the character has a numeric value that cannot be represented as a
+ * nonnegative integer (for example, a fractional value), then -2
+ * is returned.
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @return the numeric value of the character, as a nonnegative <code>int</code>
+ * value; -2 if the character has a numeric value that is not a
+ * nonnegative integer; -1 if the character has no numeric value.
+ * @see java.lang.Character#forDigit(int, int)
+ * @see java.lang.Character#isDigit(int)
+ * @since 1.5
+ */
+ public static int getNumericValue(int codePoint) {
+ return CharacterData.of(codePoint).getNumericValue(codePoint);
+ }
+
+ /**
+ * Determines if the specified character is ISO-LATIN-1 white space.
+ * This method returns <code>true</code> for the following five
+ * characters only:
+ * <table>
+ * <tr><td><code>'\t'</code></td> <td><code>'\u0009'</code></td>
+ * <td><code>HORIZONTAL TABULATION</code></td></tr>
+ * <tr><td><code>'\n'</code></td> <td><code>'\u000A'</code></td>
+ * <td><code>NEW LINE</code></td></tr>
+ * <tr><td><code>'\f'</code></td> <td><code>'\u000C'</code></td>
+ * <td><code>FORM FEED</code></td></tr>
+ * <tr><td><code>'\r'</code></td> <td><code>'\u000D'</code></td>
+ * <td><code>CARRIAGE RETURN</code></td></tr>
+ * <tr><td><code>' '</code></td> <td><code>'\u0020'</code></td>
+ * <td><code>SPACE</code></td></tr>
+ * </table>
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character is ISO-LATIN-1 white
+ * space; <code>false</code> otherwise.
+ * @see java.lang.Character#isSpaceChar(char)
+ * @see java.lang.Character#isWhitespace(char)
+ * @deprecated Replaced by isWhitespace(char).
+ */
+ @Deprecated
+ public static boolean isSpace(char ch) {
+ return (ch <= 0x0020) &&
+ (((((1L << 0x0009) |
+ (1L << 0x000A) |
+ (1L << 0x000C) |
+ (1L << 0x000D) |
+ (1L << 0x0020)) >> ch) & 1L) != 0);
+ }
+
+
+ /**
+ * Determines if the specified character is a Unicode space character.
+ * A character is considered to be a space character if and only if
+ * it is specified to be a space character by the Unicode standard. This
+ * method returns true if the character's general category type is any of
+ * the following:
+ * <ul>
+ * <li> <code>SPACE_SEPARATOR</code>
+ * <li> <code>LINE_SEPARATOR</code>
+ * <li> <code>PARAGRAPH_SEPARATOR</code>
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isSpaceChar(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character is a space character;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isWhitespace(char)
+ * @since 1.1
+ */
+ public static boolean isSpaceChar(char ch) {
+ return isSpaceChar((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is a
+ * Unicode space character. A character is considered to be a
+ * space character if and only if it is specified to be a space
+ * character by the Unicode standard. This method returns true if
+ * the character's general category type is any of the following:
+ *
+ * <ul>
+ * <li> {@link #SPACE_SEPARATOR}
+ * <li> {@link #LINE_SEPARATOR}
+ * <li> {@link #PARAGRAPH_SEPARATOR}
+ * </ul>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character is a space character;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isWhitespace(int)
+ * @since 1.5
+ */
+ public static boolean isSpaceChar(int codePoint) {
+ return ((((1 << Character.SPACE_SEPARATOR) |
+ (1 << Character.LINE_SEPARATOR) |
+ (1 << Character.PARAGRAPH_SEPARATOR)) >> getType(codePoint)) & 1)
+ != 0;
+ }
+
+ /**
+ * Determines if the specified character is white space according to Java.
+ * A character is a Java whitespace character if and only if it satisfies
+ * one of the following criteria:
+ * <ul>
+ * <li> It is a Unicode space character (<code>SPACE_SEPARATOR</code>,
+ * <code>LINE_SEPARATOR</code>, or <code>PARAGRAPH_SEPARATOR</code>)
+ * but is not also a non-breaking space (<code>'\u00A0'</code>,
+ * <code>'\u2007'</code>, <code>'\u202F'</code>).
+ * <li> It is <code>'\u0009'</code>, HORIZONTAL TABULATION.
+ * <li> It is <code>'\u000A'</code>, LINE FEED.
+ * <li> It is <code>'\u000B'</code>, VERTICAL TABULATION.
+ * <li> It is <code>'\u000C'</code>, FORM FEED.
+ * <li> It is <code>'\u000D'</code>, CARRIAGE RETURN.
+ * <li> It is <code>'\u001C'</code>, FILE SEPARATOR.
+ * <li> It is <code>'\u001D'</code>, GROUP SEPARATOR.
+ * <li> It is <code>'\u001E'</code>, RECORD SEPARATOR.
+ * <li> It is <code>'\u001F'</code>, UNIT SEPARATOR.
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isWhitespace(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character is a Java whitespace
+ * character; <code>false</code> otherwise.
+ * @see java.lang.Character#isSpaceChar(char)
+ * @since 1.1
+ */
+ public static boolean isWhitespace(char ch) {
+ return isWhitespace((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is
+ * white space according to Java. A character is a Java
+ * whitespace character if and only if it satisfies one of the
+ * following criteria:
+ * <ul>
+ * <li> It is a Unicode space character ({@link #SPACE_SEPARATOR},
+ * {@link #LINE_SEPARATOR}, or {@link #PARAGRAPH_SEPARATOR})
+ * but is not also a non-breaking space (<code>'\u00A0'</code>,
+ * <code>'\u2007'</code>, <code>'\u202F'</code>).
+ * <li> It is <code>'\u0009'</code>, HORIZONTAL TABULATION.
+ * <li> It is <code>'\u000A'</code>, LINE FEED.
+ * <li> It is <code>'\u000B'</code>, VERTICAL TABULATION.
+ * <li> It is <code>'\u000C'</code>, FORM FEED.
+ * <li> It is <code>'\u000D'</code>, CARRIAGE RETURN.
+ * <li> It is <code>'\u001C'</code>, FILE SEPARATOR.
+ * <li> It is <code>'\u001D'</code>, GROUP SEPARATOR.
+ * <li> It is <code>'\u001E'</code>, RECORD SEPARATOR.
+ * <li> It is <code>'\u001F'</code>, UNIT SEPARATOR.
+ * </ul>
+ * <p>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character is a Java whitespace
+ * character; <code>false</code> otherwise.
+ * @see java.lang.Character#isSpaceChar(int)
+ * @since 1.5
+ */
+ public static boolean isWhitespace(int codePoint) {
+ return CharacterData.of(codePoint).isWhitespace(codePoint);
+ }
+
+ /**
+ * Determines if the specified character is an ISO control
+ * character. A character is considered to be an ISO control
+ * character if its code is in the range <code>'\u0000'</code>
+ * through <code>'\u001F'</code> or in the range
+ * <code>'\u007F'</code> through <code>'\u009F'</code>.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isISOControl(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return <code>true</code> if the character is an ISO control character;
+ * <code>false</code> otherwise.
+ *
+ * @see java.lang.Character#isSpaceChar(char)
+ * @see java.lang.Character#isWhitespace(char)
+ * @since 1.1
+ */
+ public static boolean isISOControl(char ch) {
+ return isISOControl((int)ch);
+ }
+
+ /**
+ * Determines if the referenced character (Unicode code point) is an ISO control
+ * character. A character is considered to be an ISO control
+ * character if its code is in the range <code>'\u0000'</code>
+ * through <code>'\u001F'</code> or in the range
+ * <code>'\u007F'</code> through <code>'\u009F'</code>.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character is an ISO control character;
+ * <code>false</code> otherwise.
+ * @see java.lang.Character#isSpaceChar(int)
+ * @see java.lang.Character#isWhitespace(int)
+ * @since 1.5
+ */
+ public static boolean isISOControl(int codePoint) {
+ return (codePoint >= 0x0000 && codePoint <= 0x001F) ||
+ (codePoint >= 0x007F && codePoint <= 0x009F);
+ }
+
+ /**
+ * Returns a value indicating a character's general category.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #getType(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return a value of type <code>int</code> representing the
+ * character's general category.
+ * @see java.lang.Character#COMBINING_SPACING_MARK
+ * @see java.lang.Character#CONNECTOR_PUNCTUATION
+ * @see java.lang.Character#CONTROL
+ * @see java.lang.Character#CURRENCY_SYMBOL
+ * @see java.lang.Character#DASH_PUNCTUATION
+ * @see java.lang.Character#DECIMAL_DIGIT_NUMBER
+ * @see java.lang.Character#ENCLOSING_MARK
+ * @see java.lang.Character#END_PUNCTUATION
+ * @see java.lang.Character#FINAL_QUOTE_PUNCTUATION
+ * @see java.lang.Character#FORMAT
+ * @see java.lang.Character#INITIAL_QUOTE_PUNCTUATION
+ * @see java.lang.Character#LETTER_NUMBER
+ * @see java.lang.Character#LINE_SEPARATOR
+ * @see java.lang.Character#LOWERCASE_LETTER
+ * @see java.lang.Character#MATH_SYMBOL
+ * @see java.lang.Character#MODIFIER_LETTER
+ * @see java.lang.Character#MODIFIER_SYMBOL
+ * @see java.lang.Character#NON_SPACING_MARK
+ * @see java.lang.Character#OTHER_LETTER
+ * @see java.lang.Character#OTHER_NUMBER
+ * @see java.lang.Character#OTHER_PUNCTUATION
+ * @see java.lang.Character#OTHER_SYMBOL
+ * @see java.lang.Character#PARAGRAPH_SEPARATOR
+ * @see java.lang.Character#PRIVATE_USE
+ * @see java.lang.Character#SPACE_SEPARATOR
+ * @see java.lang.Character#START_PUNCTUATION
+ * @see java.lang.Character#SURROGATE
+ * @see java.lang.Character#TITLECASE_LETTER
+ * @see java.lang.Character#UNASSIGNED
+ * @see java.lang.Character#UPPERCASE_LETTER
+ * @since 1.1
+ */
+ public static int getType(char ch) {
+ return getType((int)ch);
+ }
+
+ /**
+ * Returns a value indicating a character's general category.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return a value of type <code>int</code> representing the
+ * character's general category.
+ * @see Character#COMBINING_SPACING_MARK COMBINING_SPACING_MARK
+ * @see Character#CONNECTOR_PUNCTUATION CONNECTOR_PUNCTUATION
+ * @see Character#CONTROL CONTROL
+ * @see Character#CURRENCY_SYMBOL CURRENCY_SYMBOL
+ * @see Character#DASH_PUNCTUATION DASH_PUNCTUATION
+ * @see Character#DECIMAL_DIGIT_NUMBER DECIMAL_DIGIT_NUMBER
+ * @see Character#ENCLOSING_MARK ENCLOSING_MARK
+ * @see Character#END_PUNCTUATION END_PUNCTUATION
+ * @see Character#FINAL_QUOTE_PUNCTUATION FINAL_QUOTE_PUNCTUATION
+ * @see Character#FORMAT FORMAT
+ * @see Character#INITIAL_QUOTE_PUNCTUATION INITIAL_QUOTE_PUNCTUATION
+ * @see Character#LETTER_NUMBER LETTER_NUMBER
+ * @see Character#LINE_SEPARATOR LINE_SEPARATOR
+ * @see Character#LOWERCASE_LETTER LOWERCASE_LETTER
+ * @see Character#MATH_SYMBOL MATH_SYMBOL
+ * @see Character#MODIFIER_LETTER MODIFIER_LETTER
+ * @see Character#MODIFIER_SYMBOL MODIFIER_SYMBOL
+ * @see Character#NON_SPACING_MARK NON_SPACING_MARK
+ * @see Character#OTHER_LETTER OTHER_LETTER
+ * @see Character#OTHER_NUMBER OTHER_NUMBER
+ * @see Character#OTHER_PUNCTUATION OTHER_PUNCTUATION
+ * @see Character#OTHER_SYMBOL OTHER_SYMBOL
+ * @see Character#PARAGRAPH_SEPARATOR PARAGRAPH_SEPARATOR
+ * @see Character#PRIVATE_USE PRIVATE_USE
+ * @see Character#SPACE_SEPARATOR SPACE_SEPARATOR
+ * @see Character#START_PUNCTUATION START_PUNCTUATION
+ * @see Character#SURROGATE SURROGATE
+ * @see Character#TITLECASE_LETTER TITLECASE_LETTER
+ * @see Character#UNASSIGNED UNASSIGNED
+ * @see Character#UPPERCASE_LETTER UPPERCASE_LETTER
+ * @since 1.5
+ */
+ public static int getType(int codePoint) {
+ return CharacterData.of(codePoint).getType(codePoint);
+ }
+
+ /**
+ * Determines the character representation for a specific digit in
+ * the specified radix. If the value of <code>radix</code> is not a
+ * valid radix, or the value of <code>digit</code> is not a valid
+ * digit in the specified radix, the null character
+ * (<code>'\u0000'</code>) is returned.
+ * <p>
+ * The <code>radix</code> argument is valid if it is greater than or
+ * equal to <code>MIN_RADIX</code> and less than or equal to
+ * <code>MAX_RADIX</code>. The <code>digit</code> argument is valid if
+ * <code>0 <=digit < radix</code>.
+ * <p>
+ * If the digit is less than 10, then
+ * <code>'0' + digit</code> is returned. Otherwise, the value
+ * <code>'a' + digit - 10</code> is returned.
+ *
+ * @param digit the number to convert to a character.
+ * @param radix the radix.
+ * @return the <code>char</code> representation of the specified digit
+ * in the specified radix.
+ * @see java.lang.Character#MIN_RADIX
+ * @see java.lang.Character#MAX_RADIX
+ * @see java.lang.Character#digit(char, int)
+ */
+ public static char forDigit(int digit, int radix) {
+ if ((digit >= radix) || (digit < 0)) {
+ return '\0';
+ }
+ if ((radix < Character.MIN_RADIX) || (radix > Character.MAX_RADIX)) {
+ return '\0';
+ }
+ if (digit < 10) {
+ return (char)('0' + digit);
+ }
+ return (char)('a' - 10 + digit);
+ }
+
+ /**
+ * Returns the Unicode directionality property for the given
+ * character. Character directionality is used to calculate the
+ * visual ordering of text. The directionality value of undefined
+ * <code>char</code> values is <code>DIRECTIONALITY_UNDEFINED</code>.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #getDirectionality(int)} method.
+ *
+ * @param ch <code>char</code> for which the directionality property
+ * is requested.
+ * @return the directionality property of the <code>char</code> value.
+ *
+ * @see Character#DIRECTIONALITY_UNDEFINED
+ * @see Character#DIRECTIONALITY_LEFT_TO_RIGHT
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
+ * @see Character#DIRECTIONALITY_EUROPEAN_NUMBER
+ * @see Character#DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
+ * @see Character#DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
+ * @see Character#DIRECTIONALITY_ARABIC_NUMBER
+ * @see Character#DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
+ * @see Character#DIRECTIONALITY_NONSPACING_MARK
+ * @see Character#DIRECTIONALITY_BOUNDARY_NEUTRAL
+ * @see Character#DIRECTIONALITY_PARAGRAPH_SEPARATOR
+ * @see Character#DIRECTIONALITY_SEGMENT_SEPARATOR
+ * @see Character#DIRECTIONALITY_WHITESPACE
+ * @see Character#DIRECTIONALITY_OTHER_NEUTRALS
+ * @see Character#DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
+ * @see Character#DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
+ * @see Character#DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
+ * @since 1.4
+ */
+ public static byte getDirectionality(char ch) {
+ return getDirectionality((int)ch);
+ }
+
+ /**
+ * Returns the Unicode directionality property for the given
+ * character (Unicode code point). Character directionality is
+ * used to calculate the visual ordering of text. The
+ * directionality value of undefined character is {@link
+ * #DIRECTIONALITY_UNDEFINED}.
+ *
+ * @param codePoint the character (Unicode code point) for which
+ * the directionality property is requested.
+ * @return the directionality property of the character.
+ *
+ * @see Character#DIRECTIONALITY_UNDEFINED DIRECTIONALITY_UNDEFINED
+ * @see Character#DIRECTIONALITY_LEFT_TO_RIGHT DIRECTIONALITY_LEFT_TO_RIGHT
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT DIRECTIONALITY_RIGHT_TO_LEFT
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
+ * @see Character#DIRECTIONALITY_EUROPEAN_NUMBER DIRECTIONALITY_EUROPEAN_NUMBER
+ * @see Character#DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
+ * @see Character#DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
+ * @see Character#DIRECTIONALITY_ARABIC_NUMBER DIRECTIONALITY_ARABIC_NUMBER
+ * @see Character#DIRECTIONALITY_COMMON_NUMBER_SEPARATOR DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
+ * @see Character#DIRECTIONALITY_NONSPACING_MARK DIRECTIONALITY_NONSPACING_MARK
+ * @see Character#DIRECTIONALITY_BOUNDARY_NEUTRAL DIRECTIONALITY_BOUNDARY_NEUTRAL
+ * @see Character#DIRECTIONALITY_PARAGRAPH_SEPARATOR DIRECTIONALITY_PARAGRAPH_SEPARATOR
+ * @see Character#DIRECTIONALITY_SEGMENT_SEPARATOR DIRECTIONALITY_SEGMENT_SEPARATOR
+ * @see Character#DIRECTIONALITY_WHITESPACE DIRECTIONALITY_WHITESPACE
+ * @see Character#DIRECTIONALITY_OTHER_NEUTRALS DIRECTIONALITY_OTHER_NEUTRALS
+ * @see Character#DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
+ * @see Character#DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
+ * @see Character#DIRECTIONALITY_POP_DIRECTIONAL_FORMAT DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
+ * @since 1.5
+ */
+ public static byte getDirectionality(int codePoint) {
+ return CharacterData.of(codePoint).getDirectionality(codePoint);
+ }
+
+ /**
+ * Determines whether the character is mirrored according to the
+ * Unicode specification. Mirrored characters should have their
+ * glyphs horizontally mirrored when displayed in text that is
+ * right-to-left. For example, <code>'\u0028'</code> LEFT
+ * PARENTHESIS is semantically defined to be an <i>opening
+ * parenthesis</i>. This will appear as a "(" in text that is
+ * left-to-right but as a ")" in text that is right-to-left.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isMirrored(int)} method.
+ *
+ * @param ch <code>char</code> for which the mirrored property is requested
+ * @return <code>true</code> if the char is mirrored, <code>false</code>
+ * if the <code>char</code> is not mirrored or is not defined.
+ * @since 1.4
+ */
+ public static boolean isMirrored(char ch) {
+ return isMirrored((int)ch);
+ }
+
+ /**
+ * Determines whether the specified character (Unicode code point)
+ * is mirrored according to the Unicode specification. Mirrored
+ * characters should have their glyphs horizontally mirrored when
+ * displayed in text that is right-to-left. For example,
+ * <code>'\u0028'</code> LEFT PARENTHESIS is semantically
+ * defined to be an <i>opening parenthesis</i>. This will appear
+ * as a "(" in text that is left-to-right but as a ")" in text
+ * that is right-to-left.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character is mirrored, <code>false</code>
+ * if the character is not mirrored or is not defined.
+ * @since 1.5
+ */
+ public static boolean isMirrored(int codePoint) {
+ return CharacterData.of(codePoint).isMirrored(codePoint);
+ }
+
+ /**
+ * Compares two <code>Character</code> objects numerically.
+ *
+ * @param anotherCharacter the <code>Character</code> to be compared.
+
+ * @return the value <code>0</code> if the argument <code>Character</code>
+ * is equal to this <code>Character</code>; a value less than
+ * <code>0</code> if this <code>Character</code> is numerically less
+ * than the <code>Character</code> argument; and a value greater than
+ * <code>0</code> if this <code>Character</code> is numerically greater
+ * than the <code>Character</code> argument (unsigned comparison).
+ * Note that this is strictly a numerical comparison; it is not
+ * locale-dependent.
+ * @since 1.2
+ */
+ public int compareTo(Character anotherCharacter) {
+ return this.value - anotherCharacter.value;
+ }
+
+ /**
+ * Converts the character (Unicode code point) argument to uppercase using
+ * information from the UnicodeData file.
+ * <p>
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @return either the uppercase equivalent of the character, if
+ * any, or an error flag (<code>Character.ERROR</code>)
+ * that indicates that a 1:M <code>char</code> mapping exists.
+ * @see java.lang.Character#isLowerCase(char)
+ * @see java.lang.Character#isUpperCase(char)
+ * @see java.lang.Character#toLowerCase(char)
+ * @see java.lang.Character#toTitleCase(char)
+ * @since 1.4
+ */
+ static int toUpperCaseEx(int codePoint) {
+ assert isValidCodePoint(codePoint);
+ return CharacterData.of(codePoint).toUpperCaseEx(codePoint);
+ }
+
+ /**
+ * Converts the character (Unicode code point) argument to uppercase using case
+ * mapping information from the SpecialCasing file in the Unicode
+ * specification. If a character has no explicit uppercase
+ * mapping, then the <code>char</code> itself is returned in the
+ * <code>char[]</code>.
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @return a <code>char[]</code> with the uppercased character.
+ * @since 1.4
+ */
+ static char[] toUpperCaseCharArray(int codePoint) {
+ // As of Unicode 4.0, 1:M uppercasings only happen in the BMP.
+ assert isValidCodePoint(codePoint) &&
+ !isSupplementaryCodePoint(codePoint);
+ return CharacterData.of(codePoint).toUpperCaseCharArray(codePoint);
+ }
+
+ /**
+ * The number of bits used to represent a <tt>char</tt> value in unsigned
+ * binary form.
+ *
+ * @since 1.5
+ */
+ public static final int SIZE = 16;
+
+ /**
+ * Returns the value obtained by reversing the order of the bytes in the
+ * specified <tt>char</tt> value.
+ *
+ * @return the value obtained by reversing (or, equivalently, swapping)
+ * the bytes in the specified <tt>char</tt> value.
+ * @since 1.5
+ */
+ public static char reverseBytes(char ch) {
+ return (char) (((ch & 0xFF00) >> 8) | (ch << 8));
+ }
+}