OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [java/] [lang/] [Character.java] - Blame information for rev 758

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 758 jeremybenn
/* java.lang.Character -- Wrapper class for char, and Unicode subsets
2
   Copyright (C) 1998, 1999, 2001, 2002, 2005, 2006, 2007
3
   Free Software Foundation, Inc.
4
 
5
This file is part of GNU Classpath.
6
 
7
GNU Classpath is free software; you can redistribute it and/or modify
8
it under the terms of the GNU General Public License as published by
9
the Free Software Foundation; either version 2, or (at your option)
10
any later version.
11
 
12
GNU Classpath is distributed in the hope that it will be useful, but
13
WITHOUT ANY WARRANTY; without even the implied warranty of
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
General Public License for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GNU Classpath; see the file COPYING.  If not, write to the
19
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20
02110-1301 USA.
21
 
22
Linking this library statically or dynamically with other modules is
23
making a combined work based on this library.  Thus, the terms and
24
conditions of the GNU General Public License cover the whole
25
combination.
26
 
27
As a special exception, the copyright holders of this library give you
28
permission to link this library with independent modules to produce an
29
executable, regardless of the license terms of these independent
30
modules, and to copy and distribute the resulting executable under
31
terms of your choice, provided that you also meet, for each linked
32
independent module, the terms and conditions of the license of that
33
module.  An independent module is a module which is not derived from
34
or based on this library.  If you modify this library, you may extend
35
this exception to your version of the library, but you are not
36
obligated to do so.  If you do not wish to do so, delete this
37
exception statement from your version. */
38
 
39
/*
40
 * Note: This class must not be merged with Classpath.  Gcj uses C-style
41
 * arrays (see include/java-chartables.h) to store the Unicode character
42
 * database, whereas Classpath uses Java objects (char[] extracted from
43
 * String constants) in gnu.java.lang.CharData.  Gcj's approach is more
44
 * efficient, because there is no vtable or data relocation to worry about.
45
 * However, despite the difference in the database interface, the two
46
 * versions share identical algorithms.
47
 */
48
 
49
package java.lang;
50
 
51
import java.io.Serializable;
52
import java.text.Collator;
53
import java.util.Locale;
54
 
55
/**
56
 * Wrapper class for the primitive char data type.  In addition, this class
57
 * allows one to retrieve property information and perform transformations
58
 * on the defined characters in the Unicode Standard, Version 4.0.0.
59
 * java.lang.Character is designed to be very dynamic, and as such, it
60
 * retrieves information on the Unicode character set from a separate
61
 * database, gnu.java.lang.CharData, which can be easily upgraded.
62
 *
63
 * <p>For predicates, boundaries are used to describe
64
 * the set of characters for which the method will return true.
65
 * This syntax uses fairly normal regular expression notation.
66
 * See 5.13 of the Unicode Standard, Version 4.0, for the
67
 * boundary specification.
68
 *
69
 * <p>See <a href="http://www.unicode.org">http://www.unicode.org</a>
70
 * for more information on the Unicode Standard.
71
 *
72
 * @author Tom Tromey (tromey@cygnus.com)
73
 * @author Paul N. Fisher
74
 * @author Jochen Hoenicke
75
 * @author Eric Blake (ebb9@email.byu.edu)
76
 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
77
 * @since 1.0
78
 * @status partly updated to 1.5; some things still missing
79
 */
80
public final class Character implements Serializable, Comparable<Character>
81
{
82
  /**
83
   * A subset of Unicode blocks.
84
   *
85
   * @author Paul N. Fisher
86
   * @author Eric Blake (ebb9@email.byu.edu)
87
   * @since 1.2
88
   */
89
  public static class Subset
90
  {
91
    /** The name of the subset. */
92
    private final String name;
93
 
94
    /**
95
     * Construct a new subset of characters.
96
     *
97
     * @param name the name of the subset
98
     * @throws NullPointerException if name is null
99
     */
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 &gt;= 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 &gt;= 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 &gt;=
3958
   * limit, or if limit is negative or &gt;= 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 &gt;= 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 &gt; start or &gt;
4005
   * the length of the array, or if limit is negative or &gt;= 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 &gt;= 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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.