001 /* java.lang.Character -- Wrapper class for char, and Unicode subsets
002 Copyright (C) 1998, 1999, 2001, 2002, 2005, 2006, 2007
003 Free Software Foundation, Inc.
004
005 This file is part of GNU Classpath.
006
007 GNU Classpath is free software; you can redistribute it and/or modify
008 it under the terms of the GNU General Public License as published by
009 the Free Software Foundation; either version 2, or (at your option)
010 any later version.
011
012 GNU Classpath is distributed in the hope that it will be useful, but
013 WITHOUT ANY WARRANTY; without even the implied warranty of
014 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
015 General Public License for more details.
016
017 You should have received a copy of the GNU General Public License
018 along with GNU Classpath; see the file COPYING. If not, write to the
019 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
020 02110-1301 USA.
021
022 Linking this library statically or dynamically with other modules is
023 making a combined work based on this library. Thus, the terms and
024 conditions of the GNU General Public License cover the whole
025 combination.
026
027 As a special exception, the copyright holders of this library give you
028 permission to link this library with independent modules to produce an
029 executable, regardless of the license terms of these independent
030 modules, and to copy and distribute the resulting executable under
031 terms of your choice, provided that you also meet, for each linked
032 independent module, the terms and conditions of the license of that
033 module. An independent module is a module which is not derived from
034 or based on this library. If you modify this library, you may extend
035 this exception to your version of the library, but you are not
036 obligated to do so. If you do not wish to do so, delete this
037 exception statement from your version. */
038
039 /*
040 * Note: This class must not be merged with Classpath. Gcj uses C-style
041 * arrays (see include/java-chartables.h) to store the Unicode character
042 * database, whereas Classpath uses Java objects (char[] extracted from
043 * String constants) in gnu.java.lang.CharData. Gcj's approach is more
044 * efficient, because there is no vtable or data relocation to worry about.
045 * However, despite the difference in the database interface, the two
046 * versions share identical algorithms.
047 */
048
049 package java.lang;
050
051 import java.io.Serializable;
052 import java.text.Collator;
053 import java.util.Locale;
054
055 /**
056 * Wrapper class for the primitive char data type. In addition, this class
057 * allows one to retrieve property information and perform transformations
058 * on the defined characters in the Unicode Standard, Version 4.0.0.
059 * java.lang.Character is designed to be very dynamic, and as such, it
060 * retrieves information on the Unicode character set from a separate
061 * database, gnu.java.lang.CharData, which can be easily upgraded.
062 *
063 * <p>For predicates, boundaries are used to describe
064 * the set of characters for which the method will return true.
065 * This syntax uses fairly normal regular expression notation.
066 * See 5.13 of the Unicode Standard, Version 4.0, for the
067 * boundary specification.
068 *
069 * <p>See <a href="http://www.unicode.org">http://www.unicode.org</a>
070 * for more information on the Unicode Standard.
071 *
072 * @author Tom Tromey (tromey@cygnus.com)
073 * @author Paul N. Fisher
074 * @author Jochen Hoenicke
075 * @author Eric Blake (ebb9@email.byu.edu)
076 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
077 * @since 1.0
078 * @status partly updated to 1.5; some things still missing
079 */
080 public final class Character implements Serializable, Comparable<Character>
081 {
082 /**
083 * A subset of Unicode blocks.
084 *
085 * @author Paul N. Fisher
086 * @author Eric Blake (ebb9@email.byu.edu)
087 * @since 1.2
088 */
089 public static class Subset
090 {
091 /** The name of the subset. */
092 private final String name;
093
094 /**
095 * Construct a new subset of characters.
096 *
097 * @param name the name of the subset
098 * @throws NullPointerException if name is null
099 */
100 protected Subset(String name)
101 {
102 // Note that name.toString() is name, unless name was null.
103 this.name = name.toString();
104 }
105
106 /**
107 * Compares two Subsets for equality. This is <code>final</code>, and
108 * restricts the comparison on the <code>==</code> operator, so it returns
109 * true only for the same object.
110 *
111 * @param o the object to compare
112 * @return true if o is this
113 */
114 public final boolean equals(Object o)
115 {
116 return o == this;
117 }
118
119 /**
120 * Makes the original hashCode of Object final, to be consistent with
121 * equals.
122 *
123 * @return the hash code for this object
124 */
125 public final int hashCode()
126 {
127 return super.hashCode();
128 }
129
130 /**
131 * Returns the name of the subset.
132 *
133 * @return the name
134 */
135 public final String toString()
136 {
137 return name;
138 }
139 } // class Subset
140
141 /**
142 * A family of character subsets in the Unicode specification. A character
143 * is in at most one of these blocks.
144 *
145 * This inner class was generated automatically from
146 * <code>libjava/gnu/gcj/convert/Blocks-3.txt</code>, by some perl scripts.
147 * This Unicode definition file can be found on the
148 * <a href="http://www.unicode.org">http://www.unicode.org</a> website.
149 * JDK 1.4 uses Unicode version 3.0.0.
150 *
151 * @author scripts/unicode-blocks.pl (written by Eric Blake)
152 * @since 1.2
153 */
154 public static final class UnicodeBlock extends Subset
155 {
156 /** The start of the subset. */
157 private final int start;
158
159 /** The end of the subset. */
160 private final int end;
161
162 /** The canonical name of the block according to the Unicode standard. */
163 private final String canonicalName;
164
165 /** Enumeration for the <code>forName()</code> method */
166 private enum NameType { CANONICAL, NO_SPACES, CONSTANT; }
167
168 /**
169 * Constructor for strictly defined blocks.
170 *
171 * @param start the start character of the range
172 * @param end the end character of the range
173 * @param name the block name
174 */
175 private UnicodeBlock(int start, int end, String name,
176 String canonicalName)
177 {
178 super(name);
179 this.start = start;
180 this.end = end;
181 this.canonicalName = canonicalName;
182 }
183
184 /**
185 * Returns the Unicode character block which a character belongs to.
186 * <strong>Note</strong>: This method does not support the use of
187 * supplementary characters. For such support, <code>of(int)</code>
188 * should be used instead.
189 *
190 * @param ch the character to look up
191 * @return the set it belongs to, or null if it is not in one
192 */
193 public static UnicodeBlock of(char ch)
194 {
195 return of((int) ch);
196 }
197
198 /**
199 * Returns the Unicode character block which a code point belongs to.
200 *
201 * @param codePoint the character to look up
202 * @return the set it belongs to, or null if it is not in one.
203 * @throws IllegalArgumentException if the specified code point is
204 * invalid.
205 * @since 1.5
206 */
207 public static UnicodeBlock of(int codePoint)
208 {
209 if (codePoint > MAX_CODE_POINT)
210 throw new IllegalArgumentException("The supplied integer value is " +
211 "too large to be a codepoint.");
212 // Simple binary search for the correct block.
213 int low = 0;
214 int hi = sets.length - 1;
215 while (low <= hi)
216 {
217 int mid = (low + hi) >> 1;
218 UnicodeBlock b = sets[mid];
219 if (codePoint < b.start)
220 hi = mid - 1;
221 else if (codePoint > b.end)
222 low = mid + 1;
223 else
224 return b;
225 }
226 return null;
227 }
228
229 /**
230 * <p>
231 * Returns the <code>UnicodeBlock</code> with the given name, as defined
232 * by the Unicode standard. The version of Unicode in use is defined by
233 * the <code>Character</code> class, and the names are given in the
234 * <code>Blocks-<version>.txt</code> file corresponding to that version.
235 * The name may be specified in one of three ways:
236 * </p>
237 * <ol>
238 * <li>The canonical, human-readable name used by the Unicode standard.
239 * This is the name with all spaces and hyphens retained. For example,
240 * `Basic Latin' retrieves the block, UnicodeBlock.BASIC_LATIN.</li>
241 * <li>The canonical name with all spaces removed e.g. `BasicLatin'.</li>
242 * <li>The name used for the constants specified by this class, which
243 * is the canonical name with all spaces and hyphens replaced with
244 * underscores e.g. `BASIC_LATIN'</li>
245 * </ol>
246 * <p>
247 * The names are compared case-insensitively using the case comparison
248 * associated with the U.S. English locale. The method recognises the
249 * previous names used for blocks as well as the current ones. At
250 * present, this simply means that the deprecated `SURROGATES_AREA'
251 * will be recognised by this method (the <code>of()</code> methods
252 * only return one of the three new surrogate blocks).
253 * </p>
254 *
255 * @param blockName the name of the block to look up.
256 * @return the specified block.
257 * @throws NullPointerException if the <code>blockName</code> is
258 * <code>null</code>.
259 * @throws IllegalArgumentException if the name does not match any Unicode
260 * block.
261 * @since 1.5
262 */
263 public static final UnicodeBlock forName(String blockName)
264 {
265 NameType type;
266 if (blockName.indexOf(' ') != -1)
267 type = NameType.CANONICAL;
268 else if (blockName.indexOf('_') != -1)
269 type = NameType.CONSTANT;
270 else
271 type = NameType.NO_SPACES;
272 Collator usCollator = Collator.getInstance(Locale.US);
273 usCollator.setStrength(Collator.PRIMARY);
274 /* Special case for deprecated blocks not in sets */
275 switch (type)
276 {
277 case CANONICAL:
278 if (usCollator.compare(blockName, "Surrogates Area") == 0)
279 return SURROGATES_AREA;
280 break;
281 case NO_SPACES:
282 if (usCollator.compare(blockName, "SurrogatesArea") == 0)
283 return SURROGATES_AREA;
284 break;
285 case CONSTANT:
286 if (usCollator.compare(blockName, "SURROGATES_AREA") == 0)
287 return SURROGATES_AREA;
288 break;
289 }
290 /* Other cases */
291 switch (type)
292 {
293 case CANONICAL:
294 for (UnicodeBlock block : sets)
295 if (usCollator.compare(blockName, block.canonicalName) == 0)
296 return block;
297 break;
298 case NO_SPACES:
299 for (UnicodeBlock block : sets)
300 {
301 String nsName = block.canonicalName.replaceAll(" ","");
302 if (usCollator.compare(blockName, nsName) == 0)
303 return block;
304 }
305 break;
306 case CONSTANT:
307 for (UnicodeBlock block : sets)
308 if (usCollator.compare(blockName, block.toString()) == 0)
309 return block;
310 break;
311 }
312 throw new IllegalArgumentException("No Unicode block found for " +
313 blockName + ".");
314 }
315
316 /**
317 * Basic Latin.
318 * 0x0000 - 0x007F.
319 */
320 public static final UnicodeBlock BASIC_LATIN
321 = new UnicodeBlock(0x0000, 0x007F,
322 "BASIC_LATIN",
323 "Basic Latin");
324
325 /**
326 * Latin-1 Supplement.
327 * 0x0080 - 0x00FF.
328 */
329 public static final UnicodeBlock LATIN_1_SUPPLEMENT
330 = new UnicodeBlock(0x0080, 0x00FF,
331 "LATIN_1_SUPPLEMENT",
332 "Latin-1 Supplement");
333
334 /**
335 * Latin Extended-A.
336 * 0x0100 - 0x017F.
337 */
338 public static final UnicodeBlock LATIN_EXTENDED_A
339 = new UnicodeBlock(0x0100, 0x017F,
340 "LATIN_EXTENDED_A",
341 "Latin Extended-A");
342
343 /**
344 * Latin Extended-B.
345 * 0x0180 - 0x024F.
346 */
347 public static final UnicodeBlock LATIN_EXTENDED_B
348 = new UnicodeBlock(0x0180, 0x024F,
349 "LATIN_EXTENDED_B",
350 "Latin Extended-B");
351
352 /**
353 * IPA Extensions.
354 * 0x0250 - 0x02AF.
355 */
356 public static final UnicodeBlock IPA_EXTENSIONS
357 = new UnicodeBlock(0x0250, 0x02AF,
358 "IPA_EXTENSIONS",
359 "IPA Extensions");
360
361 /**
362 * Spacing Modifier Letters.
363 * 0x02B0 - 0x02FF.
364 */
365 public static final UnicodeBlock SPACING_MODIFIER_LETTERS
366 = new UnicodeBlock(0x02B0, 0x02FF,
367 "SPACING_MODIFIER_LETTERS",
368 "Spacing Modifier Letters");
369
370 /**
371 * Combining Diacritical Marks.
372 * 0x0300 - 0x036F.
373 */
374 public static final UnicodeBlock COMBINING_DIACRITICAL_MARKS
375 = new UnicodeBlock(0x0300, 0x036F,
376 "COMBINING_DIACRITICAL_MARKS",
377 "Combining Diacritical Marks");
378
379 /**
380 * Greek.
381 * 0x0370 - 0x03FF.
382 */
383 public static final UnicodeBlock GREEK
384 = new UnicodeBlock(0x0370, 0x03FF,
385 "GREEK",
386 "Greek");
387
388 /**
389 * Cyrillic.
390 * 0x0400 - 0x04FF.
391 */
392 public static final UnicodeBlock CYRILLIC
393 = new UnicodeBlock(0x0400, 0x04FF,
394 "CYRILLIC",
395 "Cyrillic");
396
397 /**
398 * Cyrillic Supplementary.
399 * 0x0500 - 0x052F.
400 * @since 1.5
401 */
402 public static final UnicodeBlock CYRILLIC_SUPPLEMENTARY
403 = new UnicodeBlock(0x0500, 0x052F,
404 "CYRILLIC_SUPPLEMENTARY",
405 "Cyrillic Supplementary");
406
407 /**
408 * Armenian.
409 * 0x0530 - 0x058F.
410 */
411 public static final UnicodeBlock ARMENIAN
412 = new UnicodeBlock(0x0530, 0x058F,
413 "ARMENIAN",
414 "Armenian");
415
416 /**
417 * Hebrew.
418 * 0x0590 - 0x05FF.
419 */
420 public static final UnicodeBlock HEBREW
421 = new UnicodeBlock(0x0590, 0x05FF,
422 "HEBREW",
423 "Hebrew");
424
425 /**
426 * Arabic.
427 * 0x0600 - 0x06FF.
428 */
429 public static final UnicodeBlock ARABIC
430 = new UnicodeBlock(0x0600, 0x06FF,
431 "ARABIC",
432 "Arabic");
433
434 /**
435 * Syriac.
436 * 0x0700 - 0x074F.
437 * @since 1.4
438 */
439 public static final UnicodeBlock SYRIAC
440 = new UnicodeBlock(0x0700, 0x074F,
441 "SYRIAC",
442 "Syriac");
443
444 /**
445 * Thaana.
446 * 0x0780 - 0x07BF.
447 * @since 1.4
448 */
449 public static final UnicodeBlock THAANA
450 = new UnicodeBlock(0x0780, 0x07BF,
451 "THAANA",
452 "Thaana");
453
454 /**
455 * Devanagari.
456 * 0x0900 - 0x097F.
457 */
458 public static final UnicodeBlock DEVANAGARI
459 = new UnicodeBlock(0x0900, 0x097F,
460 "DEVANAGARI",
461 "Devanagari");
462
463 /**
464 * Bengali.
465 * 0x0980 - 0x09FF.
466 */
467 public static final UnicodeBlock BENGALI
468 = new UnicodeBlock(0x0980, 0x09FF,
469 "BENGALI",
470 "Bengali");
471
472 /**
473 * Gurmukhi.
474 * 0x0A00 - 0x0A7F.
475 */
476 public static final UnicodeBlock GURMUKHI
477 = new UnicodeBlock(0x0A00, 0x0A7F,
478 "GURMUKHI",
479 "Gurmukhi");
480
481 /**
482 * Gujarati.
483 * 0x0A80 - 0x0AFF.
484 */
485 public static final UnicodeBlock GUJARATI
486 = new UnicodeBlock(0x0A80, 0x0AFF,
487 "GUJARATI",
488 "Gujarati");
489
490 /**
491 * Oriya.
492 * 0x0B00 - 0x0B7F.
493 */
494 public static final UnicodeBlock ORIYA
495 = new UnicodeBlock(0x0B00, 0x0B7F,
496 "ORIYA",
497 "Oriya");
498
499 /**
500 * Tamil.
501 * 0x0B80 - 0x0BFF.
502 */
503 public static final UnicodeBlock TAMIL
504 = new UnicodeBlock(0x0B80, 0x0BFF,
505 "TAMIL",
506 "Tamil");
507
508 /**
509 * Telugu.
510 * 0x0C00 - 0x0C7F.
511 */
512 public static final UnicodeBlock TELUGU
513 = new UnicodeBlock(0x0C00, 0x0C7F,
514 "TELUGU",
515 "Telugu");
516
517 /**
518 * Kannada.
519 * 0x0C80 - 0x0CFF.
520 */
521 public static final UnicodeBlock KANNADA
522 = new UnicodeBlock(0x0C80, 0x0CFF,
523 "KANNADA",
524 "Kannada");
525
526 /**
527 * Malayalam.
528 * 0x0D00 - 0x0D7F.
529 */
530 public static final UnicodeBlock MALAYALAM
531 = new UnicodeBlock(0x0D00, 0x0D7F,
532 "MALAYALAM",
533 "Malayalam");
534
535 /**
536 * Sinhala.
537 * 0x0D80 - 0x0DFF.
538 * @since 1.4
539 */
540 public static final UnicodeBlock SINHALA
541 = new UnicodeBlock(0x0D80, 0x0DFF,
542 "SINHALA",
543 "Sinhala");
544
545 /**
546 * Thai.
547 * 0x0E00 - 0x0E7F.
548 */
549 public static final UnicodeBlock THAI
550 = new UnicodeBlock(0x0E00, 0x0E7F,
551 "THAI",
552 "Thai");
553
554 /**
555 * Lao.
556 * 0x0E80 - 0x0EFF.
557 */
558 public static final UnicodeBlock LAO
559 = new UnicodeBlock(0x0E80, 0x0EFF,
560 "LAO",
561 "Lao");
562
563 /**
564 * Tibetan.
565 * 0x0F00 - 0x0FFF.
566 */
567 public static final UnicodeBlock TIBETAN
568 = new UnicodeBlock(0x0F00, 0x0FFF,
569 "TIBETAN",
570 "Tibetan");
571
572 /**
573 * Myanmar.
574 * 0x1000 - 0x109F.
575 * @since 1.4
576 */
577 public static final UnicodeBlock MYANMAR
578 = new UnicodeBlock(0x1000, 0x109F,
579 "MYANMAR",
580 "Myanmar");
581
582 /**
583 * Georgian.
584 * 0x10A0 - 0x10FF.
585 */
586 public static final UnicodeBlock GEORGIAN
587 = new UnicodeBlock(0x10A0, 0x10FF,
588 "GEORGIAN",
589 "Georgian");
590
591 /**
592 * Hangul Jamo.
593 * 0x1100 - 0x11FF.
594 */
595 public static final UnicodeBlock HANGUL_JAMO
596 = new UnicodeBlock(0x1100, 0x11FF,
597 "HANGUL_JAMO",
598 "Hangul Jamo");
599
600 /**
601 * Ethiopic.
602 * 0x1200 - 0x137F.
603 * @since 1.4
604 */
605 public static final UnicodeBlock ETHIOPIC
606 = new UnicodeBlock(0x1200, 0x137F,
607 "ETHIOPIC",
608 "Ethiopic");
609
610 /**
611 * Cherokee.
612 * 0x13A0 - 0x13FF.
613 * @since 1.4
614 */
615 public static final UnicodeBlock CHEROKEE
616 = new UnicodeBlock(0x13A0, 0x13FF,
617 "CHEROKEE",
618 "Cherokee");
619
620 /**
621 * Unified Canadian Aboriginal Syllabics.
622 * 0x1400 - 0x167F.
623 * @since 1.4
624 */
625 public static final UnicodeBlock UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS
626 = new UnicodeBlock(0x1400, 0x167F,
627 "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS",
628 "Unified Canadian Aboriginal Syllabics");
629
630 /**
631 * Ogham.
632 * 0x1680 - 0x169F.
633 * @since 1.4
634 */
635 public static final UnicodeBlock OGHAM
636 = new UnicodeBlock(0x1680, 0x169F,
637 "OGHAM",
638 "Ogham");
639
640 /**
641 * Runic.
642 * 0x16A0 - 0x16FF.
643 * @since 1.4
644 */
645 public static final UnicodeBlock RUNIC
646 = new UnicodeBlock(0x16A0, 0x16FF,
647 "RUNIC",
648 "Runic");
649
650 /**
651 * Tagalog.
652 * 0x1700 - 0x171F.
653 * @since 1.5
654 */
655 public static final UnicodeBlock TAGALOG
656 = new UnicodeBlock(0x1700, 0x171F,
657 "TAGALOG",
658 "Tagalog");
659
660 /**
661 * Hanunoo.
662 * 0x1720 - 0x173F.
663 * @since 1.5
664 */
665 public static final UnicodeBlock HANUNOO
666 = new UnicodeBlock(0x1720, 0x173F,
667 "HANUNOO",
668 "Hanunoo");
669
670 /**
671 * Buhid.
672 * 0x1740 - 0x175F.
673 * @since 1.5
674 */
675 public static final UnicodeBlock BUHID
676 = new UnicodeBlock(0x1740, 0x175F,
677 "BUHID",
678 "Buhid");
679
680 /**
681 * Tagbanwa.
682 * 0x1760 - 0x177F.
683 * @since 1.5
684 */
685 public static final UnicodeBlock TAGBANWA
686 = new UnicodeBlock(0x1760, 0x177F,
687 "TAGBANWA",
688 "Tagbanwa");
689
690 /**
691 * Khmer.
692 * 0x1780 - 0x17FF.
693 * @since 1.4
694 */
695 public static final UnicodeBlock KHMER
696 = new UnicodeBlock(0x1780, 0x17FF,
697 "KHMER",
698 "Khmer");
699
700 /**
701 * Mongolian.
702 * 0x1800 - 0x18AF.
703 * @since 1.4
704 */
705 public static final UnicodeBlock MONGOLIAN
706 = new UnicodeBlock(0x1800, 0x18AF,
707 "MONGOLIAN",
708 "Mongolian");
709
710 /**
711 * Limbu.
712 * 0x1900 - 0x194F.
713 * @since 1.5
714 */
715 public static final UnicodeBlock LIMBU
716 = new UnicodeBlock(0x1900, 0x194F,
717 "LIMBU",
718 "Limbu");
719
720 /**
721 * Tai Le.
722 * 0x1950 - 0x197F.
723 * @since 1.5
724 */
725 public static final UnicodeBlock TAI_LE
726 = new UnicodeBlock(0x1950, 0x197F,
727 "TAI_LE",
728 "Tai Le");
729
730 /**
731 * Khmer Symbols.
732 * 0x19E0 - 0x19FF.
733 * @since 1.5
734 */
735 public static final UnicodeBlock KHMER_SYMBOLS
736 = new UnicodeBlock(0x19E0, 0x19FF,
737 "KHMER_SYMBOLS",
738 "Khmer Symbols");
739
740 /**
741 * Phonetic Extensions.
742 * 0x1D00 - 0x1D7F.
743 * @since 1.5
744 */
745 public static final UnicodeBlock PHONETIC_EXTENSIONS
746 = new UnicodeBlock(0x1D00, 0x1D7F,
747 "PHONETIC_EXTENSIONS",
748 "Phonetic Extensions");
749
750 /**
751 * Latin Extended Additional.
752 * 0x1E00 - 0x1EFF.
753 */
754 public static final UnicodeBlock LATIN_EXTENDED_ADDITIONAL
755 = new UnicodeBlock(0x1E00, 0x1EFF,
756 "LATIN_EXTENDED_ADDITIONAL",
757 "Latin Extended Additional");
758
759 /**
760 * Greek Extended.
761 * 0x1F00 - 0x1FFF.
762 */
763 public static final UnicodeBlock GREEK_EXTENDED
764 = new UnicodeBlock(0x1F00, 0x1FFF,
765 "GREEK_EXTENDED",
766 "Greek Extended");
767
768 /**
769 * General Punctuation.
770 * 0x2000 - 0x206F.
771 */
772 public static final UnicodeBlock GENERAL_PUNCTUATION
773 = new UnicodeBlock(0x2000, 0x206F,
774 "GENERAL_PUNCTUATION",
775 "General Punctuation");
776
777 /**
778 * Superscripts and Subscripts.
779 * 0x2070 - 0x209F.
780 */
781 public static final UnicodeBlock SUPERSCRIPTS_AND_SUBSCRIPTS
782 = new UnicodeBlock(0x2070, 0x209F,
783 "SUPERSCRIPTS_AND_SUBSCRIPTS",
784 "Superscripts and Subscripts");
785
786 /**
787 * Currency Symbols.
788 * 0x20A0 - 0x20CF.
789 */
790 public static final UnicodeBlock CURRENCY_SYMBOLS
791 = new UnicodeBlock(0x20A0, 0x20CF,
792 "CURRENCY_SYMBOLS",
793 "Currency Symbols");
794
795 /**
796 * Combining Marks for Symbols.
797 * 0x20D0 - 0x20FF.
798 */
799 public static final UnicodeBlock COMBINING_MARKS_FOR_SYMBOLS
800 = new UnicodeBlock(0x20D0, 0x20FF,
801 "COMBINING_MARKS_FOR_SYMBOLS",
802 "Combining Marks for Symbols");
803
804 /**
805 * Letterlike Symbols.
806 * 0x2100 - 0x214F.
807 */
808 public static final UnicodeBlock LETTERLIKE_SYMBOLS
809 = new UnicodeBlock(0x2100, 0x214F,
810 "LETTERLIKE_SYMBOLS",
811 "Letterlike Symbols");
812
813 /**
814 * Number Forms.
815 * 0x2150 - 0x218F.
816 */
817 public static final UnicodeBlock NUMBER_FORMS
818 = new UnicodeBlock(0x2150, 0x218F,
819 "NUMBER_FORMS",
820 "Number Forms");
821
822 /**
823 * Arrows.
824 * 0x2190 - 0x21FF.
825 */
826 public static final UnicodeBlock ARROWS
827 = new UnicodeBlock(0x2190, 0x21FF,
828 "ARROWS",
829 "Arrows");
830
831 /**
832 * Mathematical Operators.
833 * 0x2200 - 0x22FF.
834 */
835 public static final UnicodeBlock MATHEMATICAL_OPERATORS
836 = new UnicodeBlock(0x2200, 0x22FF,
837 "MATHEMATICAL_OPERATORS",
838 "Mathematical Operators");
839
840 /**
841 * Miscellaneous Technical.
842 * 0x2300 - 0x23FF.
843 */
844 public static final UnicodeBlock MISCELLANEOUS_TECHNICAL
845 = new UnicodeBlock(0x2300, 0x23FF,
846 "MISCELLANEOUS_TECHNICAL",
847 "Miscellaneous Technical");
848
849 /**
850 * Control Pictures.
851 * 0x2400 - 0x243F.
852 */
853 public static final UnicodeBlock CONTROL_PICTURES
854 = new UnicodeBlock(0x2400, 0x243F,
855 "CONTROL_PICTURES",
856 "Control Pictures");
857
858 /**
859 * Optical Character Recognition.
860 * 0x2440 - 0x245F.
861 */
862 public static final UnicodeBlock OPTICAL_CHARACTER_RECOGNITION
863 = new UnicodeBlock(0x2440, 0x245F,
864 "OPTICAL_CHARACTER_RECOGNITION",
865 "Optical Character Recognition");
866
867 /**
868 * Enclosed Alphanumerics.
869 * 0x2460 - 0x24FF.
870 */
871 public static final UnicodeBlock ENCLOSED_ALPHANUMERICS
872 = new UnicodeBlock(0x2460, 0x24FF,
873 "ENCLOSED_ALPHANUMERICS",
874 "Enclosed Alphanumerics");
875
876 /**
877 * Box Drawing.
878 * 0x2500 - 0x257F.
879 */
880 public static final UnicodeBlock BOX_DRAWING
881 = new UnicodeBlock(0x2500, 0x257F,
882 "BOX_DRAWING",
883 "Box Drawing");
884
885 /**
886 * Block Elements.
887 * 0x2580 - 0x259F.
888 */
889 public static final UnicodeBlock BLOCK_ELEMENTS
890 = new UnicodeBlock(0x2580, 0x259F,
891 "BLOCK_ELEMENTS",
892 "Block Elements");
893
894 /**
895 * Geometric Shapes.
896 * 0x25A0 - 0x25FF.
897 */
898 public static final UnicodeBlock GEOMETRIC_SHAPES
899 = new UnicodeBlock(0x25A0, 0x25FF,
900 "GEOMETRIC_SHAPES",
901 "Geometric Shapes");
902
903 /**
904 * Miscellaneous Symbols.
905 * 0x2600 - 0x26FF.
906 */
907 public static final UnicodeBlock MISCELLANEOUS_SYMBOLS
908 = new UnicodeBlock(0x2600, 0x26FF,
909 "MISCELLANEOUS_SYMBOLS",
910 "Miscellaneous Symbols");
911
912 /**
913 * Dingbats.
914 * 0x2700 - 0x27BF.
915 */
916 public static final UnicodeBlock DINGBATS
917 = new UnicodeBlock(0x2700, 0x27BF,
918 "DINGBATS",
919 "Dingbats");
920
921 /**
922 * Miscellaneous Mathematical Symbols-A.
923 * 0x27C0 - 0x27EF.
924 * @since 1.5
925 */
926 public static final UnicodeBlock MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A
927 = new UnicodeBlock(0x27C0, 0x27EF,
928 "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A",
929 "Miscellaneous Mathematical Symbols-A");
930
931 /**
932 * Supplemental Arrows-A.
933 * 0x27F0 - 0x27FF.
934 * @since 1.5
935 */
936 public static final UnicodeBlock SUPPLEMENTAL_ARROWS_A
937 = new UnicodeBlock(0x27F0, 0x27FF,
938 "SUPPLEMENTAL_ARROWS_A",
939 "Supplemental Arrows-A");
940
941 /**
942 * Braille Patterns.
943 * 0x2800 - 0x28FF.
944 * @since 1.4
945 */
946 public static final UnicodeBlock BRAILLE_PATTERNS
947 = new UnicodeBlock(0x2800, 0x28FF,
948 "BRAILLE_PATTERNS",
949 "Braille Patterns");
950
951 /**
952 * Supplemental Arrows-B.
953 * 0x2900 - 0x297F.
954 * @since 1.5
955 */
956 public static final UnicodeBlock SUPPLEMENTAL_ARROWS_B
957 = new UnicodeBlock(0x2900, 0x297F,
958 "SUPPLEMENTAL_ARROWS_B",
959 "Supplemental Arrows-B");
960
961 /**
962 * Miscellaneous Mathematical Symbols-B.
963 * 0x2980 - 0x29FF.
964 * @since 1.5
965 */
966 public static final UnicodeBlock MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B
967 = new UnicodeBlock(0x2980, 0x29FF,
968 "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B",
969 "Miscellaneous Mathematical Symbols-B");
970
971 /**
972 * Supplemental Mathematical Operators.
973 * 0x2A00 - 0x2AFF.
974 * @since 1.5
975 */
976 public static final UnicodeBlock SUPPLEMENTAL_MATHEMATICAL_OPERATORS
977 = new UnicodeBlock(0x2A00, 0x2AFF,
978 "SUPPLEMENTAL_MATHEMATICAL_OPERATORS",
979 "Supplemental Mathematical Operators");
980
981 /**
982 * Miscellaneous Symbols and Arrows.
983 * 0x2B00 - 0x2BFF.
984 * @since 1.5
985 */
986 public static final UnicodeBlock MISCELLANEOUS_SYMBOLS_AND_ARROWS
987 = new UnicodeBlock(0x2B00, 0x2BFF,
988 "MISCELLANEOUS_SYMBOLS_AND_ARROWS",
989 "Miscellaneous Symbols and Arrows");
990
991 /**
992 * CJK Radicals Supplement.
993 * 0x2E80 - 0x2EFF.
994 * @since 1.4
995 */
996 public static final UnicodeBlock CJK_RADICALS_SUPPLEMENT
997 = new UnicodeBlock(0x2E80, 0x2EFF,
998 "CJK_RADICALS_SUPPLEMENT",
999 "CJK Radicals Supplement");
1000
1001 /**
1002 * Kangxi Radicals.
1003 * 0x2F00 - 0x2FDF.
1004 * @since 1.4
1005 */
1006 public static final UnicodeBlock KANGXI_RADICALS
1007 = new UnicodeBlock(0x2F00, 0x2FDF,
1008 "KANGXI_RADICALS",
1009 "Kangxi Radicals");
1010
1011 /**
1012 * Ideographic Description Characters.
1013 * 0x2FF0 - 0x2FFF.
1014 * @since 1.4
1015 */
1016 public static final UnicodeBlock IDEOGRAPHIC_DESCRIPTION_CHARACTERS
1017 = new UnicodeBlock(0x2FF0, 0x2FFF,
1018 "IDEOGRAPHIC_DESCRIPTION_CHARACTERS",
1019 "Ideographic Description Characters");
1020
1021 /**
1022 * CJK Symbols and Punctuation.
1023 * 0x3000 - 0x303F.
1024 */
1025 public static final UnicodeBlock CJK_SYMBOLS_AND_PUNCTUATION
1026 = new UnicodeBlock(0x3000, 0x303F,
1027 "CJK_SYMBOLS_AND_PUNCTUATION",
1028 "CJK Symbols and Punctuation");
1029
1030 /**
1031 * Hiragana.
1032 * 0x3040 - 0x309F.
1033 */
1034 public static final UnicodeBlock HIRAGANA
1035 = new UnicodeBlock(0x3040, 0x309F,
1036 "HIRAGANA",
1037 "Hiragana");
1038
1039 /**
1040 * Katakana.
1041 * 0x30A0 - 0x30FF.
1042 */
1043 public static final UnicodeBlock KATAKANA
1044 = new UnicodeBlock(0x30A0, 0x30FF,
1045 "KATAKANA",
1046 "Katakana");
1047
1048 /**
1049 * Bopomofo.
1050 * 0x3100 - 0x312F.
1051 */
1052 public static final UnicodeBlock BOPOMOFO
1053 = new UnicodeBlock(0x3100, 0x312F,
1054 "BOPOMOFO",
1055 "Bopomofo");
1056
1057 /**
1058 * Hangul Compatibility Jamo.
1059 * 0x3130 - 0x318F.
1060 */
1061 public static final UnicodeBlock HANGUL_COMPATIBILITY_JAMO
1062 = new UnicodeBlock(0x3130, 0x318F,
1063 "HANGUL_COMPATIBILITY_JAMO",
1064 "Hangul Compatibility Jamo");
1065
1066 /**
1067 * Kanbun.
1068 * 0x3190 - 0x319F.
1069 */
1070 public static final UnicodeBlock KANBUN
1071 = new UnicodeBlock(0x3190, 0x319F,
1072 "KANBUN",
1073 "Kanbun");
1074
1075 /**
1076 * Bopomofo Extended.
1077 * 0x31A0 - 0x31BF.
1078 * @since 1.4
1079 */
1080 public static final UnicodeBlock BOPOMOFO_EXTENDED
1081 = new UnicodeBlock(0x31A0, 0x31BF,
1082 "BOPOMOFO_EXTENDED",
1083 "Bopomofo Extended");
1084
1085 /**
1086 * Katakana Phonetic Extensions.
1087 * 0x31F0 - 0x31FF.
1088 * @since 1.5
1089 */
1090 public static final UnicodeBlock KATAKANA_PHONETIC_EXTENSIONS
1091 = new UnicodeBlock(0x31F0, 0x31FF,
1092 "KATAKANA_PHONETIC_EXTENSIONS",
1093 "Katakana Phonetic Extensions");
1094
1095 /**
1096 * Enclosed CJK Letters and Months.
1097 * 0x3200 - 0x32FF.
1098 */
1099 public static final UnicodeBlock ENCLOSED_CJK_LETTERS_AND_MONTHS
1100 = new UnicodeBlock(0x3200, 0x32FF,
1101 "ENCLOSED_CJK_LETTERS_AND_MONTHS",
1102 "Enclosed CJK Letters and Months");
1103
1104 /**
1105 * CJK Compatibility.
1106 * 0x3300 - 0x33FF.
1107 */
1108 public static final UnicodeBlock CJK_COMPATIBILITY
1109 = new UnicodeBlock(0x3300, 0x33FF,
1110 "CJK_COMPATIBILITY",
1111 "CJK Compatibility");
1112
1113 /**
1114 * CJK Unified Ideographs Extension A.
1115 * 0x3400 - 0x4DBF.
1116 * @since 1.4
1117 */
1118 public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
1119 = new UnicodeBlock(0x3400, 0x4DBF,
1120 "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A",
1121 "CJK Unified Ideographs Extension A");
1122
1123 /**
1124 * Yijing Hexagram Symbols.
1125 * 0x4DC0 - 0x4DFF.
1126 * @since 1.5
1127 */
1128 public static final UnicodeBlock YIJING_HEXAGRAM_SYMBOLS
1129 = new UnicodeBlock(0x4DC0, 0x4DFF,
1130 "YIJING_HEXAGRAM_SYMBOLS",
1131 "Yijing Hexagram Symbols");
1132
1133 /**
1134 * CJK Unified Ideographs.
1135 * 0x4E00 - 0x9FFF.
1136 */
1137 public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS
1138 = new UnicodeBlock(0x4E00, 0x9FFF,
1139 "CJK_UNIFIED_IDEOGRAPHS",
1140 "CJK Unified Ideographs");
1141
1142 /**
1143 * Yi Syllables.
1144 * 0xA000 - 0xA48F.
1145 * @since 1.4
1146 */
1147 public static final UnicodeBlock YI_SYLLABLES
1148 = new UnicodeBlock(0xA000, 0xA48F,
1149 "YI_SYLLABLES",
1150 "Yi Syllables");
1151
1152 /**
1153 * Yi Radicals.
1154 * 0xA490 - 0xA4CF.
1155 * @since 1.4
1156 */
1157 public static final UnicodeBlock YI_RADICALS
1158 = new UnicodeBlock(0xA490, 0xA4CF,
1159 "YI_RADICALS",
1160 "Yi Radicals");
1161
1162 /**
1163 * Hangul Syllables.
1164 * 0xAC00 - 0xD7AF.
1165 */
1166 public static final UnicodeBlock HANGUL_SYLLABLES
1167 = new UnicodeBlock(0xAC00, 0xD7AF,
1168 "HANGUL_SYLLABLES",
1169 "Hangul Syllables");
1170
1171 /**
1172 * High Surrogates.
1173 * 0xD800 - 0xDB7F.
1174 * @since 1.5
1175 */
1176 public static final UnicodeBlock HIGH_SURROGATES
1177 = new UnicodeBlock(0xD800, 0xDB7F,
1178 "HIGH_SURROGATES",
1179 "High Surrogates");
1180
1181 /**
1182 * High Private Use Surrogates.
1183 * 0xDB80 - 0xDBFF.
1184 * @since 1.5
1185 */
1186 public static final UnicodeBlock HIGH_PRIVATE_USE_SURROGATES
1187 = new UnicodeBlock(0xDB80, 0xDBFF,
1188 "HIGH_PRIVATE_USE_SURROGATES",
1189 "High Private Use Surrogates");
1190
1191 /**
1192 * Low Surrogates.
1193 * 0xDC00 - 0xDFFF.
1194 * @since 1.5
1195 */
1196 public static final UnicodeBlock LOW_SURROGATES
1197 = new UnicodeBlock(0xDC00, 0xDFFF,
1198 "LOW_SURROGATES",
1199 "Low Surrogates");
1200
1201 /**
1202 * Private Use Area.
1203 * 0xE000 - 0xF8FF.
1204 */
1205 public static final UnicodeBlock PRIVATE_USE_AREA
1206 = new UnicodeBlock(0xE000, 0xF8FF,
1207 "PRIVATE_USE_AREA",
1208 "Private Use Area");
1209
1210 /**
1211 * CJK Compatibility Ideographs.
1212 * 0xF900 - 0xFAFF.
1213 */
1214 public static final UnicodeBlock CJK_COMPATIBILITY_IDEOGRAPHS
1215 = new UnicodeBlock(0xF900, 0xFAFF,
1216 "CJK_COMPATIBILITY_IDEOGRAPHS",
1217 "CJK Compatibility Ideographs");
1218
1219 /**
1220 * Alphabetic Presentation Forms.
1221 * 0xFB00 - 0xFB4F.
1222 */
1223 public static final UnicodeBlock ALPHABETIC_PRESENTATION_FORMS
1224 = new UnicodeBlock(0xFB00, 0xFB4F,
1225 "ALPHABETIC_PRESENTATION_FORMS",
1226 "Alphabetic Presentation Forms");
1227
1228 /**
1229 * Arabic Presentation Forms-A.
1230 * 0xFB50 - 0xFDFF.
1231 */
1232 public static final UnicodeBlock ARABIC_PRESENTATION_FORMS_A
1233 = new UnicodeBlock(0xFB50, 0xFDFF,
1234 "ARABIC_PRESENTATION_FORMS_A",
1235 "Arabic Presentation Forms-A");
1236
1237 /**
1238 * Variation Selectors.
1239 * 0xFE00 - 0xFE0F.
1240 * @since 1.5
1241 */
1242 public static final UnicodeBlock VARIATION_SELECTORS
1243 = new UnicodeBlock(0xFE00, 0xFE0F,
1244 "VARIATION_SELECTORS",
1245 "Variation Selectors");
1246
1247 /**
1248 * Combining Half Marks.
1249 * 0xFE20 - 0xFE2F.
1250 */
1251 public static final UnicodeBlock COMBINING_HALF_MARKS
1252 = new UnicodeBlock(0xFE20, 0xFE2F,
1253 "COMBINING_HALF_MARKS",
1254 "Combining Half Marks");
1255
1256 /**
1257 * CJK Compatibility Forms.
1258 * 0xFE30 - 0xFE4F.
1259 */
1260 public static final UnicodeBlock CJK_COMPATIBILITY_FORMS
1261 = new UnicodeBlock(0xFE30, 0xFE4F,
1262 "CJK_COMPATIBILITY_FORMS",
1263 "CJK Compatibility Forms");
1264
1265 /**
1266 * Small Form Variants.
1267 * 0xFE50 - 0xFE6F.
1268 */
1269 public static final UnicodeBlock SMALL_FORM_VARIANTS
1270 = new UnicodeBlock(0xFE50, 0xFE6F,
1271 "SMALL_FORM_VARIANTS",
1272 "Small Form Variants");
1273
1274 /**
1275 * Arabic Presentation Forms-B.
1276 * 0xFE70 - 0xFEFF.
1277 */
1278 public static final UnicodeBlock ARABIC_PRESENTATION_FORMS_B
1279 = new UnicodeBlock(0xFE70, 0xFEFF,
1280 "ARABIC_PRESENTATION_FORMS_B",
1281 "Arabic Presentation Forms-B");
1282
1283 /**
1284 * Halfwidth and Fullwidth Forms.
1285 * 0xFF00 - 0xFFEF.
1286 */
1287 public static final UnicodeBlock HALFWIDTH_AND_FULLWIDTH_FORMS
1288 = new UnicodeBlock(0xFF00, 0xFFEF,
1289 "HALFWIDTH_AND_FULLWIDTH_FORMS",
1290 "Halfwidth and Fullwidth Forms");
1291
1292 /**
1293 * Specials.
1294 * 0xFFF0 - 0xFFFF.
1295 */
1296 public static final UnicodeBlock SPECIALS
1297 = new UnicodeBlock(0xFFF0, 0xFFFF,
1298 "SPECIALS",
1299 "Specials");
1300
1301 /**
1302 * Linear B Syllabary.
1303 * 0x10000 - 0x1007F.
1304 * @since 1.5
1305 */
1306 public static final UnicodeBlock LINEAR_B_SYLLABARY
1307 = new UnicodeBlock(0x10000, 0x1007F,
1308 "LINEAR_B_SYLLABARY",
1309 "Linear B Syllabary");
1310
1311 /**
1312 * Linear B Ideograms.
1313 * 0x10080 - 0x100FF.
1314 * @since 1.5
1315 */
1316 public static final UnicodeBlock LINEAR_B_IDEOGRAMS
1317 = new UnicodeBlock(0x10080, 0x100FF,
1318 "LINEAR_B_IDEOGRAMS",
1319 "Linear B Ideograms");
1320
1321 /**
1322 * Aegean Numbers.
1323 * 0x10100 - 0x1013F.
1324 * @since 1.5
1325 */
1326 public static final UnicodeBlock AEGEAN_NUMBERS
1327 = new UnicodeBlock(0x10100, 0x1013F,
1328 "AEGEAN_NUMBERS",
1329 "Aegean Numbers");
1330
1331 /**
1332 * Old Italic.
1333 * 0x10300 - 0x1032F.
1334 * @since 1.5
1335 */
1336 public static final UnicodeBlock OLD_ITALIC
1337 = new UnicodeBlock(0x10300, 0x1032F,
1338 "OLD_ITALIC",
1339 "Old Italic");
1340
1341 /**
1342 * Gothic.
1343 * 0x10330 - 0x1034F.
1344 * @since 1.5
1345 */
1346 public static final UnicodeBlock GOTHIC
1347 = new UnicodeBlock(0x10330, 0x1034F,
1348 "GOTHIC",
1349 "Gothic");
1350
1351 /**
1352 * Ugaritic.
1353 * 0x10380 - 0x1039F.
1354 * @since 1.5
1355 */
1356 public static final UnicodeBlock UGARITIC
1357 = new UnicodeBlock(0x10380, 0x1039F,
1358 "UGARITIC",
1359 "Ugaritic");
1360
1361 /**
1362 * Deseret.
1363 * 0x10400 - 0x1044F.
1364 * @since 1.5
1365 */
1366 public static final UnicodeBlock DESERET
1367 = new UnicodeBlock(0x10400, 0x1044F,
1368 "DESERET",
1369 "Deseret");
1370
1371 /**
1372 * Shavian.
1373 * 0x10450 - 0x1047F.
1374 * @since 1.5
1375 */
1376 public static final UnicodeBlock SHAVIAN
1377 = new UnicodeBlock(0x10450, 0x1047F,
1378 "SHAVIAN",
1379 "Shavian");
1380
1381 /**
1382 * Osmanya.
1383 * 0x10480 - 0x104AF.
1384 * @since 1.5
1385 */
1386 public static final UnicodeBlock OSMANYA
1387 = new UnicodeBlock(0x10480, 0x104AF,
1388 "OSMANYA",
1389 "Osmanya");
1390
1391 /**
1392 * Cypriot Syllabary.
1393 * 0x10800 - 0x1083F.
1394 * @since 1.5
1395 */
1396 public static final UnicodeBlock CYPRIOT_SYLLABARY
1397 = new UnicodeBlock(0x10800, 0x1083F,
1398 "CYPRIOT_SYLLABARY",
1399 "Cypriot Syllabary");
1400
1401 /**
1402 * Byzantine Musical Symbols.
1403 * 0x1D000 - 0x1D0FF.
1404 * @since 1.5
1405 */
1406 public static final UnicodeBlock BYZANTINE_MUSICAL_SYMBOLS
1407 = new UnicodeBlock(0x1D000, 0x1D0FF,
1408 "BYZANTINE_MUSICAL_SYMBOLS",
1409 "Byzantine Musical Symbols");
1410
1411 /**
1412 * Musical Symbols.
1413 * 0x1D100 - 0x1D1FF.
1414 * @since 1.5
1415 */
1416 public static final UnicodeBlock MUSICAL_SYMBOLS
1417 = new UnicodeBlock(0x1D100, 0x1D1FF,
1418 "MUSICAL_SYMBOLS",
1419 "Musical Symbols");
1420
1421 /**
1422 * Tai Xuan Jing Symbols.
1423 * 0x1D300 - 0x1D35F.
1424 * @since 1.5
1425 */
1426 public static final UnicodeBlock TAI_XUAN_JING_SYMBOLS
1427 = new UnicodeBlock(0x1D300, 0x1D35F,
1428 "TAI_XUAN_JING_SYMBOLS",
1429 "Tai Xuan Jing Symbols");
1430
1431 /**
1432 * Mathematical Alphanumeric Symbols.
1433 * 0x1D400 - 0x1D7FF.
1434 * @since 1.5
1435 */
1436 public static final UnicodeBlock MATHEMATICAL_ALPHANUMERIC_SYMBOLS
1437 = new UnicodeBlock(0x1D400, 0x1D7FF,
1438 "MATHEMATICAL_ALPHANUMERIC_SYMBOLS",
1439 "Mathematical Alphanumeric Symbols");
1440
1441 /**
1442 * CJK Unified Ideographs Extension B.
1443 * 0x20000 - 0x2A6DF.
1444 * @since 1.5
1445 */
1446 public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B
1447 = new UnicodeBlock(0x20000, 0x2A6DF,
1448 "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B",
1449 "CJK Unified Ideographs Extension B");
1450
1451 /**
1452 * CJK Compatibility Ideographs Supplement.
1453 * 0x2F800 - 0x2FA1F.
1454 * @since 1.5
1455 */
1456 public static final UnicodeBlock CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT
1457 = new UnicodeBlock(0x2F800, 0x2FA1F,
1458 "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT",
1459 "CJK Compatibility Ideographs Supplement");
1460
1461 /**
1462 * Tags.
1463 * 0xE0000 - 0xE007F.
1464 * @since 1.5
1465 */
1466 public static final UnicodeBlock TAGS
1467 = new UnicodeBlock(0xE0000, 0xE007F,
1468 "TAGS",
1469 "Tags");
1470
1471 /**
1472 * Variation Selectors Supplement.
1473 * 0xE0100 - 0xE01EF.
1474 * @since 1.5
1475 */
1476 public static final UnicodeBlock VARIATION_SELECTORS_SUPPLEMENT
1477 = new UnicodeBlock(0xE0100, 0xE01EF,
1478 "VARIATION_SELECTORS_SUPPLEMENT",
1479 "Variation Selectors Supplement");
1480
1481 /**
1482 * Supplementary Private Use Area-A.
1483 * 0xF0000 - 0xFFFFF.
1484 * @since 1.5
1485 */
1486 public static final UnicodeBlock SUPPLEMENTARY_PRIVATE_USE_AREA_A
1487 = new UnicodeBlock(0xF0000, 0xFFFFF,
1488 "SUPPLEMENTARY_PRIVATE_USE_AREA_A",
1489 "Supplementary Private Use Area-A");
1490
1491 /**
1492 * Supplementary Private Use Area-B.
1493 * 0x100000 - 0x10FFFF.
1494 * @since 1.5
1495 */
1496 public static final UnicodeBlock SUPPLEMENTARY_PRIVATE_USE_AREA_B
1497 = new UnicodeBlock(0x100000, 0x10FFFF,
1498 "SUPPLEMENTARY_PRIVATE_USE_AREA_B",
1499 "Supplementary Private Use Area-B");
1500
1501 /**
1502 * Surrogates Area.
1503 * 'D800' - 'DFFF'.
1504 * @deprecated As of 1.5, the three areas,
1505 * <a href="#HIGH_SURROGATES">HIGH_SURROGATES</a>,
1506 * <a href="#HIGH_PRIVATE_USE_SURROGATES">HIGH_PRIVATE_USE_SURROGATES</a>
1507 * and <a href="#LOW_SURROGATES">LOW_SURROGATES</a>, as defined
1508 * by the Unicode standard, should be used in preference to
1509 * this. These are also returned from calls to <code>of(int)</code>
1510 * and <code>of(char)</code>.
1511 */
1512 @Deprecated
1513 public static final UnicodeBlock SURROGATES_AREA
1514 = new UnicodeBlock(0xD800, 0xDFFF,
1515 "SURROGATES_AREA",
1516 "Surrogates Area");
1517
1518 /**
1519 * The defined subsets.
1520 */
1521 private static final UnicodeBlock sets[] = {
1522 BASIC_LATIN,
1523 LATIN_1_SUPPLEMENT,
1524 LATIN_EXTENDED_A,
1525 LATIN_EXTENDED_B,
1526 IPA_EXTENSIONS,
1527 SPACING_MODIFIER_LETTERS,
1528 COMBINING_DIACRITICAL_MARKS,
1529 GREEK,
1530 CYRILLIC,
1531 CYRILLIC_SUPPLEMENTARY,
1532 ARMENIAN,
1533 HEBREW,
1534 ARABIC,
1535 SYRIAC,
1536 THAANA,
1537 DEVANAGARI,
1538 BENGALI,
1539 GURMUKHI,
1540 GUJARATI,
1541 ORIYA,
1542 TAMIL,
1543 TELUGU,
1544 KANNADA,
1545 MALAYALAM,
1546 SINHALA,
1547 THAI,
1548 LAO,
1549 TIBETAN,
1550 MYANMAR,
1551 GEORGIAN,
1552 HANGUL_JAMO,
1553 ETHIOPIC,
1554 CHEROKEE,
1555 UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS,
1556 OGHAM,
1557 RUNIC,
1558 TAGALOG,
1559 HANUNOO,
1560 BUHID,
1561 TAGBANWA,
1562 KHMER,
1563 MONGOLIAN,
1564 LIMBU,
1565 TAI_LE,
1566 KHMER_SYMBOLS,
1567 PHONETIC_EXTENSIONS,
1568 LATIN_EXTENDED_ADDITIONAL,
1569 GREEK_EXTENDED,
1570 GENERAL_PUNCTUATION,
1571 SUPERSCRIPTS_AND_SUBSCRIPTS,
1572 CURRENCY_SYMBOLS,
1573 COMBINING_MARKS_FOR_SYMBOLS,
1574 LETTERLIKE_SYMBOLS,
1575 NUMBER_FORMS,
1576 ARROWS,
1577 MATHEMATICAL_OPERATORS,
1578 MISCELLANEOUS_TECHNICAL,
1579 CONTROL_PICTURES,
1580 OPTICAL_CHARACTER_RECOGNITION,
1581 ENCLOSED_ALPHANUMERICS,
1582 BOX_DRAWING,
1583 BLOCK_ELEMENTS,
1584 GEOMETRIC_SHAPES,
1585 MISCELLANEOUS_SYMBOLS,
1586 DINGBATS,
1587 MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A,
1588 SUPPLEMENTAL_ARROWS_A,
1589 BRAILLE_PATTERNS,
1590 SUPPLEMENTAL_ARROWS_B,
1591 MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B,
1592 SUPPLEMENTAL_MATHEMATICAL_OPERATORS,
1593 MISCELLANEOUS_SYMBOLS_AND_ARROWS,
1594 CJK_RADICALS_SUPPLEMENT,
1595 KANGXI_RADICALS,
1596 IDEOGRAPHIC_DESCRIPTION_CHARACTERS,
1597 CJK_SYMBOLS_AND_PUNCTUATION,
1598 HIRAGANA,
1599 KATAKANA,
1600 BOPOMOFO,
1601 HANGUL_COMPATIBILITY_JAMO,
1602 KANBUN,
1603 BOPOMOFO_EXTENDED,
1604 KATAKANA_PHONETIC_EXTENSIONS,
1605 ENCLOSED_CJK_LETTERS_AND_MONTHS,
1606 CJK_COMPATIBILITY,
1607 CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A,
1608 YIJING_HEXAGRAM_SYMBOLS,
1609 CJK_UNIFIED_IDEOGRAPHS,
1610 YI_SYLLABLES,
1611 YI_RADICALS,
1612 HANGUL_SYLLABLES,
1613 HIGH_SURROGATES,
1614 HIGH_PRIVATE_USE_SURROGATES,
1615 LOW_SURROGATES,
1616 PRIVATE_USE_AREA,
1617 CJK_COMPATIBILITY_IDEOGRAPHS,
1618 ALPHABETIC_PRESENTATION_FORMS,
1619 ARABIC_PRESENTATION_FORMS_A,
1620 VARIATION_SELECTORS,
1621 COMBINING_HALF_MARKS,
1622 CJK_COMPATIBILITY_FORMS,
1623 SMALL_FORM_VARIANTS,
1624 ARABIC_PRESENTATION_FORMS_B,
1625 HALFWIDTH_AND_FULLWIDTH_FORMS,
1626 SPECIALS,
1627 LINEAR_B_SYLLABARY,
1628 LINEAR_B_IDEOGRAMS,
1629 AEGEAN_NUMBERS,
1630 OLD_ITALIC,
1631 GOTHIC,
1632 UGARITIC,
1633 DESERET,
1634 SHAVIAN,
1635 OSMANYA,
1636 CYPRIOT_SYLLABARY,
1637 BYZANTINE_MUSICAL_SYMBOLS,
1638 MUSICAL_SYMBOLS,
1639 TAI_XUAN_JING_SYMBOLS,
1640 MATHEMATICAL_ALPHANUMERIC_SYMBOLS,
1641 CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B,
1642 CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT,
1643 TAGS,
1644 VARIATION_SELECTORS_SUPPLEMENT,
1645 SUPPLEMENTARY_PRIVATE_USE_AREA_A,
1646 SUPPLEMENTARY_PRIVATE_USE_AREA_B,
1647 };
1648 } // class UnicodeBlock
1649
1650 /**
1651 * The immutable value of this Character.
1652 *
1653 * @serial the value of this Character
1654 */
1655 private final char value;
1656
1657 /**
1658 * Compatible with JDK 1.0+.
1659 */
1660 private static final long serialVersionUID = 3786198910865385080L;
1661
1662 /**
1663 * Smallest value allowed for radix arguments in Java. This value is 2.
1664 *
1665 * @see #digit(char, int)
1666 * @see #forDigit(int, int)
1667 * @see Integer#toString(int, int)
1668 * @see Integer#valueOf(String)
1669 */
1670 public static final int MIN_RADIX = 2;
1671
1672 /**
1673 * Largest value allowed for radix arguments in Java. This value is 36.
1674 *
1675 * @see #digit(char, int)
1676 * @see #forDigit(int, int)
1677 * @see Integer#toString(int, int)
1678 * @see Integer#valueOf(String)
1679 */
1680 public static final int MAX_RADIX = 36;
1681
1682 /**
1683 * The minimum value the char data type can hold.
1684 * This value is <code>'\\u0000'</code>.
1685 */
1686 public static final char MIN_VALUE = '\u0000';
1687
1688 /**
1689 * The maximum value the char data type can hold.
1690 * This value is <code>'\\uFFFF'</code>.
1691 */
1692 public static final char MAX_VALUE = '\uFFFF';
1693
1694 /**
1695 * The minimum Unicode 4.0 code point. This value is <code>0</code>.
1696 * @since 1.5
1697 */
1698 public static final int MIN_CODE_POINT = 0;
1699
1700 /**
1701 * The maximum Unicode 4.0 code point, which is greater than the range
1702 * of the char data type.
1703 * This value is <code>0x10FFFF</code>.
1704 * @since 1.5
1705 */
1706 public static final int MAX_CODE_POINT = 0x10FFFF;
1707
1708 /**
1709 * The minimum Unicode high surrogate code unit, or
1710 * <emph>leading-surrogate</emph>, in the UTF-16 character encoding.
1711 * This value is <code>'\uD800'</code>.
1712 * @since 1.5
1713 */
1714 public static final char MIN_HIGH_SURROGATE = '\uD800';
1715
1716 /**
1717 * The maximum Unicode high surrogate code unit, or
1718 * <emph>leading-surrogate</emph>, in the UTF-16 character encoding.
1719 * This value is <code>'\uDBFF'</code>.
1720 * @since 1.5
1721 */
1722 public static final char MAX_HIGH_SURROGATE = '\uDBFF';
1723
1724 /**
1725 * The minimum Unicode low surrogate code unit, or
1726 * <emph>trailing-surrogate</emph>, in the UTF-16 character encoding.
1727 * This value is <code>'\uDC00'</code>.
1728 * @since 1.5
1729 */
1730 public static final char MIN_LOW_SURROGATE = '\uDC00';
1731
1732 /**
1733 * The maximum Unicode low surrogate code unit, or
1734 * <emph>trailing-surrogate</emph>, in the UTF-16 character encoding.
1735 * This value is <code>'\uDFFF'</code>.
1736 * @since 1.5
1737 */
1738 public static final char MAX_LOW_SURROGATE = '\uDFFF';
1739
1740 /**
1741 * The minimum Unicode surrogate code unit in the UTF-16 character encoding.
1742 * This value is <code>'\uD800'</code>.
1743 * @since 1.5
1744 */
1745 public static final char MIN_SURROGATE = MIN_HIGH_SURROGATE;
1746
1747 /**
1748 * The maximum Unicode surrogate code unit in the UTF-16 character encoding.
1749 * This value is <code>'\uDFFF'</code>.
1750 * @since 1.5
1751 */
1752 public static final char MAX_SURROGATE = MAX_LOW_SURROGATE;
1753
1754 /**
1755 * The lowest possible supplementary Unicode code point (the first code
1756 * point outside the basic multilingual plane (BMP)).
1757 * This value is <code>0x10000</code>.
1758 */
1759 public static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x10000;
1760
1761 /**
1762 * Class object representing the primitive char data type.
1763 *
1764 * @since 1.1
1765 */
1766 public static final Class<Character> TYPE = (Class<Character>) VMClassLoader.getPrimitiveClass('C');
1767
1768 /**
1769 * The number of bits needed to represent a <code>char</code>.
1770 * @since 1.5
1771 */
1772 public static final int SIZE = 16;
1773
1774 // This caches some Character values, and is used by boxing
1775 // conversions via valueOf(). We must cache at least 0..127;
1776 // this constant controls how much we actually cache.
1777 private static final int MAX_CACHE = 127;
1778 private static Character[] charCache = new Character[MAX_CACHE + 1];
1779
1780 /**
1781 * Lu = Letter, Uppercase (Informative).
1782 *
1783 * @since 1.1
1784 */
1785 public static final byte UPPERCASE_LETTER = 1;
1786
1787 /**
1788 * Ll = Letter, Lowercase (Informative).
1789 *
1790 * @since 1.1
1791 */
1792 public static final byte LOWERCASE_LETTER = 2;
1793
1794 /**
1795 * Lt = Letter, Titlecase (Informative).
1796 *
1797 * @since 1.1
1798 */
1799 public static final byte TITLECASE_LETTER = 3;
1800
1801 /**
1802 * Mn = Mark, Non-Spacing (Normative).
1803 *
1804 * @since 1.1
1805 */
1806 public static final byte NON_SPACING_MARK = 6;
1807
1808 /**
1809 * Mc = Mark, Spacing Combining (Normative).
1810 *
1811 * @since 1.1
1812 */
1813 public static final byte COMBINING_SPACING_MARK = 8;
1814
1815 /**
1816 * Me = Mark, Enclosing (Normative).
1817 *
1818 * @since 1.1
1819 */
1820 public static final byte ENCLOSING_MARK = 7;
1821
1822 /**
1823 * Nd = Number, Decimal Digit (Normative).
1824 *
1825 * @since 1.1
1826 */
1827 public static final byte DECIMAL_DIGIT_NUMBER = 9;
1828
1829 /**
1830 * Nl = Number, Letter (Normative).
1831 *
1832 * @since 1.1
1833 */
1834 public static final byte LETTER_NUMBER = 10;
1835
1836 /**
1837 * No = Number, Other (Normative).
1838 *
1839 * @since 1.1
1840 */
1841 public static final byte OTHER_NUMBER = 11;
1842
1843 /**
1844 * Zs = Separator, Space (Normative).
1845 *
1846 * @since 1.1
1847 */
1848 public static final byte SPACE_SEPARATOR = 12;
1849
1850 /**
1851 * Zl = Separator, Line (Normative).
1852 *
1853 * @since 1.1
1854 */
1855 public static final byte LINE_SEPARATOR = 13;
1856
1857 /**
1858 * Zp = Separator, Paragraph (Normative).
1859 *
1860 * @since 1.1
1861 */
1862 public static final byte PARAGRAPH_SEPARATOR = 14;
1863
1864 /**
1865 * Cc = Other, Control (Normative).
1866 *
1867 * @since 1.1
1868 */
1869 public static final byte CONTROL = 15;
1870
1871 /**
1872 * Cf = Other, Format (Normative).
1873 *
1874 * @since 1.1
1875 */
1876 public static final byte FORMAT = 16;
1877
1878 /**
1879 * Cs = Other, Surrogate (Normative).
1880 *
1881 * @since 1.1
1882 */
1883 public static final byte SURROGATE = 19;
1884
1885 /**
1886 * Co = Other, Private Use (Normative).
1887 *
1888 * @since 1.1
1889 */
1890 public static final byte PRIVATE_USE = 18;
1891
1892 /**
1893 * Cn = Other, Not Assigned (Normative).
1894 *
1895 * @since 1.1
1896 */
1897 public static final byte UNASSIGNED = 0;
1898
1899 /**
1900 * Lm = Letter, Modifier (Informative).
1901 *
1902 * @since 1.1
1903 */
1904 public static final byte MODIFIER_LETTER = 4;
1905
1906 /**
1907 * Lo = Letter, Other (Informative).
1908 *
1909 * @since 1.1
1910 */
1911 public static final byte OTHER_LETTER = 5;
1912
1913 /**
1914 * Pc = Punctuation, Connector (Informative).
1915 *
1916 * @since 1.1
1917 */
1918 public static final byte CONNECTOR_PUNCTUATION = 23;
1919
1920 /**
1921 * Pd = Punctuation, Dash (Informative).
1922 *
1923 * @since 1.1
1924 */
1925 public static final byte DASH_PUNCTUATION = 20;
1926
1927 /**
1928 * Ps = Punctuation, Open (Informative).
1929 *
1930 * @since 1.1
1931 */
1932 public static final byte START_PUNCTUATION = 21;
1933
1934 /**
1935 * Pe = Punctuation, Close (Informative).
1936 *
1937 * @since 1.1
1938 */
1939 public static final byte END_PUNCTUATION = 22;
1940
1941 /**
1942 * Pi = Punctuation, Initial Quote (Informative).
1943 *
1944 * @since 1.4
1945 */
1946 public static final byte INITIAL_QUOTE_PUNCTUATION = 29;
1947
1948 /**
1949 * Pf = Punctuation, Final Quote (Informative).
1950 *
1951 * @since 1.4
1952 */
1953 public static final byte FINAL_QUOTE_PUNCTUATION = 30;
1954
1955 /**
1956 * Po = Punctuation, Other (Informative).
1957 *
1958 * @since 1.1
1959 */
1960 public static final byte OTHER_PUNCTUATION = 24;
1961
1962 /**
1963 * Sm = Symbol, Math (Informative).
1964 *
1965 * @since 1.1
1966 */
1967 public static final byte MATH_SYMBOL = 25;
1968
1969 /**
1970 * Sc = Symbol, Currency (Informative).
1971 *
1972 * @since 1.1
1973 */
1974 public static final byte CURRENCY_SYMBOL = 26;
1975
1976 /**
1977 * Sk = Symbol, Modifier (Informative).
1978 *
1979 * @since 1.1
1980 */
1981 public static final byte MODIFIER_SYMBOL = 27;
1982
1983 /**
1984 * So = Symbol, Other (Informative).
1985 *
1986 * @since 1.1
1987 */
1988 public static final byte OTHER_SYMBOL = 28;
1989
1990 /**
1991 * Undefined bidirectional character type. Undefined char values have
1992 * undefined directionality in the Unicode specification.
1993 *
1994 * @since 1.4
1995 */
1996 public static final byte DIRECTIONALITY_UNDEFINED = -1;
1997
1998 /**
1999 * Strong bidirectional character type "L".
2000 *
2001 * @since 1.4
2002 */
2003 public static final byte DIRECTIONALITY_LEFT_TO_RIGHT = 0;
2004
2005 /**
2006 * Strong bidirectional character type "R".
2007 *
2008 * @since 1.4
2009 */
2010 public static final byte DIRECTIONALITY_RIGHT_TO_LEFT = 1;
2011
2012 /**
2013 * Strong bidirectional character type "AL".
2014 *
2015 * @since 1.4
2016 */
2017 public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC = 2;
2018
2019 /**
2020 * Weak bidirectional character type "EN".
2021 *
2022 * @since 1.4
2023 */
2024 public static final byte DIRECTIONALITY_EUROPEAN_NUMBER = 3;
2025
2026 /**
2027 * Weak bidirectional character type "ES".
2028 *
2029 * @since 1.4
2030 */
2031 public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR = 4;
2032
2033 /**
2034 * Weak bidirectional character type "ET".
2035 *
2036 * @since 1.4
2037 */
2038 public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR = 5;
2039
2040 /**
2041 * Weak bidirectional character type "AN".
2042 *
2043 * @since 1.4
2044 */
2045 public static final byte DIRECTIONALITY_ARABIC_NUMBER = 6;
2046
2047 /**
2048 * Weak bidirectional character type "CS".
2049 *
2050 * @since 1.4
2051 */
2052 public static final byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR = 7;
2053
2054 /**
2055 * Weak bidirectional character type "NSM".
2056 *
2057 * @since 1.4
2058 */
2059 public static final byte DIRECTIONALITY_NONSPACING_MARK = 8;
2060
2061 /**
2062 * Weak bidirectional character type "BN".
2063 *
2064 * @since 1.4
2065 */
2066 public static final byte DIRECTIONALITY_BOUNDARY_NEUTRAL = 9;
2067
2068 /**
2069 * Neutral bidirectional character type "B".
2070 *
2071 * @since 1.4
2072 */
2073 public static final byte DIRECTIONALITY_PARAGRAPH_SEPARATOR = 10;
2074
2075 /**
2076 * Neutral bidirectional character type "S".
2077 *
2078 * @since 1.4
2079 */
2080 public static final byte DIRECTIONALITY_SEGMENT_SEPARATOR = 11;
2081
2082 /**
2083 * Strong bidirectional character type "WS".
2084 *
2085 * @since 1.4
2086 */
2087 public static final byte DIRECTIONALITY_WHITESPACE = 12;
2088
2089 /**
2090 * Neutral bidirectional character type "ON".
2091 *
2092 * @since 1.4
2093 */
2094 public static final byte DIRECTIONALITY_OTHER_NEUTRALS = 13;
2095
2096 /**
2097 * Strong bidirectional character type "LRE".
2098 *
2099 * @since 1.4
2100 */
2101 public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING = 14;
2102
2103 /**
2104 * Strong bidirectional character type "LRO".
2105 *
2106 * @since 1.4
2107 */
2108 public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE = 15;
2109
2110 /**
2111 * Strong bidirectional character type "RLE".
2112 *
2113 * @since 1.4
2114 */
2115 public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING = 16;
2116
2117 /**
2118 * Strong bidirectional character type "RLO".
2119 *
2120 * @since 1.4
2121 */
2122 public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE = 17;
2123
2124 /**
2125 * Weak bidirectional character type "PDF".
2126 *
2127 * @since 1.4
2128 */
2129 public static final byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT = 18;
2130
2131 /**
2132 * Mask for grabbing the type out of the result of readChar.
2133 * @see #readChar(char)
2134 */
2135 private static final int TYPE_MASK = 0x1F;
2136
2137 /**
2138 * Mask for grabbing the non-breaking space flag out of the result of
2139 * readChar.
2140 * @see #readChar(char)
2141 */
2142 private static final int NO_BREAK_MASK = 0x20;
2143
2144 /**
2145 * Mask for grabbing the mirrored directionality flag out of the result
2146 * of readChar.
2147 * @see #readChar(char)
2148 */
2149 private static final int MIRROR_MASK = 0x40;
2150
2151 /**
2152 * Grabs an attribute offset from the Unicode attribute database. The lower
2153 * 5 bits are the character type, the next 2 bits are flags, and the top
2154 * 9 bits are the offset into the attribute tables. Note that the top 9
2155 * bits are meaningless in this context; they are useful only in the native
2156 * code.
2157 *
2158 * @param ch the character to look up
2159 * @return the character's attribute offset and type
2160 * @see #TYPE_MASK
2161 * @see #NO_BREAK_MASK
2162 * @see #MIRROR_MASK
2163 */
2164 private static native char readChar(char ch);
2165
2166 /**
2167 * Grabs an attribute offset from the Unicode attribute database. The lower
2168 * 5 bits are the character type, the next 2 bits are flags, and the top
2169 * 9 bits are the offset into the attribute tables. Note that the top 9
2170 * bits are meaningless in this context; they are useful only in the native
2171 * code.
2172 *
2173 * @param codePoint the character to look up
2174 * @return the character's attribute offset and type
2175 * @see #TYPE_MASK
2176 * @see #NO_BREAK_MASK
2177 * @see #MIRROR_MASK
2178 */
2179 private static native char readCodePoint(int codePoint);
2180
2181 /**
2182 * Wraps up a character.
2183 *
2184 * @param value the character to wrap
2185 */
2186 public Character(char value)
2187 {
2188 this.value = value;
2189 }
2190
2191 /**
2192 * Returns the character which has been wrapped by this class.
2193 *
2194 * @return the character wrapped
2195 */
2196 public char charValue()
2197 {
2198 return value;
2199 }
2200
2201 /**
2202 * Returns the numerical value (unsigned) of the wrapped character.
2203 * Range of returned values: 0x0000-0xFFFF.
2204 *
2205 * @return the value of the wrapped character
2206 */
2207 public int hashCode()
2208 {
2209 return value;
2210 }
2211
2212 /**
2213 * Determines if an object is equal to this object. This is only true for
2214 * another Character object wrapping the same value.
2215 *
2216 * @param o object to compare
2217 * @return true if o is a Character with the same value
2218 */
2219 public boolean equals(Object o)
2220 {
2221 return o instanceof Character && value == ((Character) o).value;
2222 }
2223
2224 /**
2225 * Converts the wrapped character into a String.
2226 *
2227 * @return a String containing one character -- the wrapped character
2228 * of this instance
2229 */
2230 public String toString()
2231 {
2232 // This assumes that String.valueOf(char) can create a single-character
2233 // String more efficiently than through the public API.
2234 return String.valueOf(value);
2235 }
2236
2237 /**
2238 * Returns a String of length 1 representing the specified character.
2239 *
2240 * @param ch the character to convert
2241 * @return a String containing the character
2242 * @since 1.4
2243 */
2244 public static String toString(char ch)
2245 {
2246 // This assumes that String.valueOf(char) can create a single-character
2247 // String more efficiently than through the public API.
2248 return String.valueOf(ch);
2249 }
2250
2251 /**
2252 * Determines if a character is a Unicode lowercase letter. For example,
2253 * <code>'a'</code> is lowercase.
2254 * <br>
2255 * lowercase = [Ll]
2256 *
2257 * @param ch character to test
2258 * @return true if ch is a Unicode lowercase letter, else false
2259 * @see #isUpperCase(char)
2260 * @see #isTitleCase(char)
2261 * @see #toLowerCase(char)
2262 * @see #getType(char)
2263 */
2264 public static boolean isLowerCase(char ch)
2265 {
2266 return getType(ch) == LOWERCASE_LETTER;
2267 }
2268
2269 /**
2270 * Determines if a character is a Unicode lowercase letter. For example,
2271 * <code>'a'</code> is lowercase. Unlike isLowerCase(char), this method
2272 * supports supplementary Unicode code points.
2273 * <br>
2274 * lowercase = [Ll]
2275 *
2276 * @param codePoint character to test
2277 * @return true if codePoint is a Unicode lowercase letter, else false
2278 * @see #isUpperCase(int)
2279 * @see #isTitleCase(int)
2280 * @see #toLowerCase(int)
2281 * @see #getType(int)
2282 * @since 1.5
2283 */
2284 public static boolean isLowerCase(int codePoint)
2285 {
2286 return getType(codePoint) == LOWERCASE_LETTER;
2287 }
2288
2289 /**
2290 * Determines if a character is a Unicode uppercase letter. For example,
2291 * <code>'A'</code> is uppercase.
2292 * <br>
2293 * uppercase = [Lu]
2294 *
2295 * @param ch character to test
2296 * @return true if ch is a Unicode uppercase letter, else false
2297 * @see #isLowerCase(char)
2298 * @see #isTitleCase(char)
2299 * @see #toUpperCase(char)
2300 * @see #getType(char)
2301 */
2302 public static boolean isUpperCase(char ch)
2303 {
2304 return getType(ch) == UPPERCASE_LETTER;
2305 }
2306
2307 /**
2308 * Determines if a character is a Unicode uppercase letter. For example,
2309 * <code>'A'</code> is uppercase. Unlike isUpperCase(char), this method
2310 * supports supplementary Unicode code points.
2311 * <br>
2312 * uppercase = [Lu]
2313 *
2314 * @param codePoint character to test
2315 * @return true if codePoint is a Unicode uppercase letter, else false
2316 * @see #isLowerCase(int)
2317 * @see #isTitleCase(int)
2318 * @see #toUpperCase(int)
2319 * @see #getType(int)
2320 * @since 1.5
2321 */
2322 public static boolean isUpperCase(int codePoint)
2323 {
2324 return getType(codePoint) == UPPERCASE_LETTER;
2325 }
2326
2327 /**
2328 * Determines if a character is a Unicode titlecase letter. For example,
2329 * the character "Lj" (Latin capital L with small letter j) is titlecase.
2330 * <br>
2331 * titlecase = [Lt]
2332 *
2333 * @param ch character to test
2334 * @return true if ch is a Unicode titlecase letter, else false
2335 * @see #isLowerCase(char)
2336 * @see #isUpperCase(char)
2337 * @see #toTitleCase(char)
2338 * @see #getType(char)
2339 */
2340 public static boolean isTitleCase(char ch)
2341 {
2342 return getType(ch) == TITLECASE_LETTER;
2343 }
2344
2345 /**
2346 * Determines if a character is a Unicode titlecase letter. For example,
2347 * the character "Lj" (Latin capital L with small letter j) is titlecase.
2348 * Unlike isTitleCase(char), this method supports supplementary Unicode
2349 * code points.
2350 * <br>
2351 * titlecase = [Lt]
2352 *
2353 * @param codePoint character to test
2354 * @return true if codePoint is a Unicode titlecase letter, else false
2355 * @see #isLowerCase(int)
2356 * @see #isUpperCase(int)
2357 * @see #toTitleCase(int)
2358 * @see #getType(int)
2359 * @since 1.5
2360 */
2361 public static boolean isTitleCase(int codePoint)
2362 {
2363 return getType(codePoint) == TITLECASE_LETTER;
2364 }
2365
2366 /**
2367 * Determines if a character is a Unicode decimal digit. For example,
2368 * <code>'0'</code> is a digit.
2369 * <br>
2370 * Unicode decimal digit = [Nd]
2371 *
2372 * @param ch character to test
2373 * @return true if ch is a Unicode decimal digit, else false
2374 * @see #digit(char, int)
2375 * @see #forDigit(int, int)
2376 * @see #getType(char)
2377 */
2378 public static boolean isDigit(char ch)
2379 {
2380 return getType(ch) == DECIMAL_DIGIT_NUMBER;
2381 }
2382
2383 /**
2384 * Determines if a character is a Unicode decimal digit. For example,
2385 * <code>'0'</code> is a digit. Unlike isDigit(char), this method
2386 * supports supplementary Unicode code points.
2387 * <br>
2388 * Unicode decimal digit = [Nd]
2389 *
2390 * @param codePoint character to test
2391 * @return true if ccodePoint is a Unicode decimal digit, else false
2392 * @see #digit(int, int)
2393 * @see #forDigit(int, int)
2394 * @see #getType(int)
2395 * @since 1.5
2396 */
2397 public static boolean isDigit(int codePoint)
2398 {
2399 return getType(codePoint) == DECIMAL_DIGIT_NUMBER;
2400 }
2401
2402 /**
2403 * Determines if a character is part of the Unicode Standard. This is an
2404 * evolving standard, but covers every character in the data file.
2405 * <br>
2406 * defined = not [Cn]
2407 *
2408 * @param ch character to test
2409 * @return true if ch is a Unicode character, else false
2410 * @see #isDigit(char)
2411 * @see #isLetter(char)
2412 * @see #isLetterOrDigit(char)
2413 * @see #isLowerCase(char)
2414 * @see #isTitleCase(char)
2415 * @see #isUpperCase(char)
2416 */
2417 public static boolean isDefined(char ch)
2418 {
2419 return getType(ch) != UNASSIGNED;
2420 }
2421
2422 /**
2423 * Determines if a character is part of the Unicode Standard. This is an
2424 * evolving standard, but covers every character in the data file. Unlike
2425 * isDefined(char), this method supports supplementary Unicode code points.
2426 * <br>
2427 * defined = not [Cn]
2428 *
2429 * @param codePoint character to test
2430 * @return true if codePoint is a Unicode character, else false
2431 * @see #isDigit(int)
2432 * @see #isLetter(int)
2433 * @see #isLetterOrDigit(int)
2434 * @see #isLowerCase(int)
2435 * @see #isTitleCase(int)
2436 * @see #isUpperCase(int)
2437 * @since 1.5
2438 */
2439 public static boolean isDefined(int codePoint)
2440 {
2441 return getType(codePoint) != UNASSIGNED;
2442 }
2443
2444 /**
2445 * Determines if a character is a Unicode letter. Not all letters have case,
2446 * so this may return true when isLowerCase and isUpperCase return false.
2447 * <br>
2448 * letter = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]
2449 *
2450 * @param ch character to test
2451 * @return true if ch is a Unicode letter, else false
2452 * @see #isDigit(char)
2453 * @see #isJavaIdentifierStart(char)
2454 * @see #isJavaLetter(char)
2455 * @see #isJavaLetterOrDigit(char)
2456 * @see #isLetterOrDigit(char)
2457 * @see #isLowerCase(char)
2458 * @see #isTitleCase(char)
2459 * @see #isUnicodeIdentifierStart(char)
2460 * @see #isUpperCase(char)
2461 */
2462 public static boolean isLetter(char ch)
2463 {
2464 return ((1 << getType(ch))
2465 & ((1 << UPPERCASE_LETTER)
2466 | (1 << LOWERCASE_LETTER)
2467 | (1 << TITLECASE_LETTER)
2468 | (1 << MODIFIER_LETTER)
2469 | (1 << OTHER_LETTER))) != 0;
2470 }
2471
2472 /**
2473 * Determines if a character is a Unicode letter. Not all letters have case,
2474 * so this may return true when isLowerCase and isUpperCase return false.
2475 * Unlike isLetter(char), this method supports supplementary Unicode code
2476 * points.
2477 * <br>
2478 * letter = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]
2479 *
2480 * @param codePoint character to test
2481 * @return true if codePoint is a Unicode letter, else false
2482 * @see #isDigit(int)
2483 * @see #isJavaIdentifierStart(int)
2484 * @see #isJavaLetter(int)
2485 * @see #isJavaLetterOrDigit(int)
2486 * @see #isLetterOrDigit(int)
2487 * @see #isLowerCase(int)
2488 * @see #isTitleCase(int)
2489 * @see #isUnicodeIdentifierStart(int)
2490 * @see #isUpperCase(int)
2491 * @since 1.5
2492 */
2493 public static boolean isLetter(int codePoint)
2494 {
2495 return ((1 << getType(codePoint))
2496 & ((1 << UPPERCASE_LETTER)
2497 | (1 << LOWERCASE_LETTER)
2498 | (1 << TITLECASE_LETTER)
2499 | (1 << MODIFIER_LETTER)
2500 | (1 << OTHER_LETTER))) != 0;
2501 }
2502
2503 /**
2504 * Returns the index into the given CharSequence that is offset
2505 * <code>codePointOffset</code> code points from <code>index</code>.
2506 * @param seq the CharSequence
2507 * @param index the start position in the CharSequence
2508 * @param codePointOffset the number of code points offset from the start
2509 * position
2510 * @return the index into the CharSequence that is codePointOffset code
2511 * points offset from index
2512 *
2513 * @throws NullPointerException if seq is null
2514 * @throws IndexOutOfBoundsException if index is negative or greater than the
2515 * length of the sequence.
2516 * @throws IndexOutOfBoundsException if codePointOffset is positive and the
2517 * subsequence from index to the end of seq has fewer than codePointOffset
2518 * code points
2519 * @throws IndexOutOfBoundsException if codePointOffset is negative and the
2520 * subsequence from the start of seq to index has fewer than
2521 * (-codePointOffset) code points
2522 * @since 1.5
2523 */
2524 public static int offsetByCodePoints(CharSequence seq,
2525 int index,
2526 int codePointOffset)
2527 {
2528 int len = seq.length();
2529 if (index < 0 || index > len)
2530 throw new IndexOutOfBoundsException();
2531
2532 int numToGo = codePointOffset;
2533 int offset = index;
2534 int adjust = 1;
2535 if (numToGo >= 0)
2536 {
2537 for (; numToGo > 0; offset++)
2538 {
2539 numToGo--;
2540 if (Character.isHighSurrogate(seq.charAt(offset))
2541 && (offset + 1) < len
2542 && Character.isLowSurrogate(seq.charAt(offset + 1)))
2543 offset++;
2544 }
2545 return offset;
2546 }
2547 else
2548 {
2549 numToGo *= -1;
2550 for (; numToGo > 0;)
2551 {
2552 numToGo--;
2553 offset--;
2554 if (Character.isLowSurrogate(seq.charAt(offset))
2555 && (offset - 1) >= 0
2556 && Character.isHighSurrogate(seq.charAt(offset - 1)))
2557 offset--;
2558 }
2559 return offset;
2560 }
2561 }
2562
2563 /**
2564 * Returns the index into the given char subarray that is offset
2565 * <code>codePointOffset</code> code points from <code>index</code>.
2566 * @param a the char array
2567 * @param start the start index of the subarray
2568 * @param count the length of the subarray
2569 * @param index the index to be offset
2570 * @param codePointOffset the number of code points offset from <code>index
2571 * </code>
2572 * @return the index into the char array
2573 *
2574 * @throws NullPointerException if a is null
2575 * @throws IndexOutOfBoundsException if start or count is negative or if
2576 * start + count is greater than the length of the array
2577 * @throws IndexOutOfBoundsException if index is less than start or larger
2578 * than start + count
2579 * @throws IndexOutOfBoundsException if codePointOffset is positive and the
2580 * subarray from index to start + count - 1 has fewer than codePointOffset
2581 * code points.
2582 * @throws IndexOutOfBoundsException if codePointOffset is negative and the
2583 * subarray from start to index - 1 has fewer than (-codePointOffset) code
2584 * points
2585 * @since 1.5
2586
2587 */
2588 public static int offsetByCodePoints(char[] a,
2589 int start,
2590 int count,
2591 int index,
2592 int codePointOffset)
2593 {
2594 int len = a.length;
2595 int end = start + count;
2596 if (start < 0 || count < 0 || end > len || index < start || index > end)
2597 throw new IndexOutOfBoundsException();
2598
2599 int numToGo = codePointOffset;
2600 int offset = index;
2601 int adjust = 1;
2602 if (numToGo >= 0)
2603 {
2604 for (; numToGo > 0; offset++)
2605 {
2606 numToGo--;
2607 if (Character.isHighSurrogate(a[offset])
2608 && (offset + 1) < len
2609 && Character.isLowSurrogate(a[offset + 1]))
2610 offset++;
2611 }
2612 return offset;
2613 }
2614 else
2615 {
2616 numToGo *= -1;
2617 for (; numToGo > 0;)
2618 {
2619 numToGo--;
2620 offset--;
2621 if (Character.isLowSurrogate(a[offset])
2622 && (offset - 1) >= 0
2623 && Character.isHighSurrogate(a[offset - 1]))
2624 offset--;
2625 if (offset < start)
2626 throw new IndexOutOfBoundsException();
2627 }
2628 return offset;
2629 }
2630
2631 }
2632
2633 /**
2634 * Returns the number of Unicode code points in the specified range of the
2635 * given CharSequence. The first char in the range is at position
2636 * beginIndex and the last one is at position endIndex - 1. Paired
2637 * surrogates (supplementary characters are represented by a pair of chars -
2638 * one from the high surrogates and one from the low surrogates)
2639 * count as just one code point.
2640 * @param seq the CharSequence to inspect
2641 * @param beginIndex the beginning of the range
2642 * @param endIndex the end of the range
2643 * @return the number of Unicode code points in the given range of the
2644 * sequence
2645 * @throws NullPointerException if seq is null
2646 * @throws IndexOutOfBoundsException if beginIndex is negative, endIndex is
2647 * larger than the length of seq, or if beginIndex is greater than endIndex.
2648 * @since 1.5
2649 */
2650 public static int codePointCount(CharSequence seq, int beginIndex,
2651 int endIndex)
2652 {
2653 int len = seq.length();
2654 if (beginIndex < 0 || endIndex > len || beginIndex > endIndex)
2655 throw new IndexOutOfBoundsException();
2656
2657 int count = 0;
2658 for (int i = beginIndex; i < endIndex; i++)
2659 {
2660 count++;
2661 // If there is a pairing, count it only once.
2662 if (isHighSurrogate(seq.charAt(i)) && (i + 1) < endIndex
2663 && isLowSurrogate(seq.charAt(i + 1)))
2664 i ++;
2665 }
2666 return count;
2667 }
2668
2669 /**
2670 * Returns the number of Unicode code points in the specified range of the
2671 * given char array. The first char in the range is at position
2672 * offset and the length of the range is count. Paired surrogates
2673 * (supplementary characters are represented by a pair of chars -
2674 * one from the high surrogates and one from the low surrogates)
2675 * count as just one code point.
2676 * @param a the char array to inspect
2677 * @param offset the beginning of the range
2678 * @param count the length of the range
2679 * @return the number of Unicode code points in the given range of the
2680 * array
2681 * @throws NullPointerException if a is null
2682 * @throws IndexOutOfBoundsException if offset or count is negative or if
2683 * offset + countendIndex is larger than the length of a.
2684 * @since 1.5
2685 */
2686 public static int codePointCount(char[] a, int offset,
2687 int count)
2688 {
2689 int len = a.length;
2690 int end = offset + count;
2691 if (offset < 0 || count < 0 || end > len)
2692 throw new IndexOutOfBoundsException();
2693
2694 int counter = 0;
2695 for (int i = offset; i < end; i++)
2696 {
2697 counter++;
2698 // If there is a pairing, count it only once.
2699 if (isHighSurrogate(a[i]) && (i + 1) < end
2700 && isLowSurrogate(a[i + 1]))
2701 i ++;
2702 }
2703 return counter;
2704 }
2705
2706 /**
2707 * Determines if a character is a Unicode letter or a Unicode digit. This
2708 * is the combination of isLetter and isDigit.
2709 * <br>
2710 * letter or digit = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nd]
2711 *
2712 * @param ch character to test
2713 * @return true if ch is a Unicode letter or a Unicode digit, else false
2714 * @see #isDigit(char)
2715 * @see #isJavaIdentifierPart(char)
2716 * @see #isJavaLetter(char)
2717 * @see #isJavaLetterOrDigit(char)
2718 * @see #isLetter(char)
2719 * @see #isUnicodeIdentifierPart(char)
2720 */
2721 public static boolean isLetterOrDigit(char ch)
2722 {
2723 return ((1 << getType(ch))
2724 & ((1 << UPPERCASE_LETTER)
2725 | (1 << LOWERCASE_LETTER)
2726 | (1 << TITLECASE_LETTER)
2727 | (1 << MODIFIER_LETTER)
2728 | (1 << OTHER_LETTER)
2729 | (1 << DECIMAL_DIGIT_NUMBER))) != 0;
2730 }
2731
2732 /**
2733 * Determines if a character is a Unicode letter or a Unicode digit. This
2734 * is the combination of isLetter and isDigit. Unlike isLetterOrDigit(char),
2735 * this method supports supplementary Unicode code points.
2736 * <br>
2737 * letter or digit = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nd]
2738 *
2739 * @param codePoint character to test
2740 * @return true if codePoint is a Unicode letter or a Unicode digit, else false
2741 * @see #isDigit(int)
2742 * @see #isJavaIdentifierPart(int)
2743 * @see #isJavaLetter(int)
2744 * @see #isJavaLetterOrDigit(int)
2745 * @see #isLetter(int)
2746 * @see #isUnicodeIdentifierPart(int)
2747 * @since 1.5
2748 */
2749 public static boolean isLetterOrDigit(int codePoint)
2750 {
2751 return ((1 << getType(codePoint)
2752 & ((1 << UPPERCASE_LETTER)
2753 | (1 << LOWERCASE_LETTER)
2754 | (1 << TITLECASE_LETTER)
2755 | (1 << MODIFIER_LETTER)
2756 | (1 << OTHER_LETTER)
2757 | (1 << DECIMAL_DIGIT_NUMBER))) != 0);
2758 }
2759
2760 /**
2761 * Determines if a character can start a Java identifier. This is the
2762 * combination of isLetter, any character where getType returns
2763 * LETTER_NUMBER, currency symbols (like '$'), and connecting punctuation
2764 * (like '_').
2765 *
2766 * @param ch character to test
2767 * @return true if ch can start a Java identifier, else false
2768 * @deprecated Replaced by {@link #isJavaIdentifierStart(char)}
2769 * @see #isJavaLetterOrDigit(char)
2770 * @see #isJavaIdentifierStart(char)
2771 * @see #isJavaIdentifierPart(char)
2772 * @see #isLetter(char)
2773 * @see #isLetterOrDigit(char)
2774 * @see #isUnicodeIdentifierStart(char)
2775 */
2776 public static boolean isJavaLetter(char ch)
2777 {
2778 return isJavaIdentifierStart(ch);
2779 }
2780
2781 /**
2782 * Determines if a character can start a Java identifier. This is the
2783 * combination of isLetter, any character where getType returns
2784 * LETTER_NUMBER, currency symbols (like '$'), and connecting punctuation
2785 * (like '_'). Unlike isJavaIdentifierStart(char), this method supports
2786 * supplementary Unicode code points.
2787 * <br>
2788 * Java identifier start = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Sc]|[Pc]
2789 *
2790 * @param codePoint character to test
2791 * @return true if codePoint can start a Java identifier, else false
2792 * @see #isJavaIdentifierPart(int)
2793 * @see #isLetter(int)
2794 * @see #isUnicodeIdentifierStart(int)
2795 * @since 1.5
2796 */
2797 public static boolean isJavaIdentifierStart(int codePoint)
2798 {
2799 return ((1 << getType(codePoint))
2800 & ((1 << UPPERCASE_LETTER)
2801 | (1 << LOWERCASE_LETTER)
2802 | (1 << TITLECASE_LETTER)
2803 | (1 << MODIFIER_LETTER)
2804 | (1 << OTHER_LETTER)
2805 | (1 << LETTER_NUMBER)
2806 | (1 << CURRENCY_SYMBOL)
2807 | (1 << CONNECTOR_PUNCTUATION))) != 0;
2808 }
2809
2810 /**
2811 * Determines if a character can follow the first letter in
2812 * a Java identifier. This is the combination of isJavaLetter (isLetter,
2813 * type of LETTER_NUMBER, currency, connecting punctuation) and digit,
2814 * numeric letter (like Roman numerals), combining marks, non-spacing marks,
2815 * or isIdentifierIgnorable.
2816 *
2817 * @param ch character to test
2818 * @return true if ch can follow the first letter in a Java identifier
2819 * @deprecated Replaced by {@link #isJavaIdentifierPart(char)}
2820 * @see #isJavaLetter(char)
2821 * @see #isJavaIdentifierStart(char)
2822 * @see #isJavaIdentifierPart(char)
2823 * @see #isLetter(char)
2824 * @see #isLetterOrDigit(char)
2825 * @see #isUnicodeIdentifierPart(char)
2826 * @see #isIdentifierIgnorable(char)
2827 */
2828 public static boolean isJavaLetterOrDigit(char ch)
2829 {
2830 return isJavaIdentifierPart(ch);
2831 }
2832
2833 /**
2834 * Determines if a character can start a Java identifier. This is the
2835 * combination of isLetter, any character where getType returns
2836 * LETTER_NUMBER, currency symbols (like '$'), and connecting punctuation
2837 * (like '_').
2838 * <br>
2839 * Java identifier start = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Sc]|[Pc]
2840 *
2841 * @param ch character to test
2842 * @return true if ch can start a Java identifier, else false
2843 * @see #isJavaIdentifierPart(char)
2844 * @see #isLetter(char)
2845 * @see #isUnicodeIdentifierStart(char)
2846 * @since 1.1
2847 */
2848 public static boolean isJavaIdentifierStart(char ch)
2849 {
2850 return ((1 << getType(ch))
2851 & ((1 << UPPERCASE_LETTER)
2852 | (1 << LOWERCASE_LETTER)
2853 | (1 << TITLECASE_LETTER)
2854 | (1 << MODIFIER_LETTER)
2855 | (1 << OTHER_LETTER)
2856 | (1 << LETTER_NUMBER)
2857 | (1 << CURRENCY_SYMBOL)
2858 | (1 << CONNECTOR_PUNCTUATION))) != 0;
2859 }
2860
2861 /**
2862 * Determines if a character can follow the first letter in
2863 * a Java identifier. This is the combination of isJavaLetter (isLetter,
2864 * type of LETTER_NUMBER, currency, connecting punctuation) and digit,
2865 * numeric letter (like Roman numerals), combining marks, non-spacing marks,
2866 * or isIdentifierIgnorable.
2867 * <br>
2868 * Java identifier extender =
2869 * [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Sc]|[Pc]|[Mn]|[Mc]|[Nd]|[Cf]
2870 * |U+0000-U+0008|U+000E-U+001B|U+007F-U+009F
2871 *
2872 * @param ch character to test
2873 * @return true if ch can follow the first letter in a Java identifier
2874 * @see #isIdentifierIgnorable(char)
2875 * @see #isJavaIdentifierStart(char)
2876 * @see #isLetterOrDigit(char)
2877 * @see #isUnicodeIdentifierPart(char)
2878 * @since 1.1
2879 */
2880 public static boolean isJavaIdentifierPart(char ch)
2881 {
2882 int category = getType(ch);
2883 return ((1 << category)
2884 & ((1 << UPPERCASE_LETTER)
2885 | (1 << LOWERCASE_LETTER)
2886 | (1 << TITLECASE_LETTER)
2887 | (1 << MODIFIER_LETTER)
2888 | (1 << OTHER_LETTER)
2889 | (1 << NON_SPACING_MARK)
2890 | (1 << COMBINING_SPACING_MARK)
2891 | (1 << DECIMAL_DIGIT_NUMBER)
2892 | (1 << LETTER_NUMBER)
2893 | (1 << CURRENCY_SYMBOL)
2894 | (1 << CONNECTOR_PUNCTUATION)
2895 | (1 << FORMAT))) != 0
2896 || (category == CONTROL && isIdentifierIgnorable(ch));
2897 }
2898
2899 /**
2900 * Determines if a character can follow the first letter in
2901 * a Java identifier. This is the combination of isJavaLetter (isLetter,
2902 * type of LETTER_NUMBER, currency, connecting punctuation) and digit,
2903 * numeric letter (like Roman numerals), combining marks, non-spacing marks,
2904 * or isIdentifierIgnorable. Unlike isJavaIdentifierPart(char), this method
2905 * supports supplementary Unicode code points.
2906 * <br>
2907 * Java identifier extender =
2908 * [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Sc]|[Pc]|[Mn]|[Mc]|[Nd]|[Cf]
2909 * |U+0000-U+0008|U+000E-U+001B|U+007F-U+009F
2910 *
2911 * @param codePoint character to test
2912 * @return true if codePoint can follow the first letter in a Java identifier
2913 * @see #isIdentifierIgnorable(int)
2914 * @see #isJavaIdentifierStart(int)
2915 * @see #isLetterOrDigit(int)
2916 * @see #isUnicodeIdentifierPart(int)
2917 * @since 1.5
2918 */
2919 public static boolean isJavaIdentifierPart(int codePoint)
2920 {
2921 int category = getType(codePoint);
2922 return ((1 << category)
2923 & ((1 << UPPERCASE_LETTER)
2924 | (1 << LOWERCASE_LETTER)
2925 | (1 << TITLECASE_LETTER)
2926 | (1 << MODIFIER_LETTER)
2927 | (1 << OTHER_LETTER)
2928 | (1 << NON_SPACING_MARK)
2929 | (1 << COMBINING_SPACING_MARK)
2930 | (1 << DECIMAL_DIGIT_NUMBER)
2931 | (1 << LETTER_NUMBER)
2932 | (1 << CURRENCY_SYMBOL)
2933 | (1 << CONNECTOR_PUNCTUATION)
2934 | (1 << FORMAT))) != 0
2935 || (category == CONTROL && isIdentifierIgnorable(codePoint));
2936 }
2937
2938 /**
2939 * Determines if a character can start a Unicode identifier. Only
2940 * letters can start a Unicode identifier, but this includes characters
2941 * in LETTER_NUMBER.
2942 * <br>
2943 * Unicode identifier start = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]
2944 *
2945 * @param ch character to test
2946 * @return true if ch can start a Unicode identifier, else false
2947 * @see #isJavaIdentifierStart(char)
2948 * @see #isLetter(char)
2949 * @see #isUnicodeIdentifierPart(char)
2950 * @since 1.1
2951 */
2952 public static boolean isUnicodeIdentifierStart(char ch)
2953 {
2954 return ((1 << getType(ch))
2955 & ((1 << UPPERCASE_LETTER)
2956 | (1 << LOWERCASE_LETTER)
2957 | (1 << TITLECASE_LETTER)
2958 | (1 << MODIFIER_LETTER)
2959 | (1 << OTHER_LETTER)
2960 | (1 << LETTER_NUMBER))) != 0;
2961 }
2962
2963 /**
2964 * Determines if a character can start a Unicode identifier. Only
2965 * letters can start a Unicode identifier, but this includes characters
2966 * in LETTER_NUMBER. Unlike isUnicodeIdentifierStart(char), this method
2967 * supports supplementary Unicode code points.
2968 * <br>
2969 * Unicode identifier start = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]
2970 *
2971 * @param codePoint character to test
2972 * @return true if codePoint can start a Unicode identifier, else false
2973 * @see #isJavaIdentifierStart(int)
2974 * @see #isLetter(int)
2975 * @see #isUnicodeIdentifierPart(int)
2976 * @since 1.5
2977 */
2978 public static boolean isUnicodeIdentifierStart(int codePoint)
2979 {
2980 return ((1 << getType(codePoint))
2981 & ((1 << UPPERCASE_LETTER)
2982 | (1 << LOWERCASE_LETTER)
2983 | (1 << TITLECASE_LETTER)
2984 | (1 << MODIFIER_LETTER)
2985 | (1 << OTHER_LETTER)
2986 | (1 << LETTER_NUMBER))) != 0;
2987 }
2988
2989 /**
2990 * Determines if a character can follow the first letter in
2991 * a Unicode identifier. This includes letters, connecting punctuation,
2992 * digits, numeric letters, combining marks, non-spacing marks, and
2993 * isIdentifierIgnorable.
2994 * <br>
2995 * Unicode identifier extender =
2996 * [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Mn]|[Mc]|[Nd]|[Pc]|[Cf]|
2997 * |U+0000-U+0008|U+000E-U+001B|U+007F-U+009F
2998 *
2999 * @param ch character to test
3000 * @return true if ch can follow the first letter in a Unicode identifier
3001 * @see #isIdentifierIgnorable(char)
3002 * @see #isJavaIdentifierPart(char)
3003 * @see #isLetterOrDigit(char)
3004 * @see #isUnicodeIdentifierStart(char)
3005 * @since 1.1
3006 */
3007 public static boolean isUnicodeIdentifierPart(char ch)
3008 {
3009 int category = getType(ch);
3010 return ((1 << category)
3011 & ((1 << UPPERCASE_LETTER)
3012 | (1 << LOWERCASE_LETTER)
3013 | (1 << TITLECASE_LETTER)
3014 | (1 << MODIFIER_LETTER)
3015 | (1 << OTHER_LETTER)
3016 | (1 << NON_SPACING_MARK)
3017 | (1 << COMBINING_SPACING_MARK)
3018 | (1 << DECIMAL_DIGIT_NUMBER)
3019 | (1 << LETTER_NUMBER)
3020 | (1 << CONNECTOR_PUNCTUATION)
3021 | (1 << FORMAT))) != 0
3022 || (category == CONTROL && isIdentifierIgnorable(ch));
3023 }
3024
3025 /**
3026 * Determines if a character can follow the first letter in
3027 * a Unicode identifier. This includes letters, connecting punctuation,
3028 * digits, numeric letters, combining marks, non-spacing marks, and
3029 * isIdentifierIgnorable. Unlike isUnicodeIdentifierPart(char), this method
3030 * supports supplementary Unicode code points.
3031 * <br>
3032 * Unicode identifier extender =
3033 * [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Mn]|[Mc]|[Nd]|[Pc]|[Cf]|
3034 * |U+0000-U+0008|U+000E-U+001B|U+007F-U+009F
3035 *
3036 * @param codePoint character to test
3037 * @return true if codePoint can follow the first letter in a Unicode
3038 * identifier
3039 * @see #isIdentifierIgnorable(int)
3040 * @see #isJavaIdentifierPart(int)
3041 * @see #isLetterOrDigit(int)
3042 * @see #isUnicodeIdentifierStart(int)
3043 * @since 1.5
3044 */
3045 public static boolean isUnicodeIdentifierPart(int codePoint)
3046 {
3047 int category = getType(codePoint);
3048 return ((1 << category)
3049 & ((1 << UPPERCASE_LETTER)
3050 | (1 << LOWERCASE_LETTER)
3051 | (1 << TITLECASE_LETTER)
3052 | (1 << MODIFIER_LETTER)
3053 | (1 << OTHER_LETTER)
3054 | (1 << NON_SPACING_MARK)
3055 | (1 << COMBINING_SPACING_MARK)
3056 | (1 << DECIMAL_DIGIT_NUMBER)
3057 | (1 << LETTER_NUMBER)
3058 | (1 << CONNECTOR_PUNCTUATION)
3059 | (1 << FORMAT))) != 0
3060 || (category == CONTROL && isIdentifierIgnorable(codePoint));
3061 }
3062
3063 /**
3064 * Determines if a character is ignorable in a Unicode identifier. This
3065 * includes the non-whitespace ISO control characters (<code>'\u0000'</code>
3066 * through <code>'\u0008'</code>, <code>'\u000E'</code> through
3067 * <code>'\u001B'</code>, and <code>'\u007F'</code> through
3068 * <code>'\u009F'</code>), and FORMAT characters.
3069 * <br>
3070 * Unicode identifier ignorable = [Cf]|U+0000-U+0008|U+000E-U+001B
3071 * |U+007F-U+009F
3072 *
3073 * @param ch character to test
3074 * @return true if ch is ignorable in a Unicode or Java identifier
3075 * @see #isJavaIdentifierPart(char)
3076 * @see #isUnicodeIdentifierPart(char)
3077 * @since 1.1
3078 */
3079 public static boolean isIdentifierIgnorable(char ch)
3080 {
3081 return (ch <= '\u009F' && (ch < '\t' || ch >= '\u007F'
3082 || (ch <= '\u001B' && ch >= '\u000E')))
3083 || getType(ch) == FORMAT;
3084 }
3085
3086 /**
3087 * Determines if a character is ignorable in a Unicode identifier. This
3088 * includes the non-whitespace ISO control characters (<code>'\u0000'</code>
3089 * through <code>'\u0008'</code>, <code>'\u000E'</code> through
3090 * <code>'\u001B'</code>, and <code>'\u007F'</code> through
3091 * <code>'\u009F'</code>), and FORMAT characters. Unlike
3092 * isIdentifierIgnorable(char), this method supports supplementary Unicode
3093 * code points.
3094 * <br>
3095 * Unicode identifier ignorable = [Cf]|U+0000-U+0008|U+000E-U+001B
3096 * |U+007F-U+009F
3097 *
3098 * @param codePoint character to test
3099 * @return true if codePoint is ignorable in a Unicode or Java identifier
3100 * @see #isJavaIdentifierPart(int)
3101 * @see #isUnicodeIdentifierPart(int)
3102 * @since 1.5
3103 */
3104 public static boolean isIdentifierIgnorable(int codePoint)
3105 {
3106 return ((codePoint >= 0 && codePoint <= 0x0008)
3107 || (codePoint >= 0x000E && codePoint <= 0x001B)
3108 || (codePoint >= 0x007F && codePoint <= 0x009F)
3109 || getType(codePoint) == FORMAT);
3110 }
3111
3112 /**
3113 * Converts a Unicode character into its lowercase equivalent mapping.
3114 * If a mapping does not exist, then the character passed is returned.
3115 * Note that isLowerCase(toLowerCase(ch)) does not always return true.
3116 *
3117 * @param ch character to convert to lowercase
3118 * @return lowercase mapping of ch, or ch if lowercase mapping does
3119 * not exist
3120 * @see #isLowerCase(char)
3121 * @see #isUpperCase(char)
3122 * @see #toTitleCase(char)
3123 * @see #toUpperCase(char)
3124 */
3125 public static native char toLowerCase(char ch);
3126
3127 /**
3128 * Converts a Unicode character into its lowercase equivalent mapping.
3129 * If a mapping does not exist, then the character passed is returned.
3130 * Note that isLowerCase(toLowerCase(codePoint)) does not always return true.
3131 * Unlike toLowerCase(char), this method supports supplementary Unicode
3132 * code points.
3133 *
3134 * @param codePoint character to convert to lowercase
3135 * @return lowercase mapping of codePoint, or codePoint if lowercase
3136 * mapping does not exist
3137 * @see #isLowerCase(int)
3138 * @see #isUpperCase(int)
3139 * @see #toTitleCase(int)
3140 * @see #toUpperCase(int)
3141 * @since 1.5
3142 */
3143 public static native int toLowerCase(int codePoint);
3144
3145 /**
3146 * Converts a Unicode character into its uppercase equivalent mapping.
3147 * If a mapping does not exist, then the character passed is returned.
3148 * Note that isUpperCase(toUpperCase(ch)) does not always return true.
3149 *
3150 * @param ch character to convert to uppercase
3151 * @return uppercase mapping of ch, or ch if uppercase mapping does
3152 * not exist
3153 * @see #isLowerCase(char)
3154 * @see #isUpperCase(char)
3155 * @see #toLowerCase(char)
3156 * @see #toTitleCase(char)
3157 */
3158 public static native char toUpperCase(char ch);
3159
3160 /**
3161 * Converts a Unicode character into its uppercase equivalent mapping.
3162 * If a mapping does not exist, then the character passed is returned.
3163 * Note that isUpperCase(toUpperCase(codePoint)) does not always return true.
3164 * Unlike toUpperCase(char), this method supports supplementary
3165 * Unicode code points.
3166 *
3167 * @param codePoint character to convert to uppercase
3168 * @return uppercase mapping of codePoint, or codePoint if uppercase
3169 * mapping does not exist
3170 * @see #isLowerCase(int)
3171 * @see #isUpperCase(int)
3172 * @see #toLowerCase(int)
3173 * @see #toTitleCase(int)
3174 * @since 1.5
3175 */
3176 public static native int toUpperCase(int codePoint);
3177
3178 /**
3179 * Converts a Unicode character into its titlecase equivalent mapping.
3180 * If a mapping does not exist, then the character passed is returned.
3181 * Note that isTitleCase(toTitleCase(ch)) does not always return true.
3182 *
3183 * @param ch character to convert to titlecase
3184 * @return titlecase mapping of ch, or ch if titlecase mapping does
3185 * not exist
3186 * @see #isTitleCase(char)
3187 * @see #toLowerCase(char)
3188 * @see #toUpperCase(char)
3189 */
3190 public static native char toTitleCase(char ch);
3191
3192 /**
3193 * Converts a Unicode character into its titlecase equivalent mapping.
3194 * If a mapping does not exist, then the character passed is returned.
3195 * Note that isTitleCase(toTitleCase(codePoint)) does not always return true.
3196 * Unlike toTitleCase(char), this method supports supplementary
3197 * Unicode code points.
3198 *
3199 * @param codePoint character to convert to titlecase
3200 * @return titlecase mapping of codePoint, or codePoint if titlecase
3201 * mapping does not exist
3202 * @see #isTitleCase(int)
3203 * @see #toLowerCase(int)
3204 * @see #toUpperCase(int)
3205 * @since 1.5
3206 */
3207 public static native int toTitleCase(int codePoint);
3208
3209 /**
3210 * Converts a character into a digit of the specified radix. If the radix
3211 * exceeds MIN_RADIX or MAX_RADIX, or if the result of getNumericValue(ch)
3212 * exceeds the radix, or if ch is not a decimal digit or in the case
3213 * insensitive set of 'a'-'z', the result is -1.
3214 * <br>
3215 * character argument boundary = [Nd]|U+0041-U+005A|U+0061-U+007A
3216 * |U+FF21-U+FF3A|U+FF41-U+FF5A
3217 *
3218 * @param ch character to convert into a digit
3219 * @param radix radix in which ch is a digit
3220 * @return digit which ch represents in radix, or -1 not a valid digit
3221 * @see #MIN_RADIX
3222 * @see #MAX_RADIX
3223 * @see #forDigit(int, int)
3224 * @see #isDigit(char)
3225 * @see #getNumericValue(char)
3226 */
3227 public static native int digit(char ch, int radix);
3228
3229 /**
3230 * Converts a character into a digit of the specified radix. If the radix
3231 * exceeds MIN_RADIX or MAX_RADIX, or if the result of getNumericValue(int)
3232 * exceeds the radix, or if codePoint is not a decimal digit or in the case
3233 * insensitive set of 'a'-'z', the result is -1. Unlike digit(char, int),
3234 * this method supports supplementary Unicode code points.
3235 * <br>
3236 * character argument boundary = [Nd]|U+0041-U+005A|U+0061-U+007A
3237 * |U+FF21-U+FF3A|U+FF41-U+FF5A
3238 *
3239 * @param codePoint character to convert into a digit
3240 * @param radix radix in which codePoint is a digit
3241 * @return digit which codePoint represents in radix, or -1 not a valid digit
3242 * @see #MIN_RADIX
3243 * @see #MAX_RADIX
3244 * @see #forDigit(int, int)
3245 * @see #isDigit(int)
3246 * @see #getNumericValue(int)
3247 * @since 1.5
3248 */
3249 public static native int digit(int codePoint, int radix);
3250
3251 /**
3252 * Returns the Unicode numeric value property of a character. For example,
3253 * <code>'\\u216C'</code> (the Roman numeral fifty) returns 50.
3254 *
3255 * <p>This method also returns values for the letters A through Z, (not
3256 * specified by Unicode), in these ranges: <code>'\u0041'</code>
3257 * through <code>'\u005A'</code> (uppercase); <code>'\u0061'</code>
3258 * through <code>'\u007A'</code> (lowercase); and <code>'\uFF21'</code>
3259 * through <code>'\uFF3A'</code>, <code>'\uFF41'</code> through
3260 * <code>'\uFF5A'</code> (full width variants).
3261 *
3262 * <p>If the character lacks a numeric value property, -1 is returned.
3263 * If the character has a numeric value property which is not representable
3264 * as a nonnegative integer, such as a fraction, -2 is returned.
3265 *
3266 * character argument boundary = [Nd]|[Nl]|[No]|U+0041-U+005A|U+0061-U+007A
3267 * |U+FF21-U+FF3A|U+FF41-U+FF5A
3268 *
3269 * @param ch character from which the numeric value property will
3270 * be retrieved
3271 * @return the numeric value property of ch, or -1 if it does not exist, or
3272 * -2 if it is not representable as a nonnegative integer
3273 * @see #forDigit(int, int)
3274 * @see #digit(char, int)
3275 * @see #isDigit(char)
3276 * @since 1.1
3277 */
3278 public static native int getNumericValue(char ch);
3279
3280 /**
3281 * Returns the Unicode numeric value property of a character. For example,
3282 * <code>'\\u216C'</code> (the Roman numeral fifty) returns 50.
3283 *
3284 * <p>This method also returns values for the letters A through Z, (not
3285 * specified by Unicode), in these ranges: <code>'\u0041'</code>
3286 * through <code>'\u005A'</code> (uppercase); <code>'\u0061'</code>
3287 * through <code>'\u007A'</code> (lowercase); and <code>'\uFF21'</code>
3288 * through <code>'\uFF3A'</code>, <code>'\uFF41'</code> through
3289 * <code>'\uFF5A'</code> (full width variants).
3290 *
3291 * <p>If the character lacks a numeric value property, -1 is returned.
3292 * If the character has a numeric value property which is not representable
3293 * as a nonnegative integer, such as a fraction, -2 is returned.
3294 *
3295 * Unlike getNumericValue(char), this method supports supplementary Unicode
3296 * code points.
3297 *
3298 * character argument boundary = [Nd]|[Nl]|[No]|U+0041-U+005A|U+0061-U+007A
3299 * |U+FF21-U+FF3A|U+FF41-U+FF5A
3300 *
3301 * @param codePoint character from which the numeric value property will
3302 * be retrieved
3303 * @return the numeric value property of codePoint, or -1 if it does not
3304 * exist, or -2 if it is not representable as a nonnegative integer
3305 * @see #forDigit(int, int)
3306 * @see #digit(int, int)
3307 * @see #isDigit(int)
3308 * @since 1.5
3309 */
3310 public static native int getNumericValue(int codePoint);
3311
3312 /**
3313 * Determines if a character is a ISO-LATIN-1 space. This is only the five
3314 * characters <code>'\t'</code>, <code>'\n'</code>, <code>'\f'</code>,
3315 * <code>'\r'</code>, and <code>' '</code>.
3316 * <br>
3317 * Java space = U+0020|U+0009|U+000A|U+000C|U+000D
3318 *
3319 * @param ch character to test
3320 * @return true if ch is a space, else false
3321 * @deprecated Replaced by {@link #isWhitespace(char)}
3322 * @see #isSpaceChar(char)
3323 * @see #isWhitespace(char)
3324 */
3325 public static boolean isSpace(char ch)
3326 {
3327 // Performing the subtraction up front alleviates need to compare longs.
3328 return ch-- <= ' ' && ((1 << ch)
3329 & ((1 << (' ' - 1))
3330 | (1 << ('\t' - 1))
3331 | (1 << ('\n' - 1))
3332 | (1 << ('\r' - 1))
3333 | (1 << ('\f' - 1)))) != 0;
3334 }
3335
3336 /**
3337 * Determines if a character is a Unicode space character. This includes
3338 * SPACE_SEPARATOR, LINE_SEPARATOR, and PARAGRAPH_SEPARATOR.
3339 * <br>
3340 * Unicode space = [Zs]|[Zp]|[Zl]
3341 *
3342 * @param ch character to test
3343 * @return true if ch is a Unicode space, else false
3344 * @see #isWhitespace(char)
3345 * @since 1.1
3346 */
3347 public static boolean isSpaceChar(char ch)
3348 {
3349 return ((1 << getType(ch))
3350 & ((1 << SPACE_SEPARATOR)
3351 | (1 << LINE_SEPARATOR)
3352 | (1 << PARAGRAPH_SEPARATOR))) != 0;
3353 }
3354
3355 /**
3356 * Determines if a character is a Unicode space character. This includes
3357 * SPACE_SEPARATOR, LINE_SEPARATOR, and PARAGRAPH_SEPARATOR. Unlike
3358 * isSpaceChar(char), this method supports supplementary Unicode code points.
3359 * <br>
3360 * Unicode space = [Zs]|[Zp]|[Zl]
3361 *
3362 * @param codePoint character to test
3363 * @return true if codePoint is a Unicode space, else false
3364 * @see #isWhitespace(int)
3365 * @since 1.5
3366 */
3367 public static boolean isSpaceChar(int codePoint)
3368 {
3369 return ((1 << getType(codePoint))
3370 & ((1 << SPACE_SEPARATOR)
3371 | (1 << LINE_SEPARATOR)
3372 | (1 << PARAGRAPH_SEPARATOR))) != 0;
3373 }
3374
3375 /**
3376 * Determines if a character is Java whitespace. This includes Unicode
3377 * space characters (SPACE_SEPARATOR, LINE_SEPARATOR, and
3378 * PARAGRAPH_SEPARATOR) except the non-breaking spaces
3379 * (<code>'\u00A0'</code>, <code>'\u2007'</code>, and <code>'\u202F'</code>);
3380 * and these characters: <code>'\u0009'</code>, <code>'\u000A'</code>,
3381 * <code>'\u000B'</code>, <code>'\u000C'</code>, <code>'\u000D'</code>,
3382 * <code>'\u001C'</code>, <code>'\u001D'</code>, <code>'\u001E'</code>,
3383 * and <code>'\u001F'</code>.
3384 * <br>
3385 * Java whitespace = ([Zs] not Nb)|[Zl]|[Zp]|U+0009-U+000D|U+001C-U+001F
3386 *
3387 * @param ch character to test
3388 * @return true if ch is Java whitespace, else false
3389 * @see #isSpaceChar(char)
3390 * @since 1.1
3391 */
3392 public static boolean isWhitespace(char ch)
3393 {
3394 int attr = readChar(ch);
3395 return ((((1 << (attr & TYPE_MASK))
3396 & ((1 << SPACE_SEPARATOR)
3397 | (1 << LINE_SEPARATOR)
3398 | (1 << PARAGRAPH_SEPARATOR))) != 0)
3399 && (attr & NO_BREAK_MASK) == 0)
3400 || (ch <= '\u001F' && ((1 << ch)
3401 & ((1 << '\t')
3402 | (1 << '\n')
3403 | (1 << '\u000B')
3404 | (1 << '\u000C')
3405 | (1 << '\r')
3406 | (1 << '\u001C')
3407 | (1 << '\u001D')
3408 | (1 << '\u001E')
3409 | (1 << '\u001F'))) != 0);
3410 }
3411
3412 /**
3413 * Determines if a character is Java whitespace. This includes Unicode
3414 * space characters (SPACE_SEPARATOR, LINE_SEPARATOR, and
3415 * PARAGRAPH_SEPARATOR) except the non-breaking spaces
3416 * (<code>'\u00A0'</code>, <code>'\u2007'</code>, and <code>'\u202F'</code>);
3417 * and these characters: <code>'\u0009'</code>, <code>'\u000A'</code>,
3418 * <code>'\u000B'</code>, <code>'\u000C'</code>, <code>'\u000D'</code>,
3419 * <code>'\u001C'</code>, <code>'\u001D'</code>, <code>'\u001E'</code>,
3420 * and <code>'\u001F'</code>. Unlike isWhitespace(char), this method
3421 * supports supplementary Unicode code points.
3422 * <br>
3423 * Java whitespace = ([Zs] not Nb)|[Zl]|[Zp]|U+0009-U+000D|U+001C-U+001F
3424 *
3425 * @param codePoint character to test
3426 * @return true if codePoint is Java whitespace, else false
3427 * @see #isSpaceChar(int)
3428 * @since 1.5
3429 */
3430 public static boolean isWhitespace(int codePoint)
3431 {
3432 int plane = codePoint >>> 16;
3433 if (plane > 2 && plane != 14)
3434 return false;
3435 int attr = readCodePoint(codePoint);
3436 return ((((1 << (attr & TYPE_MASK))
3437 & ((1 << SPACE_SEPARATOR)
3438 | (1 << LINE_SEPARATOR)
3439 | (1 << PARAGRAPH_SEPARATOR))) != 0)
3440 && (attr & NO_BREAK_MASK) == 0)
3441 || (codePoint <= '\u001F' && ((1 << codePoint)
3442 & ((1 << '\t')
3443 | (1 << '\n')
3444 | (1 << '\u000B')
3445 | (1 << '\u000C')
3446 | (1 << '\r')
3447 | (1 << '\u001C')
3448 | (1 << '\u001D')
3449 | (1 << '\u001E')
3450 | (1 << '\u001F'))) != 0);
3451 }
3452
3453 /**
3454 * Determines if a character has the ISO Control property.
3455 * <br>
3456 * ISO Control = [Cc]
3457 *
3458 * @param ch character to test
3459 * @return true if ch is an ISO Control character, else false
3460 * @see #isSpaceChar(char)
3461 * @see #isWhitespace(char)
3462 * @since 1.1
3463 */
3464 public static boolean isISOControl(char ch)
3465 {
3466 return getType(ch) == CONTROL;
3467 }
3468
3469 /**
3470 * Determines if a character has the ISO Control property. Unlike
3471 * isISOControl(char), this method supports supplementary unicode
3472 * code points.
3473 * <br>
3474 * ISO Control = [Cc]
3475 *
3476 * @param codePoint character to test
3477 * @return true if codePoint is an ISO Control character, else false
3478 * @see #isSpaceChar(int)
3479 * @see #isWhitespace(int)
3480 * @since 1.5
3481 */
3482 public static boolean isISOControl(int codePoint)
3483 {
3484 return getType(codePoint) == CONTROL;
3485 }
3486
3487 /**
3488 * Returns the Unicode general category property of a character.
3489 *
3490 * @param ch character from which the general category property will
3491 * be retrieved
3492 * @return the character category property of ch as an integer
3493 * @see #UNASSIGNED
3494 * @see #UPPERCASE_LETTER
3495 * @see #LOWERCASE_LETTER
3496 * @see #TITLECASE_LETTER
3497 * @see #MODIFIER_LETTER
3498 * @see #OTHER_LETTER
3499 * @see #NON_SPACING_MARK
3500 * @see #ENCLOSING_MARK
3501 * @see #COMBINING_SPACING_MARK
3502 * @see #DECIMAL_DIGIT_NUMBER
3503 * @see #LETTER_NUMBER
3504 * @see #OTHER_NUMBER
3505 * @see #SPACE_SEPARATOR
3506 * @see #LINE_SEPARATOR
3507 * @see #PARAGRAPH_SEPARATOR
3508 * @see #CONTROL
3509 * @see #FORMAT
3510 * @see #PRIVATE_USE
3511 * @see #SURROGATE
3512 * @see #DASH_PUNCTUATION
3513 * @see #START_PUNCTUATION
3514 * @see #END_PUNCTUATION
3515 * @see #CONNECTOR_PUNCTUATION
3516 * @see #OTHER_PUNCTUATION
3517 * @see #MATH_SYMBOL
3518 * @see #CURRENCY_SYMBOL
3519 * @see #MODIFIER_SYMBOL
3520 * @see #INITIAL_QUOTE_PUNCTUATION
3521 * @see #FINAL_QUOTE_PUNCTUATION
3522 * @since 1.1
3523 */
3524 public static native int getType(char ch);
3525
3526 /**
3527 * Returns the Unicode general category property of a character. Supports
3528 * supplementary Unicode code points.
3529 *
3530 * @param codePoint character from which the general category property will
3531 * be retrieved
3532 * @return the character category property of codePoint as an integer
3533 * @see #UNASSIGNED
3534 * @see #UPPERCASE_LETTER
3535 * @see #LOWERCASE_LETTER
3536 * @see #TITLECASE_LETTER
3537 * @see #MODIFIER_LETTER
3538 * @see #OTHER_LETTER
3539 * @see #NON_SPACING_MARK
3540 * @see #ENCLOSING_MARK
3541 * @see #COMBINING_SPACING_MARK
3542 * @see #DECIMAL_DIGIT_NUMBER
3543 * @see #LETTER_NUMBER
3544 * @see #OTHER_NUMBER
3545 * @see #SPACE_SEPARATOR
3546 * @see #LINE_SEPARATOR
3547 * @see #PARAGRAPH_SEPARATOR
3548 * @see #CONTROL
3549 * @see #FORMAT
3550 * @see #PRIVATE_USE
3551 * @see #SURROGATE
3552 * @see #DASH_PUNCTUATION
3553 * @see #START_PUNCTUATION
3554 * @see #END_PUNCTUATION
3555 * @see #CONNECTOR_PUNCTUATION
3556 * @see #OTHER_PUNCTUATION
3557 * @see #MATH_SYMBOL
3558 * @see #CURRENCY_SYMBOL
3559 * @see #MODIFIER_SYMBOL
3560 * @see #INITIAL_QUOTE_PUNCTUATION
3561 * @see #FINAL_QUOTE_PUNCTUATION
3562 * @since 1.5
3563 */
3564 public static native int getType(int codePoint);
3565
3566 /**
3567 * Converts a digit into a character which represents that digit
3568 * in a specified radix. If the radix exceeds MIN_RADIX or MAX_RADIX,
3569 * or the digit exceeds the radix, then the null character <code>'\0'</code>
3570 * is returned. Otherwise the return value is in '0'-'9' and 'a'-'z'.
3571 * <br>
3572 * return value boundary = U+0030-U+0039|U+0061-U+007A
3573 *
3574 * @param digit digit to be converted into a character
3575 * @param radix radix of digit
3576 * @return character representing digit in radix, or '\0'
3577 * @see #MIN_RADIX
3578 * @see #MAX_RADIX
3579 * @see #digit(char, int)
3580 */
3581 public static char forDigit(int digit, int radix)
3582 {
3583 if (radix < MIN_RADIX || radix > MAX_RADIX
3584 || digit < 0 || digit >= radix)
3585 return '\0';
3586 return (char) (digit < 10 ? ('0' + digit) : ('a' - 10 + digit));
3587 }
3588
3589 /**
3590 * Returns the Unicode directionality property of the character. This
3591 * is used in the visual ordering of text.
3592 *
3593 * @param ch the character to look up
3594 * @return the directionality constant, or DIRECTIONALITY_UNDEFINED
3595 * @see #DIRECTIONALITY_UNDEFINED
3596 * @see #DIRECTIONALITY_LEFT_TO_RIGHT
3597 * @see #DIRECTIONALITY_RIGHT_TO_LEFT
3598 * @see #DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
3599 * @see #DIRECTIONALITY_EUROPEAN_NUMBER
3600 * @see #DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
3601 * @see #DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
3602 * @see #DIRECTIONALITY_ARABIC_NUMBER
3603 * @see #DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
3604 * @see #DIRECTIONALITY_NONSPACING_MARK
3605 * @see #DIRECTIONALITY_BOUNDARY_NEUTRAL
3606 * @see #DIRECTIONALITY_PARAGRAPH_SEPARATOR
3607 * @see #DIRECTIONALITY_SEGMENT_SEPARATOR
3608 * @see #DIRECTIONALITY_WHITESPACE
3609 * @see #DIRECTIONALITY_OTHER_NEUTRALS
3610 * @see #DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
3611 * @see #DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
3612 * @see #DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
3613 * @see #DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
3614 * @see #DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
3615 * @since 1.4
3616 */
3617 public static native byte getDirectionality(char ch);
3618
3619 /**
3620 * Returns the Unicode directionality property of the character. This
3621 * is used in the visual ordering of text. Unlike getDirectionality(char),
3622 * this method supports supplementary Unicode code points.
3623 *
3624 * @param codePoint the character to look up
3625 * @return the directionality constant, or DIRECTIONALITY_UNDEFINED
3626 * @see #DIRECTIONALITY_UNDEFINED
3627 * @see #DIRECTIONALITY_LEFT_TO_RIGHT
3628 * @see #DIRECTIONALITY_RIGHT_TO_LEFT
3629 * @see #DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
3630 * @see #DIRECTIONALITY_EUROPEAN_NUMBER
3631 * @see #DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
3632 * @see #DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
3633 * @see #DIRECTIONALITY_ARABIC_NUMBER
3634 * @see #DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
3635 * @see #DIRECTIONALITY_NONSPACING_MARK
3636 * @see #DIRECTIONALITY_BOUNDARY_NEUTRAL
3637 * @see #DIRECTIONALITY_PARAGRAPH_SEPARATOR
3638 * @see #DIRECTIONALITY_SEGMENT_SEPARATOR
3639 * @see #DIRECTIONALITY_WHITESPACE
3640 * @see #DIRECTIONALITY_OTHER_NEUTRALS
3641 * @see #DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
3642 * @see #DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
3643 * @see #DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
3644 * @see #DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
3645 * @see #DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
3646 * @since 1.5
3647 */
3648 public static native byte getDirectionality(int codePoint);
3649
3650 /**
3651 * Determines whether the character is mirrored according to Unicode. For
3652 * example, <code>\u0028</code> (LEFT PARENTHESIS) appears as '(' in
3653 * left-to-right text, but ')' in right-to-left text.
3654 *
3655 * @param ch the character to look up
3656 * @return true if the character is mirrored
3657 * @since 1.4
3658 */
3659 public static boolean isMirrored(char ch)
3660 {
3661 return (readChar(ch) & MIRROR_MASK) != 0;
3662 }
3663
3664 /**
3665 * Determines whether the character is mirrored according to Unicode. For
3666 * example, <code>\u0028</code> (LEFT PARENTHESIS) appears as '(' in
3667 * left-to-right text, but ')' in right-to-left text. Unlike
3668 * isMirrored(char), this method supports supplementary Unicode code points.
3669 *
3670 * @param codePoint the character to look up
3671 * @return true if the character is mirrored
3672 * @since 1.5
3673 */
3674 public static boolean isMirrored(int codePoint)
3675 {
3676 int plane = codePoint >>> 16;
3677 if (plane > 2 && plane != 14)
3678 return false;
3679 return (readCodePoint(codePoint) & MIRROR_MASK) != 0;
3680 }
3681
3682 /**
3683 * Compares another Character to this Character, numerically.
3684 *
3685 * @param anotherCharacter Character to compare with this Character
3686 * @return a negative integer if this Character is less than
3687 * anotherCharacter, zero if this Character is equal, and
3688 * a positive integer if this Character is greater
3689 * @throws NullPointerException if anotherCharacter is null
3690 * @since 1.2
3691 */
3692 public int compareTo(Character anotherCharacter)
3693 {
3694 return value - anotherCharacter.value;
3695 }
3696
3697 /**
3698 * Returns an <code>Character</code> object wrapping the value.
3699 * In contrast to the <code>Character</code> constructor, this method
3700 * will cache some values. It is used by boxing conversion.
3701 *
3702 * @param val the value to wrap
3703 * @return the <code>Character</code>
3704 *
3705 * @since 1.5
3706 */
3707 public static Character valueOf(char val)
3708 {
3709 if (val > MAX_CACHE)
3710 return new Character(val);
3711 synchronized (charCache)
3712 {
3713 if (charCache[val - MIN_VALUE] == null)
3714 charCache[val - MIN_VALUE] = new Character(val);
3715 return charCache[val - MIN_VALUE];
3716 }
3717 }
3718
3719 /**
3720 * Reverse the bytes in val.
3721 * @since 1.5
3722 */
3723 public static char reverseBytes(char val)
3724 {
3725 return (char) (((val >> 8) & 0xff) | ((val << 8) & 0xff00));
3726 }
3727
3728 /**
3729 * Converts a unicode code point to a UTF-16 representation of that
3730 * code point.
3731 *
3732 * @param codePoint the unicode code point
3733 *
3734 * @return the UTF-16 representation of that code point
3735 *
3736 * @throws IllegalArgumentException if the code point is not a valid
3737 * unicode code point
3738 *
3739 * @since 1.5
3740 */
3741 public static char[] toChars(int codePoint)
3742 {
3743 if (!isValidCodePoint(codePoint))
3744 throw new IllegalArgumentException("Illegal Unicode code point : "
3745 + codePoint);
3746 char[] result = new char[charCount(codePoint)];
3747 int ignore = toChars(codePoint, result, 0);
3748 return result;
3749 }
3750
3751 /**
3752 * Converts a unicode code point to its UTF-16 representation.
3753 *
3754 * @param codePoint the unicode code point
3755 * @param dst the target char array
3756 * @param dstIndex the start index for the target
3757 *
3758 * @return number of characters written to <code>dst</code>
3759 *
3760 * @throws IllegalArgumentException if <code>codePoint</code> is not a
3761 * valid unicode code point
3762 * @throws NullPointerException if <code>dst</code> is <code>null</code>
3763 * @throws IndexOutOfBoundsException if <code>dstIndex</code> is not valid
3764 * in <code>dst</code> or if the UTF-16 representation does not
3765 * fit into <code>dst</code>
3766 *
3767 * @since 1.5
3768 */
3769 public static int toChars(int codePoint, char[] dst, int dstIndex)
3770 {
3771 if (!isValidCodePoint(codePoint))
3772 {
3773 throw new IllegalArgumentException("not a valid code point: "
3774 + codePoint);
3775 }
3776
3777 int result;
3778 if (isSupplementaryCodePoint(codePoint))
3779 {
3780 // Write second char first to cause IndexOutOfBoundsException
3781 // immediately.
3782 final int cp2 = codePoint - 0x10000;
3783 dst[dstIndex + 1] = (char) ((cp2 % 0x400) + (int) MIN_LOW_SURROGATE);
3784 dst[dstIndex] = (char) ((cp2 / 0x400) + (int) MIN_HIGH_SURROGATE);
3785 result = 2;
3786 }
3787 else
3788 {
3789 dst[dstIndex] = (char) codePoint;
3790 result = 1;
3791 }
3792 return result;
3793 }
3794
3795 /**
3796 * Return number of 16-bit characters required to represent the given
3797 * code point.
3798 *
3799 * @param codePoint a unicode code point
3800 *
3801 * @return 2 if codePoint >= 0x10000, 1 otherwise.
3802 *
3803 * @since 1.5
3804 */
3805 public static int charCount(int codePoint)
3806 {
3807 return
3808 (codePoint >= MIN_SUPPLEMENTARY_CODE_POINT)
3809 ? 2
3810 : 1;
3811 }
3812
3813 /**
3814 * Determines whether the specified code point is
3815 * in the range 0x10000 .. 0x10FFFF, i.e. the character is within the Unicode
3816 * supplementary character range.
3817 *
3818 * @param codePoint a Unicode code point
3819 *
3820 * @return <code>true</code> if code point is in supplementary range
3821 *
3822 * @since 1.5
3823 */
3824 public static boolean isSupplementaryCodePoint(int codePoint)
3825 {
3826 return codePoint >= MIN_SUPPLEMENTARY_CODE_POINT
3827 && codePoint <= MAX_CODE_POINT;
3828 }
3829
3830 /**
3831 * Determines whether the specified code point is
3832 * in the range 0x0000 .. 0x10FFFF, i.e. it is a valid Unicode code point.
3833 *
3834 * @param codePoint a Unicode code point
3835 *
3836 * @return <code>true</code> if code point is valid
3837 *
3838 * @since 1.5
3839 */
3840 public static boolean isValidCodePoint(int codePoint)
3841 {
3842 return codePoint >= MIN_CODE_POINT && codePoint <= MAX_CODE_POINT;
3843 }
3844
3845 /**
3846 * Return true if the given character is a high surrogate.
3847 * @param ch the character
3848 * @return true if the character is a high surrogate character
3849 *
3850 * @since 1.5
3851 */
3852 public static boolean isHighSurrogate(char ch)
3853 {
3854 return ch >= MIN_HIGH_SURROGATE && ch <= MAX_HIGH_SURROGATE;
3855 }
3856
3857 /**
3858 * Return true if the given character is a low surrogate.
3859 * @param ch the character
3860 * @return true if the character is a low surrogate character
3861 *
3862 * @since 1.5
3863 */
3864 public static boolean isLowSurrogate(char ch)
3865 {
3866 return ch >= MIN_LOW_SURROGATE && ch <= MAX_LOW_SURROGATE;
3867 }
3868
3869 /**
3870 * Return true if the given characters compose a surrogate pair.
3871 * This is true if the first character is a high surrogate and the
3872 * second character is a low surrogate.
3873 * @param ch1 the first character
3874 * @param ch2 the first character
3875 * @return true if the characters compose a surrogate pair
3876 *
3877 * @since 1.5
3878 */
3879 public static boolean isSurrogatePair(char ch1, char ch2)
3880 {
3881 return isHighSurrogate(ch1) && isLowSurrogate(ch2);
3882 }
3883
3884 /**
3885 * Given a valid surrogate pair, this returns the corresponding
3886 * code point.
3887 * @param high the high character of the pair
3888 * @param low the low character of the pair
3889 * @return the corresponding code point
3890 *
3891 * @since 1.5
3892 */
3893 public static int toCodePoint(char high, char low)
3894 {
3895 return ((high - MIN_HIGH_SURROGATE) * 0x400) +
3896 (low - MIN_LOW_SURROGATE) + 0x10000;
3897 }
3898
3899 /**
3900 * Get the code point at the specified index in the CharSequence.
3901 * This is like CharSequence#charAt(int), but if the character is
3902 * the start of a surrogate pair, and there is a following
3903 * character, and this character completes the pair, then the
3904 * corresponding supplementary code point is returned. Otherwise,
3905 * the character at the index is returned.
3906 *
3907 * @param sequence the CharSequence
3908 * @param index the index of the codepoint to get, starting at 0
3909 * @return the codepoint at the specified index
3910 * @throws IndexOutOfBoundsException if index is negative or >= length()
3911 * @since 1.5
3912 */
3913 public static int codePointAt(CharSequence sequence, int index)
3914 {
3915 int len = sequence.length();
3916 if (index < 0 || index >= len)
3917 throw new IndexOutOfBoundsException();
3918 char high = sequence.charAt(index);
3919 if (! isHighSurrogate(high) || ++index >= len)
3920 return high;
3921 char low = sequence.charAt(index);
3922 if (! isLowSurrogate(low))
3923 return high;
3924 return toCodePoint(high, low);
3925 }
3926
3927 /**
3928 * Get the code point at the specified index in the CharSequence.
3929 * If the character is the start of a surrogate pair, and there is a
3930 * following character, and this character completes the pair, then
3931 * the corresponding supplementary code point is returned.
3932 * Otherwise, the character at the index is returned.
3933 *
3934 * @param chars the character array in which to look
3935 * @param index the index of the codepoint to get, starting at 0
3936 * @return the codepoint at the specified index
3937 * @throws IndexOutOfBoundsException if index is negative or >= length()
3938 * @since 1.5
3939 */
3940 public static int codePointAt(char[] chars, int index)
3941 {
3942 return codePointAt(chars, index, chars.length);
3943 }
3944
3945 /**
3946 * Get the code point at the specified index in the CharSequence.
3947 * If the character is the start of a surrogate pair, and there is a
3948 * following character within the specified range, and this
3949 * character completes the pair, then the corresponding
3950 * supplementary code point is returned. Otherwise, the character
3951 * at the index is returned.
3952 *
3953 * @param chars the character array in which to look
3954 * @param index the index of the codepoint to get, starting at 0
3955 * @param limit the limit past which characters should not be examined
3956 * @return the codepoint at the specified index
3957 * @throws IndexOutOfBoundsException if index is negative or >=
3958 * limit, or if limit is negative or >= the length of the array
3959 * @since 1.5
3960 */
3961 public static int codePointAt(char[] chars, int index, int limit)
3962 {
3963 if (index < 0 || index >= limit || limit < 0 || limit > chars.length)
3964 throw new IndexOutOfBoundsException();
3965 char high = chars[index];
3966 if (! isHighSurrogate(high) || ++index >= limit)
3967 return high;
3968 char low = chars[index];
3969 if (! isLowSurrogate(low))
3970 return high;
3971 return toCodePoint(high, low);
3972 }
3973
3974 /**
3975 * Get the code point before the specified index. This is like
3976 * #codePointAt(char[], int), but checks the characters at
3977 * <code>index-1</code> and <code>index-2</code> to see if they form
3978 * a supplementary code point. If they do not, the character at
3979 * <code>index-1</code> is returned.
3980 *
3981 * @param chars the character array
3982 * @param index the index just past the codepoint to get, starting at 0
3983 * @return the codepoint at the specified index
3984 * @throws IndexOutOfBoundsException if index is negative or >= length()
3985 * @since 1.5
3986 */
3987 public static int codePointBefore(char[] chars, int index)
3988 {
3989 return codePointBefore(chars, index, 1);
3990 }
3991
3992 /**
3993 * Get the code point before the specified index. This is like
3994 * #codePointAt(char[], int), but checks the characters at
3995 * <code>index-1</code> and <code>index-2</code> to see if they form
3996 * a supplementary code point. If they do not, the character at
3997 * <code>index-1</code> is returned. The start parameter is used to
3998 * limit the range of the array which may be examined.
3999 *
4000 * @param chars the character array
4001 * @param index the index just past the codepoint to get, starting at 0
4002 * @param start the index before which characters should not be examined
4003 * @return the codepoint at the specified index
4004 * @throws IndexOutOfBoundsException if index is > start or >
4005 * the length of the array, or if limit is negative or >= the
4006 * length of the array
4007 * @since 1.5
4008 */
4009 public static int codePointBefore(char[] chars, int index, int start)
4010 {
4011 if (index < start || index > chars.length
4012 || start < 0 || start >= chars.length)
4013 throw new IndexOutOfBoundsException();
4014 --index;
4015 char low = chars[index];
4016 if (! isLowSurrogate(low) || --index < start)
4017 return low;
4018 char high = chars[index];
4019 if (! isHighSurrogate(high))
4020 return low;
4021 return toCodePoint(high, low);
4022 }
4023
4024 /**
4025 * Get the code point before the specified index. This is like
4026 * #codePointAt(CharSequence, int), but checks the characters at
4027 * <code>index-1</code> and <code>index-2</code> to see if they form
4028 * a supplementary code point. If they do not, the character at
4029 * <code>index-1</code> is returned.
4030 *
4031 * @param sequence the CharSequence
4032 * @param index the index just past the codepoint to get, starting at 0
4033 * @return the codepoint at the specified index
4034 * @throws IndexOutOfBoundsException if index is negative or >= length()
4035 * @since 1.5
4036 */
4037 public static int codePointBefore(CharSequence sequence, int index)
4038 {
4039 int len = sequence.length();
4040 if (index < 1 || index > len)
4041 throw new IndexOutOfBoundsException();
4042 --index;
4043 char low = sequence.charAt(index);
4044 if (! isLowSurrogate(low) || --index < 0)
4045 return low;
4046 char high = sequence.charAt(index);
4047 if (! isHighSurrogate(high))
4048 return low;
4049 return toCodePoint(high, low);
4050 }
4051 } // class Character