e1bea0c068
2007-05-31 Matthias Klose <doko@ubuntu.com>
* javax/management/NotificationBroadcasterSupport.java
(getNotificationInfo): Add cast.
* native/jni/qt-peer/Makefile.am (AM_CXXFLAGS): Add libstdc++ include
directories.
* native/jni/qt-peer/Makefile.in: Regenerate.
libjava/ChangeLog:
2007-06-03 Matthias Klose <doko@ubuntu.com>
* java/io/natFileWin32.cc (setFilePermissions): New (stub only).
_access: Handle EXEC query, stub only.
2007-06-03 Matthias Klose <doko@ubuntu.com>
Merged from classpath:
* gnu/java/nio/SelectorProviderImpl.java: Whitespace merge.
* java/lang/System.java(inheritedChannel): New.
* java/lang/Character.java: Remove stray`;'.
* java/net/MulticastSocket.java: Merged.
* java/text/DateFormatSymbols.java(getInstance): New, comment updates.
* java/text/Collator.java(getInstance): Merged.
* java/util/Calendar.java: New attributes ALL_STYLES, SHORT, LONG.
getDisplayName, getDisplayNames: New.
* java/util/logging/Logger.java: Merged.
* Regenerate .class and .h files.
2007-06-03 Matthias Klose <doko@ubuntu.com>
* java/io/File.java: Merge with classpath-0.95, new method
setFilePermissions, new attribute EXEC.
* java/io/natFilePosix.cc (setFilePermissions): New.
_access: Handle EXEC query.
* classpath/lib/java/io/File.class, java/io/File.h: Regenerate.
2007-06-03 Matthias Klose <doko@ubuntu.com>
Imported GNU Classpath 0.95.
* classpath/Makefile.in,
classpath/native/jni/midi-dssi/Makefile.in,
classpath/native/jni/classpath/Makefile.in,
classpath/native/jni/Makefile.in,
classpath/native/jni/gconf-peer/Makefile.in,
classpath/native/jni/java-io/Makefile.in,
classpath/native/jni/native-lib/Makefile.in,
classpath/native/jni/java-util/Makefile.in,
classpath/native/jni/midi-alsa/Makefile.in,
classpath/native/jni/java-lang/Makefile.in,
classpath/native/jni/java-nio/Makefile.in,
classpath/native/jni/java-net/Makefile.in,
classpath/native/jni/xmlj/Makefile.in,
classpath/native/jni/qt-peer/Makefile.in,
classpath/native/jni/gtk-peer/Makefile.in,
classpath/native/Makefile.in, classpath/native/jawt/Makefile.in,
classpath/native/fdlibm/Makefile.in,
classpath/native/plugin/Makefile.in,
classpath/resource/Makefile.in, classpath/scripts/Makefile.in,
classpath/tools/Makefile.in, classpath/doc/Makefile.in,
classpath/doc/api/Makefile.in, classpath/lib/Makefile.in,
classpath/external/Makefile.in, classpath/external/jsr166/Makefile.in,
classpath/external/sax/Makefile.in,
classpath/external/w3c_dom/Makefile.in,
classpath/external/relaxngDatatype/Makefile.in,
classpath/include/Makefile.in,
classpath/examples/Makefile.in: Regenerate.
* classpath/config.guess, classpath/config.sub,
classpath/ltmain.sh : Update.
* classpath/configure, classpath/depcomp, classpath/missing,
classpath/aclocal.m4, classpath/install-sh: Regenerate.
* gnu/classpath/Configuration.java (CLASSPATH_VERSION): Now 0.95.
* sources.am: Regenerate.
* Makefile.in: Regenerate.
* Update the .class files and generated CNI header files, add new
.class and generated CNI header files.
* Remove generated files for removed java source files:
classpath/gnu/java/net/BASE64.java,
classpath/gnu/java/security/util/Base64.java,
classpath/gnu/java/awt/peer/gtk/GThreadMutex.java,
classpath/gnu/java/awt/peer/gtk/GThreadNativeMethodRunner.java,
classpath/gnu/java/awt/font/autofit/Scaler.java,
classpath/gnu/classpath/jdwp/util/Value.java,
classpath/gnu/javax/net/ssl/Base64.java.
* Remove empty directories.
* Makefile.am(nat_source_files): Add natVMOperatingSystemMXBeanImpl.cc.
* java/lang/Class.java(setAccessible): Merge from classpath.
* java/util/Locale.java: Remove.
* gnu/java/lang/management/VMOperatingSystemMXBeanImpl.java,
gnu/java/lang/management/natVMOperatingSystemMXBeanImpl.cc: New.
* gcj/javaprims.h: Update class declarations.
* scripts/classes.pl: Update usage.
* HACKING: Mention to build all peers.
From-SVN: r125302
4552 lines
136 KiB
Java
4552 lines
136 KiB
Java
/* java.lang.Character -- Wrapper class for char, and Unicode subsets
|
|
Copyright (C) 1998, 1999, 2001, 2002, 2004, 2005 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath 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 for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
|
|
package java.lang;
|
|
|
|
import gnu.java.lang.CharData;
|
|
|
|
import java.io.Serializable;
|
|
import java.text.Collator;
|
|
import java.util.Locale;
|
|
|
|
/**
|
|
* Wrapper class for the primitive char data type. In addition, this class
|
|
* allows one to retrieve property information and perform transformations
|
|
* on the defined characters in the Unicode Standard, Version 4.0.0.
|
|
* java.lang.Character is designed to be very dynamic, and as such, it
|
|
* retrieves information on the Unicode character set from a separate
|
|
* database, gnu.java.lang.CharData, which can be easily upgraded.
|
|
*
|
|
* <p>For predicates, boundaries are used to describe
|
|
* the set of characters for which the method will return true.
|
|
* This syntax uses fairly normal regular expression notation.
|
|
* See 5.13 of the Unicode Standard, Version 4.0, for the
|
|
* boundary specification.
|
|
*
|
|
* <p>See <a href="http://www.unicode.org">http://www.unicode.org</a>
|
|
* for more information on the Unicode Standard.
|
|
*
|
|
* @author Tom Tromey (tromey@cygnus.com)
|
|
* @author Paul N. Fisher
|
|
* @author Jochen Hoenicke
|
|
* @author Eric Blake (ebb9@email.byu.edu)
|
|
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
|
|
* @see CharData
|
|
* @since 1.0
|
|
* @status partly updated to 1.5; some things still missing
|
|
*/
|
|
public final class Character implements Serializable, Comparable<Character>
|
|
{
|
|
/**
|
|
* A subset of Unicode blocks.
|
|
*
|
|
* @author Paul N. Fisher
|
|
* @author Eric Blake (ebb9@email.byu.edu)
|
|
* @since 1.2
|
|
*/
|
|
public static class Subset
|
|
{
|
|
/** The name of the subset. */
|
|
private final String name;
|
|
|
|
/**
|
|
* Construct a new subset of characters.
|
|
*
|
|
* @param name the name of the subset
|
|
* @throws NullPointerException if name is null
|
|
*/
|
|
protected Subset(String name)
|
|
{
|
|
// Note that name.toString() is name, unless name was null.
|
|
this.name = name.toString();
|
|
}
|
|
|
|
/**
|
|
* Compares two Subsets for equality. This is <code>final</code>, and
|
|
* restricts the comparison on the <code>==</code> operator, so it returns
|
|
* true only for the same object.
|
|
*
|
|
* @param o the object to compare
|
|
* @return true if o is this
|
|
*/
|
|
public final boolean equals(Object o)
|
|
{
|
|
return o == this;
|
|
}
|
|
|
|
/**
|
|
* Makes the original hashCode of Object final, to be consistent with
|
|
* equals.
|
|
*
|
|
* @return the hash code for this object
|
|
*/
|
|
public final int hashCode()
|
|
{
|
|
return super.hashCode();
|
|
}
|
|
|
|
/**
|
|
* Returns the name of the subset.
|
|
*
|
|
* @return the name
|
|
*/
|
|
public final String toString()
|
|
{
|
|
return name;
|
|
}
|
|
} // class Subset
|
|
|
|
/**
|
|
* A family of character subsets in the Unicode specification. A character
|
|
* is in at most one of these blocks.
|
|
*
|
|
* This inner class was generated automatically from
|
|
* <code>doc/unicode/Blocks-4.0.0.txt</code>, by some perl scripts.
|
|
* This Unicode definition file can be found on the
|
|
* <a href="http://www.unicode.org">http://www.unicode.org</a> website.
|
|
* JDK 1.5 uses Unicode version 4.0.0.
|
|
*
|
|
* @author scripts/unicode-blocks.pl (written by Eric Blake)
|
|
* @since 1.2
|
|
*/
|
|
public static final class UnicodeBlock extends Subset
|
|
{
|
|
/** The start of the subset. */
|
|
private final int start;
|
|
|
|
/** The end of the subset. */
|
|
private final int end;
|
|
|
|
/** The canonical name of the block according to the Unicode standard. */
|
|
private final String canonicalName;
|
|
|
|
/** Enumeration for the <code>forName()</code> method */
|
|
private enum NameType { CANONICAL, NO_SPACES, CONSTANT; }
|
|
|
|
/**
|
|
* Constructor for strictly defined blocks.
|
|
*
|
|
* @param start the start character of the range
|
|
* @param end the end character of the range
|
|
* @param name the block name
|
|
* @param canonicalName the name of the block as defined in the Unicode
|
|
* standard.
|
|
*/
|
|
private UnicodeBlock(int start, int end, String name,
|
|
String canonicalName)
|
|
{
|
|
super(name);
|
|
this.start = start;
|
|
this.end = end;
|
|
this.canonicalName = canonicalName;
|
|
}
|
|
|
|
/**
|
|
* Returns the Unicode character block which a character belongs to.
|
|
* <strong>Note</strong>: This method does not support the use of
|
|
* supplementary characters. For such support, <code>of(int)</code>
|
|
* should be used instead.
|
|
*
|
|
* @param ch the character to look up
|
|
* @return the set it belongs to, or null if it is not in one
|
|
*/
|
|
public static UnicodeBlock of(char ch)
|
|
{
|
|
return of((int) ch);
|
|
}
|
|
|
|
/**
|
|
* Returns the Unicode character block which a code point belongs to.
|
|
*
|
|
* @param codePoint the character to look up
|
|
* @return the set it belongs to, or null if it is not in one.
|
|
* @throws IllegalArgumentException if the specified code point is
|
|
* invalid.
|
|
* @since 1.5
|
|
*/
|
|
public static UnicodeBlock of(int codePoint)
|
|
{
|
|
if (codePoint > MAX_CODE_POINT)
|
|
throw new IllegalArgumentException("The supplied integer value is " +
|
|
"too large to be a codepoint.");
|
|
// Simple binary search for the correct block.
|
|
int low = 0;
|
|
int hi = sets.length - 1;
|
|
while (low <= hi)
|
|
{
|
|
int mid = (low + hi) >> 1;
|
|
UnicodeBlock b = sets[mid];
|
|
if (codePoint < b.start)
|
|
hi = mid - 1;
|
|
else if (codePoint > b.end)
|
|
low = mid + 1;
|
|
else
|
|
return b;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Returns the <code>UnicodeBlock</code> with the given name, as defined
|
|
* by the Unicode standard. The version of Unicode in use is defined by
|
|
* the <code>Character</code> class, and the names are given in the
|
|
* <code>Blocks-<version>.txt</code> file corresponding to that version.
|
|
* The name may be specified in one of three ways:
|
|
* </p>
|
|
* <ol>
|
|
* <li>The canonical, human-readable name used by the Unicode standard.
|
|
* This is the name with all spaces and hyphens retained. For example,
|
|
* `Basic Latin' retrieves the block, UnicodeBlock.BASIC_LATIN.</li>
|
|
* <li>The canonical name with all spaces removed e.g. `BasicLatin'.</li>
|
|
* <li>The name used for the constants specified by this class, which
|
|
* is the canonical name with all spaces and hyphens replaced with
|
|
* underscores e.g. `BASIC_LATIN'</li>
|
|
* </ol>
|
|
* <p>
|
|
* The names are compared case-insensitively using the case comparison
|
|
* associated with the U.S. English locale. The method recognises the
|
|
* previous names used for blocks as well as the current ones. At
|
|
* present, this simply means that the deprecated `SURROGATES_AREA'
|
|
* will be recognised by this method (the <code>of()</code> methods
|
|
* only return one of the three new surrogate blocks).
|
|
* </p>
|
|
*
|
|
* @param blockName the name of the block to look up.
|
|
* @return the specified block.
|
|
* @throws NullPointerException if the <code>blockName</code> is
|
|
* <code>null</code>.
|
|
* @throws IllegalArgumentException if the name does not match any Unicode
|
|
* block.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock forName(String blockName)
|
|
{
|
|
NameType type;
|
|
if (blockName.indexOf(' ') != -1)
|
|
type = NameType.CANONICAL;
|
|
else if (blockName.indexOf('_') != -1)
|
|
type = NameType.CONSTANT;
|
|
else
|
|
type = NameType.NO_SPACES;
|
|
Collator usCollator = Collator.getInstance(Locale.US);
|
|
usCollator.setStrength(Collator.PRIMARY);
|
|
/* Special case for deprecated blocks not in sets */
|
|
switch (type)
|
|
{
|
|
case CANONICAL:
|
|
if (usCollator.compare(blockName, "Surrogates Area") == 0)
|
|
return SURROGATES_AREA;
|
|
break;
|
|
case NO_SPACES:
|
|
if (usCollator.compare(blockName, "SurrogatesArea") == 0)
|
|
return SURROGATES_AREA;
|
|
break;
|
|
case CONSTANT:
|
|
if (usCollator.compare(blockName, "SURROGATES_AREA") == 0)
|
|
return SURROGATES_AREA;
|
|
break;
|
|
}
|
|
/* Other cases */
|
|
switch (type)
|
|
{
|
|
case CANONICAL:
|
|
for (UnicodeBlock block : sets)
|
|
if (usCollator.compare(blockName, block.canonicalName) == 0)
|
|
return block;
|
|
break;
|
|
case NO_SPACES:
|
|
for (UnicodeBlock block : sets)
|
|
{
|
|
String nsName = block.canonicalName.replaceAll(" ","");
|
|
if (usCollator.compare(blockName, nsName) == 0)
|
|
return block;
|
|
}
|
|
break;
|
|
case CONSTANT:
|
|
for (UnicodeBlock block : sets)
|
|
if (usCollator.compare(blockName, block.toString()) == 0)
|
|
return block;
|
|
break;
|
|
}
|
|
throw new IllegalArgumentException("No Unicode block found for " +
|
|
blockName + ".");
|
|
}
|
|
|
|
/**
|
|
* Basic Latin.
|
|
* 0x0000 - 0x007F.
|
|
*/
|
|
public static final UnicodeBlock BASIC_LATIN
|
|
= new UnicodeBlock(0x0000, 0x007F,
|
|
"BASIC_LATIN",
|
|
"Basic Latin");
|
|
|
|
/**
|
|
* Latin-1 Supplement.
|
|
* 0x0080 - 0x00FF.
|
|
*/
|
|
public static final UnicodeBlock LATIN_1_SUPPLEMENT
|
|
= new UnicodeBlock(0x0080, 0x00FF,
|
|
"LATIN_1_SUPPLEMENT",
|
|
"Latin-1 Supplement");
|
|
|
|
/**
|
|
* Latin Extended-A.
|
|
* 0x0100 - 0x017F.
|
|
*/
|
|
public static final UnicodeBlock LATIN_EXTENDED_A
|
|
= new UnicodeBlock(0x0100, 0x017F,
|
|
"LATIN_EXTENDED_A",
|
|
"Latin Extended-A");
|
|
|
|
/**
|
|
* Latin Extended-B.
|
|
* 0x0180 - 0x024F.
|
|
*/
|
|
public static final UnicodeBlock LATIN_EXTENDED_B
|
|
= new UnicodeBlock(0x0180, 0x024F,
|
|
"LATIN_EXTENDED_B",
|
|
"Latin Extended-B");
|
|
|
|
/**
|
|
* IPA Extensions.
|
|
* 0x0250 - 0x02AF.
|
|
*/
|
|
public static final UnicodeBlock IPA_EXTENSIONS
|
|
= new UnicodeBlock(0x0250, 0x02AF,
|
|
"IPA_EXTENSIONS",
|
|
"IPA Extensions");
|
|
|
|
/**
|
|
* Spacing Modifier Letters.
|
|
* 0x02B0 - 0x02FF.
|
|
*/
|
|
public static final UnicodeBlock SPACING_MODIFIER_LETTERS
|
|
= new UnicodeBlock(0x02B0, 0x02FF,
|
|
"SPACING_MODIFIER_LETTERS",
|
|
"Spacing Modifier Letters");
|
|
|
|
/**
|
|
* Combining Diacritical Marks.
|
|
* 0x0300 - 0x036F.
|
|
*/
|
|
public static final UnicodeBlock COMBINING_DIACRITICAL_MARKS
|
|
= new UnicodeBlock(0x0300, 0x036F,
|
|
"COMBINING_DIACRITICAL_MARKS",
|
|
"Combining Diacritical Marks");
|
|
|
|
/**
|
|
* Greek.
|
|
* 0x0370 - 0x03FF.
|
|
*/
|
|
public static final UnicodeBlock GREEK
|
|
= new UnicodeBlock(0x0370, 0x03FF,
|
|
"GREEK",
|
|
"Greek");
|
|
|
|
/**
|
|
* Cyrillic.
|
|
* 0x0400 - 0x04FF.
|
|
*/
|
|
public static final UnicodeBlock CYRILLIC
|
|
= new UnicodeBlock(0x0400, 0x04FF,
|
|
"CYRILLIC",
|
|
"Cyrillic");
|
|
|
|
/**
|
|
* Cyrillic Supplementary.
|
|
* 0x0500 - 0x052F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock CYRILLIC_SUPPLEMENTARY
|
|
= new UnicodeBlock(0x0500, 0x052F,
|
|
"CYRILLIC_SUPPLEMENTARY",
|
|
"Cyrillic Supplementary");
|
|
|
|
/**
|
|
* Armenian.
|
|
* 0x0530 - 0x058F.
|
|
*/
|
|
public static final UnicodeBlock ARMENIAN
|
|
= new UnicodeBlock(0x0530, 0x058F,
|
|
"ARMENIAN",
|
|
"Armenian");
|
|
|
|
/**
|
|
* Hebrew.
|
|
* 0x0590 - 0x05FF.
|
|
*/
|
|
public static final UnicodeBlock HEBREW
|
|
= new UnicodeBlock(0x0590, 0x05FF,
|
|
"HEBREW",
|
|
"Hebrew");
|
|
|
|
/**
|
|
* Arabic.
|
|
* 0x0600 - 0x06FF.
|
|
*/
|
|
public static final UnicodeBlock ARABIC
|
|
= new UnicodeBlock(0x0600, 0x06FF,
|
|
"ARABIC",
|
|
"Arabic");
|
|
|
|
/**
|
|
* Syriac.
|
|
* 0x0700 - 0x074F.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock SYRIAC
|
|
= new UnicodeBlock(0x0700, 0x074F,
|
|
"SYRIAC",
|
|
"Syriac");
|
|
|
|
/**
|
|
* Thaana.
|
|
* 0x0780 - 0x07BF.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock THAANA
|
|
= new UnicodeBlock(0x0780, 0x07BF,
|
|
"THAANA",
|
|
"Thaana");
|
|
|
|
/**
|
|
* Devanagari.
|
|
* 0x0900 - 0x097F.
|
|
*/
|
|
public static final UnicodeBlock DEVANAGARI
|
|
= new UnicodeBlock(0x0900, 0x097F,
|
|
"DEVANAGARI",
|
|
"Devanagari");
|
|
|
|
/**
|
|
* Bengali.
|
|
* 0x0980 - 0x09FF.
|
|
*/
|
|
public static final UnicodeBlock BENGALI
|
|
= new UnicodeBlock(0x0980, 0x09FF,
|
|
"BENGALI",
|
|
"Bengali");
|
|
|
|
/**
|
|
* Gurmukhi.
|
|
* 0x0A00 - 0x0A7F.
|
|
*/
|
|
public static final UnicodeBlock GURMUKHI
|
|
= new UnicodeBlock(0x0A00, 0x0A7F,
|
|
"GURMUKHI",
|
|
"Gurmukhi");
|
|
|
|
/**
|
|
* Gujarati.
|
|
* 0x0A80 - 0x0AFF.
|
|
*/
|
|
public static final UnicodeBlock GUJARATI
|
|
= new UnicodeBlock(0x0A80, 0x0AFF,
|
|
"GUJARATI",
|
|
"Gujarati");
|
|
|
|
/**
|
|
* Oriya.
|
|
* 0x0B00 - 0x0B7F.
|
|
*/
|
|
public static final UnicodeBlock ORIYA
|
|
= new UnicodeBlock(0x0B00, 0x0B7F,
|
|
"ORIYA",
|
|
"Oriya");
|
|
|
|
/**
|
|
* Tamil.
|
|
* 0x0B80 - 0x0BFF.
|
|
*/
|
|
public static final UnicodeBlock TAMIL
|
|
= new UnicodeBlock(0x0B80, 0x0BFF,
|
|
"TAMIL",
|
|
"Tamil");
|
|
|
|
/**
|
|
* Telugu.
|
|
* 0x0C00 - 0x0C7F.
|
|
*/
|
|
public static final UnicodeBlock TELUGU
|
|
= new UnicodeBlock(0x0C00, 0x0C7F,
|
|
"TELUGU",
|
|
"Telugu");
|
|
|
|
/**
|
|
* Kannada.
|
|
* 0x0C80 - 0x0CFF.
|
|
*/
|
|
public static final UnicodeBlock KANNADA
|
|
= new UnicodeBlock(0x0C80, 0x0CFF,
|
|
"KANNADA",
|
|
"Kannada");
|
|
|
|
/**
|
|
* Malayalam.
|
|
* 0x0D00 - 0x0D7F.
|
|
*/
|
|
public static final UnicodeBlock MALAYALAM
|
|
= new UnicodeBlock(0x0D00, 0x0D7F,
|
|
"MALAYALAM",
|
|
"Malayalam");
|
|
|
|
/**
|
|
* Sinhala.
|
|
* 0x0D80 - 0x0DFF.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock SINHALA
|
|
= new UnicodeBlock(0x0D80, 0x0DFF,
|
|
"SINHALA",
|
|
"Sinhala");
|
|
|
|
/**
|
|
* Thai.
|
|
* 0x0E00 - 0x0E7F.
|
|
*/
|
|
public static final UnicodeBlock THAI
|
|
= new UnicodeBlock(0x0E00, 0x0E7F,
|
|
"THAI",
|
|
"Thai");
|
|
|
|
/**
|
|
* Lao.
|
|
* 0x0E80 - 0x0EFF.
|
|
*/
|
|
public static final UnicodeBlock LAO
|
|
= new UnicodeBlock(0x0E80, 0x0EFF,
|
|
"LAO",
|
|
"Lao");
|
|
|
|
/**
|
|
* Tibetan.
|
|
* 0x0F00 - 0x0FFF.
|
|
*/
|
|
public static final UnicodeBlock TIBETAN
|
|
= new UnicodeBlock(0x0F00, 0x0FFF,
|
|
"TIBETAN",
|
|
"Tibetan");
|
|
|
|
/**
|
|
* Myanmar.
|
|
* 0x1000 - 0x109F.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock MYANMAR
|
|
= new UnicodeBlock(0x1000, 0x109F,
|
|
"MYANMAR",
|
|
"Myanmar");
|
|
|
|
/**
|
|
* Georgian.
|
|
* 0x10A0 - 0x10FF.
|
|
*/
|
|
public static final UnicodeBlock GEORGIAN
|
|
= new UnicodeBlock(0x10A0, 0x10FF,
|
|
"GEORGIAN",
|
|
"Georgian");
|
|
|
|
/**
|
|
* Hangul Jamo.
|
|
* 0x1100 - 0x11FF.
|
|
*/
|
|
public static final UnicodeBlock HANGUL_JAMO
|
|
= new UnicodeBlock(0x1100, 0x11FF,
|
|
"HANGUL_JAMO",
|
|
"Hangul Jamo");
|
|
|
|
/**
|
|
* Ethiopic.
|
|
* 0x1200 - 0x137F.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock ETHIOPIC
|
|
= new UnicodeBlock(0x1200, 0x137F,
|
|
"ETHIOPIC",
|
|
"Ethiopic");
|
|
|
|
/**
|
|
* Cherokee.
|
|
* 0x13A0 - 0x13FF.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock CHEROKEE
|
|
= new UnicodeBlock(0x13A0, 0x13FF,
|
|
"CHEROKEE",
|
|
"Cherokee");
|
|
|
|
/**
|
|
* Unified Canadian Aboriginal Syllabics.
|
|
* 0x1400 - 0x167F.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS
|
|
= new UnicodeBlock(0x1400, 0x167F,
|
|
"UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS",
|
|
"Unified Canadian Aboriginal Syllabics");
|
|
|
|
/**
|
|
* Ogham.
|
|
* 0x1680 - 0x169F.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock OGHAM
|
|
= new UnicodeBlock(0x1680, 0x169F,
|
|
"OGHAM",
|
|
"Ogham");
|
|
|
|
/**
|
|
* Runic.
|
|
* 0x16A0 - 0x16FF.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock RUNIC
|
|
= new UnicodeBlock(0x16A0, 0x16FF,
|
|
"RUNIC",
|
|
"Runic");
|
|
|
|
/**
|
|
* Tagalog.
|
|
* 0x1700 - 0x171F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock TAGALOG
|
|
= new UnicodeBlock(0x1700, 0x171F,
|
|
"TAGALOG",
|
|
"Tagalog");
|
|
|
|
/**
|
|
* Hanunoo.
|
|
* 0x1720 - 0x173F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock HANUNOO
|
|
= new UnicodeBlock(0x1720, 0x173F,
|
|
"HANUNOO",
|
|
"Hanunoo");
|
|
|
|
/**
|
|
* Buhid.
|
|
* 0x1740 - 0x175F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock BUHID
|
|
= new UnicodeBlock(0x1740, 0x175F,
|
|
"BUHID",
|
|
"Buhid");
|
|
|
|
/**
|
|
* Tagbanwa.
|
|
* 0x1760 - 0x177F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock TAGBANWA
|
|
= new UnicodeBlock(0x1760, 0x177F,
|
|
"TAGBANWA",
|
|
"Tagbanwa");
|
|
|
|
/**
|
|
* Khmer.
|
|
* 0x1780 - 0x17FF.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock KHMER
|
|
= new UnicodeBlock(0x1780, 0x17FF,
|
|
"KHMER",
|
|
"Khmer");
|
|
|
|
/**
|
|
* Mongolian.
|
|
* 0x1800 - 0x18AF.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock MONGOLIAN
|
|
= new UnicodeBlock(0x1800, 0x18AF,
|
|
"MONGOLIAN",
|
|
"Mongolian");
|
|
|
|
/**
|
|
* Limbu.
|
|
* 0x1900 - 0x194F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock LIMBU
|
|
= new UnicodeBlock(0x1900, 0x194F,
|
|
"LIMBU",
|
|
"Limbu");
|
|
|
|
/**
|
|
* Tai Le.
|
|
* 0x1950 - 0x197F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock TAI_LE
|
|
= new UnicodeBlock(0x1950, 0x197F,
|
|
"TAI_LE",
|
|
"Tai Le");
|
|
|
|
/**
|
|
* Khmer Symbols.
|
|
* 0x19E0 - 0x19FF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock KHMER_SYMBOLS
|
|
= new UnicodeBlock(0x19E0, 0x19FF,
|
|
"KHMER_SYMBOLS",
|
|
"Khmer Symbols");
|
|
|
|
/**
|
|
* Phonetic Extensions.
|
|
* 0x1D00 - 0x1D7F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock PHONETIC_EXTENSIONS
|
|
= new UnicodeBlock(0x1D00, 0x1D7F,
|
|
"PHONETIC_EXTENSIONS",
|
|
"Phonetic Extensions");
|
|
|
|
/**
|
|
* Latin Extended Additional.
|
|
* 0x1E00 - 0x1EFF.
|
|
*/
|
|
public static final UnicodeBlock LATIN_EXTENDED_ADDITIONAL
|
|
= new UnicodeBlock(0x1E00, 0x1EFF,
|
|
"LATIN_EXTENDED_ADDITIONAL",
|
|
"Latin Extended Additional");
|
|
|
|
/**
|
|
* Greek Extended.
|
|
* 0x1F00 - 0x1FFF.
|
|
*/
|
|
public static final UnicodeBlock GREEK_EXTENDED
|
|
= new UnicodeBlock(0x1F00, 0x1FFF,
|
|
"GREEK_EXTENDED",
|
|
"Greek Extended");
|
|
|
|
/**
|
|
* General Punctuation.
|
|
* 0x2000 - 0x206F.
|
|
*/
|
|
public static final UnicodeBlock GENERAL_PUNCTUATION
|
|
= new UnicodeBlock(0x2000, 0x206F,
|
|
"GENERAL_PUNCTUATION",
|
|
"General Punctuation");
|
|
|
|
/**
|
|
* Superscripts and Subscripts.
|
|
* 0x2070 - 0x209F.
|
|
*/
|
|
public static final UnicodeBlock SUPERSCRIPTS_AND_SUBSCRIPTS
|
|
= new UnicodeBlock(0x2070, 0x209F,
|
|
"SUPERSCRIPTS_AND_SUBSCRIPTS",
|
|
"Superscripts and Subscripts");
|
|
|
|
/**
|
|
* Currency Symbols.
|
|
* 0x20A0 - 0x20CF.
|
|
*/
|
|
public static final UnicodeBlock CURRENCY_SYMBOLS
|
|
= new UnicodeBlock(0x20A0, 0x20CF,
|
|
"CURRENCY_SYMBOLS",
|
|
"Currency Symbols");
|
|
|
|
/**
|
|
* Combining Marks for Symbols.
|
|
* 0x20D0 - 0x20FF.
|
|
*/
|
|
public static final UnicodeBlock COMBINING_MARKS_FOR_SYMBOLS
|
|
= new UnicodeBlock(0x20D0, 0x20FF,
|
|
"COMBINING_MARKS_FOR_SYMBOLS",
|
|
"Combining Marks for Symbols");
|
|
|
|
/**
|
|
* Letterlike Symbols.
|
|
* 0x2100 - 0x214F.
|
|
*/
|
|
public static final UnicodeBlock LETTERLIKE_SYMBOLS
|
|
= new UnicodeBlock(0x2100, 0x214F,
|
|
"LETTERLIKE_SYMBOLS",
|
|
"Letterlike Symbols");
|
|
|
|
/**
|
|
* Number Forms.
|
|
* 0x2150 - 0x218F.
|
|
*/
|
|
public static final UnicodeBlock NUMBER_FORMS
|
|
= new UnicodeBlock(0x2150, 0x218F,
|
|
"NUMBER_FORMS",
|
|
"Number Forms");
|
|
|
|
/**
|
|
* Arrows.
|
|
* 0x2190 - 0x21FF.
|
|
*/
|
|
public static final UnicodeBlock ARROWS
|
|
= new UnicodeBlock(0x2190, 0x21FF,
|
|
"ARROWS",
|
|
"Arrows");
|
|
|
|
/**
|
|
* Mathematical Operators.
|
|
* 0x2200 - 0x22FF.
|
|
*/
|
|
public static final UnicodeBlock MATHEMATICAL_OPERATORS
|
|
= new UnicodeBlock(0x2200, 0x22FF,
|
|
"MATHEMATICAL_OPERATORS",
|
|
"Mathematical Operators");
|
|
|
|
/**
|
|
* Miscellaneous Technical.
|
|
* 0x2300 - 0x23FF.
|
|
*/
|
|
public static final UnicodeBlock MISCELLANEOUS_TECHNICAL
|
|
= new UnicodeBlock(0x2300, 0x23FF,
|
|
"MISCELLANEOUS_TECHNICAL",
|
|
"Miscellaneous Technical");
|
|
|
|
/**
|
|
* Control Pictures.
|
|
* 0x2400 - 0x243F.
|
|
*/
|
|
public static final UnicodeBlock CONTROL_PICTURES
|
|
= new UnicodeBlock(0x2400, 0x243F,
|
|
"CONTROL_PICTURES",
|
|
"Control Pictures");
|
|
|
|
/**
|
|
* Optical Character Recognition.
|
|
* 0x2440 - 0x245F.
|
|
*/
|
|
public static final UnicodeBlock OPTICAL_CHARACTER_RECOGNITION
|
|
= new UnicodeBlock(0x2440, 0x245F,
|
|
"OPTICAL_CHARACTER_RECOGNITION",
|
|
"Optical Character Recognition");
|
|
|
|
/**
|
|
* Enclosed Alphanumerics.
|
|
* 0x2460 - 0x24FF.
|
|
*/
|
|
public static final UnicodeBlock ENCLOSED_ALPHANUMERICS
|
|
= new UnicodeBlock(0x2460, 0x24FF,
|
|
"ENCLOSED_ALPHANUMERICS",
|
|
"Enclosed Alphanumerics");
|
|
|
|
/**
|
|
* Box Drawing.
|
|
* 0x2500 - 0x257F.
|
|
*/
|
|
public static final UnicodeBlock BOX_DRAWING
|
|
= new UnicodeBlock(0x2500, 0x257F,
|
|
"BOX_DRAWING",
|
|
"Box Drawing");
|
|
|
|
/**
|
|
* Block Elements.
|
|
* 0x2580 - 0x259F.
|
|
*/
|
|
public static final UnicodeBlock BLOCK_ELEMENTS
|
|
= new UnicodeBlock(0x2580, 0x259F,
|
|
"BLOCK_ELEMENTS",
|
|
"Block Elements");
|
|
|
|
/**
|
|
* Geometric Shapes.
|
|
* 0x25A0 - 0x25FF.
|
|
*/
|
|
public static final UnicodeBlock GEOMETRIC_SHAPES
|
|
= new UnicodeBlock(0x25A0, 0x25FF,
|
|
"GEOMETRIC_SHAPES",
|
|
"Geometric Shapes");
|
|
|
|
/**
|
|
* Miscellaneous Symbols.
|
|
* 0x2600 - 0x26FF.
|
|
*/
|
|
public static final UnicodeBlock MISCELLANEOUS_SYMBOLS
|
|
= new UnicodeBlock(0x2600, 0x26FF,
|
|
"MISCELLANEOUS_SYMBOLS",
|
|
"Miscellaneous Symbols");
|
|
|
|
/**
|
|
* Dingbats.
|
|
* 0x2700 - 0x27BF.
|
|
*/
|
|
public static final UnicodeBlock DINGBATS
|
|
= new UnicodeBlock(0x2700, 0x27BF,
|
|
"DINGBATS",
|
|
"Dingbats");
|
|
|
|
/**
|
|
* Miscellaneous Mathematical Symbols-A.
|
|
* 0x27C0 - 0x27EF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A
|
|
= new UnicodeBlock(0x27C0, 0x27EF,
|
|
"MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A",
|
|
"Miscellaneous Mathematical Symbols-A");
|
|
|
|
/**
|
|
* Supplemental Arrows-A.
|
|
* 0x27F0 - 0x27FF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock SUPPLEMENTAL_ARROWS_A
|
|
= new UnicodeBlock(0x27F0, 0x27FF,
|
|
"SUPPLEMENTAL_ARROWS_A",
|
|
"Supplemental Arrows-A");
|
|
|
|
/**
|
|
* Braille Patterns.
|
|
* 0x2800 - 0x28FF.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock BRAILLE_PATTERNS
|
|
= new UnicodeBlock(0x2800, 0x28FF,
|
|
"BRAILLE_PATTERNS",
|
|
"Braille Patterns");
|
|
|
|
/**
|
|
* Supplemental Arrows-B.
|
|
* 0x2900 - 0x297F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock SUPPLEMENTAL_ARROWS_B
|
|
= new UnicodeBlock(0x2900, 0x297F,
|
|
"SUPPLEMENTAL_ARROWS_B",
|
|
"Supplemental Arrows-B");
|
|
|
|
/**
|
|
* Miscellaneous Mathematical Symbols-B.
|
|
* 0x2980 - 0x29FF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B
|
|
= new UnicodeBlock(0x2980, 0x29FF,
|
|
"MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B",
|
|
"Miscellaneous Mathematical Symbols-B");
|
|
|
|
/**
|
|
* Supplemental Mathematical Operators.
|
|
* 0x2A00 - 0x2AFF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock SUPPLEMENTAL_MATHEMATICAL_OPERATORS
|
|
= new UnicodeBlock(0x2A00, 0x2AFF,
|
|
"SUPPLEMENTAL_MATHEMATICAL_OPERATORS",
|
|
"Supplemental Mathematical Operators");
|
|
|
|
/**
|
|
* Miscellaneous Symbols and Arrows.
|
|
* 0x2B00 - 0x2BFF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock MISCELLANEOUS_SYMBOLS_AND_ARROWS
|
|
= new UnicodeBlock(0x2B00, 0x2BFF,
|
|
"MISCELLANEOUS_SYMBOLS_AND_ARROWS",
|
|
"Miscellaneous Symbols and Arrows");
|
|
|
|
/**
|
|
* CJK Radicals Supplement.
|
|
* 0x2E80 - 0x2EFF.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock CJK_RADICALS_SUPPLEMENT
|
|
= new UnicodeBlock(0x2E80, 0x2EFF,
|
|
"CJK_RADICALS_SUPPLEMENT",
|
|
"CJK Radicals Supplement");
|
|
|
|
/**
|
|
* Kangxi Radicals.
|
|
* 0x2F00 - 0x2FDF.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock KANGXI_RADICALS
|
|
= new UnicodeBlock(0x2F00, 0x2FDF,
|
|
"KANGXI_RADICALS",
|
|
"Kangxi Radicals");
|
|
|
|
/**
|
|
* Ideographic Description Characters.
|
|
* 0x2FF0 - 0x2FFF.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock IDEOGRAPHIC_DESCRIPTION_CHARACTERS
|
|
= new UnicodeBlock(0x2FF0, 0x2FFF,
|
|
"IDEOGRAPHIC_DESCRIPTION_CHARACTERS",
|
|
"Ideographic Description Characters");
|
|
|
|
/**
|
|
* CJK Symbols and Punctuation.
|
|
* 0x3000 - 0x303F.
|
|
*/
|
|
public static final UnicodeBlock CJK_SYMBOLS_AND_PUNCTUATION
|
|
= new UnicodeBlock(0x3000, 0x303F,
|
|
"CJK_SYMBOLS_AND_PUNCTUATION",
|
|
"CJK Symbols and Punctuation");
|
|
|
|
/**
|
|
* Hiragana.
|
|
* 0x3040 - 0x309F.
|
|
*/
|
|
public static final UnicodeBlock HIRAGANA
|
|
= new UnicodeBlock(0x3040, 0x309F,
|
|
"HIRAGANA",
|
|
"Hiragana");
|
|
|
|
/**
|
|
* Katakana.
|
|
* 0x30A0 - 0x30FF.
|
|
*/
|
|
public static final UnicodeBlock KATAKANA
|
|
= new UnicodeBlock(0x30A0, 0x30FF,
|
|
"KATAKANA",
|
|
"Katakana");
|
|
|
|
/**
|
|
* Bopomofo.
|
|
* 0x3100 - 0x312F.
|
|
*/
|
|
public static final UnicodeBlock BOPOMOFO
|
|
= new UnicodeBlock(0x3100, 0x312F,
|
|
"BOPOMOFO",
|
|
"Bopomofo");
|
|
|
|
/**
|
|
* Hangul Compatibility Jamo.
|
|
* 0x3130 - 0x318F.
|
|
*/
|
|
public static final UnicodeBlock HANGUL_COMPATIBILITY_JAMO
|
|
= new UnicodeBlock(0x3130, 0x318F,
|
|
"HANGUL_COMPATIBILITY_JAMO",
|
|
"Hangul Compatibility Jamo");
|
|
|
|
/**
|
|
* Kanbun.
|
|
* 0x3190 - 0x319F.
|
|
*/
|
|
public static final UnicodeBlock KANBUN
|
|
= new UnicodeBlock(0x3190, 0x319F,
|
|
"KANBUN",
|
|
"Kanbun");
|
|
|
|
/**
|
|
* Bopomofo Extended.
|
|
* 0x31A0 - 0x31BF.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock BOPOMOFO_EXTENDED
|
|
= new UnicodeBlock(0x31A0, 0x31BF,
|
|
"BOPOMOFO_EXTENDED",
|
|
"Bopomofo Extended");
|
|
|
|
/**
|
|
* Katakana Phonetic Extensions.
|
|
* 0x31F0 - 0x31FF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock KATAKANA_PHONETIC_EXTENSIONS
|
|
= new UnicodeBlock(0x31F0, 0x31FF,
|
|
"KATAKANA_PHONETIC_EXTENSIONS",
|
|
"Katakana Phonetic Extensions");
|
|
|
|
/**
|
|
* Enclosed CJK Letters and Months.
|
|
* 0x3200 - 0x32FF.
|
|
*/
|
|
public static final UnicodeBlock ENCLOSED_CJK_LETTERS_AND_MONTHS
|
|
= new UnicodeBlock(0x3200, 0x32FF,
|
|
"ENCLOSED_CJK_LETTERS_AND_MONTHS",
|
|
"Enclosed CJK Letters and Months");
|
|
|
|
/**
|
|
* CJK Compatibility.
|
|
* 0x3300 - 0x33FF.
|
|
*/
|
|
public static final UnicodeBlock CJK_COMPATIBILITY
|
|
= new UnicodeBlock(0x3300, 0x33FF,
|
|
"CJK_COMPATIBILITY",
|
|
"CJK Compatibility");
|
|
|
|
/**
|
|
* CJK Unified Ideographs Extension A.
|
|
* 0x3400 - 0x4DBF.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
|
|
= new UnicodeBlock(0x3400, 0x4DBF,
|
|
"CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A",
|
|
"CJK Unified Ideographs Extension A");
|
|
|
|
/**
|
|
* Yijing Hexagram Symbols.
|
|
* 0x4DC0 - 0x4DFF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock YIJING_HEXAGRAM_SYMBOLS
|
|
= new UnicodeBlock(0x4DC0, 0x4DFF,
|
|
"YIJING_HEXAGRAM_SYMBOLS",
|
|
"Yijing Hexagram Symbols");
|
|
|
|
/**
|
|
* CJK Unified Ideographs.
|
|
* 0x4E00 - 0x9FFF.
|
|
*/
|
|
public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS
|
|
= new UnicodeBlock(0x4E00, 0x9FFF,
|
|
"CJK_UNIFIED_IDEOGRAPHS",
|
|
"CJK Unified Ideographs");
|
|
|
|
/**
|
|
* Yi Syllables.
|
|
* 0xA000 - 0xA48F.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock YI_SYLLABLES
|
|
= new UnicodeBlock(0xA000, 0xA48F,
|
|
"YI_SYLLABLES",
|
|
"Yi Syllables");
|
|
|
|
/**
|
|
* Yi Radicals.
|
|
* 0xA490 - 0xA4CF.
|
|
* @since 1.4
|
|
*/
|
|
public static final UnicodeBlock YI_RADICALS
|
|
= new UnicodeBlock(0xA490, 0xA4CF,
|
|
"YI_RADICALS",
|
|
"Yi Radicals");
|
|
|
|
/**
|
|
* Hangul Syllables.
|
|
* 0xAC00 - 0xD7AF.
|
|
*/
|
|
public static final UnicodeBlock HANGUL_SYLLABLES
|
|
= new UnicodeBlock(0xAC00, 0xD7AF,
|
|
"HANGUL_SYLLABLES",
|
|
"Hangul Syllables");
|
|
|
|
/**
|
|
* High Surrogates.
|
|
* 0xD800 - 0xDB7F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock HIGH_SURROGATES
|
|
= new UnicodeBlock(0xD800, 0xDB7F,
|
|
"HIGH_SURROGATES",
|
|
"High Surrogates");
|
|
|
|
/**
|
|
* High Private Use Surrogates.
|
|
* 0xDB80 - 0xDBFF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock HIGH_PRIVATE_USE_SURROGATES
|
|
= new UnicodeBlock(0xDB80, 0xDBFF,
|
|
"HIGH_PRIVATE_USE_SURROGATES",
|
|
"High Private Use Surrogates");
|
|
|
|
/**
|
|
* Low Surrogates.
|
|
* 0xDC00 - 0xDFFF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock LOW_SURROGATES
|
|
= new UnicodeBlock(0xDC00, 0xDFFF,
|
|
"LOW_SURROGATES",
|
|
"Low Surrogates");
|
|
|
|
/**
|
|
* Private Use Area.
|
|
* 0xE000 - 0xF8FF.
|
|
*/
|
|
public static final UnicodeBlock PRIVATE_USE_AREA
|
|
= new UnicodeBlock(0xE000, 0xF8FF,
|
|
"PRIVATE_USE_AREA",
|
|
"Private Use Area");
|
|
|
|
/**
|
|
* CJK Compatibility Ideographs.
|
|
* 0xF900 - 0xFAFF.
|
|
*/
|
|
public static final UnicodeBlock CJK_COMPATIBILITY_IDEOGRAPHS
|
|
= new UnicodeBlock(0xF900, 0xFAFF,
|
|
"CJK_COMPATIBILITY_IDEOGRAPHS",
|
|
"CJK Compatibility Ideographs");
|
|
|
|
/**
|
|
* Alphabetic Presentation Forms.
|
|
* 0xFB00 - 0xFB4F.
|
|
*/
|
|
public static final UnicodeBlock ALPHABETIC_PRESENTATION_FORMS
|
|
= new UnicodeBlock(0xFB00, 0xFB4F,
|
|
"ALPHABETIC_PRESENTATION_FORMS",
|
|
"Alphabetic Presentation Forms");
|
|
|
|
/**
|
|
* Arabic Presentation Forms-A.
|
|
* 0xFB50 - 0xFDFF.
|
|
*/
|
|
public static final UnicodeBlock ARABIC_PRESENTATION_FORMS_A
|
|
= new UnicodeBlock(0xFB50, 0xFDFF,
|
|
"ARABIC_PRESENTATION_FORMS_A",
|
|
"Arabic Presentation Forms-A");
|
|
|
|
/**
|
|
* Variation Selectors.
|
|
* 0xFE00 - 0xFE0F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock VARIATION_SELECTORS
|
|
= new UnicodeBlock(0xFE00, 0xFE0F,
|
|
"VARIATION_SELECTORS",
|
|
"Variation Selectors");
|
|
|
|
/**
|
|
* Combining Half Marks.
|
|
* 0xFE20 - 0xFE2F.
|
|
*/
|
|
public static final UnicodeBlock COMBINING_HALF_MARKS
|
|
= new UnicodeBlock(0xFE20, 0xFE2F,
|
|
"COMBINING_HALF_MARKS",
|
|
"Combining Half Marks");
|
|
|
|
/**
|
|
* CJK Compatibility Forms.
|
|
* 0xFE30 - 0xFE4F.
|
|
*/
|
|
public static final UnicodeBlock CJK_COMPATIBILITY_FORMS
|
|
= new UnicodeBlock(0xFE30, 0xFE4F,
|
|
"CJK_COMPATIBILITY_FORMS",
|
|
"CJK Compatibility Forms");
|
|
|
|
/**
|
|
* Small Form Variants.
|
|
* 0xFE50 - 0xFE6F.
|
|
*/
|
|
public static final UnicodeBlock SMALL_FORM_VARIANTS
|
|
= new UnicodeBlock(0xFE50, 0xFE6F,
|
|
"SMALL_FORM_VARIANTS",
|
|
"Small Form Variants");
|
|
|
|
/**
|
|
* Arabic Presentation Forms-B.
|
|
* 0xFE70 - 0xFEFF.
|
|
*/
|
|
public static final UnicodeBlock ARABIC_PRESENTATION_FORMS_B
|
|
= new UnicodeBlock(0xFE70, 0xFEFF,
|
|
"ARABIC_PRESENTATION_FORMS_B",
|
|
"Arabic Presentation Forms-B");
|
|
|
|
/**
|
|
* Halfwidth and Fullwidth Forms.
|
|
* 0xFF00 - 0xFFEF.
|
|
*/
|
|
public static final UnicodeBlock HALFWIDTH_AND_FULLWIDTH_FORMS
|
|
= new UnicodeBlock(0xFF00, 0xFFEF,
|
|
"HALFWIDTH_AND_FULLWIDTH_FORMS",
|
|
"Halfwidth and Fullwidth Forms");
|
|
|
|
/**
|
|
* Specials.
|
|
* 0xFFF0 - 0xFFFF.
|
|
*/
|
|
public static final UnicodeBlock SPECIALS
|
|
= new UnicodeBlock(0xFFF0, 0xFFFF,
|
|
"SPECIALS",
|
|
"Specials");
|
|
|
|
/**
|
|
* Linear B Syllabary.
|
|
* 0x10000 - 0x1007F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock LINEAR_B_SYLLABARY
|
|
= new UnicodeBlock(0x10000, 0x1007F,
|
|
"LINEAR_B_SYLLABARY",
|
|
"Linear B Syllabary");
|
|
|
|
/**
|
|
* Linear B Ideograms.
|
|
* 0x10080 - 0x100FF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock LINEAR_B_IDEOGRAMS
|
|
= new UnicodeBlock(0x10080, 0x100FF,
|
|
"LINEAR_B_IDEOGRAMS",
|
|
"Linear B Ideograms");
|
|
|
|
/**
|
|
* Aegean Numbers.
|
|
* 0x10100 - 0x1013F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock AEGEAN_NUMBERS
|
|
= new UnicodeBlock(0x10100, 0x1013F,
|
|
"AEGEAN_NUMBERS",
|
|
"Aegean Numbers");
|
|
|
|
/**
|
|
* Old Italic.
|
|
* 0x10300 - 0x1032F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock OLD_ITALIC
|
|
= new UnicodeBlock(0x10300, 0x1032F,
|
|
"OLD_ITALIC",
|
|
"Old Italic");
|
|
|
|
/**
|
|
* Gothic.
|
|
* 0x10330 - 0x1034F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock GOTHIC
|
|
= new UnicodeBlock(0x10330, 0x1034F,
|
|
"GOTHIC",
|
|
"Gothic");
|
|
|
|
/**
|
|
* Ugaritic.
|
|
* 0x10380 - 0x1039F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock UGARITIC
|
|
= new UnicodeBlock(0x10380, 0x1039F,
|
|
"UGARITIC",
|
|
"Ugaritic");
|
|
|
|
/**
|
|
* Deseret.
|
|
* 0x10400 - 0x1044F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock DESERET
|
|
= new UnicodeBlock(0x10400, 0x1044F,
|
|
"DESERET",
|
|
"Deseret");
|
|
|
|
/**
|
|
* Shavian.
|
|
* 0x10450 - 0x1047F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock SHAVIAN
|
|
= new UnicodeBlock(0x10450, 0x1047F,
|
|
"SHAVIAN",
|
|
"Shavian");
|
|
|
|
/**
|
|
* Osmanya.
|
|
* 0x10480 - 0x104AF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock OSMANYA
|
|
= new UnicodeBlock(0x10480, 0x104AF,
|
|
"OSMANYA",
|
|
"Osmanya");
|
|
|
|
/**
|
|
* Cypriot Syllabary.
|
|
* 0x10800 - 0x1083F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock CYPRIOT_SYLLABARY
|
|
= new UnicodeBlock(0x10800, 0x1083F,
|
|
"CYPRIOT_SYLLABARY",
|
|
"Cypriot Syllabary");
|
|
|
|
/**
|
|
* Byzantine Musical Symbols.
|
|
* 0x1D000 - 0x1D0FF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock BYZANTINE_MUSICAL_SYMBOLS
|
|
= new UnicodeBlock(0x1D000, 0x1D0FF,
|
|
"BYZANTINE_MUSICAL_SYMBOLS",
|
|
"Byzantine Musical Symbols");
|
|
|
|
/**
|
|
* Musical Symbols.
|
|
* 0x1D100 - 0x1D1FF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock MUSICAL_SYMBOLS
|
|
= new UnicodeBlock(0x1D100, 0x1D1FF,
|
|
"MUSICAL_SYMBOLS",
|
|
"Musical Symbols");
|
|
|
|
/**
|
|
* Tai Xuan Jing Symbols.
|
|
* 0x1D300 - 0x1D35F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock TAI_XUAN_JING_SYMBOLS
|
|
= new UnicodeBlock(0x1D300, 0x1D35F,
|
|
"TAI_XUAN_JING_SYMBOLS",
|
|
"Tai Xuan Jing Symbols");
|
|
|
|
/**
|
|
* Mathematical Alphanumeric Symbols.
|
|
* 0x1D400 - 0x1D7FF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock MATHEMATICAL_ALPHANUMERIC_SYMBOLS
|
|
= new UnicodeBlock(0x1D400, 0x1D7FF,
|
|
"MATHEMATICAL_ALPHANUMERIC_SYMBOLS",
|
|
"Mathematical Alphanumeric Symbols");
|
|
|
|
/**
|
|
* CJK Unified Ideographs Extension B.
|
|
* 0x20000 - 0x2A6DF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B
|
|
= new UnicodeBlock(0x20000, 0x2A6DF,
|
|
"CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B",
|
|
"CJK Unified Ideographs Extension B");
|
|
|
|
/**
|
|
* CJK Compatibility Ideographs Supplement.
|
|
* 0x2F800 - 0x2FA1F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT
|
|
= new UnicodeBlock(0x2F800, 0x2FA1F,
|
|
"CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT",
|
|
"CJK Compatibility Ideographs Supplement");
|
|
|
|
/**
|
|
* Tags.
|
|
* 0xE0000 - 0xE007F.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock TAGS
|
|
= new UnicodeBlock(0xE0000, 0xE007F,
|
|
"TAGS",
|
|
"Tags");
|
|
|
|
/**
|
|
* Variation Selectors Supplement.
|
|
* 0xE0100 - 0xE01EF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock VARIATION_SELECTORS_SUPPLEMENT
|
|
= new UnicodeBlock(0xE0100, 0xE01EF,
|
|
"VARIATION_SELECTORS_SUPPLEMENT",
|
|
"Variation Selectors Supplement");
|
|
|
|
/**
|
|
* Supplementary Private Use Area-A.
|
|
* 0xF0000 - 0xFFFFF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock SUPPLEMENTARY_PRIVATE_USE_AREA_A
|
|
= new UnicodeBlock(0xF0000, 0xFFFFF,
|
|
"SUPPLEMENTARY_PRIVATE_USE_AREA_A",
|
|
"Supplementary Private Use Area-A");
|
|
|
|
/**
|
|
* Supplementary Private Use Area-B.
|
|
* 0x100000 - 0x10FFFF.
|
|
* @since 1.5
|
|
*/
|
|
public static final UnicodeBlock SUPPLEMENTARY_PRIVATE_USE_AREA_B
|
|
= new UnicodeBlock(0x100000, 0x10FFFF,
|
|
"SUPPLEMENTARY_PRIVATE_USE_AREA_B",
|
|
"Supplementary Private Use Area-B");
|
|
|
|
/**
|
|
* Surrogates Area.
|
|
* 'D800' - 'DFFF'.
|
|
* @deprecated As of 1.5, the three areas,
|
|
* <a href="#HIGH_SURROGATES">HIGH_SURROGATES</a>,
|
|
* <a href="#HIGH_PRIVATE_USE_SURROGATES">HIGH_PRIVATE_USE_SURROGATES</a>
|
|
* and <a href="#LOW_SURROGATES">LOW_SURROGATES</a>, as defined
|
|
* by the Unicode standard, should be used in preference to
|
|
* this. These are also returned from calls to <code>of(int)</code>
|
|
* and <code>of(char)</code>.
|
|
*/
|
|
@Deprecated
|
|
public static final UnicodeBlock SURROGATES_AREA
|
|
= new UnicodeBlock(0xD800, 0xDFFF,
|
|
"SURROGATES_AREA",
|
|
"Surrogates Area");
|
|
|
|
/**
|
|
* The defined subsets.
|
|
*/
|
|
private static final UnicodeBlock sets[] = {
|
|
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,
|
|
THAANA,
|
|
DEVANAGARI,
|
|
BENGALI,
|
|
GURMUKHI,
|
|
GUJARATI,
|
|
ORIYA,
|
|
TAMIL,
|
|
TELUGU,
|
|
KANNADA,
|
|
MALAYALAM,
|
|
SINHALA,
|
|
THAI,
|
|
LAO,
|
|
TIBETAN,
|
|
MYANMAR,
|
|
GEORGIAN,
|
|
HANGUL_JAMO,
|
|
ETHIOPIC,
|
|
CHEROKEE,
|
|
UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS,
|
|
OGHAM,
|
|
RUNIC,
|
|
TAGALOG,
|
|
HANUNOO,
|
|
BUHID,
|
|
TAGBANWA,
|
|
KHMER,
|
|
MONGOLIAN,
|
|
LIMBU,
|
|
TAI_LE,
|
|
KHMER_SYMBOLS,
|
|
PHONETIC_EXTENSIONS,
|
|
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,
|
|
CJK_RADICALS_SUPPLEMENT,
|
|
KANGXI_RADICALS,
|
|
IDEOGRAPHIC_DESCRIPTION_CHARACTERS,
|
|
CJK_SYMBOLS_AND_PUNCTUATION,
|
|
HIRAGANA,
|
|
KATAKANA,
|
|
BOPOMOFO,
|
|
HANGUL_COMPATIBILITY_JAMO,
|
|
KANBUN,
|
|
BOPOMOFO_EXTENDED,
|
|
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,
|
|
HANGUL_SYLLABLES,
|
|
HIGH_SURROGATES,
|
|
HIGH_PRIVATE_USE_SURROGATES,
|
|
LOW_SURROGATES,
|
|
PRIVATE_USE_AREA,
|
|
CJK_COMPATIBILITY_IDEOGRAPHS,
|
|
ALPHABETIC_PRESENTATION_FORMS,
|
|
ARABIC_PRESENTATION_FORMS_A,
|
|
VARIATION_SELECTORS,
|
|
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,
|
|
OLD_ITALIC,
|
|
GOTHIC,
|
|
UGARITIC,
|
|
DESERET,
|
|
SHAVIAN,
|
|
OSMANYA,
|
|
CYPRIOT_SYLLABARY,
|
|
BYZANTINE_MUSICAL_SYMBOLS,
|
|
MUSICAL_SYMBOLS,
|
|
TAI_XUAN_JING_SYMBOLS,
|
|
MATHEMATICAL_ALPHANUMERIC_SYMBOLS,
|
|
CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B,
|
|
CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT,
|
|
TAGS,
|
|
VARIATION_SELECTORS_SUPPLEMENT,
|
|
SUPPLEMENTARY_PRIVATE_USE_AREA_A,
|
|
SUPPLEMENTARY_PRIVATE_USE_AREA_B,
|
|
};
|
|
} // class UnicodeBlock
|
|
|
|
/**
|
|
* A class to encompass all the properties of characters in the
|
|
* private use blocks in the Unicode standard. This class extends
|
|
* UnassignedCharacters because the return type from getType() is
|
|
* different.
|
|
* @author Anthony Balkissoon abalkiss at redhat dot com
|
|
*
|
|
*/
|
|
private static class PrivateUseCharacters extends UnassignedCharacters
|
|
{
|
|
/**
|
|
* Returns the type of the character cp.
|
|
*/
|
|
static int getType(int cp)
|
|
{
|
|
// The upper 2 code points in any plane are considered unassigned,
|
|
// even in the private-use planes.
|
|
if ((cp & 0xffff) >= 0xfffe)
|
|
return UnassignedCharacters.getType(cp);
|
|
return PRIVATE_USE;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the character cp is defined.
|
|
*/
|
|
static boolean isDefined(int cp)
|
|
{
|
|
// The upper 2 code points in any plane are considered unassigned,
|
|
// even in the private-use planes.
|
|
if ((cp & 0xffff) >= 0xfffe)
|
|
return UnassignedCharacters.isDefined(cp);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Gets the directionality for the character cp.
|
|
*/
|
|
static byte getDirectionality(int cp)
|
|
{
|
|
if ((cp & 0xffff) >= 0xfffe)
|
|
return UnassignedCharacters.getDirectionality(cp);
|
|
return DIRECTIONALITY_LEFT_TO_RIGHT;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A class to encompass all the properties of code points that are
|
|
* currently undefined in the Unicode standard.
|
|
* @author Anthony Balkissoon abalkiss at redhat dot com
|
|
*
|
|
*/
|
|
private static class UnassignedCharacters
|
|
{
|
|
/**
|
|
* Returns the numeric value for the unassigned characters.
|
|
* @param cp the character
|
|
* @param radix the radix (not used)
|
|
* @return the numeric value of this character in this radix
|
|
*/
|
|
static int digit(int cp, int radix)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Returns the Unicode directionality property for unassigned
|
|
* characters.
|
|
* @param cp the character
|
|
* @return DIRECTIONALITY_UNDEFINED
|
|
*/
|
|
static byte getDirectionality(int cp)
|
|
{
|
|
return DIRECTIONALITY_UNDEFINED;
|
|
}
|
|
|
|
/**
|
|
* Returns -1, the numeric value for unassigned Unicode characters.
|
|
* @param cp the character
|
|
* @return -1
|
|
*/
|
|
static int getNumericValue(int cp)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Returns UNASSIGNED, the type of unassigned Unicode characters.
|
|
* @param cp the character
|
|
* @return UNASSIGNED
|
|
*/
|
|
static int getType(int cp)
|
|
{
|
|
return UNASSIGNED;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indiciate that the character is not defined in the
|
|
* Unicode standard.
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isDefined(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indicate that the character is not a digit.
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isDigit(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indicate that the character cannot be ignored
|
|
* within an identifier
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isIdentifierIgnorable(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indicate that the character cannot be part of a
|
|
* Java identifier.
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isJavaIdentifierPart(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indicate that the character cannot be start a
|
|
* Java identifier.
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isJavaIdentiferStart(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indicate that the character is not a letter.
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isLetter(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indicate that the character cannot is neither a letter
|
|
* nor a digit.
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isLetterOrDigit(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indicate that the character is not a lowercase letter.
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isLowerCase(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indicate that the character cannot is not mirrored.
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isMirrored(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indicate that the character is not a space character.
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isSpaceChar(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indicate that the character it not a titlecase letter.
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isTitleCase(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indicate that the character cannot be part of a
|
|
* Unicode identifier.
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isUnicodeIdentifierPart(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indicate that the character cannot start a
|
|
* Unicode identifier.
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isUnicodeIdentifierStart(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indicate that the character is not an uppercase letter.
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isUpperCase(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns false to indicate that the character is not a whitespace
|
|
* character.
|
|
* @param cp the character
|
|
* @return false
|
|
*/
|
|
static boolean isWhiteSpace(int cp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns cp to indicate this character has no lowercase conversion.
|
|
* @param cp the character
|
|
* @return cp
|
|
*/
|
|
static int toLowerCase(int cp)
|
|
{
|
|
return cp;
|
|
}
|
|
|
|
/**
|
|
* Returns cp to indicate this character has no titlecase conversion.
|
|
* @param cp the character
|
|
* @return cp
|
|
*/
|
|
static int toTitleCase(int cp)
|
|
{
|
|
return cp;
|
|
}
|
|
|
|
/**
|
|
* Returns cp to indicate this character has no uppercase conversion.
|
|
* @param cp the character
|
|
* @return cp
|
|
*/
|
|
static int toUpperCase(int cp)
|
|
{
|
|
return cp;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The immutable value of this Character.
|
|
*
|
|
* @serial the value of this Character
|
|
*/
|
|
private final char value;
|
|
|
|
/**
|
|
* Compatible with JDK 1.0+.
|
|
*/
|
|
private static final long serialVersionUID = 3786198910865385080L;
|
|
|
|
/**
|
|
* Smallest value allowed for radix arguments in Java. This value is 2.
|
|
*
|
|
* @see #digit(char, int)
|
|
* @see #forDigit(int, int)
|
|
* @see Integer#toString(int, int)
|
|
* @see Integer#valueOf(String)
|
|
*/
|
|
public static final int MIN_RADIX = 2;
|
|
|
|
/**
|
|
* Largest value allowed for radix arguments in Java. This value is 36.
|
|
*
|
|
* @see #digit(char, int)
|
|
* @see #forDigit(int, int)
|
|
* @see Integer#toString(int, int)
|
|
* @see Integer#valueOf(String)
|
|
*/
|
|
public static final int MAX_RADIX = 36;
|
|
|
|
/**
|
|
* The minimum value the char data type can hold.
|
|
* This value is <code>'\\u0000'</code>.
|
|
*/
|
|
public static final char MIN_VALUE = '\u0000';
|
|
|
|
/**
|
|
* The maximum value the char data type can hold.
|
|
* This value is <code>'\\uFFFF'</code>.
|
|
*/
|
|
public static final char MAX_VALUE = '\uFFFF';
|
|
|
|
/**
|
|
* The minimum Unicode 4.0 code point. This value is <code>0</code>.
|
|
* @since 1.5
|
|
*/
|
|
public static final int MIN_CODE_POINT = 0;
|
|
|
|
/**
|
|
* The maximum Unicode 4.0 code point, which is greater than the range
|
|
* of the char data type.
|
|
* This value is <code>0x10FFFF</code>.
|
|
* @since 1.5
|
|
*/
|
|
public static final int MAX_CODE_POINT = 0x10FFFF;
|
|
|
|
/**
|
|
* The minimum Unicode high surrogate code unit, or
|
|
* <emph>leading-surrogate</emph>, in the UTF-16 character encoding.
|
|
* This value is <code>'\uD800'</code>.
|
|
* @since 1.5
|
|
*/
|
|
public static final char MIN_HIGH_SURROGATE = '\uD800';
|
|
|
|
/**
|
|
* The maximum Unicode high surrogate code unit, or
|
|
* <emph>leading-surrogate</emph>, in the UTF-16 character encoding.
|
|
* This value is <code>'\uDBFF'</code>.
|
|
* @since 1.5
|
|
*/
|
|
public static final char MAX_HIGH_SURROGATE = '\uDBFF';
|
|
|
|
/**
|
|
* The minimum Unicode low surrogate code unit, or
|
|
* <emph>trailing-surrogate</emph>, in the UTF-16 character encoding.
|
|
* This value is <code>'\uDC00'</code>.
|
|
* @since 1.5
|
|
*/
|
|
public static final char MIN_LOW_SURROGATE = '\uDC00';
|
|
|
|
/**
|
|
* The maximum Unicode low surrogate code unit, or
|
|
* <emph>trailing-surrogate</emph>, in the UTF-16 character encoding.
|
|
* This value is <code>'\uDFFF'</code>.
|
|
* @since 1.5
|
|
*/
|
|
public static final char MAX_LOW_SURROGATE = '\uDFFF';
|
|
|
|
/**
|
|
* The minimum Unicode surrogate code unit in the UTF-16 character encoding.
|
|
* This value is <code>'\uD800'</code>.
|
|
* @since 1.5
|
|
*/
|
|
public static final char MIN_SURROGATE = MIN_HIGH_SURROGATE;
|
|
|
|
/**
|
|
* The maximum Unicode surrogate code unit in the UTF-16 character encoding.
|
|
* This value is <code>'\uDFFF'</code>.
|
|
* @since 1.5
|
|
*/
|
|
public static final char MAX_SURROGATE = MAX_LOW_SURROGATE;
|
|
|
|
/**
|
|
* The lowest possible supplementary Unicode code point (the first code
|
|
* point outside the basic multilingual plane (BMP)).
|
|
* This value is <code>0x10000</code>.
|
|
*/
|
|
public static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x10000;
|
|
|
|
/**
|
|
* Class object representing the primitive char data type.
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final Class<Character> TYPE = (Class<Character>) VMClassLoader.getPrimitiveClass('C');
|
|
|
|
/**
|
|
* The number of bits needed to represent a <code>char</code>.
|
|
* @since 1.5
|
|
*/
|
|
public static final int SIZE = 16;
|
|
|
|
// This caches some Character values, and is used by boxing
|
|
// conversions via valueOf(). We must cache at least 0..127;
|
|
// this constant controls how much we actually cache.
|
|
private static final int MAX_CACHE = 127;
|
|
private static Character[] charCache = new Character[MAX_CACHE + 1];
|
|
|
|
/**
|
|
* Lu = Letter, Uppercase (Informative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte UPPERCASE_LETTER = 1;
|
|
|
|
/**
|
|
* Ll = Letter, Lowercase (Informative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte LOWERCASE_LETTER = 2;
|
|
|
|
/**
|
|
* Lt = Letter, Titlecase (Informative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte TITLECASE_LETTER = 3;
|
|
|
|
/**
|
|
* Mn = Mark, Non-Spacing (Normative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte NON_SPACING_MARK = 6;
|
|
|
|
/**
|
|
* Mc = Mark, Spacing Combining (Normative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte COMBINING_SPACING_MARK = 8;
|
|
|
|
/**
|
|
* Me = Mark, Enclosing (Normative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte ENCLOSING_MARK = 7;
|
|
|
|
/**
|
|
* Nd = Number, Decimal Digit (Normative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte DECIMAL_DIGIT_NUMBER = 9;
|
|
|
|
/**
|
|
* Nl = Number, Letter (Normative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte LETTER_NUMBER = 10;
|
|
|
|
/**
|
|
* No = Number, Other (Normative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte OTHER_NUMBER = 11;
|
|
|
|
/**
|
|
* Zs = Separator, Space (Normative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte SPACE_SEPARATOR = 12;
|
|
|
|
/**
|
|
* Zl = Separator, Line (Normative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte LINE_SEPARATOR = 13;
|
|
|
|
/**
|
|
* Zp = Separator, Paragraph (Normative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte PARAGRAPH_SEPARATOR = 14;
|
|
|
|
/**
|
|
* Cc = Other, Control (Normative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte CONTROL = 15;
|
|
|
|
/**
|
|
* Cf = Other, Format (Normative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte FORMAT = 16;
|
|
|
|
/**
|
|
* Cs = Other, Surrogate (Normative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte SURROGATE = 19;
|
|
|
|
/**
|
|
* Co = Other, Private Use (Normative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte PRIVATE_USE = 18;
|
|
|
|
/**
|
|
* Cn = Other, Not Assigned (Normative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte UNASSIGNED = 0;
|
|
|
|
/**
|
|
* Lm = Letter, Modifier (Informative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte MODIFIER_LETTER = 4;
|
|
|
|
/**
|
|
* Lo = Letter, Other (Informative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte OTHER_LETTER = 5;
|
|
|
|
/**
|
|
* Pc = Punctuation, Connector (Informative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte CONNECTOR_PUNCTUATION = 23;
|
|
|
|
/**
|
|
* Pd = Punctuation, Dash (Informative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte DASH_PUNCTUATION = 20;
|
|
|
|
/**
|
|
* Ps = Punctuation, Open (Informative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte START_PUNCTUATION = 21;
|
|
|
|
/**
|
|
* Pe = Punctuation, Close (Informative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte END_PUNCTUATION = 22;
|
|
|
|
/**
|
|
* Pi = Punctuation, Initial Quote (Informative).
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte INITIAL_QUOTE_PUNCTUATION = 29;
|
|
|
|
/**
|
|
* Pf = Punctuation, Final Quote (Informative).
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte FINAL_QUOTE_PUNCTUATION = 30;
|
|
|
|
/**
|
|
* Po = Punctuation, Other (Informative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte OTHER_PUNCTUATION = 24;
|
|
|
|
/**
|
|
* Sm = Symbol, Math (Informative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte MATH_SYMBOL = 25;
|
|
|
|
/**
|
|
* Sc = Symbol, Currency (Informative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte CURRENCY_SYMBOL = 26;
|
|
|
|
/**
|
|
* Sk = Symbol, Modifier (Informative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte MODIFIER_SYMBOL = 27;
|
|
|
|
/**
|
|
* So = Symbol, Other (Informative).
|
|
*
|
|
* @since 1.1
|
|
*/
|
|
public static final byte OTHER_SYMBOL = 28;
|
|
|
|
/**
|
|
* Undefined bidirectional character type. Undefined char values have
|
|
* undefined directionality in the Unicode specification.
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_UNDEFINED = -1;
|
|
|
|
/**
|
|
* Strong bidirectional character type "L".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT = 0;
|
|
|
|
/**
|
|
* Strong bidirectional character type "R".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT = 1;
|
|
|
|
/**
|
|
* Strong bidirectional character type "AL".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC = 2;
|
|
|
|
/**
|
|
* Weak bidirectional character type "EN".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_EUROPEAN_NUMBER = 3;
|
|
|
|
/**
|
|
* Weak bidirectional character type "ES".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR = 4;
|
|
|
|
/**
|
|
* Weak bidirectional character type "ET".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR = 5;
|
|
|
|
/**
|
|
* Weak bidirectional character type "AN".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_ARABIC_NUMBER = 6;
|
|
|
|
/**
|
|
* Weak bidirectional character type "CS".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR = 7;
|
|
|
|
/**
|
|
* Weak bidirectional character type "NSM".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_NONSPACING_MARK = 8;
|
|
|
|
/**
|
|
* Weak bidirectional character type "BN".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_BOUNDARY_NEUTRAL = 9;
|
|
|
|
/**
|
|
* Neutral bidirectional character type "B".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_PARAGRAPH_SEPARATOR = 10;
|
|
|
|
/**
|
|
* Neutral bidirectional character type "S".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_SEGMENT_SEPARATOR = 11;
|
|
|
|
/**
|
|
* Strong bidirectional character type "WS".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_WHITESPACE = 12;
|
|
|
|
/**
|
|
* Neutral bidirectional character type "ON".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_OTHER_NEUTRALS = 13;
|
|
|
|
/**
|
|
* Strong bidirectional character type "LRE".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING = 14;
|
|
|
|
/**
|
|
* Strong bidirectional character type "LRO".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE = 15;
|
|
|
|
/**
|
|
* Strong bidirectional character type "RLE".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING = 16;
|
|
|
|
/**
|
|
* Strong bidirectional character type "RLO".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE = 17;
|
|
|
|
/**
|
|
* Weak bidirectional character type "PDF".
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public static final byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT = 18;
|
|
|
|
/**
|
|
* Stores unicode block offset lookup table. Exploit package visibility of
|
|
* String.value to avoid copying the array.
|
|
* @see #readCodePoint(int)
|
|
* @see CharData#BLOCKS
|
|
*/
|
|
private static final char[][] blocks =
|
|
new char[][]{
|
|
String.zeroBasedStringValue(CharData.BLOCKS[0]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[1]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[2]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[3]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[4]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[5]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[6]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[7]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[8]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[9]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[10]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[11]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[12]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[13]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[14]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[15]),
|
|
String.zeroBasedStringValue(CharData.BLOCKS[16])};
|
|
|
|
/**
|
|
* Stores unicode attribute offset lookup table. Exploit package visibility
|
|
* of String.value to avoid copying the array.
|
|
* @see CharData#DATA
|
|
*/
|
|
private static final char[][] data =
|
|
new char[][]{
|
|
String.zeroBasedStringValue(CharData.DATA[0]),
|
|
String.zeroBasedStringValue(CharData.DATA[1]),
|
|
String.zeroBasedStringValue(CharData.DATA[2]),
|
|
String.zeroBasedStringValue(CharData.DATA[3]),
|
|
String.zeroBasedStringValue(CharData.DATA[4]),
|
|
String.zeroBasedStringValue(CharData.DATA[5]),
|
|
String.zeroBasedStringValue(CharData.DATA[6]),
|
|
String.zeroBasedStringValue(CharData.DATA[7]),
|
|
String.zeroBasedStringValue(CharData.DATA[8]),
|
|
String.zeroBasedStringValue(CharData.DATA[9]),
|
|
String.zeroBasedStringValue(CharData.DATA[10]),
|
|
String.zeroBasedStringValue(CharData.DATA[11]),
|
|
String.zeroBasedStringValue(CharData.DATA[12]),
|
|
String.zeroBasedStringValue(CharData.DATA[13]),
|
|
String.zeroBasedStringValue(CharData.DATA[14]),
|
|
String.zeroBasedStringValue(CharData.DATA[15]),
|
|
String.zeroBasedStringValue(CharData.DATA[16])};
|
|
|
|
/**
|
|
* Stores unicode numeric value attribute table. Exploit package visibility
|
|
* of String.value to avoid copying the array.
|
|
* @see CharData#NUM_VALUE
|
|
*/
|
|
private static final char[][] numValue =
|
|
new char[][]{
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[0]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[1]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[2]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[3]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[4]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[5]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[6]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[7]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[8]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[9]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[10]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[11]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[12]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[13]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[14]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[15]),
|
|
String.zeroBasedStringValue(CharData.NUM_VALUE[16])};
|
|
|
|
/**
|
|
* Stores unicode uppercase attribute table. Exploit package visibility
|
|
* of String.value to avoid copying the array.
|
|
* @see CharData#UPPER
|
|
*/
|
|
private static final char[][] upper =
|
|
new char[][]{
|
|
String.zeroBasedStringValue(CharData.UPPER[0]),
|
|
String.zeroBasedStringValue(CharData.UPPER[1]),
|
|
String.zeroBasedStringValue(CharData.UPPER[2]),
|
|
String.zeroBasedStringValue(CharData.UPPER[3]),
|
|
String.zeroBasedStringValue(CharData.UPPER[4]),
|
|
String.zeroBasedStringValue(CharData.UPPER[5]),
|
|
String.zeroBasedStringValue(CharData.UPPER[6]),
|
|
String.zeroBasedStringValue(CharData.UPPER[7]),
|
|
String.zeroBasedStringValue(CharData.UPPER[8]),
|
|
String.zeroBasedStringValue(CharData.UPPER[9]),
|
|
String.zeroBasedStringValue(CharData.UPPER[10]),
|
|
String.zeroBasedStringValue(CharData.UPPER[11]),
|
|
String.zeroBasedStringValue(CharData.UPPER[12]),
|
|
String.zeroBasedStringValue(CharData.UPPER[13]),
|
|
String.zeroBasedStringValue(CharData.UPPER[14]),
|
|
String.zeroBasedStringValue(CharData.UPPER[15]),
|
|
String.zeroBasedStringValue(CharData.UPPER[16])};
|
|
|
|
/**
|
|
* Stores unicode lowercase attribute table. Exploit package visibility
|
|
* of String.value to avoid copying the array.
|
|
* @see CharData#LOWER
|
|
*/
|
|
private static final char[][] lower =
|
|
new char[][]{
|
|
String.zeroBasedStringValue(CharData.LOWER[0]),
|
|
String.zeroBasedStringValue(CharData.LOWER[1]),
|
|
String.zeroBasedStringValue(CharData.LOWER[2]),
|
|
String.zeroBasedStringValue(CharData.LOWER[3]),
|
|
String.zeroBasedStringValue(CharData.LOWER[4]),
|
|
String.zeroBasedStringValue(CharData.LOWER[5]),
|
|
String.zeroBasedStringValue(CharData.LOWER[6]),
|
|
String.zeroBasedStringValue(CharData.LOWER[7]),
|
|
String.zeroBasedStringValue(CharData.LOWER[8]),
|
|
String.zeroBasedStringValue(CharData.LOWER[9]),
|
|
String.zeroBasedStringValue(CharData.LOWER[10]),
|
|
String.zeroBasedStringValue(CharData.LOWER[11]),
|
|
String.zeroBasedStringValue(CharData.LOWER[12]),
|
|
String.zeroBasedStringValue(CharData.LOWER[13]),
|
|
String.zeroBasedStringValue(CharData.LOWER[14]),
|
|
String.zeroBasedStringValue(CharData.LOWER[15]),
|
|
String.zeroBasedStringValue(CharData.LOWER[16])};
|
|
|
|
/**
|
|
* Stores unicode direction attribute table. Exploit package visibility
|
|
* of String.value to avoid copying the array.
|
|
* @see CharData#DIRECTION
|
|
*/
|
|
// Package visible for use by String.
|
|
static final char[][] direction =
|
|
new char[][]{
|
|
String.zeroBasedStringValue(CharData.DIRECTION[0]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[1]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[2]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[3]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[4]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[5]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[6]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[7]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[8]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[9]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[10]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[11]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[12]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[13]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[14]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[15]),
|
|
String.zeroBasedStringValue(CharData.DIRECTION[16])};
|
|
|
|
/**
|
|
* Stores unicode titlecase table. Exploit package visibility of
|
|
* String.value to avoid copying the array.
|
|
* @see CharData#TITLE
|
|
*/
|
|
private static final char[] title = String.zeroBasedStringValue(CharData.TITLE);
|
|
|
|
/**
|
|
* Mask for grabbing the type out of the contents of data.
|
|
* @see CharData#DATA
|
|
*/
|
|
private static final int TYPE_MASK = 0x1F;
|
|
|
|
/**
|
|
* Mask for grabbing the non-breaking space flag out of the contents of
|
|
* data.
|
|
* @see CharData#DATA
|
|
*/
|
|
private static final int NO_BREAK_MASK = 0x20;
|
|
|
|
/**
|
|
* Mask for grabbing the mirrored directionality flag out of the contents
|
|
* of data.
|
|
* @see CharData#DATA
|
|
*/
|
|
private static final int MIRROR_MASK = 0x40;
|
|
|
|
/**
|
|
* Grabs an attribute offset from the Unicode attribute database. The lower
|
|
* 5 bits are the character type, the next 2 bits are flags, and the top
|
|
* 9 bits are the offset into the attribute tables.
|
|
*
|
|
* @param codePoint the character to look up
|
|
* @return the character's attribute offset and type
|
|
* @see #TYPE_MASK
|
|
* @see #NO_BREAK_MASK
|
|
* @see #MIRROR_MASK
|
|
* @see CharData#DATA
|
|
* @see CharData#SHIFT
|
|
*/
|
|
// Package visible for use in String.
|
|
static char readCodePoint(int codePoint)
|
|
{
|
|
int plane = codePoint >>> 16;
|
|
char offset = (char) (codePoint & 0xffff);
|
|
return data[plane][(char) (blocks[plane][offset >> CharData.SHIFT[plane]] + offset)];
|
|
}
|
|
|
|
/**
|
|
* Wraps up a character.
|
|
*
|
|
* @param value the character to wrap
|
|
*/
|
|
public Character(char value)
|
|
{
|
|
this.value = value;
|
|
}
|
|
|
|
/**
|
|
* Returns the character which has been wrapped by this class.
|
|
*
|
|
* @return the character wrapped
|
|
*/
|
|
public char charValue()
|
|
{
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Returns the numerical value (unsigned) of the wrapped character.
|
|
* Range of returned values: 0x0000-0xFFFF.
|
|
*
|
|
* @return the value of the wrapped character
|
|
*/
|
|
public int hashCode()
|
|
{
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Determines if an object is equal to this object. This is only true for
|
|
* another Character object wrapping the same value.
|
|
*
|
|
* @param o object to compare
|
|
* @return true if o is a Character with the same value
|
|
*/
|
|
public boolean equals(Object o)
|
|
{
|
|
return o instanceof Character && value == ((Character) o).value;
|
|
}
|
|
|
|
/**
|
|
* Converts the wrapped character into a String.
|
|
*
|
|
* @return a String containing one character -- the wrapped character
|
|
* of this instance
|
|
*/
|
|
public String toString()
|
|
{
|
|
// Package constructor avoids an array copy.
|
|
return new String(new char[] { value }, 0, 1, true);
|
|
}
|
|
|
|
/**
|
|
* Returns a String of length 1 representing the specified character.
|
|
*
|
|
* @param ch the character to convert
|
|
* @return a String containing the character
|
|
* @since 1.4
|
|
*/
|
|
public static String toString(char ch)
|
|
{
|
|
// Package constructor avoids an array copy.
|
|
return new String(new char[] { ch }, 0, 1, true);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is a Unicode lowercase letter. For example,
|
|
* <code>'a'</code> is lowercase. Returns true if getType() returns
|
|
* LOWERCASE_LETTER.
|
|
* <br>
|
|
* lowercase = [Ll]
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch is a Unicode lowercase letter, else false
|
|
* @see #isUpperCase(char)
|
|
* @see #isTitleCase(char)
|
|
* @see #toLowerCase(char)
|
|
* @see #getType(char)
|
|
*/
|
|
public static boolean isLowerCase(char ch)
|
|
{
|
|
return isLowerCase((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is a Unicode lowercase letter. For example,
|
|
* <code>'a'</code> is lowercase. Returns true if getType() returns
|
|
* LOWERCASE_LETTER.
|
|
* <br>
|
|
* lowercase = [Ll]
|
|
*
|
|
* @param codePoint character to test
|
|
* @return true if ch is a Unicode lowercase letter, else false
|
|
* @see #isUpperCase(char)
|
|
* @see #isTitleCase(char)
|
|
* @see #toLowerCase(char)
|
|
* @see #getType(char)
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isLowerCase(int codePoint)
|
|
{
|
|
return getType(codePoint) == LOWERCASE_LETTER;
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is a Unicode uppercase letter. For example,
|
|
* <code>'A'</code> is uppercase. Returns true if getType() returns
|
|
* UPPERCASE_LETTER.
|
|
* <br>
|
|
* uppercase = [Lu]
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch is a Unicode uppercase letter, else false
|
|
* @see #isLowerCase(char)
|
|
* @see #isTitleCase(char)
|
|
* @see #toUpperCase(char)
|
|
* @see #getType(char)
|
|
*/
|
|
public static boolean isUpperCase(char ch)
|
|
{
|
|
return isUpperCase((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is a Unicode uppercase letter. For example,
|
|
* <code>'A'</code> is uppercase. Returns true if getType() returns
|
|
* UPPERCASE_LETTER.
|
|
* <br>
|
|
* uppercase = [Lu]
|
|
*
|
|
* @param codePoint character to test
|
|
* @return true if ch is a Unicode uppercase letter, else false
|
|
* @see #isLowerCase(char)
|
|
* @see #isTitleCase(char)
|
|
* @see #toUpperCase(char)
|
|
* @see #getType(char)
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isUpperCase(int codePoint)
|
|
{
|
|
return getType(codePoint) == UPPERCASE_LETTER;
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is a Unicode titlecase letter. For example,
|
|
* the character "Lj" (Latin capital L with small letter j) is titlecase.
|
|
* True if getType() returns TITLECASE_LETTER.
|
|
* <br>
|
|
* titlecase = [Lt]
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch is a Unicode titlecase letter, else false
|
|
* @see #isLowerCase(char)
|
|
* @see #isUpperCase(char)
|
|
* @see #toTitleCase(char)
|
|
* @see #getType(char)
|
|
*/
|
|
public static boolean isTitleCase(char ch)
|
|
{
|
|
return isTitleCase((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is a Unicode titlecase letter. For example,
|
|
* the character "Lj" (Latin capital L with small letter j) is titlecase.
|
|
* True if getType() returns TITLECASE_LETTER.
|
|
* <br>
|
|
* titlecase = [Lt]
|
|
*
|
|
* @param codePoint character to test
|
|
* @return true if ch is a Unicode titlecase letter, else false
|
|
* @see #isLowerCase(char)
|
|
* @see #isUpperCase(char)
|
|
* @see #toTitleCase(char)
|
|
* @see #getType(char)
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isTitleCase(int codePoint)
|
|
{
|
|
return getType(codePoint) == TITLECASE_LETTER;
|
|
}
|
|
|
|
|
|
/**
|
|
* Determines if a character is a Unicode decimal digit. For example,
|
|
* <code>'0'</code> is a digit. A character is a Unicode digit if
|
|
* getType() returns DECIMAL_DIGIT_NUMBER.
|
|
* <br>
|
|
* Unicode decimal digit = [Nd]
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch is a Unicode decimal digit, else false
|
|
* @see #digit(char, int)
|
|
* @see #forDigit(int, int)
|
|
* @see #getType(char)
|
|
*/
|
|
public static boolean isDigit(char ch)
|
|
{
|
|
return isDigit((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is a Unicode decimal digit. For example,
|
|
* <code>'0'</code> is a digit. A character is a Unicode digit if
|
|
* getType() returns DECIMAL_DIGIT_NUMBER.
|
|
* <br>
|
|
* Unicode decimal digit = [Nd]
|
|
*
|
|
* @param codePoint character to test
|
|
* @return true if ch is a Unicode decimal digit, else false
|
|
* @see #digit(char, int)
|
|
* @see #forDigit(int, int)
|
|
* @see #getType(char)
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
|
|
public static boolean isDigit(int codePoint)
|
|
{
|
|
return getType(codePoint) == DECIMAL_DIGIT_NUMBER;
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is part of the Unicode Standard. This is an
|
|
* evolving standard, but covers every character in the data file.
|
|
* <br>
|
|
* defined = not [Cn]
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch is a Unicode character, else false
|
|
* @see #isDigit(char)
|
|
* @see #isLetter(char)
|
|
* @see #isLetterOrDigit(char)
|
|
* @see #isLowerCase(char)
|
|
* @see #isTitleCase(char)
|
|
* @see #isUpperCase(char)
|
|
*/
|
|
public static boolean isDefined(char ch)
|
|
{
|
|
return isDefined((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is part of the Unicode Standard. This is an
|
|
* evolving standard, but covers every character in the data file.
|
|
* <br>
|
|
* defined = not [Cn]
|
|
*
|
|
* @param codePoint character to test
|
|
* @return true if ch is a Unicode character, else false
|
|
* @see #isDigit(char)
|
|
* @see #isLetter(char)
|
|
* @see #isLetterOrDigit(char)
|
|
* @see #isLowerCase(char)
|
|
* @see #isTitleCase(char)
|
|
* @see #isUpperCase(char)
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isDefined(int codePoint)
|
|
{
|
|
return getType(codePoint) != UNASSIGNED;
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is a Unicode letter. Not all letters have case,
|
|
* so this may return true when isLowerCase and isUpperCase return false.
|
|
* A character is a Unicode letter if getType() returns one of
|
|
* UPPERCASE_LETTER, LOWERCASE_LETTER, TITLECASE_LETTER, MODIFIER_LETTER,
|
|
* or OTHER_LETTER.
|
|
* <br>
|
|
* letter = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch is a Unicode letter, else false
|
|
* @see #isDigit(char)
|
|
* @see #isJavaIdentifierStart(char)
|
|
* @see #isJavaLetter(char)
|
|
* @see #isJavaLetterOrDigit(char)
|
|
* @see #isLetterOrDigit(char)
|
|
* @see #isLowerCase(char)
|
|
* @see #isTitleCase(char)
|
|
* @see #isUnicodeIdentifierStart(char)
|
|
* @see #isUpperCase(char)
|
|
*/
|
|
public static boolean isLetter(char ch)
|
|
{
|
|
return isLetter((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is a Unicode letter. Not all letters have case,
|
|
* so this may return true when isLowerCase and isUpperCase return false.
|
|
* A character is a Unicode letter if getType() returns one of
|
|
* UPPERCASE_LETTER, LOWERCASE_LETTER, TITLECASE_LETTER, MODIFIER_LETTER,
|
|
* or OTHER_LETTER.
|
|
* <br>
|
|
* letter = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]
|
|
*
|
|
* @param codePoint character to test
|
|
* @return true if ch is a Unicode letter, else false
|
|
* @see #isDigit(char)
|
|
* @see #isJavaIdentifierStart(char)
|
|
* @see #isJavaLetter(char)
|
|
* @see #isJavaLetterOrDigit(char)
|
|
* @see #isLetterOrDigit(char)
|
|
* @see #isLowerCase(char)
|
|
* @see #isTitleCase(char)
|
|
* @see #isUnicodeIdentifierStart(char)
|
|
* @see #isUpperCase(char)
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isLetter(int codePoint)
|
|
{
|
|
return ((1 << getType(codePoint))
|
|
& ((1 << UPPERCASE_LETTER)
|
|
| (1 << LOWERCASE_LETTER)
|
|
| (1 << TITLECASE_LETTER)
|
|
| (1 << MODIFIER_LETTER)
|
|
| (1 << OTHER_LETTER))) != 0;
|
|
}
|
|
/**
|
|
* Returns the index into the given CharSequence that is offset
|
|
* <code>codePointOffset</code> code points from <code>index</code>.
|
|
* @param seq the CharSequence
|
|
* @param index the start position in the CharSequence
|
|
* @param codePointOffset the number of code points offset from the start
|
|
* position
|
|
* @return the index into the CharSequence that is codePointOffset code
|
|
* points offset from index
|
|
*
|
|
* @throws NullPointerException if seq is null
|
|
* @throws IndexOutOfBoundsException if index is negative or greater than the
|
|
* length of the sequence.
|
|
* @throws IndexOutOfBoundsException if codePointOffset is positive and the
|
|
* subsequence from index to the end of seq has fewer than codePointOffset
|
|
* code points
|
|
* @throws IndexOutOfBoundsException if codePointOffset is negative and the
|
|
* subsequence from the start of seq to index has fewer than
|
|
* (-codePointOffset) code points
|
|
* @since 1.5
|
|
*/
|
|
public static int offsetByCodePoints(CharSequence seq,
|
|
int index,
|
|
int codePointOffset)
|
|
{
|
|
int len = seq.length();
|
|
if (index < 0 || index > len)
|
|
throw new IndexOutOfBoundsException();
|
|
|
|
int numToGo = codePointOffset;
|
|
int offset = index;
|
|
int adjust = 1;
|
|
if (numToGo >= 0)
|
|
{
|
|
for (; numToGo > 0; offset++)
|
|
{
|
|
numToGo--;
|
|
if (Character.isHighSurrogate(seq.charAt(offset))
|
|
&& (offset + 1) < len
|
|
&& Character.isLowSurrogate(seq.charAt(offset + 1)))
|
|
offset++;
|
|
}
|
|
return offset;
|
|
}
|
|
else
|
|
{
|
|
numToGo *= -1;
|
|
for (; numToGo > 0;)
|
|
{
|
|
numToGo--;
|
|
offset--;
|
|
if (Character.isLowSurrogate(seq.charAt(offset))
|
|
&& (offset - 1) >= 0
|
|
&& Character.isHighSurrogate(seq.charAt(offset - 1)))
|
|
offset--;
|
|
}
|
|
return offset;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the index into the given char subarray that is offset
|
|
* <code>codePointOffset</code> code points from <code>index</code>.
|
|
* @param a the char array
|
|
* @param start the start index of the subarray
|
|
* @param count the length of the subarray
|
|
* @param index the index to be offset
|
|
* @param codePointOffset the number of code points offset from <code>index
|
|
* </code>
|
|
* @return the index into the char array
|
|
*
|
|
* @throws NullPointerException if a is null
|
|
* @throws IndexOutOfBoundsException if start or count is negative or if
|
|
* start + count is greater than the length of the array
|
|
* @throws IndexOutOfBoundsException if index is less than start or larger
|
|
* than start + count
|
|
* @throws IndexOutOfBoundsException if codePointOffset is positive and the
|
|
* subarray from index to start + count - 1 has fewer than codePointOffset
|
|
* code points.
|
|
* @throws IndexOutOfBoundsException if codePointOffset is negative and the
|
|
* subarray from start to index - 1 has fewer than (-codePointOffset) code
|
|
* points
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static int offsetByCodePoints(char[] a,
|
|
int start,
|
|
int count,
|
|
int index,
|
|
int codePointOffset)
|
|
{
|
|
int len = a.length;
|
|
int end = start + count;
|
|
if (start < 0 || count < 0 || end > len || index < start || index > end)
|
|
throw new IndexOutOfBoundsException();
|
|
|
|
int numToGo = codePointOffset;
|
|
int offset = index;
|
|
int adjust = 1;
|
|
if (numToGo >= 0)
|
|
{
|
|
for (; numToGo > 0; offset++)
|
|
{
|
|
numToGo--;
|
|
if (Character.isHighSurrogate(a[offset])
|
|
&& (offset + 1) < len
|
|
&& Character.isLowSurrogate(a[offset + 1]))
|
|
offset++;
|
|
}
|
|
return offset;
|
|
}
|
|
else
|
|
{
|
|
numToGo *= -1;
|
|
for (; numToGo > 0;)
|
|
{
|
|
numToGo--;
|
|
offset--;
|
|
if (Character.isLowSurrogate(a[offset])
|
|
&& (offset - 1) >= 0
|
|
&& Character.isHighSurrogate(a[offset - 1]))
|
|
offset--;
|
|
if (offset < start)
|
|
throw new IndexOutOfBoundsException();
|
|
}
|
|
return offset;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Returns the number of Unicode code points in the specified range of the
|
|
* given CharSequence. The first char in the range is at position
|
|
* beginIndex and the last one is at position endIndex - 1. Paired
|
|
* surrogates (supplementary characters are represented by a pair of chars -
|
|
* one from the high surrogates and one from the low surrogates)
|
|
* count as just one code point.
|
|
* @param seq the CharSequence to inspect
|
|
* @param beginIndex the beginning of the range
|
|
* @param endIndex the end of the range
|
|
* @return the number of Unicode code points in the given range of the
|
|
* sequence
|
|
* @throws NullPointerException if seq is null
|
|
* @throws IndexOutOfBoundsException if beginIndex is negative, endIndex is
|
|
* larger than the length of seq, or if beginIndex is greater than endIndex.
|
|
* @since 1.5
|
|
*/
|
|
public static int codePointCount(CharSequence seq, int beginIndex,
|
|
int endIndex)
|
|
{
|
|
int len = seq.length();
|
|
if (beginIndex < 0 || endIndex > len || beginIndex > endIndex)
|
|
throw new IndexOutOfBoundsException();
|
|
|
|
int count = 0;
|
|
for (int i = beginIndex; i < endIndex; i++)
|
|
{
|
|
count++;
|
|
// If there is a pairing, count it only once.
|
|
if (isHighSurrogate(seq.charAt(i)) && (i + 1) < endIndex
|
|
&& isLowSurrogate(seq.charAt(i + 1)))
|
|
i ++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of Unicode code points in the specified range of the
|
|
* given char array. The first char in the range is at position
|
|
* offset and the length of the range is count. Paired surrogates
|
|
* (supplementary characters are represented by a pair of chars -
|
|
* one from the high surrogates and one from the low surrogates)
|
|
* count as just one code point.
|
|
* @param a the char array to inspect
|
|
* @param offset the beginning of the range
|
|
* @param count the length of the range
|
|
* @return the number of Unicode code points in the given range of the
|
|
* array
|
|
* @throws NullPointerException if a is null
|
|
* @throws IndexOutOfBoundsException if offset or count is negative or if
|
|
* offset + countendIndex is larger than the length of a.
|
|
* @since 1.5
|
|
*/
|
|
public static int codePointCount(char[] a, int offset,
|
|
int count)
|
|
{
|
|
int len = a.length;
|
|
int end = offset + count;
|
|
if (offset < 0 || count < 0 || end > len)
|
|
throw new IndexOutOfBoundsException();
|
|
|
|
int counter = 0;
|
|
for (int i = offset; i < end; i++)
|
|
{
|
|
counter++;
|
|
// If there is a pairing, count it only once.
|
|
if (isHighSurrogate(a[i]) && (i + 1) < end
|
|
&& isLowSurrogate(a[i + 1]))
|
|
i ++;
|
|
}
|
|
return counter;
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is a Unicode letter or a Unicode digit. This
|
|
* is the combination of isLetter and isDigit.
|
|
* <br>
|
|
* letter or digit = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nd]
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch is a Unicode letter or a Unicode digit, else false
|
|
* @see #isDigit(char)
|
|
* @see #isJavaIdentifierPart(char)
|
|
* @see #isJavaLetter(char)
|
|
* @see #isJavaLetterOrDigit(char)
|
|
* @see #isLetter(char)
|
|
* @see #isUnicodeIdentifierPart(char)
|
|
*/
|
|
public static boolean isLetterOrDigit(char ch)
|
|
{
|
|
return isLetterOrDigit((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is a Unicode letter or a Unicode digit. This
|
|
* is the combination of isLetter and isDigit.
|
|
* <br>
|
|
* letter or digit = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nd]
|
|
*
|
|
* @param codePoint character to test
|
|
* @return true if ch is a Unicode letter or a Unicode digit, else false
|
|
* @see #isDigit(char)
|
|
* @see #isJavaIdentifierPart(char)
|
|
* @see #isJavaLetter(char)
|
|
* @see #isJavaLetterOrDigit(char)
|
|
* @see #isLetter(char)
|
|
* @see #isUnicodeIdentifierPart(char)
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isLetterOrDigit(int codePoint)
|
|
{
|
|
return ((1 << getType(codePoint))
|
|
& ((1 << UPPERCASE_LETTER)
|
|
| (1 << LOWERCASE_LETTER)
|
|
| (1 << TITLECASE_LETTER)
|
|
| (1 << MODIFIER_LETTER)
|
|
| (1 << OTHER_LETTER)
|
|
| (1 << DECIMAL_DIGIT_NUMBER))) != 0;
|
|
}
|
|
|
|
/**
|
|
* Determines if a character can start a Java identifier. This is the
|
|
* combination of isLetter, any character where getType returns
|
|
* LETTER_NUMBER, currency symbols (like '$'), and connecting punctuation
|
|
* (like '_').
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch can start a Java identifier, else false
|
|
* @deprecated Replaced by {@link #isJavaIdentifierStart(char)}
|
|
* @see #isJavaLetterOrDigit(char)
|
|
* @see #isJavaIdentifierStart(char)
|
|
* @see #isJavaIdentifierPart(char)
|
|
* @see #isLetter(char)
|
|
* @see #isLetterOrDigit(char)
|
|
* @see #isUnicodeIdentifierStart(char)
|
|
*/
|
|
public static boolean isJavaLetter(char ch)
|
|
{
|
|
return isJavaIdentifierStart(ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character can follow the first letter in
|
|
* a Java identifier. This is the combination of isJavaLetter (isLetter,
|
|
* type of LETTER_NUMBER, currency, connecting punctuation) and digit,
|
|
* numeric letter (like Roman numerals), combining marks, non-spacing marks,
|
|
* or isIdentifierIgnorable.
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch can follow the first letter in a Java identifier
|
|
* @deprecated Replaced by {@link #isJavaIdentifierPart(char)}
|
|
* @see #isJavaLetter(char)
|
|
* @see #isJavaIdentifierStart(char)
|
|
* @see #isJavaIdentifierPart(char)
|
|
* @see #isLetter(char)
|
|
* @see #isLetterOrDigit(char)
|
|
* @see #isUnicodeIdentifierPart(char)
|
|
* @see #isIdentifierIgnorable(char)
|
|
*/
|
|
public static boolean isJavaLetterOrDigit(char ch)
|
|
{
|
|
return isJavaIdentifierPart(ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character can start a Java identifier. This is the
|
|
* combination of isLetter, any character where getType returns
|
|
* LETTER_NUMBER, currency symbols (like '$'), and connecting punctuation
|
|
* (like '_').
|
|
* <br>
|
|
* Java identifier start = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Sc]|[Pc]
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch can start a Java identifier, else false
|
|
* @see #isJavaIdentifierPart(char)
|
|
* @see #isLetter(char)
|
|
* @see #isUnicodeIdentifierStart(char)
|
|
* @since 1.1
|
|
*/
|
|
public static boolean isJavaIdentifierStart(char ch)
|
|
{
|
|
return isJavaIdentifierStart((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character can start a Java identifier. This is the
|
|
* combination of isLetter, any character where getType returns
|
|
* LETTER_NUMBER, currency symbols (like '$'), and connecting punctuation
|
|
* (like '_').
|
|
* <br>
|
|
* Java identifier start = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Sc]|[Pc]
|
|
*
|
|
* @param codePoint character to test
|
|
* @return true if ch can start a Java identifier, else false
|
|
* @see #isJavaIdentifierPart(char)
|
|
* @see #isLetter(char)
|
|
* @see #isUnicodeIdentifierStart(char)
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isJavaIdentifierStart(int codePoint)
|
|
{
|
|
return ((1 << getType(codePoint))
|
|
& ((1 << UPPERCASE_LETTER)
|
|
| (1 << LOWERCASE_LETTER)
|
|
| (1 << TITLECASE_LETTER)
|
|
| (1 << MODIFIER_LETTER)
|
|
| (1 << OTHER_LETTER)
|
|
| (1 << LETTER_NUMBER)
|
|
| (1 << CURRENCY_SYMBOL)
|
|
| (1 << CONNECTOR_PUNCTUATION))) != 0;
|
|
}
|
|
|
|
/**
|
|
* Determines if a character can follow the first letter in
|
|
* a Java identifier. This is the combination of isJavaLetter (isLetter,
|
|
* type of LETTER_NUMBER, currency, connecting punctuation) and digit,
|
|
* numeric letter (like Roman numerals), combining marks, non-spacing marks,
|
|
* or isIdentifierIgnorable.
|
|
* <br>
|
|
* Java identifier extender =
|
|
* [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Sc]|[Pc]|[Mn]|[Mc]|[Nd]|[Cf]
|
|
* |U+0000-U+0008|U+000E-U+001B|U+007F-U+009F
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch can follow the first letter in a Java identifier
|
|
* @see #isIdentifierIgnorable(char)
|
|
* @see #isJavaIdentifierStart(char)
|
|
* @see #isLetterOrDigit(char)
|
|
* @see #isUnicodeIdentifierPart(char)
|
|
* @since 1.1
|
|
*/
|
|
public static boolean isJavaIdentifierPart(char ch)
|
|
{
|
|
return isJavaIdentifierPart((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character can follow the first letter in
|
|
* a Java identifier. This is the combination of isJavaLetter (isLetter,
|
|
* type of LETTER_NUMBER, currency, connecting punctuation) and digit,
|
|
* numeric letter (like Roman numerals), combining marks, non-spacing marks,
|
|
* or isIdentifierIgnorable.
|
|
* <br>
|
|
* Java identifier extender =
|
|
* [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Sc]|[Pc]|[Mn]|[Mc]|[Nd]|[Cf]
|
|
* |U+0000-U+0008|U+000E-U+001B|U+007F-U+009F
|
|
*
|
|
* @param codePoint character to test
|
|
* @return true if ch can follow the first letter in a Java identifier
|
|
* @see #isIdentifierIgnorable(char)
|
|
* @see #isJavaIdentifierStart(char)
|
|
* @see #isLetterOrDigit(char)
|
|
* @see #isUnicodeIdentifierPart(char)
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isJavaIdentifierPart(int codePoint)
|
|
{
|
|
int category = getType(codePoint);
|
|
return ((1 << category)
|
|
& ((1 << UPPERCASE_LETTER)
|
|
| (1 << LOWERCASE_LETTER)
|
|
| (1 << TITLECASE_LETTER)
|
|
| (1 << MODIFIER_LETTER)
|
|
| (1 << OTHER_LETTER)
|
|
| (1 << NON_SPACING_MARK)
|
|
| (1 << COMBINING_SPACING_MARK)
|
|
| (1 << DECIMAL_DIGIT_NUMBER)
|
|
| (1 << LETTER_NUMBER)
|
|
| (1 << CURRENCY_SYMBOL)
|
|
| (1 << CONNECTOR_PUNCTUATION)
|
|
| (1 << FORMAT))) != 0
|
|
|| (category == CONTROL && isIdentifierIgnorable(codePoint));
|
|
}
|
|
|
|
/**
|
|
* Determines if a character can start a Unicode identifier. Only
|
|
* letters can start a Unicode identifier, but this includes characters
|
|
* in LETTER_NUMBER.
|
|
* <br>
|
|
* Unicode identifier start = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch can start a Unicode identifier, else false
|
|
* @see #isJavaIdentifierStart(char)
|
|
* @see #isLetter(char)
|
|
* @see #isUnicodeIdentifierPart(char)
|
|
* @since 1.1
|
|
*/
|
|
public static boolean isUnicodeIdentifierStart(char ch)
|
|
{
|
|
return isUnicodeIdentifierStart((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character can start a Unicode identifier. Only
|
|
* letters can start a Unicode identifier, but this includes characters
|
|
* in LETTER_NUMBER.
|
|
* <br>
|
|
* Unicode identifier start = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]
|
|
*
|
|
* @param codePoint character to test
|
|
* @return true if ch can start a Unicode identifier, else false
|
|
* @see #isJavaIdentifierStart(char)
|
|
* @see #isLetter(char)
|
|
* @see #isUnicodeIdentifierPart(char)
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isUnicodeIdentifierStart(int codePoint)
|
|
{
|
|
return ((1 << getType(codePoint))
|
|
& ((1 << UPPERCASE_LETTER)
|
|
| (1 << LOWERCASE_LETTER)
|
|
| (1 << TITLECASE_LETTER)
|
|
| (1 << MODIFIER_LETTER)
|
|
| (1 << OTHER_LETTER)
|
|
| (1 << LETTER_NUMBER))) != 0;
|
|
}
|
|
|
|
/**
|
|
* Determines if a character can follow the first letter in
|
|
* a Unicode identifier. This includes letters, connecting punctuation,
|
|
* digits, numeric letters, combining marks, non-spacing marks, and
|
|
* isIdentifierIgnorable.
|
|
* <br>
|
|
* Unicode identifier extender =
|
|
* [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Mn]|[Mc]|[Nd]|[Pc]|[Cf]|
|
|
* |U+0000-U+0008|U+000E-U+001B|U+007F-U+009F
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch can follow the first letter in a Unicode identifier
|
|
* @see #isIdentifierIgnorable(char)
|
|
* @see #isJavaIdentifierPart(char)
|
|
* @see #isLetterOrDigit(char)
|
|
* @see #isUnicodeIdentifierStart(char)
|
|
* @since 1.1
|
|
*/
|
|
public static boolean isUnicodeIdentifierPart(char ch)
|
|
{
|
|
return isUnicodeIdentifierPart((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character can follow the first letter in
|
|
* a Unicode identifier. This includes letters, connecting punctuation,
|
|
* digits, numeric letters, combining marks, non-spacing marks, and
|
|
* isIdentifierIgnorable.
|
|
* <br>
|
|
* Unicode identifier extender =
|
|
* [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Mn]|[Mc]|[Nd]|[Pc]|[Cf]|
|
|
* |U+0000-U+0008|U+000E-U+001B|U+007F-U+009F
|
|
*
|
|
* @param codePoint character to test
|
|
* @return true if ch can follow the first letter in a Unicode identifier
|
|
* @see #isIdentifierIgnorable(char)
|
|
* @see #isJavaIdentifierPart(char)
|
|
* @see #isLetterOrDigit(char)
|
|
* @see #isUnicodeIdentifierStart(char)
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isUnicodeIdentifierPart(int codePoint)
|
|
{
|
|
int category = getType(codePoint);
|
|
return ((1 << category)
|
|
& ((1 << UPPERCASE_LETTER)
|
|
| (1 << LOWERCASE_LETTER)
|
|
| (1 << TITLECASE_LETTER)
|
|
| (1 << MODIFIER_LETTER)
|
|
| (1 << OTHER_LETTER)
|
|
| (1 << NON_SPACING_MARK)
|
|
| (1 << COMBINING_SPACING_MARK)
|
|
| (1 << DECIMAL_DIGIT_NUMBER)
|
|
| (1 << LETTER_NUMBER)
|
|
| (1 << CONNECTOR_PUNCTUATION)
|
|
| (1 << FORMAT))) != 0
|
|
|| (category == CONTROL && isIdentifierIgnorable(codePoint));
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is ignorable in a Unicode identifier. This
|
|
* includes the non-whitespace ISO control characters (<code>'\u0000'</code>
|
|
* through <code>'\u0008'</code>, <code>'\u000E'</code> through
|
|
* <code>'\u001B'</code>, and <code>'\u007F'</code> through
|
|
* <code>'\u009F'</code>), and FORMAT characters.
|
|
* <br>
|
|
* Unicode identifier ignorable = [Cf]|U+0000-U+0008|U+000E-U+001B
|
|
* |U+007F-U+009F
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch is ignorable in a Unicode or Java identifier
|
|
* @see #isJavaIdentifierPart(char)
|
|
* @see #isUnicodeIdentifierPart(char)
|
|
* @since 1.1
|
|
*/
|
|
public static boolean isIdentifierIgnorable(char ch)
|
|
{
|
|
return isIdentifierIgnorable((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is ignorable in a Unicode identifier. This
|
|
* includes the non-whitespace ISO control characters (<code>'\u0000'</code>
|
|
* through <code>'\u0008'</code>, <code>'\u000E'</code> through
|
|
* <code>'\u001B'</code>, and <code>'\u007F'</code> through
|
|
* <code>'\u009F'</code>), and FORMAT characters.
|
|
* <br>
|
|
* Unicode identifier ignorable = [Cf]|U+0000-U+0008|U+000E-U+001B
|
|
* |U+007F-U+009F
|
|
*
|
|
* @param codePoint character to test
|
|
* @return true if ch is ignorable in a Unicode or Java identifier
|
|
* @see #isJavaIdentifierPart(char)
|
|
* @see #isUnicodeIdentifierPart(char)
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isIdentifierIgnorable(int codePoint)
|
|
{
|
|
if ((codePoint >= 0 && codePoint <= 0x0008)
|
|
|| (codePoint >= 0x000E && codePoint <= 0x001B)
|
|
|| (codePoint >= 0x007F && codePoint <= 0x009F)
|
|
|| getType(codePoint) == FORMAT)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Converts a Unicode character into its lowercase equivalent mapping.
|
|
* If a mapping does not exist, then the character passed is returned.
|
|
* Note that isLowerCase(toLowerCase(ch)) does not always return true.
|
|
*
|
|
* @param ch character to convert to lowercase
|
|
* @return lowercase mapping of ch, or ch if lowercase mapping does
|
|
* not exist
|
|
* @see #isLowerCase(char)
|
|
* @see #isUpperCase(char)
|
|
* @see #toTitleCase(char)
|
|
* @see #toUpperCase(char)
|
|
*/
|
|
public static char toLowerCase(char ch)
|
|
{
|
|
return (char) (lower[0][readCodePoint((int)ch) >>> 7] + ch);
|
|
}
|
|
|
|
/**
|
|
* Converts a Unicode character into its lowercase equivalent mapping.
|
|
* If a mapping does not exist, then the character passed is returned.
|
|
* Note that isLowerCase(toLowerCase(ch)) does not always return true.
|
|
*
|
|
* @param codePoint character to convert to lowercase
|
|
* @return lowercase mapping of ch, or ch if lowercase mapping does
|
|
* not exist
|
|
* @see #isLowerCase(char)
|
|
* @see #isUpperCase(char)
|
|
* @see #toTitleCase(char)
|
|
* @see #toUpperCase(char)
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static int toLowerCase(int codePoint)
|
|
{
|
|
// If the code point is unassigned or in one of the private use areas
|
|
// then we delegate the call to the appropriate private static inner class.
|
|
int plane = codePoint >>> 16;
|
|
if (plane > 2 && plane < 14)
|
|
return UnassignedCharacters.toLowerCase(codePoint);
|
|
if (plane > 14)
|
|
return PrivateUseCharacters.toLowerCase(codePoint);
|
|
|
|
// The short value stored in lower[plane] is the signed difference between
|
|
// codePoint and its lowercase conversion.
|
|
return ((short)lower[plane][readCodePoint(codePoint) >>> 7]) + codePoint;
|
|
}
|
|
|
|
/**
|
|
* Converts a Unicode character into its uppercase equivalent mapping.
|
|
* If a mapping does not exist, then the character passed is returned.
|
|
* Note that isUpperCase(toUpperCase(ch)) does not always return true.
|
|
*
|
|
* @param ch character to convert to uppercase
|
|
* @return uppercase mapping of ch, or ch if uppercase mapping does
|
|
* not exist
|
|
* @see #isLowerCase(char)
|
|
* @see #isUpperCase(char)
|
|
* @see #toLowerCase(char)
|
|
* @see #toTitleCase(char)
|
|
*/
|
|
public static char toUpperCase(char ch)
|
|
{
|
|
return (char) (upper[0][readCodePoint((int)ch) >>> 7] + ch);
|
|
}
|
|
|
|
/**
|
|
* Converts a Unicode character into its uppercase equivalent mapping.
|
|
* If a mapping does not exist, then the character passed is returned.
|
|
* Note that isUpperCase(toUpperCase(ch)) does not always return true.
|
|
*
|
|
* @param codePoint character to convert to uppercase
|
|
* @return uppercase mapping of ch, or ch if uppercase mapping does
|
|
* not exist
|
|
* @see #isLowerCase(char)
|
|
* @see #isUpperCase(char)
|
|
* @see #toLowerCase(char)
|
|
* @see #toTitleCase(char)
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static int toUpperCase(int codePoint)
|
|
{
|
|
// If the code point is unassigned or in one of the private use areas
|
|
// then we delegate the call to the appropriate private static inner class.
|
|
int plane = codePoint >>> 16;
|
|
if (plane > 2 && plane < 14)
|
|
return UnassignedCharacters.toUpperCase(codePoint);
|
|
if (plane > 14)
|
|
return PrivateUseCharacters.toUpperCase(codePoint);
|
|
|
|
// The short value stored in upper[plane] is the signed difference between
|
|
// codePoint and its uppercase conversion.
|
|
return ((short)upper[plane][readCodePoint(codePoint) >>> 7]) + codePoint;
|
|
}
|
|
|
|
/**
|
|
* Converts a Unicode character into its titlecase equivalent mapping.
|
|
* If a mapping does not exist, then the character passed is returned.
|
|
* Note that isTitleCase(toTitleCase(ch)) does not always return true.
|
|
*
|
|
* @param ch character to convert to titlecase
|
|
* @return titlecase mapping of ch, or ch if titlecase mapping does
|
|
* not exist
|
|
* @see #isTitleCase(char)
|
|
* @see #toLowerCase(char)
|
|
* @see #toUpperCase(char)
|
|
*/
|
|
public static char toTitleCase(char ch)
|
|
{
|
|
// As title is short, it doesn't hurt to exhaustively iterate over it.
|
|
for (int i = title.length - 2; i >= 0; i -= 2)
|
|
if (title[i] == ch)
|
|
return title[i + 1];
|
|
return toUpperCase(ch);
|
|
}
|
|
|
|
/**
|
|
* Converts a Unicode character into its titlecase equivalent mapping.
|
|
* If a mapping does not exist, then the character passed is returned.
|
|
* Note that isTitleCase(toTitleCase(ch)) does not always return true.
|
|
*
|
|
* @param codePoint character to convert to titlecase
|
|
* @return titlecase mapping of ch, or ch if titlecase mapping does
|
|
* not exist
|
|
* @see #isTitleCase(char)
|
|
* @see #toLowerCase(char)
|
|
* @see #toUpperCase(char)
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static int toTitleCase(int codePoint)
|
|
{
|
|
// As of Unicode 4.0.0 no characters outside of plane 0 have
|
|
// titlecase mappings that are different from their uppercase
|
|
// mapping.
|
|
if (codePoint < 0x10000)
|
|
return (int) toTitleCase((char)codePoint);
|
|
return toUpperCase(codePoint);
|
|
}
|
|
|
|
/**
|
|
* Converts a character into a digit of the specified radix. If the radix
|
|
* exceeds MIN_RADIX or MAX_RADIX, or if the result of getNumericValue(ch)
|
|
* exceeds the radix, or if ch is not a decimal digit or in the case
|
|
* insensitive set of 'a'-'z', the result is -1.
|
|
* <br>
|
|
* character argument boundary = [Nd]|U+0041-U+005A|U+0061-U+007A
|
|
* |U+FF21-U+FF3A|U+FF41-U+FF5A
|
|
*
|
|
* @param ch character to convert into a digit
|
|
* @param radix radix in which ch is a digit
|
|
* @return digit which ch represents in radix, or -1 not a valid digit
|
|
* @see #MIN_RADIX
|
|
* @see #MAX_RADIX
|
|
* @see #forDigit(int, int)
|
|
* @see #isDigit(char)
|
|
* @see #getNumericValue(char)
|
|
*/
|
|
public static int digit(char ch, int radix)
|
|
{
|
|
if (radix < MIN_RADIX || radix > MAX_RADIX)
|
|
return -1;
|
|
char attr = readCodePoint((int)ch);
|
|
if (((1 << (attr & TYPE_MASK))
|
|
& ((1 << UPPERCASE_LETTER)
|
|
| (1 << LOWERCASE_LETTER)
|
|
| (1 << DECIMAL_DIGIT_NUMBER))) != 0)
|
|
{
|
|
// Signedness doesn't matter; 0xffff vs. -1 are both rejected.
|
|
int digit = numValue[0][attr >> 7];
|
|
return (digit < radix) ? digit : -1;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Converts a character into a digit of the specified radix. If the radix
|
|
* exceeds MIN_RADIX or MAX_RADIX, or if the result of getNumericValue(ch)
|
|
* exceeds the radix, or if ch is not a decimal digit or in the case
|
|
* insensitive set of 'a'-'z', the result is -1.
|
|
* <br>
|
|
* character argument boundary = [Nd]|U+0041-U+005A|U+0061-U+007A
|
|
* |U+FF21-U+FF3A|U+FF41-U+FF5A
|
|
*
|
|
* @param codePoint character to convert into a digit
|
|
* @param radix radix in which ch is a digit
|
|
* @return digit which ch represents in radix, or -1 not a valid digit
|
|
* @see #MIN_RADIX
|
|
* @see #MAX_RADIX
|
|
* @see #forDigit(int, int)
|
|
* @see #isDigit(char)
|
|
* @see #getNumericValue(char)
|
|
*/
|
|
public static int digit(int codePoint, int radix)
|
|
{
|
|
if (radix < MIN_RADIX || radix > MAX_RADIX)
|
|
return -1;
|
|
|
|
// If the code point is unassigned or in one of the private use areas
|
|
// then we delegate the call to the appropriate private static inner class.
|
|
int plane = codePoint >>> 16;
|
|
if (plane > 2 && plane < 14)
|
|
return UnassignedCharacters.digit(codePoint, radix);
|
|
if (plane > 14)
|
|
return PrivateUseCharacters.digit(codePoint, radix);
|
|
char attr = readCodePoint(codePoint);
|
|
if (((1 << (attr & TYPE_MASK))
|
|
& ((1 << UPPERCASE_LETTER)
|
|
| (1 << LOWERCASE_LETTER)
|
|
| (1 << DECIMAL_DIGIT_NUMBER))) != 0)
|
|
{
|
|
// Signedness doesn't matter; 0xffff vs. -1 are both rejected.
|
|
int digit = numValue[plane][attr >> 7];
|
|
|
|
// If digit is less than or equal to -3 then the numerical value was
|
|
// too large to fit into numValue and is stored in CharData.LARGENUMS.
|
|
if (digit <= -3)
|
|
digit = CharData.LARGENUMS[-digit - 3];
|
|
return (digit < radix) ? digit : -1;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Returns the Unicode numeric value property of a character. For example,
|
|
* <code>'\\u216C'</code> (the Roman numeral fifty) returns 50.
|
|
*
|
|
* <p>This method also returns values for the letters A through Z, (not
|
|
* specified by Unicode), in these ranges: <code>'\u0041'</code>
|
|
* through <code>'\u005A'</code> (uppercase); <code>'\u0061'</code>
|
|
* through <code>'\u007A'</code> (lowercase); and <code>'\uFF21'</code>
|
|
* through <code>'\uFF3A'</code>, <code>'\uFF41'</code> through
|
|
* <code>'\uFF5A'</code> (full width variants).
|
|
*
|
|
* <p>If the character lacks a numeric value property, -1 is returned.
|
|
* If the character has a numeric value property which is not representable
|
|
* as a nonnegative integer, such as a fraction, -2 is returned.
|
|
*
|
|
* character argument boundary = [Nd]|[Nl]|[No]|U+0041-U+005A|U+0061-U+007A
|
|
* |U+FF21-U+FF3A|U+FF41-U+FF5A
|
|
*
|
|
* @param ch character from which the numeric value property will
|
|
* be retrieved
|
|
* @return the numeric value property of ch, or -1 if it does not exist, or
|
|
* -2 if it is not representable as a nonnegative integer
|
|
* @see #forDigit(int, int)
|
|
* @see #digit(char, int)
|
|
* @see #isDigit(char)
|
|
* @since 1.1
|
|
*/
|
|
public static int getNumericValue(char ch)
|
|
{
|
|
// Treat numValue as signed.
|
|
return (short) numValue[0][readCodePoint((int)ch) >> 7];
|
|
}
|
|
|
|
/**
|
|
* Returns the Unicode numeric value property of a character. For example,
|
|
* <code>'\\u216C'</code> (the Roman numeral fifty) returns 50.
|
|
*
|
|
* <p>This method also returns values for the letters A through Z, (not
|
|
* specified by Unicode), in these ranges: <code>'\u0041'</code>
|
|
* through <code>'\u005A'</code> (uppercase); <code>'\u0061'</code>
|
|
* through <code>'\u007A'</code> (lowercase); and <code>'\uFF21'</code>
|
|
* through <code>'\uFF3A'</code>, <code>'\uFF41'</code> through
|
|
* <code>'\uFF5A'</code> (full width variants).
|
|
*
|
|
* <p>If the character lacks a numeric value property, -1 is returned.
|
|
* If the character has a numeric value property which is not representable
|
|
* as a nonnegative integer, such as a fraction, -2 is returned.
|
|
*
|
|
* character argument boundary = [Nd]|[Nl]|[No]|U+0041-U+005A|U+0061-U+007A
|
|
* |U+FF21-U+FF3A|U+FF41-U+FF5A
|
|
*
|
|
* @param codePoint character from which the numeric value property will
|
|
* be retrieved
|
|
* @return the numeric value property of ch, or -1 if it does not exist, or
|
|
* -2 if it is not representable as a nonnegative integer
|
|
* @see #forDigit(int, int)
|
|
* @see #digit(char, int)
|
|
* @see #isDigit(char)
|
|
* @since 1.5
|
|
*/
|
|
public static int getNumericValue(int codePoint)
|
|
{
|
|
// If the code point is unassigned or in one of the private use areas
|
|
// then we delegate the call to the appropriate private static inner class.
|
|
int plane = codePoint >>> 16;
|
|
if (plane > 2 && plane < 14)
|
|
return UnassignedCharacters.getNumericValue(codePoint);
|
|
if (plane > 14)
|
|
return PrivateUseCharacters.getNumericValue(codePoint);
|
|
|
|
// If the value N found in numValue[plane] is less than or equal to -3
|
|
// then the numeric value was too big to fit into 16 bits and is
|
|
// stored in CharData.LARGENUMS at offset (-N - 3).
|
|
short num = (short)numValue[plane][readCodePoint(codePoint) >> 7];
|
|
if (num <= -3)
|
|
return CharData.LARGENUMS[-num - 3];
|
|
return num;
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is a ISO-LATIN-1 space. This is only the five
|
|
* characters <code>'\t'</code>, <code>'\n'</code>, <code>'\f'</code>,
|
|
* <code>'\r'</code>, and <code>' '</code>.
|
|
* <br>
|
|
* Java space = U+0020|U+0009|U+000A|U+000C|U+000D
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch is a space, else false
|
|
* @deprecated Replaced by {@link #isWhitespace(char)}
|
|
* @see #isSpaceChar(char)
|
|
* @see #isWhitespace(char)
|
|
*/
|
|
public static boolean isSpace(char ch)
|
|
{
|
|
// Performing the subtraction up front alleviates need to compare longs.
|
|
return ch-- <= ' ' && ((1 << ch)
|
|
& ((1 << (' ' - 1))
|
|
| (1 << ('\t' - 1))
|
|
| (1 << ('\n' - 1))
|
|
| (1 << ('\r' - 1))
|
|
| (1 << ('\f' - 1)))) != 0;
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is a Unicode space character. This includes
|
|
* SPACE_SEPARATOR, LINE_SEPARATOR, and PARAGRAPH_SEPARATOR.
|
|
* <br>
|
|
* Unicode space = [Zs]|[Zp]|[Zl]
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch is a Unicode space, else false
|
|
* @see #isWhitespace(char)
|
|
* @since 1.1
|
|
*/
|
|
public static boolean isSpaceChar(char ch)
|
|
{
|
|
return isSpaceChar((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is a Unicode space character. This includes
|
|
* SPACE_SEPARATOR, LINE_SEPARATOR, and PARAGRAPH_SEPARATOR.
|
|
* <br>
|
|
* Unicode space = [Zs]|[Zp]|[Zl]
|
|
*
|
|
* @param codePoint character to test
|
|
* @return true if ch is a Unicode space, else false
|
|
* @see #isWhitespace(char)
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isSpaceChar(int codePoint)
|
|
{
|
|
return ((1 << getType(codePoint))
|
|
& ((1 << SPACE_SEPARATOR)
|
|
| (1 << LINE_SEPARATOR)
|
|
| (1 << PARAGRAPH_SEPARATOR))) != 0;
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is Java whitespace. This includes Unicode
|
|
* space characters (SPACE_SEPARATOR, LINE_SEPARATOR, and
|
|
* PARAGRAPH_SEPARATOR) except the non-breaking spaces
|
|
* (<code>'\u00A0'</code>, <code>'\u2007'</code>, and <code>'\u202F'</code>);
|
|
* and these characters: <code>'\u0009'</code>, <code>'\u000A'</code>,
|
|
* <code>'\u000B'</code>, <code>'\u000C'</code>, <code>'\u000D'</code>,
|
|
* <code>'\u001C'</code>, <code>'\u001D'</code>, <code>'\u001E'</code>,
|
|
* and <code>'\u001F'</code>.
|
|
* <br>
|
|
* Java whitespace = ([Zs] not Nb)|[Zl]|[Zp]|U+0009-U+000D|U+001C-U+001F
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch is Java whitespace, else false
|
|
* @see #isSpaceChar(char)
|
|
* @since 1.1
|
|
*/
|
|
public static boolean isWhitespace(char ch)
|
|
{
|
|
return isWhitespace((int) ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character is Java whitespace. This includes Unicode
|
|
* space characters (SPACE_SEPARATOR, LINE_SEPARATOR, and
|
|
* PARAGRAPH_SEPARATOR) except the non-breaking spaces
|
|
* (<code>'\u00A0'</code>, <code>'\u2007'</code>, and <code>'\u202F'</code>);
|
|
* and these characters: <code>'\u0009'</code>, <code>'\u000A'</code>,
|
|
* <code>'\u000B'</code>, <code>'\u000C'</code>, <code>'\u000D'</code>,
|
|
* <code>'\u001C'</code>, <code>'\u001D'</code>, <code>'\u001E'</code>,
|
|
* and <code>'\u001F'</code>.
|
|
* <br>
|
|
* Java whitespace = ([Zs] not Nb)|[Zl]|[Zp]|U+0009-U+000D|U+001C-U+001F
|
|
*
|
|
* @param codePoint character to test
|
|
* @return true if ch is Java whitespace, else false
|
|
* @see #isSpaceChar(char)
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isWhitespace(int codePoint)
|
|
{
|
|
int plane = codePoint >>> 16;
|
|
if (plane > 2 && plane < 14)
|
|
return UnassignedCharacters.isWhiteSpace(codePoint);
|
|
if (plane > 14)
|
|
return PrivateUseCharacters.isWhiteSpace(codePoint);
|
|
|
|
int attr = readCodePoint(codePoint);
|
|
return ((((1 << (attr & TYPE_MASK))
|
|
& ((1 << SPACE_SEPARATOR)
|
|
| (1 << LINE_SEPARATOR)
|
|
| (1 << PARAGRAPH_SEPARATOR))) != 0)
|
|
&& (attr & NO_BREAK_MASK) == 0)
|
|
|| (codePoint <= '\u001F' && ((1 << codePoint)
|
|
& ((1 << '\t')
|
|
| (1 << '\n')
|
|
| (1 << '\u000B')
|
|
| (1 << '\u000C')
|
|
| (1 << '\r')
|
|
| (1 << '\u001C')
|
|
| (1 << '\u001D')
|
|
| (1 << '\u001E')
|
|
| (1 << '\u001F'))) != 0);
|
|
}
|
|
|
|
/**
|
|
* Determines if a character has the ISO Control property.
|
|
* <br>
|
|
* ISO Control = [Cc]
|
|
*
|
|
* @param ch character to test
|
|
* @return true if ch is an ISO Control character, else false
|
|
* @see #isSpaceChar(char)
|
|
* @see #isWhitespace(char)
|
|
* @since 1.1
|
|
*/
|
|
public static boolean isISOControl(char ch)
|
|
{
|
|
return isISOControl((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Determines if the character is an ISO Control character. This is true
|
|
* if the code point is in the range [0, 0x001F] or if it is in the range
|
|
* [0x007F, 0x009F].
|
|
* @param codePoint the character to check
|
|
* @return true if the character is in one of the above ranges
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isISOControl(int codePoint)
|
|
{
|
|
if ((codePoint >= 0 && codePoint <= 0x001F)
|
|
|| (codePoint >= 0x007F && codePoint <= 0x009F))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns the Unicode general category property of a character.
|
|
*
|
|
* @param ch character from which the general category property will
|
|
* be retrieved
|
|
* @return the character category property of ch as an integer
|
|
* @see #UNASSIGNED
|
|
* @see #UPPERCASE_LETTER
|
|
* @see #LOWERCASE_LETTER
|
|
* @see #TITLECASE_LETTER
|
|
* @see #MODIFIER_LETTER
|
|
* @see #OTHER_LETTER
|
|
* @see #NON_SPACING_MARK
|
|
* @see #ENCLOSING_MARK
|
|
* @see #COMBINING_SPACING_MARK
|
|
* @see #DECIMAL_DIGIT_NUMBER
|
|
* @see #LETTER_NUMBER
|
|
* @see #OTHER_NUMBER
|
|
* @see #SPACE_SEPARATOR
|
|
* @see #LINE_SEPARATOR
|
|
* @see #PARAGRAPH_SEPARATOR
|
|
* @see #CONTROL
|
|
* @see #FORMAT
|
|
* @see #PRIVATE_USE
|
|
* @see #SURROGATE
|
|
* @see #DASH_PUNCTUATION
|
|
* @see #START_PUNCTUATION
|
|
* @see #END_PUNCTUATION
|
|
* @see #CONNECTOR_PUNCTUATION
|
|
* @see #OTHER_PUNCTUATION
|
|
* @see #MATH_SYMBOL
|
|
* @see #CURRENCY_SYMBOL
|
|
* @see #MODIFIER_SYMBOL
|
|
* @see #INITIAL_QUOTE_PUNCTUATION
|
|
* @see #FINAL_QUOTE_PUNCTUATION
|
|
* @since 1.1
|
|
*/
|
|
public static int getType(char ch)
|
|
{
|
|
return getType((int)ch);
|
|
}
|
|
|
|
/**
|
|
* Returns the Unicode general category property of a character.
|
|
*
|
|
* @param codePoint character from which the general category property will
|
|
* be retrieved
|
|
* @return the character category property of ch as an integer
|
|
* @see #UNASSIGNED
|
|
* @see #UPPERCASE_LETTER
|
|
* @see #LOWERCASE_LETTER
|
|
* @see #TITLECASE_LETTER
|
|
* @see #MODIFIER_LETTER
|
|
* @see #OTHER_LETTER
|
|
* @see #NON_SPACING_MARK
|
|
* @see #ENCLOSING_MARK
|
|
* @see #COMBINING_SPACING_MARK
|
|
* @see #DECIMAL_DIGIT_NUMBER
|
|
* @see #LETTER_NUMBER
|
|
* @see #OTHER_NUMBER
|
|
* @see #SPACE_SEPARATOR
|
|
* @see #LINE_SEPARATOR
|
|
* @see #PARAGRAPH_SEPARATOR
|
|
* @see #CONTROL
|
|
* @see #FORMAT
|
|
* @see #PRIVATE_USE
|
|
* @see #SURROGATE
|
|
* @see #DASH_PUNCTUATION
|
|
* @see #START_PUNCTUATION
|
|
* @see #END_PUNCTUATION
|
|
* @see #CONNECTOR_PUNCTUATION
|
|
* @see #OTHER_PUNCTUATION
|
|
* @see #MATH_SYMBOL
|
|
* @see #CURRENCY_SYMBOL
|
|
* @see #MODIFIER_SYMBOL
|
|
* @see #INITIAL_QUOTE_PUNCTUATION
|
|
* @see #FINAL_QUOTE_PUNCTUATION
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static int getType(int codePoint)
|
|
{
|
|
// If the codePoint is unassigned or in one of the private use areas
|
|
// then we delegate the call to the appropriate private static inner class.
|
|
int plane = codePoint >>> 16;
|
|
if (plane > 2 && plane < 14)
|
|
return UnassignedCharacters.getType(codePoint);
|
|
if (plane > 14)
|
|
return PrivateUseCharacters.getType(codePoint);
|
|
|
|
return readCodePoint(codePoint) & TYPE_MASK;
|
|
}
|
|
|
|
/**
|
|
* Converts a digit into a character which represents that digit
|
|
* in a specified radix. If the radix exceeds MIN_RADIX or MAX_RADIX,
|
|
* or the digit exceeds the radix, then the null character <code>'\0'</code>
|
|
* is returned. Otherwise the return value is in '0'-'9' and 'a'-'z'.
|
|
* <br>
|
|
* return value boundary = U+0030-U+0039|U+0061-U+007A
|
|
*
|
|
* @param digit digit to be converted into a character
|
|
* @param radix radix of digit
|
|
* @return character representing digit in radix, or '\0'
|
|
* @see #MIN_RADIX
|
|
* @see #MAX_RADIX
|
|
* @see #digit(char, int)
|
|
*/
|
|
public static char forDigit(int digit, int radix)
|
|
{
|
|
if (radix < MIN_RADIX || radix > MAX_RADIX
|
|
|| digit < 0 || digit >= radix)
|
|
return '\0';
|
|
return Number.digits[digit];
|
|
}
|
|
|
|
/**
|
|
* Returns the Unicode directionality property of the character. This
|
|
* is used in the visual ordering of text.
|
|
*
|
|
* @param ch the character to look up
|
|
* @return the directionality constant, or DIRECTIONALITY_UNDEFINED
|
|
* @see #DIRECTIONALITY_UNDEFINED
|
|
* @see #DIRECTIONALITY_LEFT_TO_RIGHT
|
|
* @see #DIRECTIONALITY_RIGHT_TO_LEFT
|
|
* @see #DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
|
|
* @see #DIRECTIONALITY_EUROPEAN_NUMBER
|
|
* @see #DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
|
|
* @see #DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
|
|
* @see #DIRECTIONALITY_ARABIC_NUMBER
|
|
* @see #DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
|
|
* @see #DIRECTIONALITY_NONSPACING_MARK
|
|
* @see #DIRECTIONALITY_BOUNDARY_NEUTRAL
|
|
* @see #DIRECTIONALITY_PARAGRAPH_SEPARATOR
|
|
* @see #DIRECTIONALITY_SEGMENT_SEPARATOR
|
|
* @see #DIRECTIONALITY_WHITESPACE
|
|
* @see #DIRECTIONALITY_OTHER_NEUTRALS
|
|
* @see #DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
|
|
* @see #DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
|
|
* @see #DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
|
|
* @see #DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
|
|
* @see #DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
|
|
* @since 1.4
|
|
*/
|
|
public static byte getDirectionality(char ch)
|
|
{
|
|
// The result will correctly be signed.
|
|
return getDirectionality((int)ch);
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the Unicode directionality property of the character. This
|
|
* is used in the visual ordering of text.
|
|
*
|
|
* @param codePoint the character to look up
|
|
* @return the directionality constant, or DIRECTIONALITY_UNDEFINED
|
|
* @see #DIRECTIONALITY_UNDEFINED
|
|
* @see #DIRECTIONALITY_LEFT_TO_RIGHT
|
|
* @see #DIRECTIONALITY_RIGHT_TO_LEFT
|
|
* @see #DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
|
|
* @see #DIRECTIONALITY_EUROPEAN_NUMBER
|
|
* @see #DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
|
|
* @see #DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
|
|
* @see #DIRECTIONALITY_ARABIC_NUMBER
|
|
* @see #DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
|
|
* @see #DIRECTIONALITY_NONSPACING_MARK
|
|
* @see #DIRECTIONALITY_BOUNDARY_NEUTRAL
|
|
* @see #DIRECTIONALITY_PARAGRAPH_SEPARATOR
|
|
* @see #DIRECTIONALITY_SEGMENT_SEPARATOR
|
|
* @see #DIRECTIONALITY_WHITESPACE
|
|
* @see #DIRECTIONALITY_OTHER_NEUTRALS
|
|
* @see #DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
|
|
* @see #DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
|
|
* @see #DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
|
|
* @see #DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
|
|
* @see #DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
|
|
* @since 1.5
|
|
*/
|
|
public static byte getDirectionality(int codePoint)
|
|
{
|
|
// If the code point is unassigned or in one of the private use areas
|
|
// then we delegate the call to the appropriate private static inner class.
|
|
int plane = codePoint >>> 16;
|
|
if (plane > 2 && plane < 14)
|
|
return UnassignedCharacters.getDirectionality(codePoint);
|
|
if (plane > 14)
|
|
return PrivateUseCharacters.getDirectionality(codePoint);
|
|
|
|
// The result will correctly be signed.
|
|
return (byte) (direction[plane][readCodePoint(codePoint) >> 7] >> 2);
|
|
}
|
|
|
|
/**
|
|
* Determines whether the character is mirrored according to Unicode. For
|
|
* example, <code>\u0028</code> (LEFT PARENTHESIS) appears as '(' in
|
|
* left-to-right text, but ')' in right-to-left text.
|
|
*
|
|
* @param ch the character to look up
|
|
* @return true if the character is mirrored
|
|
* @since 1.4
|
|
*/
|
|
public static boolean isMirrored(char ch)
|
|
{
|
|
return (readCodePoint((int)ch) & MIRROR_MASK) != 0;
|
|
}
|
|
|
|
/**
|
|
* Determines whether the character is mirrored according to Unicode. For
|
|
* example, <code>\u0028</code> (LEFT PARENTHESIS) appears as '(' in
|
|
* left-to-right text, but ')' in right-to-left text.
|
|
*
|
|
* @param codePoint the character to look up
|
|
* @return true if the character is mirrored
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isMirrored(int codePoint)
|
|
{
|
|
// If the code point is unassigned or part of one of the private use areas
|
|
// then we delegate the call to the appropriate private static inner class.
|
|
int plane = codePoint >>> 16;
|
|
if (plane > 2 && plane < 14)
|
|
return UnassignedCharacters.isMirrored(codePoint);
|
|
if (plane > 14)
|
|
return PrivateUseCharacters.isMirrored(codePoint);
|
|
|
|
return (readCodePoint(codePoint) & MIRROR_MASK) != 0;
|
|
}
|
|
|
|
/**
|
|
* Compares another Character to this Character, numerically.
|
|
*
|
|
* @param anotherCharacter Character to compare with this Character
|
|
* @return a negative integer if this Character is less than
|
|
* anotherCharacter, zero if this Character is equal, and
|
|
* a positive integer if this Character is greater
|
|
* @throws NullPointerException if anotherCharacter is null
|
|
* @since 1.2
|
|
*/
|
|
public int compareTo(Character anotherCharacter)
|
|
{
|
|
return value - anotherCharacter.value;
|
|
}
|
|
|
|
/**
|
|
* Returns an <code>Character</code> object wrapping the value.
|
|
* In contrast to the <code>Character</code> constructor, this method
|
|
* will cache some values. It is used by boxing conversion.
|
|
*
|
|
* @param val the value to wrap
|
|
* @return the <code>Character</code>
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static Character valueOf(char val)
|
|
{
|
|
if (val > MAX_CACHE)
|
|
return new Character(val);
|
|
synchronized (charCache)
|
|
{
|
|
if (charCache[val - MIN_VALUE] == null)
|
|
charCache[val - MIN_VALUE] = new Character(val);
|
|
return charCache[val - MIN_VALUE];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reverse the bytes in val.
|
|
* @since 1.5
|
|
*/
|
|
public static char reverseBytes(char val)
|
|
{
|
|
return (char) (((val >> 8) & 0xff) | ((val << 8) & 0xff00));
|
|
}
|
|
|
|
/**
|
|
* Converts a unicode code point to a UTF-16 representation of that
|
|
* code point.
|
|
*
|
|
* @param codePoint the unicode code point
|
|
*
|
|
* @return the UTF-16 representation of that code point
|
|
*
|
|
* @throws IllegalArgumentException if the code point is not a valid
|
|
* unicode code point
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static char[] toChars(int codePoint)
|
|
{
|
|
if (!isValidCodePoint(codePoint))
|
|
throw new IllegalArgumentException("Illegal Unicode code point : "
|
|
+ codePoint);
|
|
char[] result = new char[charCount(codePoint)];
|
|
int ignore = toChars(codePoint, result, 0);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Converts a unicode code point to its UTF-16 representation.
|
|
*
|
|
* @param codePoint the unicode code point
|
|
* @param dst the target char array
|
|
* @param dstIndex the start index for the target
|
|
*
|
|
* @return number of characters written to <code>dst</code>
|
|
*
|
|
* @throws IllegalArgumentException if <code>codePoint</code> is not a
|
|
* valid unicode code point
|
|
* @throws NullPointerException if <code>dst</code> is <code>null</code>
|
|
* @throws IndexOutOfBoundsException if <code>dstIndex</code> is not valid
|
|
* in <code>dst</code> or if the UTF-16 representation does not
|
|
* fit into <code>dst</code>
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static int toChars(int codePoint, char[] dst, int dstIndex)
|
|
{
|
|
if (!isValidCodePoint(codePoint))
|
|
{
|
|
throw new IllegalArgumentException("not a valid code point: "
|
|
+ codePoint);
|
|
}
|
|
|
|
int result;
|
|
if (isSupplementaryCodePoint(codePoint))
|
|
{
|
|
// Write second char first to cause IndexOutOfBoundsException
|
|
// immediately.
|
|
final int cp2 = codePoint - 0x10000;
|
|
dst[dstIndex + 1] = (char) ((cp2 % 0x400) + (int) MIN_LOW_SURROGATE);
|
|
dst[dstIndex] = (char) ((cp2 / 0x400) + (int) MIN_HIGH_SURROGATE);
|
|
result = 2;
|
|
}
|
|
else
|
|
{
|
|
dst[dstIndex] = (char) codePoint;
|
|
result = 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Return number of 16-bit characters required to represent the given
|
|
* code point.
|
|
*
|
|
* @param codePoint a unicode code point
|
|
*
|
|
* @return 2 if codePoint >= 0x10000, 1 otherwise.
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static int charCount(int codePoint)
|
|
{
|
|
return
|
|
(codePoint >= MIN_SUPPLEMENTARY_CODE_POINT)
|
|
? 2
|
|
: 1;
|
|
}
|
|
|
|
/**
|
|
* Determines whether the specified code point is
|
|
* in the range 0x10000 .. 0x10FFFF, i.e. the character is within the Unicode
|
|
* supplementary character range.
|
|
*
|
|
* @param codePoint a Unicode code point
|
|
*
|
|
* @return <code>true</code> if code point is in supplementary range
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isSupplementaryCodePoint(int codePoint)
|
|
{
|
|
return codePoint >= MIN_SUPPLEMENTARY_CODE_POINT
|
|
&& codePoint <= MAX_CODE_POINT;
|
|
}
|
|
|
|
/**
|
|
* Determines whether the specified code point is
|
|
* in the range 0x0000 .. 0x10FFFF, i.e. it is a valid Unicode code point.
|
|
*
|
|
* @param codePoint a Unicode code point
|
|
*
|
|
* @return <code>true</code> if code point is valid
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isValidCodePoint(int codePoint)
|
|
{
|
|
return codePoint >= MIN_CODE_POINT && codePoint <= MAX_CODE_POINT;
|
|
}
|
|
|
|
/**
|
|
* Return true if the given character is a high surrogate.
|
|
* @param ch the character
|
|
* @return true if the character is a high surrogate character
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isHighSurrogate(char ch)
|
|
{
|
|
return ch >= MIN_HIGH_SURROGATE && ch <= MAX_HIGH_SURROGATE;
|
|
}
|
|
|
|
/**
|
|
* Return true if the given character is a low surrogate.
|
|
* @param ch the character
|
|
* @return true if the character is a low surrogate character
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isLowSurrogate(char ch)
|
|
{
|
|
return ch >= MIN_LOW_SURROGATE && ch <= MAX_LOW_SURROGATE;
|
|
}
|
|
|
|
/**
|
|
* Return true if the given characters compose a surrogate pair.
|
|
* This is true if the first character is a high surrogate and the
|
|
* second character is a low surrogate.
|
|
* @param ch1 the first character
|
|
* @param ch2 the first character
|
|
* @return true if the characters compose a surrogate pair
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static boolean isSurrogatePair(char ch1, char ch2)
|
|
{
|
|
return isHighSurrogate(ch1) && isLowSurrogate(ch2);
|
|
}
|
|
|
|
/**
|
|
* Given a valid surrogate pair, this returns the corresponding
|
|
* code point.
|
|
* @param high the high character of the pair
|
|
* @param low the low character of the pair
|
|
* @return the corresponding code point
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public static int toCodePoint(char high, char low)
|
|
{
|
|
return ((high - MIN_HIGH_SURROGATE) * 0x400) +
|
|
(low - MIN_LOW_SURROGATE) + 0x10000;
|
|
}
|
|
|
|
/**
|
|
* Get the code point at the specified index in the CharSequence.
|
|
* This is like CharSequence#charAt(int), but if the character is
|
|
* the start of a surrogate pair, and there is a following
|
|
* character, and this character completes the pair, then the
|
|
* corresponding supplementary code point is returned. Otherwise,
|
|
* the character at the index is returned.
|
|
*
|
|
* @param sequence the CharSequence
|
|
* @param index the index of the codepoint to get, starting at 0
|
|
* @return the codepoint at the specified index
|
|
* @throws IndexOutOfBoundsException if index is negative or >= length()
|
|
* @since 1.5
|
|
*/
|
|
public static int codePointAt(CharSequence sequence, int index)
|
|
{
|
|
int len = sequence.length();
|
|
if (index < 0 || index >= len)
|
|
throw new IndexOutOfBoundsException();
|
|
char high = sequence.charAt(index);
|
|
if (! isHighSurrogate(high) || ++index >= len)
|
|
return high;
|
|
char low = sequence.charAt(index);
|
|
if (! isLowSurrogate(low))
|
|
return high;
|
|
return toCodePoint(high, low);
|
|
}
|
|
|
|
/**
|
|
* Get the code point at the specified index in the CharSequence.
|
|
* If the character is the start of a surrogate pair, and there is a
|
|
* following character, and this character completes the pair, then
|
|
* the corresponding supplementary code point is returned.
|
|
* Otherwise, the character at the index is returned.
|
|
*
|
|
* @param chars the character array in which to look
|
|
* @param index the index of the codepoint to get, starting at 0
|
|
* @return the codepoint at the specified index
|
|
* @throws IndexOutOfBoundsException if index is negative or >= length()
|
|
* @since 1.5
|
|
*/
|
|
public static int codePointAt(char[] chars, int index)
|
|
{
|
|
return codePointAt(chars, index, chars.length);
|
|
}
|
|
|
|
/**
|
|
* Get the code point at the specified index in the CharSequence.
|
|
* If the character is the start of a surrogate pair, and there is a
|
|
* following character within the specified range, and this
|
|
* character completes the pair, then the corresponding
|
|
* supplementary code point is returned. Otherwise, the character
|
|
* at the index is returned.
|
|
*
|
|
* @param chars the character array in which to look
|
|
* @param index the index of the codepoint to get, starting at 0
|
|
* @param limit the limit past which characters should not be examined
|
|
* @return the codepoint at the specified index
|
|
* @throws IndexOutOfBoundsException if index is negative or >=
|
|
* limit, or if limit is negative or >= the length of the array
|
|
* @since 1.5
|
|
*/
|
|
public static int codePointAt(char[] chars, int index, int limit)
|
|
{
|
|
if (index < 0 || index >= limit || limit < 0 || limit > chars.length)
|
|
throw new IndexOutOfBoundsException();
|
|
char high = chars[index];
|
|
if (! isHighSurrogate(high) || ++index >= limit)
|
|
return high;
|
|
char low = chars[index];
|
|
if (! isLowSurrogate(low))
|
|
return high;
|
|
return toCodePoint(high, low);
|
|
}
|
|
|
|
/**
|
|
* Get the code point before the specified index. This is like
|
|
* #codePointAt(char[], int), but checks the characters at
|
|
* <code>index-1</code> and <code>index-2</code> to see if they form
|
|
* a supplementary code point. If they do not, the character at
|
|
* <code>index-1</code> is returned.
|
|
*
|
|
* @param chars the character array
|
|
* @param index the index just past the codepoint to get, starting at 0
|
|
* @return the codepoint at the specified index
|
|
* @throws IndexOutOfBoundsException if index is negative or >= length()
|
|
* @since 1.5
|
|
*/
|
|
public static int codePointBefore(char[] chars, int index)
|
|
{
|
|
return codePointBefore(chars, index, 1);
|
|
}
|
|
|
|
/**
|
|
* Get the code point before the specified index. This is like
|
|
* #codePointAt(char[], int), but checks the characters at
|
|
* <code>index-1</code> and <code>index-2</code> to see if they form
|
|
* a supplementary code point. If they do not, the character at
|
|
* <code>index-1</code> is returned. The start parameter is used to
|
|
* limit the range of the array which may be examined.
|
|
*
|
|
* @param chars the character array
|
|
* @param index the index just past the codepoint to get, starting at 0
|
|
* @param start the index before which characters should not be examined
|
|
* @return the codepoint at the specified index
|
|
* @throws IndexOutOfBoundsException if index is > start or >
|
|
* the length of the array, or if limit is negative or >= the
|
|
* length of the array
|
|
* @since 1.5
|
|
*/
|
|
public static int codePointBefore(char[] chars, int index, int start)
|
|
{
|
|
if (index < start || index > chars.length
|
|
|| start < 0 || start >= chars.length)
|
|
throw new IndexOutOfBoundsException();
|
|
--index;
|
|
char low = chars[index];
|
|
if (! isLowSurrogate(low) || --index < start)
|
|
return low;
|
|
char high = chars[index];
|
|
if (! isHighSurrogate(high))
|
|
return low;
|
|
return toCodePoint(high, low);
|
|
}
|
|
|
|
/**
|
|
* Get the code point before the specified index. This is like
|
|
* #codePointAt(CharSequence, int), but checks the characters at
|
|
* <code>index-1</code> and <code>index-2</code> to see if they form
|
|
* a supplementary code point. If they do not, the character at
|
|
* <code>index-1</code> is returned.
|
|
*
|
|
* @param sequence the CharSequence
|
|
* @param index the index just past the codepoint to get, starting at 0
|
|
* @return the codepoint at the specified index
|
|
* @throws IndexOutOfBoundsException if index is negative or >= length()
|
|
* @since 1.5
|
|
*/
|
|
public static int codePointBefore(CharSequence sequence, int index)
|
|
{
|
|
int len = sequence.length();
|
|
if (index < 1 || index > len)
|
|
throw new IndexOutOfBoundsException();
|
|
--index;
|
|
char low = sequence.charAt(index);
|
|
if (! isLowSurrogate(low) || --index < 0)
|
|
return low;
|
|
char high = sequence.charAt(index);
|
|
if (! isHighSurrogate(high))
|
|
return low;
|
|
return toCodePoint(high, low);
|
|
}
|
|
} // class Character
|