* <td valign="top">No characters
* </tr>
* <td nowrap valign="top" align="left">
[a]
* <td valign="top">The character 'a'
* </tr>
* <td nowrap valign="top" align="left">
[ae]
* <td valign="top">The characters 'a' and 'e'
* </tr>
* <tr>
* <td nowrap valign="top" align="left">
[a-e]
* <td valign="top">The characters 'a' through 'e' inclusive, in Unicode code
* point order</td>
* </tr>
* <tr>
* <td nowrap valign="top" align="left">
[\\u4E01]
* <td valign="top">The character U+4E01
* </tr>
* <tr>
* <td nowrap valign="top" align="left">
[a{ab}{ac}]
* <td valign="top">The character 'a' and the multicharacter strings "ab" and
* "ac"</td>
* </tr>
* <tr>
* <td nowrap valign="top" align="left">
[\p{Lu}]
* <td valign="top">All characters in the general category Uppercase Letter
* </tr>
* </table>
* </blockquote>
*
* Any character may be preceded by a backslash in order to remove any special
* meaning. White space characters, as defined by UCharacterProperty.isRuleWhiteSpace(), are
* ignored, unless they are escaped.
*
* <p>Property patterns specify a set of characters having a certain
* property as defined by the Unicode standard. Both the POSIX-like
* "[:Lu:]" and the Perl-like syntax "\p{Lu}" are recognized. For a
* complete list of supported property patterns, see the User's Guide
* for UnicodeSet at
* <a href="http://www.icu-project.org/userguide/unicodeSet.html">
* http://www.icu-project.org/userguide/unicodeSet.html</a>.
* Actual determination of property data is defined by the underlying
* Unicode database as implemented by UCharacter.
*
* <p>Patterns specify individual characters, ranges of characters, and
* Unicode property sets. When elements are concatenated, they
* specify their union. To complement a set, place a '^' immediately
* after the opening '['. Property patterns are inverted by modifying
* their delimiters; "[:^foo]" and "\P{foo}". In any other location,
* '^' has no special meaning.
*
* <p>Ranges are indicated by placing two a '-' between two
* characters, as in "a-z". This specifies the range of all
* characters from the left to the right, in Unicode order. If the
* left character is greater than or equal to the
* right character it is a syntax error. If a '-' occurs as the first
* character after the opening '[' or '[^', or if it occurs as the
* last character before the closing ']', then it is taken as a
* literal. Thus "[a\\-b]", "[-ab]", and "[ab-]" all indicate the same
* set of three characters, 'a', 'b', and '-'.
*
* <p>Sets may be intersected using the '&' operator or the asymmetric
* set difference may be taken using the '-' operator, for example,
* "[[:L:]&[\\u0000-\\u0FFF]]" indicates the set of all Unicode letters
* with values less than 4096. Operators ('&' and '|') have equal
* precedence and bind left-to-right. Thus
* "[[:L:]-[a-z]-[\\u0100-\\u01FF]]" is equivalent to
* "[[[:L:]-[a-z]]-[\\u0100-\\u01FF]]". This only really matters for
* difference; intersection is commutative.
*
* <table>
* <tr valign=top>
* <td valign="top">
('[' '^'? item* ']') |
* property</code>
* </tr>
* <tr align="top">
* <td nowrap valign="top" align="right">item :=
* <td valign="top">char | (char '-' char) | pattern-expr
* </code>
* </tr>
* <tr align="top">
* <td nowrap valign="top" align="right">pattern-expr :=
* <td valign="top">pattern | pattern-expr pattern |
* pattern-expr op pattern<br>
* </code>
* </tr>
* <tr align="top">
* <td nowrap valign="top" align="right">op :=
* <td valign="top">'&' | '-'
* </code>
* </tr>
* <tr align="top">
* <td nowrap valign="top" align="right">special :=
* <td valign="top">'[' | ']' | '-'
* </code>
* </tr>
* <tr align="top">
* <td nowrap valign="top" align="right">char :=
* <td valign="top">any character that is not special
* | ('\\' </code>any character)
* | ('\u' hex hex hex hex)<br>
* </code>
* </tr>
* <tr align="top">
* <td nowrap valign="top" align="right">hex :=
* <td valign="top">any character for which
* </em>Character.digit(c, 16)
* returns a non-negative result</em>
* </tr>
* <tr>
* <td nowrap valign="top" align="right">property :=
* <td valign="top">a Unicode property set pattern
* </tr>
* </table>
* <br>
* <table border="1">
* <tr>
* <td>Legend:
|
|
Java example source code file (UnicodeSet.java)
This example Java source code file (UnicodeSet.java) is included in the alvinalexander.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn
Java by Example" TM.
Learn more about this Java project at its project page.
The UnicodeSet.java Java example source code
/*
* Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
*******************************************************************************
* (C) Copyright IBM Corp. and others, 1996-2009 - All Rights Reserved *
* *
* The original version of this source code and documentation is copyrighted *
* and owned by IBM, These materials are provided under terms of a License *
* Agreement between IBM and Sun. This technology is protected by multiple *
* US and International patents. This notice and attribution to IBM may not *
* to removed. *
*******************************************************************************
*/
package sun.text.normalizer;
import java.text.ParsePosition;
import java.util.Iterator;
import java.util.TreeSet;
/**
* A mutable set of Unicode characters and multicharacter strings. Objects of this class
* represent <em>character classes used in regular expressions.
* A character specifies a subset of Unicode code points. Legal
* code points are U+0000 to U+10FFFF, inclusive.
*
* <p>The UnicodeSet class is not designed to be subclassed.
*
* <p>UnicodeSet supports two APIs. The first is the
* <em>operand API that allows the caller to modify the value of
* a <code>UnicodeSet object. It conforms to Java 2's
* <code>java.util.Set interface, although
* <code>UnicodeSet does not actually implement that
* interface. All methods of <code>Set are supported, with the
* modification that they take a character range or single character
* instead of an <code>Object, and they take a
* <code>UnicodeSet instead of a Collection. The
* operand API may be thought of in terms of boolean logic: a boolean
* OR is implemented by <code>add, a boolean AND is implemented
* by <code>retain, a boolean XOR is implemented by
* <code>complement taking an argument, and a boolean NOT is
* implemented by <code>complement with no argument. In terms
* of traditional set theory function names, <code>add is a
* union, <code>retain is an intersection, remove
* is an asymmetric difference, and <code>complement with no
* argument is a set complement with respect to the superset range
* <code>MIN_VALUE-MAX_VALUE
*
* <p>The second API is the
* <code>applyPattern()/toPattern() API from the
* <code>java.text.Format-derived classes. Unlike the
* methods that add characters, add categories, and control the logic
* of the set, the method <code>applyPattern() sets all
* attributes of a <code>UnicodeSet at once, based on a
* string pattern.
*
* <p>Pattern syntax
*
* Patterns are accepted by the constructors and the
* <code>applyPattern() methods and returned by the
* <code>toPattern() method. These patterns follow a syntax
* similar to that employed by version 8 regular expression character
* classes. Here are some simple examples:
*
* <blockquote>
* <table>
* <tr align="top">
* <td nowrap valign="top" align="left">[] |
|
[a] | The set containing 'a'
* <tr valign=top> | [a-z] | The set containing 'a'
* through 'z' and all letters in between, in Unicode order
* <tr valign=top> | [^a-z] | The set containing
* all characters but 'a' through 'z',
* that is, U+0000 through 'a'-1 and 'z'+1 through U+10FFFF
* <tr valign=top> | [[pat1][pat2]]
* <td>The union of sets specified by pat1 and pat2
* <tr valign=top> | [[pat1]&[pat2]]
* <td>The intersection of sets specified by pat1 and pat2
* <tr valign=top> | [[pat1]-[pat2]]
* <td>The asymmetric difference of sets specified by pat1 and
* <em>pat2
* <tr valign=top> | [:Lu:] or \p{Lu}
* <td>The set of characters having the specified
* Unicode property; in
* this case, Unicode uppercase letters
* <tr valign=top> | [:^Lu:] or \P{Lu}
* <td>The set of characters not having the given
* Unicode property
* </table>
*
* <p>Warning: you cannot add an empty string ("") to a UnicodeSet.
*
* <p>Formal syntax
*
* <blockquote>
* <table>
* <tr align="top">
* <td nowrap valign="top" align="right">pattern := |
* <tr>
* <td nowrap valign="top">a := b
* <td width="20" valign="top">
* <td valign="top">a may be replaced by b
* </tr>
* <tr>
* <td nowrap valign="top">a?
* <td valign="top">
* <td valign="top">zero or one instance of a
* </td>
* </tr>
* <tr>
* <td nowrap valign="top">a*
* <td valign="top">
* <td valign="top">one or more instances of a
* </td>
* </tr>
* <tr>
* <td nowrap valign="top">a | b
* <td valign="top">
* <td valign="top">either a or b
* </td>
* </tr>
* <tr>
* <td nowrap valign="top">'a'
* <td valign="top">
* <td valign="top">the literal string between the quotes
* </tr>
* </table>
* </td>
* </tr>
* </table>
* </blockquote>
* <p>To iterate over contents of UnicodeSet, use UnicodeSetIterator class.
*
* @author Alan Liu
* @stable ICU 2.0
* @see UnicodeSetIterator
*/
public class UnicodeSet implements UnicodeMatcher {
private static final int LOW = 0x000000; // LOW <= all valid values. ZERO for codepoints
private static final int HIGH = 0x110000; // HIGH > all valid values. 10000 for code units.
// 110000 for codepoints
/**
* Minimum value that can be stored in a UnicodeSet.
* @stable ICU 2.0
*/
public static final int MIN_VALUE = LOW;
/**
* Maximum value that can be stored in a UnicodeSet.
* @stable ICU 2.0
*/
public static final int MAX_VALUE = HIGH - 1;
private int len; // length used; list may be longer to minimize reallocs
private int[] list; // MUST be terminated with HIGH
private int[] rangeList; // internal buffer
private int[] buffer; // internal buffer
// NOTE: normally the field should be of type SortedSet; but that is missing a public clone!!
// is not private so that UnicodeSetIterator can get access
TreeSet<String> strings = new TreeSet<>();
/**
* The pattern representation of this set. This may not be the
* most economical pattern. It is the pattern supplied to
* applyPattern(), with variables substituted and whitespace
* removed. For sets constructed without applyPattern(), or
* modified using the non-pattern API, this string will be null,
* indicating that toPattern() must generate a pattern
* representation from the inversion list.
*/
private String pat = null;
private static final int START_EXTRA = 16; // initial storage. Must be >= 0
private static final int GROW_EXTRA = START_EXTRA; // extra amount for growth. Must be >= 0
/**
* A set of all characters _except_ the second through last characters of
* certain ranges. These ranges are ranges of characters whose
* properties are all exactly alike, e.g. CJK Ideographs from
* U+4E00 to U+9FA5.
*/
private static UnicodeSet INCLUSIONS[] = null;
//----------------------------------------------------------------
// Public API
//----------------------------------------------------------------
/**
* Constructs an empty set.
* @stable ICU 2.0
*/
public UnicodeSet() {
list = new int[1 + START_EXTRA];
list[len++] = HIGH;
}
/**
* Constructs a set containing the given range. If <code>end >
* start</code> then an empty set is created.
*
* @param start first character, inclusive, of range
* @param end last character, inclusive, of range
* @stable ICU 2.0
*/
public UnicodeSet(int start, int end) {
this();
complement(start, end);
}
/**
* Constructs a set from the given pattern. See the class description
* for the syntax of the pattern language. Whitespace is ignored.
* @param pattern a string specifying what characters are in the set
* @exception java.lang.IllegalArgumentException if the pattern contains
* a syntax error.
* @stable ICU 2.0
*/
public UnicodeSet(String pattern) {
this();
applyPattern(pattern, null, null, IGNORE_SPACE);
}
/**
* Make this object represent the same set as <code>other.
* @param other a <code>UnicodeSet
Other Java examples (source code examples)
Here is a short list of links related to this Java UnicodeSet.java source code file:
The search page
Other Java source code examples at this package level
Click here to learn more about this project
