|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectcom.ibm.icu.text.UnicodeFilter
com.ibm.icu.text.UnicodeSet
public class UnicodeSet
A mutable set of Unicode characters and multicharacter strings. Objects of this class represent 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. Note: method freeze() will not only makes the set immutable, but also makes important methods much higher performance: contains(c), containsNone(...), span(...), spanBack(...) etc. After the object is frozen, any subsequent call that wants to change the object will throw UnsupportedOperationException.
The UnicodeSet class is not designed to be subclassed.
UnicodeSet
supports two APIs. The first is the
operand API that allows the caller to modify the value of
a UnicodeSet
object. It conforms to Java 2's
java.util.Set
interface, although
UnicodeSet
does not actually implement that
interface. All methods of Set
are supported, with the
modification that they take a character range or single character
instead of an Object
, and they take a
UnicodeSet
instead of a Collection
. The
operand API may be thought of in terms of boolean logic: a boolean
OR is implemented by add
, a boolean AND is implemented
by retain
, a boolean XOR is implemented by
complement
taking an argument, and a boolean NOT is
implemented by complement
with no argument. In terms
of traditional set theory function names, add
is a
union, retain
is an intersection, remove
is an asymmetric difference, and complement
with no
argument is a set complement with respect to the superset range
MIN_VALUE-MAX_VALUE
The second API is the
applyPattern()
/toPattern()
API from the
java.text.Format
-derived classes. Unlike the
methods that add characters, add categories, and control the logic
of the set, the method applyPattern()
sets all
attributes of a UnicodeSet
at once, based on a
string pattern.
Pattern syntax
Patterns are accepted by the constructors and theapplyPattern()
methods and returned by the
toPattern()
method. These patterns follow a syntax
similar to that employed by version 8 regular expression character
classes. Here are some simple examples:
Any character may be preceded by a backslash in order to remove any special meaning. White space characters, as defined by the Unicode Pattern_White_Space property, are ignored, unless they are escaped.
[]
No characters [a]
The character 'a' [ae]
The characters 'a' and 'e' [a-e]
The characters 'a' through 'e' inclusive, in Unicode code point order [\\u4E01]
The character U+4E01 [a{ab}{ac}]
The character 'a' and the multicharacter strings "ab" and "ac" [\p{Lu}]
All characters in the general category Uppercase Letter
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 http://www.icu-project.org/userguide/unicodeSet.html. Actual determination of property data is defined by the underlying Unicode database as implemented by UCharacter.
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.
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 '-'.
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.
[a] | The set containing 'a' |
[a-z] | The set containing 'a' through 'z' and all letters in between, in Unicode order |
[^a-z] | The set containing all characters but 'a' through 'z', that is, U+0000 through 'a'-1 and 'z'+1 through U+10FFFF |
[[pat1][pat2]]
| The union of sets specified by pat1 and pat2 |
[[pat1]&[pat2]]
| The intersection of sets specified by pat1 and pat2 |
[[pat1]-[pat2]]
| The asymmetric difference of sets specified by pat1 and pat2 |
[:Lu:] or \p{Lu}
| The set of characters having the specified Unicode property; in this case, Unicode uppercase letters |
[:^Lu:] or \P{Lu}
| The set of characters not having the given Unicode property |
Warning: you cannot add an empty string ("") to a UnicodeSet.
Formal syntax
pattern :=
('[' '^'? item* ']') | property
item :=
char | (char '-' char) | pattern-expr
pattern-expr :=
pattern | pattern-expr pattern | pattern-expr op pattern
op :=
'&' | '-'
special :=
'[' | ']' | '-'
char :=
any character that is not special
any character
| ('\\')
| ('\u' hex hex hex hex)
hex :=
any character for which Character.digit(c, 16)
returns a non-negative resultproperty :=
a Unicode property set pattern
Legend:
a := b
a
may be replaced byb
a?
zero or one instance of a
a*
one or more instances of a
a | b
either a
orb
'a'
the literal string between the quotes
To iterate over contents of UnicodeSet, use UnicodeSetIterator class.
UnicodeSetIterator
Nested Class Summary | |
---|---|
static class |
UnicodeSet.ComparisonStyle
Comparison style enums used by compareTo(UnicodeSet, ComparisonStyle) . |
static class |
UnicodeSet.SpanCondition
Argument values for whether span() and similar functions continue while the current character is contained vs. |
static class |
UnicodeSet.XSymbolTable
Internal class for customizing UnicodeSet parsing of properties. |
Field Summary | |
---|---|
static int |
ADD_CASE_MAPPINGS
Bitmask for constructor, applyPattern(), and closeOver() indicating letter case. |
static UnicodeSet |
ALL_CODE_POINTS
Constant for the set of all code points. |
static int |
CASE
Bitmask for constructor, applyPattern(), and closeOver() indicating letter case. |
static int |
CASE_INSENSITIVE
Alias for UnicodeSet.CASE, for ease of porting from C++ where ICU4C also has both USET_CASE and USET_CASE_INSENSITIVE (see uset.h). |
static UnicodeSet |
EMPTY
Constant for the empty set. |
static int |
IGNORE_SPACE
Bitmask for constructor and applyPattern() indicating that white space should be ignored. |
static int |
MAX_VALUE
Maximum value that can be stored in a UnicodeSet. |
static int |
MIN_VALUE
Minimum value that can be stored in a UnicodeSet. |
Fields inherited from interface com.ibm.icu.text.UnicodeMatcher |
---|
ETHER, U_MATCH, U_MISMATCH, U_PARTIAL_MATCH |
Constructor Summary | |
---|---|
UnicodeSet()
Constructs an empty set. |
|
UnicodeSet(int... pairs)
Quickly constructs a set from a set of ranges |
|
UnicodeSet(int start,
int end)
Constructs a set containing the given range. |
|
UnicodeSet(String pattern)
Constructs a set from the given pattern. |
|
UnicodeSet(String pattern,
boolean ignoreWhitespace)
Constructs a set from the given pattern. |
|
UnicodeSet(String pattern,
int options)
Constructs a set from the given pattern. |
|
UnicodeSet(String pattern,
ParsePosition pos,
SymbolTable symbols)
Constructs a set from the given pattern. |
|
UnicodeSet(String pattern,
ParsePosition pos,
SymbolTable symbols,
int options)
Constructs a set from the given pattern. |
|
UnicodeSet(UnicodeSet other)
Constructs a copy of an existing set. |
Method Summary | ||
---|---|---|
StringBuffer |
_generatePattern(StringBuffer result,
boolean escapeUnprintable)
Generate and append a string representation of this set to result. |
|
StringBuffer |
_generatePattern(StringBuffer result,
boolean escapeUnprintable,
boolean includeStrings)
Generate and append a string representation of this set to result. |
|
UnicodeSet |
add(CharSequence s)
Adds the specified multicharacter to this set if it is not already present. |
|
UnicodeSet |
add(Collection<?> source)
Add the contents of the collection (as strings) into this UnicodeSet. |
|
UnicodeSet |
add(int c)
Adds the specified character to this set if it is not already present. |
|
UnicodeSet |
add(int start,
int end)
Adds the specified range to this set if it is not already present. |
|
UnicodeSet |
addAll(CharSequence s)
Adds each of the characters in this string to the set. |
|
UnicodeSet |
addAll(Collection<?> source)
Add the contents of the UnicodeSet (as strings) into a collection. |
|
UnicodeSet |
addAll(int start,
int end)
Adds all characters in range (uses preferred naming convention). |
|
UnicodeSet |
addAll(String... collection)
|
|
UnicodeSet |
addAll(UnicodeSet c)
Adds all of the elements in the specified set to this set if they're not already present. |
|
static
|
addAllTo(Iterable<T> source,
T[] target)
Utility for adding the contents of an iterable to a collection. |
|
static
|
addAllTo(Iterable<T> source,
U target)
Utility for adding the contents of an iterable to a collection. |
|
String[] |
addAllTo(String[] target)
Add the contents of the UnicodeSet (as strings) into a collection. |
|
|
addAllTo(T target)
Add the contents of the UnicodeSet (as strings) into a collection. |
|
UnicodeSet |
addBridges(UnicodeSet dontCare)
Deprecated. This API is ICU internal only. |
|
void |
addMatchSetTo(UnicodeSet toUnionTo)
Implementation of UnicodeMatcher API. |
|
UnicodeSet |
applyIntPropertyValue(int prop,
int value)
Modifies this set to contain those code points which have the given value for the given binary or enumerated property, as returned by UCharacter.getIntPropertyValue. |
|
UnicodeSet |
applyPattern(String pattern)
Modifies this set to represent the set specified by the given pattern. |
|
UnicodeSet |
applyPattern(String pattern,
boolean ignoreWhitespace)
Modifies this set to represent the set specified by the given pattern, optionally ignoring whitespace. |
|
UnicodeSet |
applyPattern(String pattern,
int options)
Modifies this set to represent the set specified by the given pattern, optionally ignoring whitespace. |
|
UnicodeSet |
applyPattern(String pattern,
ParsePosition pos,
SymbolTable symbols,
int options)
Deprecated. This API is ICU internal only. |
|
UnicodeSet |
applyPropertyAlias(String propertyAlias,
String valueAlias)
Modifies this set to contain those code points which have the given value for the given property. |
|
UnicodeSet |
applyPropertyAlias(String propertyAlias,
String valueAlias,
SymbolTable symbols)
Modifies this set to contain those code points which have the given value for the given property. |
|
int |
charAt(int index)
Returns the character at the given index within this set, where the set is ordered by ascending code point. |
|
UnicodeSet |
clear()
Removes all of the elements from this set. |
|
Object |
clone()
Return a new set that is equivalent to this one. |
|
UnicodeSet |
cloneAsThawed()
Clone a thawed version of this class, according to the Freezable interface. |
|
UnicodeSet |
closeOver(int attribute)
Close this set over the given attribute. |
|
UnicodeSet |
compact()
Reallocate this objects internal structures to take up the least possible space, without changing this object's value. |
|
static
|
compare(Collection<T> collection1,
Collection<T> collection2,
UnicodeSet.ComparisonStyle style)
Utility to compare two collections, optionally by size, and then lexicographically. |
|
static int |
compare(int codePoint,
String string)
Utility to compare a string to a code point. |
|
static
|
compare(Iterable<T> collection1,
Iterable<T> collection2)
Utility to compare two iterables. |
|
static
|
compare(Iterator<T> first,
Iterator<T> other)
Deprecated. This API is ICU internal only. |
|
static int |
compare(String string,
int codePoint)
Utility to compare a string to a code point. |
|
int |
compareTo(Iterable<String> other)
|
|
int |
compareTo(UnicodeSet o)
Compares UnicodeSets, where shorter come first, and otherwise lexigraphically (according to the comparison of the first characters that differ). |
|
int |
compareTo(UnicodeSet o,
UnicodeSet.ComparisonStyle style)
Compares UnicodeSets, in three different ways. |
|
UnicodeSet |
complement()
This is equivalent to complement(MIN_VALUE, MAX_VALUE) . |
|
UnicodeSet |
complement(int c)
Complements the specified character in this set. |
|
UnicodeSet |
complement(int start,
int end)
Complements the specified range in this set. |
|
UnicodeSet |
complement(String s)
Complement the specified string in this set. |
|
UnicodeSet |
complementAll(String s)
Complement EACH of the characters in this string. |
|
UnicodeSet |
complementAll(UnicodeSet c)
Complements in this set all elements contained in the specified set. |
|
boolean |
contains(int c)
Returns true if this set contains the given character. |
|
boolean |
contains(int start,
int end)
Returns true if this set contains every character of the given range. |
|
boolean |
contains(String s)
Returns true if this set contains the given multicharacter string. |
|
boolean |
containsAll(Collection<String> collection)
|
|
boolean |
containsAll(String s)
Returns true if there is a partition of the string such that this set contains each of the partitioned strings. |
|
boolean |
containsAll(UnicodeSet b)
Returns true if this set contains all the characters and strings of the given set. |
|
boolean |
containsNone(Collection<String> collection)
|
|
boolean |
containsNone(int start,
int end)
Returns true if this set contains none of the characters of the given range. |
|
boolean |
containsNone(String s)
Returns true if this set contains none of the characters of the given string. |
|
boolean |
containsNone(UnicodeSet b)
Returns true if none of the characters or strings in this UnicodeSet appears in the string. |
|
boolean |
containsSome(Collection<String> collection)
|
|
boolean |
containsSome(int start,
int end)
Returns true if this set contains one or more of the characters in the given range. |
|
boolean |
containsSome(String s)
Returns true if this set contains one or more of the characters of the given string. |
|
boolean |
containsSome(UnicodeSet s)
Returns true if this set contains one or more of the characters and strings of the given set. |
|
boolean |
equals(Object o)
Compares the specified object with this set for equality. |
|
int |
findIn(CharSequence value,
int fromIndex,
boolean findNot)
Deprecated. This API is ICU internal only. |
|
int |
findLastIn(CharSequence value,
int fromIndex,
boolean findNot)
Deprecated. This API is ICU internal only. |
|
UnicodeSet |
freeze()
Freeze this class, according to the Freezable interface. |
|
static UnicodeSet |
from(String s)
Makes a set from a multicharacter string. |
|
static UnicodeSet |
fromAll(String s)
Makes a set from each of the characters in the string. |
|
static UnicodeSet.XSymbolTable |
getDefaultXSymbolTable()
Get the default symbol table. |
|
int |
getRangeCount()
Iteration method that returns the number of ranges contained in this set. |
|
int |
getRangeEnd(int index)
Iteration method that returns the last character in the specified range of this set. |
|
int |
getRangeStart(int index)
Iteration method that returns the first character in the specified range of this set. |
|
String |
getRegexEquivalent()
Deprecated. This API is ICU internal only. |
|
static int |
getSingleCodePoint(CharSequence s)
Deprecated. This API is ICU internal only. |
|
int |
hashCode()
Returns the hash code value for this set. |
|
int |
indexOf(int c)
Returns the index of the given character within this set, where the set is ordered by ascending code point. |
|
boolean |
isEmpty()
Returns true if this set contains no elements. |
|
boolean |
isFrozen()
Is this frozen, according to the Freezable interface? |
|
Iterator<String> |
iterator()
Returns a string iterator. |
|
int |
matches(Replaceable text,
int[] offset,
int limit,
boolean incremental)
Implementation of UnicodeMatcher.matches(). |
|
int |
matchesAt(CharSequence text,
int offset)
Deprecated. This API is ICU internal only. |
|
boolean |
matchesIndexValue(int v)
Implementation of UnicodeMatcher API. |
|
UnicodeSet |
remove(int c)
Removes the specified character from this set if it is present. |
|
UnicodeSet |
remove(int start,
int end)
Removes the specified range from this set if it is present. |
|
UnicodeSet |
remove(String s)
Removes the specified string from this set if it is present. |
|
UnicodeSet |
removeAll(Collection<String> collection)
|
|
UnicodeSet |
removeAll(String s)
Remove EACH of the characters in this string. |
|
UnicodeSet |
removeAll(UnicodeSet c)
Removes from this set all of its elements that are contained in the specified set. |
|
UnicodeSet |
removeAllStrings()
Remove all strings from this UnicodeSet |
|
static boolean |
resemblesPattern(String pattern,
int pos)
Return true if the given position, in the given pattern, appears to be the start of a UnicodeSet pattern. |
|
UnicodeSet |
retain(int c)
Retain the specified character from this set if it is present. |
|
UnicodeSet |
retain(int start,
int end)
Retain only the elements in this set that are contained in the specified range. |
|
UnicodeSet |
retain(String s)
Retain the specified string in this set if it is present. |
|
UnicodeSet |
retainAll(Collection<String> collection)
|
|
UnicodeSet |
retainAll(String s)
Retains EACH of the characters in this string. |
|
UnicodeSet |
retainAll(UnicodeSet c)
Retains only the elements in this set that are contained in the specified set. |
|
UnicodeSet |
set(int start,
int end)
Make this object represent the range start - end . |
|
UnicodeSet |
set(UnicodeSet other)
Make this object represent the same set as other . |
|
static void |
setDefaultXSymbolTable(UnicodeSet.XSymbolTable xSymbolTable)
Set the default symbol table. |
|
int |
size()
Returns the number of elements in this set (its cardinality) Note than the elements of a set may include both individual codepoints and strings. |
|
int |
span(CharSequence s,
int start,
UnicodeSet.SpanCondition spanCondition)
Span a string using this UnicodeSet. |
|
int |
span(CharSequence s,
UnicodeSet.SpanCondition spanCondition)
Span a string using this UnicodeSet. |
|
int |
spanBack(CharSequence s,
int fromIndex,
UnicodeSet.SpanCondition spanCondition)
Span a string backwards (from the fromIndex) using this UnicodeSet. |
|
int |
spanBack(CharSequence s,
UnicodeSet.SpanCondition spanCondition)
Span a string backwards (from the end) using this UnicodeSet. |
|
Iterable<String> |
strings()
For iterating through the strings in the set. |
|
String |
stripFrom(CharSequence source,
boolean matches)
Deprecated. This API is ICU internal only. |
|
static String[] |
toArray(UnicodeSet set)
Add the contents of the UnicodeSet (as strings) into an array. |
|
String |
toPattern(boolean escapeUnprintable)
Returns a string representation of this set. |
|
String |
toString()
Return a programmer-readable string representation of this object. |
Methods inherited from class java.lang.Object |
---|
finalize, getClass, notify, notifyAll, wait, wait, wait |
Field Detail |
---|
public static final UnicodeSet EMPTY
public static final UnicodeSet ALL_CODE_POINTS
public static final int MIN_VALUE
public static final int MAX_VALUE
public static final int IGNORE_SPACE
public static final int CASE
public static final int CASE_INSENSITIVE
CASE
,
Constant Field Valuespublic static final int ADD_CASE_MAPPINGS
Constructor Detail |
---|
public UnicodeSet()
public UnicodeSet(UnicodeSet other)
public UnicodeSet(int start, int end)
end >
start
then an empty set is created.
start
- first character, inclusive, of rangeend
- last character, inclusive, of rangepublic UnicodeSet(int... pairs)
pairs
- pairs of character representing rangespublic UnicodeSet(String pattern)
pattern
- a string specifying what characters are in the set
IllegalArgumentException
- if the pattern contains
a syntax error.public UnicodeSet(String pattern, boolean ignoreWhitespace)
pattern
- a string specifying what characters are in the setignoreWhitespace
- if true, ignore Unicode Pattern_White_Space characters
IllegalArgumentException
- if the pattern contains
a syntax error.public UnicodeSet(String pattern, int options)
pattern
- a string specifying what characters are in the setoptions
- a bitmask indicating which options to apply.
Valid options are IGNORE_SPACE and CASE.
IllegalArgumentException
- if the pattern contains
a syntax error.public UnicodeSet(String pattern, ParsePosition pos, SymbolTable symbols)
pattern
- a string specifying what characters are in the setpos
- on input, the position in pattern at which to start parsing.
On output, the position after the last character parsed.symbols
- a symbol table mapping variables to char[] arrays
and chars to UnicodeSets
IllegalArgumentException
- if the pattern
contains a syntax error.public UnicodeSet(String pattern, ParsePosition pos, SymbolTable symbols, int options)
pattern
- a string specifying what characters are in the setpos
- on input, the position in pattern at which to start parsing.
On output, the position after the last character parsed.symbols
- a symbol table mapping variables to char[] arrays
and chars to UnicodeSetsoptions
- a bitmask indicating which options to apply.
Valid options are IGNORE_SPACE and CASE.
IllegalArgumentException
- if the pattern
contains a syntax error.Method Detail |
---|
public Object clone()
clone
in class Object
public UnicodeSet set(int start, int end)
start - end
.
If end > start
then this object is set to an
an empty range.
start
- first character in the set, inclusiveend
- last character in the set, inclusivepublic UnicodeSet set(UnicodeSet other)
other
.
other
- a UnicodeSet
whose value will be
copied to this objectpublic final UnicodeSet applyPattern(String pattern)
pattern
- a string specifying what characters are in the set
IllegalArgumentException
- if the pattern
contains a syntax error.public UnicodeSet applyPattern(String pattern, boolean ignoreWhitespace)
pattern
- a string specifying what characters are in the setignoreWhitespace
- if true then Unicode Pattern_White_Space characters are ignored
IllegalArgumentException
- if the pattern
contains a syntax error.public UnicodeSet applyPattern(String pattern, int options)
pattern
- a string specifying what characters are in the setoptions
- a bitmask indicating which options to apply.
Valid options are IGNORE_SPACE and CASE.
IllegalArgumentException
- if the pattern
contains a syntax error.public static boolean resemblesPattern(String pattern, int pos)
public String toPattern(boolean escapeUnprintable)
toPattern
in interface UnicodeMatcher
escapeUnprintable
- if TRUE then convert unprintable
character to their hex escape representations, \\uxxxx or
\\Uxxxxxxxx. Unprintable characters are those other than
U+000A, U+0020..U+007E.public StringBuffer _generatePattern(StringBuffer result, boolean escapeUnprintable)
result
- the buffer into which to generate the patternescapeUnprintable
- escape unprintable characters if truepublic StringBuffer _generatePattern(StringBuffer result, boolean escapeUnprintable, boolean includeStrings)
includeStrings
- if false, doesn't include the strings.public int size()
public boolean isEmpty()
public boolean matchesIndexValue(int v)
matchesIndexValue
in interface UnicodeMatcher
public int matches(Replaceable text, int[] offset, int limit, boolean incremental)
matches
in interface UnicodeMatcher
matches
in class UnicodeFilter
text
- the text to be matchedoffset
- on input, the index into text at which to begin
matching. On output, the limit of the matched text. The
number of matched characters is the output value of offset
minus the input value. Offset should always point to the
HIGH SURROGATE (leading code unit) of a pair of surrogates,
both on entry and upon return.limit
- the limit index of text to be matched. Greater
than offset for a forward direction match, less than offset for
a backward direction match. The last character to be
considered for matching will be text.charAt(limit-1) in the
forward direction or text.charAt(limit+1) in the backward
direction.incremental
- if TRUE, then assume further characters may
be inserted at limit and check for partial matching. Otherwise
assume the text as given is complete.
public int matchesAt(CharSequence text, int offset)
public void addMatchSetTo(UnicodeSet toUnionTo)
addMatchSetTo
in interface UnicodeMatcher
toUnionTo
- the set into which to union the source characterspublic int indexOf(int c)
charAt()
.
public int charAt(int index)
indexOf()
.
index
- an index from 0..size()-1
public UnicodeSet add(int start, int end)
end > start
then an empty range is added, leaving the set unchanged.
start
- first character, inclusive, of range to be added
to this set.end
- last character, inclusive, of range to be added
to this set.public UnicodeSet addAll(int start, int end)
start
- The index of where to start on adding all characters.end
- The index of where to end on adding all characters.
public final UnicodeSet add(int c)
public final UnicodeSet add(CharSequence s)
s
- the source string
public final UnicodeSet addAll(CharSequence s)
s
- the source string
public final UnicodeSet retainAll(String s)
s
- the source string
public final UnicodeSet complementAll(String s)
s
- the source string
public final UnicodeSet removeAll(String s)
s
- the source string
public final UnicodeSet removeAllStrings()
public static UnicodeSet from(String s)
s
- the source string
public static UnicodeSet fromAll(String s)
s
- the source string
public UnicodeSet retain(int start, int end)
end > start
then an empty range is
retained, leaving the set empty.
start
- first character, inclusive, of range to be retained
to this set.end
- last character, inclusive, of range to be retained
to this set.public final UnicodeSet retain(int c)
c
- the character to be retained
public final UnicodeSet retain(String s)
s
- the string to be retained
public UnicodeSet remove(int start, int end)
end > start
then an empty range is
removed, leaving the set unchanged.
start
- first character, inclusive, of range to be removed
from this set.end
- last character, inclusive, of range to be removed
from this set.public final UnicodeSet remove(int c)
c
- the character to be removed
public final UnicodeSet remove(String s)
s
- the string to be removed
public UnicodeSet complement(int start, int end)
end > start
then an empty range is complemented, leaving the set unchanged.
start
- first character, inclusive, of range to be removed
from this set.end
- last character, inclusive, of range to be removed
from this set.public final UnicodeSet complement(int c)
public UnicodeSet complement()
complement(MIN_VALUE, MAX_VALUE)
.
public final UnicodeSet complement(String s)
s
- the string to complement
public boolean contains(int c)
contains
in class UnicodeFilter
c
- character to be checked for containment
public boolean contains(int start, int end)
start
- first character, inclusive, of the rangeend
- last character, inclusive, of the range
public final boolean contains(String s)
s
- string to be checked for containment
public boolean containsAll(UnicodeSet b)
b
- set to be checked for containment
public boolean containsAll(String s)
s
- string containing characters to be checked for containment
public String getRegexEquivalent()
public boolean containsNone(int start, int end)
start
- first character, inclusive, of the rangeend
- last character, inclusive, of the range
public boolean containsNone(UnicodeSet b)
b
- set to be checked for containment
public boolean containsNone(String s)
s
- string containing characters to be checked for containment
public final boolean containsSome(int start, int end)
start
- first character, inclusive, of the rangeend
- last character, inclusive, of the range
public final boolean containsSome(UnicodeSet s)
s
- set to be checked for containment
public final boolean containsSome(String s)
s
- string containing characters to be checked for containment
public UnicodeSet addAll(UnicodeSet c)
c
- set whose elements are to be added to this set.public UnicodeSet retainAll(UnicodeSet c)
c
- set that defines which elements this set will retain.public UnicodeSet removeAll(UnicodeSet c)
c
- set that defines which elements will be removed from
this set.public UnicodeSet complementAll(UnicodeSet c)
c
- set that defines which elements will be complemented from
this set.public UnicodeSet clear()
public int getRangeCount()
getRangeStart(int)
,
getRangeEnd(int)
public int getRangeStart(int index)
ArrayIndexOutOfBoundsException
- if index is outside
the range 0..getRangeCount()-1
getRangeCount()
,
getRangeEnd(int)
public int getRangeEnd(int index)
ArrayIndexOutOfBoundsException
- if index is outside
the range 0..getRangeCount()-1
getRangeStart(int)
,
getRangeEnd(int)
public UnicodeSet compact()
public boolean equals(Object o)
equals
in class Object
o
- Object to be compared for equality with this set.
public int hashCode()
hashCode
in class Object
Object.hashCode()
public String toString()
toString
in class Object
public UnicodeSet applyPattern(String pattern, ParsePosition pos, SymbolTable symbols, int options)
pattern
- the string containing the pattern to be parsed. The
portion of the string from pos.getIndex(), which must be a '[', to the
corresponding closing ']', is parsed.pos
- upon entry, the position at which to being parsing. The
character at pattern.charAt(pos.getIndex()) must be a '['. Upon return
from a successful parse, pos.getIndex() is either the character after the
closing ']' of the parsed pattern, or pattern.length() if the closing ']'
is the last character of the pattern string.
pattern
IllegalArgumentException
- if the parse fails.public <T extends Collection<String>> T addAllTo(T target)
target
- collection to add intopublic String[] addAllTo(String[] target)
target
- collection to add intopublic static String[] toArray(UnicodeSet set)
public UnicodeSet add(Collection<?> source)
source
- the collection to add
public UnicodeSet addAll(Collection<?> source)
source
- collection to add into
public UnicodeSet applyIntPropertyValue(int prop, int value)
prop
- a property in the range
UProperty.BIN_START..UProperty.BIN_LIMIT-1 or
UProperty.INT_START..UProperty.INT_LIMIT-1 or.
UProperty.MASK_START..UProperty.MASK_LIMIT-1.value
- a value in the range
UCharacter.getIntPropertyMinValue(prop)..
UCharacter.getIntPropertyMaxValue(prop), with one exception.
If prop is UProperty.GENERAL_CATEGORY_MASK, then value should not be
a UCharacter.getType() result, but rather a mask value produced
by logically ORing (1 << UCharacter.getType()) values together.
This allows grouped categories such as [:L:] to be represented.
public UnicodeSet applyPropertyAlias(String propertyAlias, String valueAlias)
propertyAlias
- a property alias, either short or long.
The name is matched loosely. See PropertyAliases.txt for names
and a description of loose matching. If the value string is
empty, then this string is interpreted as either a
General_Category value alias, a Script value alias, a binary
property alias, or a special ID. Special IDs are matched
loosely and correspond to the following sets:
"ANY" = [ -\U0010FFFF],
"ASCII" = [ -].valueAlias
- a value alias, either short or long. The
name is matched loosely. See PropertyValueAliases.txt for
names and a description of loose matching. In addition to
aliases listed, numeric values and canonical combining classes
may be expressed numerically, e.g., ("nv", "0.5") or ("ccc",
"220"). The value string may also be empty.
public UnicodeSet applyPropertyAlias(String propertyAlias, String valueAlias, SymbolTable symbols)
propertyAlias
- A string of the property alias.valueAlias
- A string of the value alias.symbols
- if not null, then symbols are first called to see if a property
is available. If true, then everything else is skipped.
public UnicodeSet closeOver(int attribute)
attribute
- bitmask for attributes to close over.
Currently only the CASE bit is supported. Any undefined bits
are ignored.
public boolean isFrozen()
isFrozen
in interface Freezable<UnicodeSet>
public UnicodeSet freeze()
freeze
in interface Freezable<UnicodeSet>
public int span(CharSequence s, UnicodeSet.SpanCondition spanCondition)
s
- The string to be spannedspanCondition
- The span condition
public int span(CharSequence s, int start, UnicodeSet.SpanCondition spanCondition)
s
- The string to be spannedstart
- The start index that the span beginsspanCondition
- The span condition
public int spanBack(CharSequence s, UnicodeSet.SpanCondition spanCondition)
s
- The string to be spannedspanCondition
- The span condition
public int spanBack(CharSequence s, int fromIndex, UnicodeSet.SpanCondition spanCondition)
s
- The string to be spannedfromIndex
- The index of the char (exclusive) that the string should be spanned backwardsspanCondition
- The span condition
public UnicodeSet cloneAsThawed()
cloneAsThawed
in interface Freezable<UnicodeSet>
public Iterator<String> iterator()
UnicodeSetIterator
.
iterator
in interface Iterable<String>
Set.iterator()
public boolean containsAll(Collection<String> collection)
containsAll(com.ibm.icu.text.UnicodeSet)
public boolean containsNone(Collection<String> collection)
containsNone(com.ibm.icu.text.UnicodeSet)
public final boolean containsSome(Collection<String> collection)
containsAll(com.ibm.icu.text.UnicodeSet)
public UnicodeSet addAll(String... collection)
addAll(com.ibm.icu.text.UnicodeSet)
public UnicodeSet removeAll(Collection<String> collection)
removeAll(com.ibm.icu.text.UnicodeSet)
public UnicodeSet retainAll(Collection<String> collection)
retainAll(com.ibm.icu.text.UnicodeSet)
public int compareTo(UnicodeSet o)
compareTo
in interface Comparable<UnicodeSet>
Comparable.compareTo(java.lang.Object)
public int compareTo(UnicodeSet o, UnicodeSet.ComparisonStyle style)
Comparable.compareTo(java.lang.Object)
public int compareTo(Iterable<String> other)
public static int compare(String string, int codePoint)
public static int compare(int codePoint, String string)
public static <T extends Comparable<T>> int compare(Iterable<T> collection1, Iterable<T> collection2)
public static <T extends Comparable<T>> int compare(Iterator<T> first, Iterator<T> other)
public static <T extends Comparable<T>> int compare(Collection<T> collection1, Collection<T> collection2, UnicodeSet.ComparisonStyle style)
public static <T,U extends Collection<T>> U addAllTo(Iterable<T> source, U target)
public static <T> T[] addAllTo(Iterable<T> source, T[] target)
public Iterable<String> strings()
for (String key : myUnicodeSet.strings()) { doSomethingWith(key); }
public static int getSingleCodePoint(CharSequence s)
public UnicodeSet addBridges(UnicodeSet dontCare)
dontCare
- Set with the don't-care characters for spanning
public int findIn(CharSequence value, int fromIndex, boolean findNot)
public int findLastIn(CharSequence value, int fromIndex, boolean findNot)
public String stripFrom(CharSequence source, boolean matches)
source
- The source of the CharSequence to strip from.matches
- A boolean to either strip all that matches or don't match with the current UnicodeSet object.
public static UnicodeSet.XSymbolTable getDefaultXSymbolTable()
public static void setDefaultXSymbolTable(UnicodeSet.XSymbolTable xSymbolTable)
WARNING: If this function is used with a UnicodeProperty, and the
Unassigned characters (gc=Cn) are different than in ICU other than in ICU, you MUST call
UnicodeProperty.ResetCacheProperties
afterwards. If you then call UnicodeSet.setDefaultXSymbolTable
with null to clear the value, you MUST also call UnicodeProperty.ResetCacheProperties
.
xSymbolTable
- the new default symbol table.
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |