com.ibm.icu.text.UnicodeSet Maven / Gradle / Ivy
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 1996-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
package com.ibm.icu.text;
import java.io.IOException;
import java.text.ParsePosition;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.SortedSet;
import java.util.TreeSet;
import com.ibm.icu.impl.BMPSet;
import com.ibm.icu.impl.CharacterPropertiesImpl;
import com.ibm.icu.impl.PatternProps;
import com.ibm.icu.impl.RuleCharacterIterator;
import com.ibm.icu.impl.SortedSetRelation;
import com.ibm.icu.impl.StringRange;
import com.ibm.icu.impl.UCaseProps;
import com.ibm.icu.impl.UPropertyAliases;
import com.ibm.icu.impl.UnicodeSetStringSpan;
import com.ibm.icu.impl.Utility;
import com.ibm.icu.lang.CharSequences;
import com.ibm.icu.lang.CharacterProperties;
import com.ibm.icu.lang.UCharacter;
import com.ibm.icu.lang.UProperty;
import com.ibm.icu.lang.UScript;
import com.ibm.icu.util.Freezable;
import com.ibm.icu.util.ICUUncheckedIOException;
import com.ibm.icu.util.OutputInt;
import com.ibm.icu.util.ULocale;
import com.ibm.icu.util.VersionInfo;
/**
* 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 make 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 the
* applyPattern() 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:
*
*
*
*
* []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
*
*
*
*
* 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.
*
* 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
*
* https://unicode-org.github.io/icu/userguide/strings/unicodeset.
* 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.
*
*
Since ICU 70, "[^...]", "[:^foo]", "\P{foo}", and "[:binaryProperty=No:]"
* perform a “code point complement” (all code points minus the original set),
* removing all multicharacter strings,
* equivalent to .{@link #complement()}.{@link #removeAllStrings()} .
* The {@link #complement()} API function continues to perform a
* symmetric difference with all code points and thus retains all multicharacter strings.
*
*
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
*
*
* 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 := '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' |
* 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
*
* property := a Unicode property set pattern
*
*
*
*
*
* Legend:
*
* a := b
* a may be replaced by b
*
* a?zero or one instance of a
*
*
*
* a*one or more instances of a
*
*
*
* a | beither a or b
*
*
*
* 'a'the literal string between the quotes
*
*
*
*
*
*
* To iterate over contents of UnicodeSet, the following are available:
*
- {@link #ranges()} to iterate through the ranges
* - {@link #strings()} to iterate through the strings
* - {@link #iterator()} to iterate through the entire contents in a single loop.
* That method is, however, not particularly efficient, since it "boxes" each code point into a String.
*
* All of the above can be used in for loops.
* The {@link com.ibm.icu.text.UnicodeSetIterator UnicodeSetIterator} can also be used, but not in for loops.
* To replace, count elements, or delete spans, see {@link com.ibm.icu.text.UnicodeSetSpanner UnicodeSetSpanner}.
*
* @author Alan Liu
* @stable ICU 2.0
* @see UnicodeSetIterator
* @see UnicodeSetSpanner
*/
public class UnicodeSet extends UnicodeFilter implements Iterable, Comparable, Freezable {
private static final SortedSet EMPTY_STRINGS =
Collections.unmodifiableSortedSet(new TreeSet());
/**
* Constant for the empty set.
* @stable ICU 4.8
*/
public static final UnicodeSet EMPTY = new UnicodeSet().freeze();
/**
* Constant for the set of all code points. (Since UnicodeSets can include strings, does not include everything that a UnicodeSet can.)
* @stable ICU 4.8
*/
public static final UnicodeSet ALL_CODE_POINTS = new UnicodeSet(0, 0x10FFFF).freeze();
private static XSymbolTable XSYMBOL_TABLE = null; // for overriding the the function processing
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
/**
* Enough for sets with few ranges.
* For example, White_Space has 10 ranges, list length 21.
*/
private static final int INITIAL_CAPACITY = 25;
/** Max list [0, 1, 2, ..., max code point, HIGH] */
private static final int MAX_LENGTH = HIGH + 1;
/**
* 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
// is not private so that UnicodeSetIterator can get access
SortedSet strings = EMPTY_STRINGS;
/**
* 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;
// Special property set IDs
private static final String ANY_ID = "ANY"; // [\u0000-\U0010FFFF]
private static final String ASCII_ID = "ASCII"; // [\u0000-\u007F]
private static final String ASSIGNED = "Assigned"; // [:^Cn:]
private volatile BMPSet bmpSet; // The set is frozen if bmpSet or stringSpan is not null.
private volatile UnicodeSetStringSpan stringSpan;
//----------------------------------------------------------------
// Public API
//----------------------------------------------------------------
/**
* Constructs an empty set.
* @stable ICU 2.0
*/
public UnicodeSet() {
list = new int[INITIAL_CAPACITY];
list[0] = HIGH;
len = 1;
}
/**
* Constructs a copy of an existing set.
* @stable ICU 2.0
*/
public UnicodeSet(UnicodeSet other) {
set(other);
}
/**
* Constructs a set containing the given range. If end >
* start 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();
add(start, end);
}
/**
* Quickly constructs a set from a set of ranges <s0, e0, s1, e1, s2, e2, ..., sn, en>.
* There must be an even number of integers, and they must be all greater than zero,
* all less than or equal to Character.MAX_CODE_POINT.
* In each pair (..., si, ei, ...) it must be true that si <= ei
* Between adjacent pairs (...ei, sj...), it must be true that ei+1 < sj
* @param pairs pairs of character representing ranges
* @stable ICU 4.4
*/
public UnicodeSet(int... pairs) {
if ((pairs.length & 1) != 0) {
throw new IllegalArgumentException("Must have even number of integers");
}
list = new int[pairs.length + 1]; // don't allocate extra space, because it is likely that this is a fixed set.
len = list.length;
int last = -1; // used to ensure that the results are monotonically increasing.
int i = 0;
while (i < pairs.length) {
int start = pairs[i];
if (last >= start) {
throw new IllegalArgumentException("Must be monotonically increasing.");
}
list[i++] = start;
int limit = pairs[i] + 1;
if (start >= limit) {
throw new IllegalArgumentException("Must be monotonically increasing.");
}
list[i++] = last = limit;
}
list[i] = HIGH; // terminate
}
/**
* 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);
}
/**
* Constructs a set from the given pattern. See the class description
* for the syntax of the pattern language.
* @param pattern a string specifying what characters are in the set
* @param ignoreWhitespace if true, ignore Unicode Pattern_White_Space characters
* @exception java.lang.IllegalArgumentException if the pattern contains
* a syntax error.
* @stable ICU 2.0
*/
public UnicodeSet(String pattern, boolean ignoreWhitespace) {
this();
applyPattern(pattern, null, null, ignoreWhitespace ? IGNORE_SPACE : 0);
}
/**
* Constructs a set from the given pattern. See the class description
* for the syntax of the pattern language.
* @param pattern a string specifying what characters are in the set
* @param options a bitmask indicating which options to apply.
* Valid options are IGNORE_SPACE and CASE.
* @exception java.lang.IllegalArgumentException if the pattern contains
* a syntax error.
* @stable ICU 3.8
*/
public UnicodeSet(String pattern, int options) {
this();
applyPattern(pattern, null, null, options);
}
/**
* Constructs a set from the given pattern. See the class description
* for the syntax of the pattern language.
* @param pattern a string specifying what characters are in the set
* @param pos on input, the position in pattern at which to start parsing.
* On output, the position after the last character parsed.
* @param symbols a symbol table mapping variables to char[] arrays
* and chars to UnicodeSets
* @exception java.lang.IllegalArgumentException if the pattern
* contains a syntax error.
* @stable ICU 2.0
*/
public UnicodeSet(String pattern, ParsePosition pos, SymbolTable symbols) {
this();
applyPattern(pattern, pos, symbols, IGNORE_SPACE);
}
/**
* Constructs a set from the given pattern. See the class description
* for the syntax of the pattern language.
* @param pattern a string specifying what characters are in the set
* @param pos on input, the position in pattern at which to start parsing.
* On output, the position after the last character parsed.
* @param symbols a symbol table mapping variables to char[] arrays
* and chars to UnicodeSets
* @param options a bitmask indicating which options to apply.
* Valid options are IGNORE_SPACE and CASE.
* @exception java.lang.IllegalArgumentException if the pattern
* contains a syntax error.
* @stable ICU 3.2
*/
public UnicodeSet(String pattern, ParsePosition pos, SymbolTable symbols, int options) {
this();
applyPattern(pattern, pos, symbols, options);
}
/**
* Return a new set that is equivalent to this one.
* @stable ICU 2.0
*/
@Override
public Object clone() {
if (isFrozen()) {
return this;
}
return new UnicodeSet(this);
}
/**
* Make this object represent the range start - end.
* If start > end then this object is set to an empty range.
*
* @param start first character in the set, inclusive
* @param end last character in the set, inclusive
* @stable ICU 2.0
*/
public UnicodeSet set(int start, int end) {
checkFrozen();
clear();
complement(start, end);
return this;
}
/**
* Make this object represent the same set as other.
* @param other a UnicodeSet whose value will be
* copied to this object
* @stable ICU 2.0
*/
public UnicodeSet set(UnicodeSet other) {
checkFrozen();
list = Arrays.copyOf(other.list, other.len);
len = other.len;
pat = other.pat;
if (other.hasStrings()) {
strings = new TreeSet<>(other.strings);
} else {
strings = EMPTY_STRINGS;
}
return this;
}
/**
* Modifies this set to represent the set specified by 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 final UnicodeSet applyPattern(String pattern) {
checkFrozen();
return applyPattern(pattern, null, null, IGNORE_SPACE);
}
/**
* Modifies this set to represent the set specified by the given pattern,
* optionally ignoring whitespace.
* See the class description for the syntax of the pattern language.
* @param pattern a string specifying what characters are in the set
* @param ignoreWhitespace if true then Unicode Pattern_White_Space characters are ignored
* @exception java.lang.IllegalArgumentException if the pattern
* contains a syntax error.
* @stable ICU 2.0
*/
public UnicodeSet applyPattern(String pattern, boolean ignoreWhitespace) {
checkFrozen();
return applyPattern(pattern, null, null, ignoreWhitespace ? IGNORE_SPACE : 0);
}
/**
* Modifies this set to represent the set specified by the given pattern,
* optionally ignoring whitespace.
* See the class description for the syntax of the pattern language.
* @param pattern a string specifying what characters are in the set
* @param options a bitmask indicating which options to apply.
* Valid options are IGNORE_SPACE and CASE.
* @exception java.lang.IllegalArgumentException if the pattern
* contains a syntax error.
* @stable ICU 3.8
*/
public UnicodeSet applyPattern(String pattern, int options) {
checkFrozen();
return applyPattern(pattern, null, null, options);
}
/**
* Return true if the given position, in the given pattern, appears
* to be the start of a UnicodeSet pattern.
* @stable ICU 2.0
*/
public static boolean resemblesPattern(String pattern, int pos) {
return ((pos+1) < pattern.length() &&
pattern.charAt(pos) == '[') ||
resemblesPropertyPattern(pattern, pos);
}
/**
* TODO: create Appendable version of UTF16.append(buf, c),
* maybe in new class Appendables?
* @throws IOException
*/
private static void appendCodePoint(Appendable app, int c) {
assert 0 <= c && c <= 0x10ffff;
try {
if (c <= 0xffff) {
app.append((char) c);
} else {
app.append(UTF16.getLeadSurrogate(c)).append(UTF16.getTrailSurrogate(c));
}
} catch (IOException e) {
throw new ICUUncheckedIOException(e);
}
}
/**
* TODO: create class Appendables?
* @throws IOException
*/
private static void append(Appendable app, CharSequence s) {
try {
app.append(s);
} catch (IOException e) {
throw new ICUUncheckedIOException(e);
}
}
/**
* Append the toPattern() representation of a
* string to the given Appendable.
*/
private static T _appendToPat(T buf, String s, boolean escapeUnprintable) {
int cp;
for (int i = 0; i < s.length(); i += Character.charCount(cp)) {
cp = s.codePointAt(i);
_appendToPat(buf, cp, escapeUnprintable);
}
return buf;
}
/**
* Append the toPattern() representation of a
* character to the given Appendable.
*/
private static T _appendToPat(T buf, int c, boolean escapeUnprintable) {
try {
if (escapeUnprintable ? Utility.isUnprintable(c) : Utility.shouldAlwaysBeEscaped(c)) {
// Use hex escape notation (uxxxx or Uxxxxxxxx) for anything
// unprintable
return Utility.escape(buf, c);
}
// Okay to let ':' pass through
switch (c) {
case '[': // SET_OPEN:
case ']': // SET_CLOSE:
case '-': // HYPHEN:
case '^': // COMPLEMENT:
case '&': // INTERSECTION:
case '\\': //BACKSLASH:
case '{':
case '}':
case '$':
case ':':
buf.append('\\');
break;
default:
// Escape whitespace
if (PatternProps.isWhiteSpace(c)) {
buf.append('\\');
}
break;
}
appendCodePoint(buf, c);
return buf;
} catch (IOException e) {
throw new ICUUncheckedIOException(e);
}
}
private static T _appendToPat(
T result, int start, int end, boolean escapeUnprintable) {
_appendToPat(result, start, escapeUnprintable);
if (start != end) {
if ((start+1) != end ||
// Avoid writing what looks like a lead+trail surrogate pair.
start == 0xdbff) {
try {
result.append('-');
} catch (IOException e) {
throw new ICUUncheckedIOException(e);
}
}
_appendToPat(result, end, escapeUnprintable);
}
return result;
}
/**
* Returns a string representation of this set. If the result of
* calling this function is passed to a UnicodeSet constructor, it
* will produce another set that is equal to this one.
* @stable ICU 2.0
*/
@Override
public String toPattern(boolean escapeUnprintable) {
if (pat != null && !escapeUnprintable) {
return pat;
}
StringBuilder result = new StringBuilder();
return _toPattern(result, escapeUnprintable).toString();
}
/**
* Append a string representation of this set to result. This will be
* a cleaned version of the string passed to applyPattern(), if there
* is one. Otherwise it will be generated.
*/
private T _toPattern(T result,
boolean escapeUnprintable) {
if (pat == null) {
return appendNewPattern(result, escapeUnprintable, true);
}
try {
if (!escapeUnprintable) {
// TODO: The C++ version does not have this shortcut, and instead
// always cleans up the pattern string,
// which also escapes Utility.shouldAlwaysBeEscaped(c).
// We should sync these implementations.
result.append(pat);
return result;
}
boolean oddNumberOfBackslashes = false;
for (int i=0; i T appendNewPattern(
T result, boolean escapeUnprintable, boolean includeStrings) {
try {
result.append('[');
int i = 0;
int limit = len & ~1; // = 2 * getRangeCount()
// If the set contains at least 2 intervals and includes both
// MIN_VALUE and MAX_VALUE, then the inverse representation will
// be more economical.
// if (getRangeCount() >= 2 &&
// getRangeStart(0) == MIN_VALUE &&
// getRangeEnd(last) == MAX_VALUE)
// Invariant: list[len-1] == HIGH == MAX_VALUE + 1
// If limit == len then len is even and the last range ends with MAX_VALUE.
//
// *But* do not write the inverse (complement) if there are strings.
// Since ICU 70, the '^' performs a code point complement which removes all strings.
if (len >= 4 && list[0] == 0 && limit == len && !hasStrings()) {
// Emit the inverse
result.append('^');
// Offsetting the inversion list index by one lets us
// iterate over the ranges of the set complement.
i = 1;
--limit;
}
// Emit the ranges as pairs.
while (i < limit) {
int start = list[i]; // getRangeStart()
int end = list[i + 1] - 1; // getRangeEnd() = range limit minus one
if (!(0xd800 <= end && end <= 0xdbff)) {
_appendToPat(result, start, end, escapeUnprintable);
i += 2;
} else {
// The range ends with a lead surrogate.
// Avoid writing what looks like a lead+trail surrogate pair.
// 1. Postpone ranges that start with a lead surrogate code point.
int firstLead = i;
while ((i += 2) < limit && list[i] <= 0xdbff) {}
int firstAfterLead = i;
// 2. Write following ranges that start with a trail surrogate code point.
while (i < limit && (start = list[i]) <= 0xdfff) {
_appendToPat(result, start, list[i + 1] - 1, escapeUnprintable);
i += 2;
}
// 3. Now write the postponed ranges.
for (int j = firstLead; j < firstAfterLead; j += 2) {
_appendToPat(result, list[j], list[j + 1] - 1, escapeUnprintable);
}
}
}
if (includeStrings && hasStrings()) {
for (String s : strings) {
result.append('{');
_appendToPat(result, s, escapeUnprintable);
result.append('}');
}
}
result.append(']');
return result;
} catch (IOException e) {
throw new ICUUncheckedIOException(e);
}
}
/**
* Returns the number of elements in this set (its cardinality)
* Note than the elements of a set may include both individual
* codepoints and strings.
*
* @return the number of elements in this set (its cardinality).
* @stable ICU 2.0
*/
public int size() {
int n = 0;
int count = getRangeCount();
for (int i = 0; i < count; ++i) {
n += getRangeEnd(i) - getRangeStart(i) + 1;
}
return n + strings.size();
}
/**
* Returns true if this set contains no elements.
*
* @return true if this set contains no elements.
* @stable ICU 2.0
*/
public boolean isEmpty() {
return len == 1 && !hasStrings();
}
/**
* @return true if this set contains multi-character strings or the empty string.
* @stable ICU 70
*/
public boolean hasStrings() {
return !strings.isEmpty();
}
/**
* Implementation of UnicodeMatcher API. Returns true if
* this set contains any character whose low byte is the given
* value. This is used by RuleBasedTransliterator for
* indexing.
* @stable ICU 2.0
*/
@Override
public boolean matchesIndexValue(int v) {
/* The index value v, in the range [0,255], is contained in this set if
* it is contained in any pair of this set. Pairs either have the high
* bytes equal, or unequal. If the high bytes are equal, then we have
* aaxx..aayy, where aa is the high byte. Then v is contained if xx <=
* v <= yy. If the high bytes are unequal we have aaxx..bbyy, bb>aa.
* Then v is contained if xx <= v || v <= yy. (This is identical to the
* time zone month containment logic.)
*/
for (int i=0; i firstChar) break;
if (c != firstChar) continue;
int length = matchRest(text, offset[0], limit, trial);
if (incremental) {
int maxLen = forward ? limit-offset[0] : offset[0]-limit;
if (length == maxLen) {
// We have successfully matched but only up to limit.
return U_PARTIAL_MATCH;
}
}
if (length == trial.length()) {
// We have successfully matched the whole string.
if (length > highWaterLength) {
highWaterLength = length;
}
// In the forward direction we know strings
// are sorted so we can bail early.
if (forward && length < highWaterLength) {
break;
}
continue;
}
}
// We've checked all strings without a partial match.
// If we have full matches, return the longest one.
if (highWaterLength != 0) {
offset[0] += forward ? highWaterLength : -highWaterLength;
return U_MATCH;
}
}
return super.matches(text, offset, limit, incremental);
}
}
/**
* Returns the longest match for s in text at the given position.
* If limit > start then match forward from start+1 to limit
* matching all characters except s.charAt(0). If limit < start,
* go backward starting from start-1 matching all characters
* except s.charAt(s.length()-1). This method assumes that the
* first character, text.charAt(start), matches s, so it does not
* check it.
* @param text the text to match
* @param start the first character to match. In the forward
* direction, text.charAt(start) is matched against s.charAt(0).
* In the reverse direction, it is matched against
* s.charAt(s.length()-1).
* @param limit the limit offset for matching, either last+1 in
* the forward direction, or last-1 in the reverse direction,
* where last is the index of the last character to match.
* @return If part of s matches up to the limit, return |limit -
* start|. If all of s matches before reaching the limit, return
* s.length(). If there is a mismatch between s and text, return
* 0
*/
private static int matchRest (Replaceable text, int start, int limit, String s) {
int maxLen;
int slen = s.length();
if (start < limit) {
maxLen = limit - start;
if (maxLen > slen) maxLen = slen;
for (int i = 1; i < maxLen; ++i) {
if (text.charAt(start + i) != s.charAt(i)) return 0;
}
} else {
maxLen = start - limit;
if (maxLen > slen) maxLen = slen;
--slen; // <=> slen = s.length() - 1;
for (int i = 1; i < maxLen; ++i) {
if (text.charAt(start - i) != s.charAt(slen - i)) return 0;
}
}
return maxLen;
}
/**
* Tests whether the text matches at the offset. If so, returns the end of the longest substring that it matches. If not, returns -1.
* @internal
* @deprecated This API is ICU internal only.
*/
@Deprecated
public int matchesAt(CharSequence text, int offset) {
int lastLen = -1;
strings:
if (hasStrings()) {
char firstChar = text.charAt(offset);
String trial = null;
// find the first string starting with firstChar
Iterator it = strings.iterator();
while (it.hasNext()) {
trial = it.next();
char firstStringChar = trial.charAt(0);
if (firstStringChar < firstChar) continue;
if (firstStringChar > firstChar) break strings;
}
// now keep checking string until we get the longest one
for (;;) {
int tempLen = matchesAt(text, offset, trial);
if (lastLen > tempLen) break strings;
lastLen = tempLen;
if (!it.hasNext()) break;
trial = it.next();
}
}
if (lastLen < 2) {
int cp = UTF16.charAt(text, offset);
if (contains(cp)) lastLen = UTF16.getCharCount(cp);
}
return offset+lastLen;
}
/**
* Does one string contain another, starting at a specific offset?
* @param text text to match
* @param offsetInText offset within that text
* @param substring substring to match at offset in text
* @return -1 if match fails, otherwise other.length()
*/
// Note: This method was moved from CollectionUtilities
private static int matchesAt(CharSequence text, int offsetInText, CharSequence substring) {
int len = substring.length();
int textLength = text.length();
if (textLength + offsetInText > len) {
return -1;
}
int i = 0;
for (int j = offsetInText; i < len; ++i, ++j) {
char pc = substring.charAt(i);
char tc = text.charAt(j);
if (pc != tc) return -1;
}
return i;
}
/**
* Implementation of UnicodeMatcher API. Union the set of all
* characters that may be matched by this object into the given
* set.
* @param toUnionTo the set into which to union the source characters
* @stable ICU 2.2
*/
@Override
public void addMatchSetTo(UnicodeSet toUnionTo) {
toUnionTo.addAll(this);
}
/**
* Returns the index of the given character within this set, where
* the set is ordered by ascending code point. If the character
* is not in this set, return -1. The inverse of this method is
* charAt().
* @return an index from 0..size()-1, or -1
* @stable ICU 2.0
*/
public int indexOf(int c) {
if (c < MIN_VALUE || c > MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(c, 6));
}
int i = 0;
int n = 0;
for (;;) {
int start = list[i++];
if (c < start) {
return -1;
}
int limit = list[i++];
if (c < limit) {
return n + c - start;
}
n += limit - start;
}
}
/**
* Returns the character at the given index within this set, where
* the set is ordered by ascending code point. If the index is
* out of range, return -1. The inverse of this method is
* indexOf().
* @param index an index from 0..size()-1
* @return the character at the given index, or -1.
* @stable ICU 2.0
*/
public int charAt(int index) {
if (index >= 0) {
// len2 is the largest even integer <= len, that is, it is len
// for even values and len-1 for odd values. With odd values
// the last entry is UNICODESET_HIGH.
int len2 = len & ~1;
for (int i=0; i < len2;) {
int start = list[i++];
int count = list[i++] - start;
if (index < count) {
return start + index;
}
index -= count;
}
}
return -1;
}
/**
* Adds the specified range to this set if it is not already
* present. If this set already contains the specified range,
* the call leaves this set unchanged. If start > end
* then an empty range is added, leaving the set unchanged.
*
* @param start first character, inclusive, of range to be added
* to this set.
* @param end last character, inclusive, of range to be added
* to this set.
* @stable ICU 2.0
*/
public UnicodeSet add(int start, int end) {
checkFrozen();
return add_unchecked(start, end);
}
/**
* Adds all characters in range (uses preferred naming convention).
* @param start The index of where to start on adding all characters.
* @param end The index of where to end on adding all characters.
* @return a reference to this object
* @stable ICU 4.4
*/
public UnicodeSet addAll(int start, int end) {
checkFrozen();
return add_unchecked(start, end);
}
// for internal use, after checkFrozen has been called
private UnicodeSet add_unchecked(int start, int end) {
if (start < MIN_VALUE || start > MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(start, 6));
}
if (end < MIN_VALUE || end > MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(end, 6));
}
if (start < end) {
int limit = end + 1;
// Fast path for adding a new range after the last one.
// Odd list length: [..., lastStart, lastLimit, HIGH]
if ((len & 1) != 0) {
// If the list is empty, set lastLimit low enough to not be adjacent to 0.
int lastLimit = len == 1 ? -2 : list[len - 2];
if (lastLimit <= start) {
checkFrozen();
if (lastLimit == start) {
// Extend the last range.
list[len - 2] = limit;
if (limit == HIGH) {
--len;
}
} else {
list[len - 1] = start;
if (limit < HIGH) {
ensureCapacity(len + 2);
list[len++] = limit;
list[len++] = HIGH;
} else { // limit == HIGH
ensureCapacity(len + 1);
list[len++] = HIGH;
}
}
pat = null;
return this;
}
}
// This is slow. Could be much faster using findCodePoint(start)
// and modifying the list, dealing with adjacent & overlapping ranges.
add(range(start, end), 2, 0);
} else if (start == end) {
add(start);
}
return this;
}
// /**
// * Format out the inversion list as a string, for debugging. Uncomment when
// * needed.
// */
// public final String dump() {
// StringBuffer buf = new StringBuffer("[");
// for (int i=0; i MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(c, 6));
}
// find smallest i such that c < list[i]
// if odd, then it is IN the set
// if even, then it is OUT of the set
int i = findCodePoint(c);
// already in set?
if ((i & 1) != 0) return this;
// HIGH is 0x110000
// assert(list[len-1] == HIGH);
// empty = [HIGH]
// [start_0, limit_0, start_1, limit_1, HIGH]
// [..., start_k-1, limit_k-1, start_k, limit_k, ..., HIGH]
// ^
// list[i]
// i == 0 means c is before the first range
// TODO: Is the "list[i]-1" a typo? Even if you pass MAX_VALUE into
// add_unchecked, the maximum value that "c" will be compared to
// is "MAX_VALUE-1" meaning that "if (c == MAX_VALUE)" will
// never be reached according to this logic.
if (c == list[i]-1) {
// c is before start of next range
list[i] = c;
// if we touched the HIGH mark, then add a new one
if (c == MAX_VALUE) {
ensureCapacity(len+1);
list[len++] = HIGH;
}
if (i > 0 && c == list[i-1]) {
// collapse adjacent ranges
// [..., start_k-1, c, c, limit_k, ..., HIGH]
// ^
// list[i]
System.arraycopy(list, i+1, list, i-1, len-i-1);
len -= 2;
}
}
else if (i > 0 && c == list[i-1]) {
// c is after end of prior range
list[i-1]++;
// no need to check for collapse here
}
else {
// At this point we know the new char is not adjacent to
// any existing ranges, and it is not 10FFFF.
// [..., start_k-1, limit_k-1, start_k, limit_k, ..., HIGH]
// ^
// list[i]
// [..., start_k-1, limit_k-1, c, c+1, start_k, limit_k, ..., HIGH]
// ^
// list[i]
// Don't use ensureCapacity() to save on copying.
// NOTE: This has no measurable impact on performance,
// but it might help in some usage patterns.
if (len+2 > list.length) {
int[] temp = new int[nextCapacity(len + 2)];
if (i != 0) System.arraycopy(list, 0, temp, 0, i);
System.arraycopy(list, i, temp, i+2, len-i);
list = temp;
} else {
System.arraycopy(list, i, list, i+2, len-i);
}
list[i] = c;
list[i+1] = c+1;
len += 2;
}
pat = null;
return this;
}
/**
* Adds the specified multicharacter to this set if it is not already
* present. If this set already contains the multicharacter,
* the call leaves this set unchanged.
* Thus "ch" => {"ch"}
*
* @param s the source string
* @return this object, for chaining
* @stable ICU 2.0
*/
public final UnicodeSet add(CharSequence s) {
checkFrozen();
int cp = getSingleCP(s);
if (cp < 0) {
String str = s.toString();
if (!strings.contains(str)) {
addString(str);
pat = null;
}
} else {
add_unchecked(cp, cp);
}
return this;
}
private void addString(CharSequence s) {
if (strings == EMPTY_STRINGS) {
strings = new TreeSet<>();
}
strings.add(s.toString());
}
/**
* Utility for getting code point from single code point CharSequence.
* See the public UTF16.getSingleCodePoint() (which returns -1 for null rather than throwing NPE).
*
* @return a code point IF the string consists of a single one.
* otherwise returns -1.
* @param s to test
*/
private static int getSingleCP(CharSequence s) {
if (s.length() == 1) return s.charAt(0);
if (s.length() == 2) {
int cp = Character.codePointAt(s, 0);
if (cp > 0xFFFF) { // is surrogate pair
return cp;
}
}
return -1;
}
/**
* Adds each of the characters in this string to the set. Thus "ch" => {"c", "h"}
* If this set already any particular character, it has no effect on that character.
* @param s the source string
* @return this object, for chaining
* @stable ICU 2.0
*/
public final UnicodeSet addAll(CharSequence s) {
checkFrozen();
int cp;
for (int i = 0; i < s.length(); i += UTF16.getCharCount(cp)) {
cp = UTF16.charAt(s, i);
add_unchecked(cp, cp);
}
return this;
}
/**
* Retains EACH of the characters in this string. Note: "ch" == {"c", "h"}
* If this set already any particular character, it has no effect on that character.
* @param s the source string
* @return this object, for chaining
* @stable ICU 2.0
*/
public final UnicodeSet retainAll(CharSequence s) {
return retainAll(fromAll(s));
}
/**
* Complement EACH of the characters in this string. Note: "ch" == {"c", "h"}
* If this set already any particular character, it has no effect on that character.
* @param s the source string
* @return this object, for chaining
* @stable ICU 2.0
*/
public final UnicodeSet complementAll(CharSequence s) {
return complementAll(fromAll(s));
}
/**
* Remove EACH of the characters in this string. Note: "ch" == {"c", "h"}
* If this set already any particular character, it has no effect on that character.
* @param s the source string
* @return this object, for chaining
* @stable ICU 2.0
*/
public final UnicodeSet removeAll(CharSequence s) {
return removeAll(fromAll(s));
}
/**
* Remove all strings from this UnicodeSet
* @return this object, for chaining
* @stable ICU 4.2
*/
public final UnicodeSet removeAllStrings() {
checkFrozen();
if (hasStrings()) {
strings.clear();
pat = null;
}
return this;
}
/**
* Makes a set from a multicharacter string. Thus "ch" => {"ch"}
*
* @param s the source string
* @return a newly created set containing the given string
* @stable ICU 2.0
*/
public static UnicodeSet from(CharSequence s) {
return new UnicodeSet().add(s);
}
/**
* Makes a set from each of the characters in the string. Thus "ch" => {"c", "h"}
* @param s the source string
* @return a newly created set containing the given characters
* @stable ICU 2.0
*/
public static UnicodeSet fromAll(CharSequence s) {
return new UnicodeSet().addAll(s);
}
/**
* Retain only the elements in this set that are contained in the
* specified range. If start > end then an empty range is
* retained, leaving the set empty.
*
* @param start first character, inclusive, of range
* @param end last character, inclusive, of range
* @stable ICU 2.0
*/
public UnicodeSet retain(int start, int end) {
checkFrozen();
if (start < MIN_VALUE || start > MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(start, 6));
}
if (end < MIN_VALUE || end > MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(end, 6));
}
if (start <= end) {
retain(range(start, end), 2, 0);
} else {
clear();
}
return this;
}
/**
* Retain the specified character from this set if it is present.
* Upon return this set will be empty if it did not contain c, or
* will only contain c if it did contain c.
* @param c the character to be retained
* @return this object, for chaining
* @stable ICU 2.0
*/
public final UnicodeSet retain(int c) {
return retain(c, c);
}
/**
* Retain the specified string in this set if it is present.
* Upon return this set will be empty if it did not contain s, or
* will only contain s if it did contain s.
* @param cs the string to be retained
* @return this object, for chaining
* @stable ICU 2.0
*/
public final UnicodeSet retain(CharSequence cs) {
int cp = getSingleCP(cs);
if (cp < 0) {
checkFrozen();
String s = cs.toString();
boolean isIn = strings.contains(s);
// Check for getRangeCount() first to avoid somewhat-expensive size()
// when there are single code points.
if (isIn && getRangeCount() == 0 && size() == 1) {
return this;
}
clear();
if (isIn) {
addString(s);
}
pat = null;
} else {
retain(cp, cp);
}
return this;
}
/**
* Removes the specified range from this set if it is present.
* The set will not contain the specified range once the call
* returns. If start > end then an empty range is
* removed, leaving the set unchanged.
*
* @param start first character, inclusive, of range to be removed
* from this set.
* @param end last character, inclusive, of range to be removed
* from this set.
* @stable ICU 2.0
*/
public UnicodeSet remove(int start, int end) {
checkFrozen();
if (start < MIN_VALUE || start > MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(start, 6));
}
if (end < MIN_VALUE || end > MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(end, 6));
}
if (start <= end) {
retain(range(start, end), 2, 2);
}
return this;
}
/**
* Removes the specified character from this set if it is present.
* The set will not contain the specified character once the call
* returns.
* @param c the character to be removed
* @return this object, for chaining
* @stable ICU 2.0
*/
public final UnicodeSet remove(int c) {
return remove(c, c);
}
/**
* Removes the specified string from this set if it is present.
* The set will not contain the specified string once the call
* returns.
* @param s the string to be removed
* @return this object, for chaining
* @stable ICU 2.0
*/
public final UnicodeSet remove(CharSequence s) {
int cp = getSingleCP(s);
if (cp < 0) {
checkFrozen();
String str = s.toString();
if (strings.contains(str)) {
strings.remove(str);
pat = null;
}
} else {
remove(cp, cp);
}
return this;
}
/**
* Complements the specified range in this set. Any character in
* the range will be removed if it is in this set, or will be
* added if it is not in this set. If start > end
* then an empty range is complemented, leaving the set unchanged.
*
* @param start first character, inclusive, of range
* @param end last character, inclusive, of range
* @stable ICU 2.0
*/
public UnicodeSet complement(int start, int end) {
checkFrozen();
if (start < MIN_VALUE || start > MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(start, 6));
}
if (end < MIN_VALUE || end > MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(end, 6));
}
if (start <= end) {
xor(range(start, end), 2, 0);
}
pat = null;
return this;
}
/**
* Complements the specified character in this set. The character
* will be removed if it is in this set, or will be added if it is
* not in this set.
* @stable ICU 2.0
*/
public final UnicodeSet complement(int c) {
return complement(c, c);
}
/**
* This is equivalent to
* complement(MIN_VALUE, MAX_VALUE).
*
* Note: This performs a symmetric difference with all code points
* and thus retains all multicharacter strings.
* In order to achieve a “code point complement” (all code points minus this set),
* the easiest is to .{@link #complement()}.{@link #removeAllStrings()} .
*
* @stable ICU 2.0
*/
public UnicodeSet complement() {
checkFrozen();
if (list[0] == LOW) {
System.arraycopy(list, 1, list, 0, len-1);
--len;
} else {
ensureCapacity(len+1);
System.arraycopy(list, 0, list, 1, len);
list[0] = LOW;
++len;
}
pat = null;
return this;
}
/**
* Complement the specified string in this set.
* The set will not contain the specified string once the call
* returns.
*
* @param s the string to complement
* @return this object, for chaining
* @stable ICU 2.0
*/
public final UnicodeSet complement(CharSequence s) {
checkFrozen();
int cp = getSingleCP(s);
if (cp < 0) {
String s2 = s.toString();
if (strings.contains(s2)) {
strings.remove(s2);
} else {
addString(s2);
}
pat = null;
} else {
complement(cp, cp);
}
return this;
}
/**
* Returns true if this set contains the given character.
* @param c character to be checked for containment
* @return true if the test condition is met
* @stable ICU 2.0
*/
@Override
public boolean contains(int c) {
if (c < MIN_VALUE || c > MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(c, 6));
}
if (bmpSet != null) {
return bmpSet.contains(c);
}
if (stringSpan != null) {
return stringSpan.contains(c);
}
/*
// Set i to the index of the start item greater than ch
// We know we will terminate without length test!
int i = -1;
while (true) {
if (c < list[++i]) break;
}
*/
int i = findCodePoint(c);
return ((i & 1) != 0); // return true if odd
}
/**
* Returns the smallest value i such that c < list[i]. Caller
* must ensure that c is a legal value or this method will enter
* an infinite loop. This method performs a binary search.
* @param c a character in the range MIN_VALUE..MAX_VALUE
* inclusive
* @return the smallest integer i in the range 0..len-1,
* inclusive, such that c < list[i]
*/
private final int findCodePoint(int c) {
/* Examples:
findCodePoint(c)
set list[] c=0 1 3 4 7 8
=== ============== ===========
[] [110000] 0 0 0 0 0 0
[\u0000-\u0003] [0, 4, 110000] 1 1 1 2 2 2
[\u0004-\u0007] [4, 8, 110000] 0 0 0 1 1 2
[:all:] [0, 110000] 1 1 1 1 1 1
*/
// Return the smallest i such that c < list[i]. Assume
// list[len - 1] == HIGH and that c is legal (0..HIGH-1).
if (c < list[0]) return 0;
// High runner test. c is often after the last range, so an
// initial check for this condition pays off.
if (len >= 2 && c >= list[len-2]) return len-1;
int lo = 0;
int hi = len - 1;
// invariant: c >= list[lo]
// invariant: c < list[hi]
for (;;) {
int i = (lo + hi) >>> 1;
if (i == lo) return hi;
if (c < list[i]) {
hi = i;
} else {
lo = i;
}
}
}
// //----------------------------------------------------------------
// // Unrolled binary search
// //----------------------------------------------------------------
//
// private int validLen = -1; // validated value of len
// private int topOfLow;
// private int topOfHigh;
// private int power;
// private int deltaStart;
//
// private void validate() {
// if (len <= 1) {
// throw new IllegalArgumentException("list.len==" + len + "; must be >1");
// }
//
// // find greatest power of 2 less than or equal to len
// for (power = exp2.length-1; power > 0 && exp2[power] > len; power--) {}
//
// // assert(exp2[power] <= len);
//
// // determine the starting points
// topOfLow = exp2[power] - 1;
// topOfHigh = len - 1;
// deltaStart = exp2[power-1];
// validLen = len;
// }
//
// private static final int exp2[] = {
// 0x1, 0x2, 0x4, 0x8,
// 0x10, 0x20, 0x40, 0x80,
// 0x100, 0x200, 0x400, 0x800,
// 0x1000, 0x2000, 0x4000, 0x8000,
// 0x10000, 0x20000, 0x40000, 0x80000,
// 0x100000, 0x200000, 0x400000, 0x800000,
// 0x1000000, 0x2000000, 0x4000000, 0x8000000,
// 0x10000000, 0x20000000 // , 0x40000000 // no unsigned int in Java
// };
//
// /**
// * Unrolled lowest index GT.
// */
// private final int leastIndexGT(int searchValue) {
//
// if (len != validLen) {
// if (len == 1) return 0;
// validate();
// }
// int temp;
//
// // set up initial range to search. Each subrange is a power of two in length
// int high = searchValue < list[topOfLow] ? topOfLow : topOfHigh;
//
// // Completely unrolled binary search, folhighing "Programming Pearls"
// // Each case deliberately falls through to the next
// // Logically, list[-1] < all_search_values && list[count] > all_search_values
// // although the values -1 and count are never actually touched.
//
// // The bounds at each point are low & high,
// // where low == high - delta*2
// // so high - delta is the midpoint
//
// // The invariant AFTER each line is that list[low] < searchValue <= list[high]
//
// switch (power) {
// //case 31: if (searchValue < list[temp = high-0x40000000]) high = temp; // no unsigned int in Java
// case 30: if (searchValue < list[temp = high-0x20000000]) high = temp;
// case 29: if (searchValue < list[temp = high-0x10000000]) high = temp;
//
// case 28: if (searchValue < list[temp = high- 0x8000000]) high = temp;
// case 27: if (searchValue < list[temp = high- 0x4000000]) high = temp;
// case 26: if (searchValue < list[temp = high- 0x2000000]) high = temp;
// case 25: if (searchValue < list[temp = high- 0x1000000]) high = temp;
//
// case 24: if (searchValue < list[temp = high- 0x800000]) high = temp;
// case 23: if (searchValue < list[temp = high- 0x400000]) high = temp;
// case 22: if (searchValue < list[temp = high- 0x200000]) high = temp;
// case 21: if (searchValue < list[temp = high- 0x100000]) high = temp;
//
// case 20: if (searchValue < list[temp = high- 0x80000]) high = temp;
// case 19: if (searchValue < list[temp = high- 0x40000]) high = temp;
// case 18: if (searchValue < list[temp = high- 0x20000]) high = temp;
// case 17: if (searchValue < list[temp = high- 0x10000]) high = temp;
//
// case 16: if (searchValue < list[temp = high- 0x8000]) high = temp;
// case 15: if (searchValue < list[temp = high- 0x4000]) high = temp;
// case 14: if (searchValue < list[temp = high- 0x2000]) high = temp;
// case 13: if (searchValue < list[temp = high- 0x1000]) high = temp;
//
// case 12: if (searchValue < list[temp = high- 0x800]) high = temp;
// case 11: if (searchValue < list[temp = high- 0x400]) high = temp;
// case 10: if (searchValue < list[temp = high- 0x200]) high = temp;
// case 9: if (searchValue < list[temp = high- 0x100]) high = temp;
//
// case 8: if (searchValue < list[temp = high- 0x80]) high = temp;
// case 7: if (searchValue < list[temp = high- 0x40]) high = temp;
// case 6: if (searchValue < list[temp = high- 0x20]) high = temp;
// case 5: if (searchValue < list[temp = high- 0x10]) high = temp;
//
// case 4: if (searchValue < list[temp = high- 0x8]) high = temp;
// case 3: if (searchValue < list[temp = high- 0x4]) high = temp;
// case 2: if (searchValue < list[temp = high- 0x2]) high = temp;
// case 1: if (searchValue < list[temp = high- 0x1]) high = temp;
// }
//
// return high;
// }
//
// // For debugging only
// public int len() {
// return len;
// }
//
// //----------------------------------------------------------------
// //----------------------------------------------------------------
/**
* Returns true if this set contains every character
* of the given range.
* @param start first character, inclusive, of the range
* @param end last character, inclusive, of the range
* @return true if the test condition is met
* @stable ICU 2.0
*/
public boolean contains(int start, int end) {
if (start < MIN_VALUE || start > MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(start, 6));
}
if (end < MIN_VALUE || end > MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(end, 6));
}
//int i = -1;
//while (true) {
// if (start < list[++i]) break;
//}
int i = findCodePoint(start);
return ((i & 1) != 0 && end < list[i]);
}
/**
* Returns true if this set contains the given
* multicharacter string.
* @param s string to be checked for containment
* @return true if this set contains the specified string
* @stable ICU 2.0
*/
public final boolean contains(CharSequence s) {
int cp = getSingleCP(s);
if (cp < 0) {
return strings.contains(s.toString());
} else {
return contains(cp);
}
}
/**
* Returns true if this set contains all the characters and strings
* of the given set.
* @param b set to be checked for containment
* @return true if the test condition is met
* @stable ICU 2.0
*/
public boolean containsAll(UnicodeSet b) {
// The specified set is a subset if all of its pairs are contained in
// this set. This implementation accesses the lists directly for speed.
// TODO: this could be faster if size() were cached. But that would affect building speed
// so it needs investigation.
int[] listB = b.list;
boolean needA = true;
boolean needB = true;
int aPtr = 0;
int bPtr = 0;
int aLen = len - 1;
int bLen = b.len - 1;
int startA = 0, startB = 0, limitA = 0, limitB = 0;
while (true) {
// double iterations are such a pain...
if (needA) {
if (aPtr >= aLen) {
// ran out of A. If B is also exhausted, then break;
if (needB && bPtr >= bLen) {
break;
}
return false;
}
startA = list[aPtr++];
limitA = list[aPtr++];
}
if (needB) {
if (bPtr >= bLen) {
// ran out of B. Since we got this far, we have an A and we are ok so far
break;
}
startB = listB[bPtr++];
limitB = listB[bPtr++];
}
// if B doesn't overlap and is greater than A, get new A
if (startB >= limitA) {
needA = true;
needB = false;
continue;
}
// if B is wholy contained in A, then get a new B
if (startB >= startA && limitB <= limitA) {
needA = false;
needB = true;
continue;
}
// all other combinations mean we fail
return false;
}
if (!strings.containsAll(b.strings)) return false;
return true;
}
// /**
// * Returns true if this set contains all the characters and strings
// * of the given set.
// * @param c set to be checked for containment
// * @return true if the test condition is met
// * @stable ICU 2.0
// */
// public boolean containsAllOld(UnicodeSet c) {
// // The specified set is a subset if all of its pairs are contained in
// // this set. It's possible to code this more efficiently in terms of
// // direct manipulation of the inversion lists if the need arises.
// int n = c.getRangeCount();
// for (int i=0; i
* containsAll is true for each of: "a", "bc", ""cdbca"
* containsAll is false for each of: "acb", "bcda", "bcx"
* @param s string containing characters to be checked for containment
* @return true if the test condition is met
* @stable ICU 2.0
*/
public boolean containsAll(String s) {
int cp;
for (int i = 0; i < s.length(); i += UTF16.getCharCount(cp)) {
cp = UTF16.charAt(s, i);
if (!contains(cp)) {
if (!hasStrings()) {
return false;
}
return containsAll(s, 0);
}
}
return true;
}
/**
* Recursive routine called if we fail to find a match in containsAll, and there are strings
* @param s source string
* @param i point to match to the end on
* @return true if ok
*/
private boolean containsAll(String s, int i) {
if (i >= s.length()) {
return true;
}
int cp= UTF16.charAt(s, i);
if (contains(cp) && containsAll(s, i+UTF16.getCharCount(cp))) {
return true;
}
for (String setStr : strings) {
if (!setStr.isEmpty() && // skip the empty string
s.startsWith(setStr, i) && containsAll(s, i+setStr.length())) {
return true;
}
}
return false;
}
/**
* Get the Regex equivalent for this UnicodeSet
* @return regex pattern equivalent to this UnicodeSet
* @internal
* @deprecated This API is ICU internal only.
*/
@Deprecated
public String getRegexEquivalent() {
if (!hasStrings()) {
return toString();
}
StringBuilder result = new StringBuilder("(?:");
appendNewPattern(result, true, false);
for (String s : strings) {
result.append('|');
_appendToPat(result, s, true);
}
return result.append(")").toString();
}
/**
* Returns true if this set contains none of the characters
* of the given range.
* @param start first character, inclusive, of the range
* @param end last character, inclusive, of the range
* @return true if the test condition is met
* @stable ICU 2.0
*/
public boolean containsNone(int start, int end) {
if (start < MIN_VALUE || start > MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(start, 6));
}
if (end < MIN_VALUE || end > MAX_VALUE) {
throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(end, 6));
}
int i = -1;
while (true) {
if (start < list[++i]) break;
}
return ((i & 1) == 0 && end < list[i]);
}
/**
* Returns true if none of the characters or strings in this UnicodeSet appears in the string.
* For example, for the Unicode set [a{bc}{cd}]
* containsNone is true for: "xy", "cb"
* containsNone is false for: "a", "bc", "bcd"
* @param b set to be checked for containment
* @return true if the test condition is met
* @stable ICU 2.0
*/
public boolean containsNone(UnicodeSet b) {
// The specified set is a subset if some of its pairs overlap with some of this set's pairs.
// This implementation accesses the lists directly for speed.
int[] listB = b.list;
boolean needA = true;
boolean needB = true;
int aPtr = 0;
int bPtr = 0;
int aLen = len - 1;
int bLen = b.len - 1;
int startA = 0, startB = 0, limitA = 0, limitB = 0;
while (true) {
// double iterations are such a pain...
if (needA) {
if (aPtr >= aLen) {
// ran out of A: break so we test strings
break;
}
startA = list[aPtr++];
limitA = list[aPtr++];
}
if (needB) {
if (bPtr >= bLen) {
// ran out of B: break so we test strings
break;
}
startB = listB[bPtr++];
limitB = listB[bPtr++];
}
// if B is higher than any part of A, get new A
if (startB >= limitA) {
needA = true;
needB = false;
continue;
}
// if A is higher than any part of B, get new B
if (startA >= limitB) {
needA = false;
needB = true;
continue;
}
// all other combinations mean we fail
return false;
}
if (!SortedSetRelation.hasRelation(strings, SortedSetRelation.DISJOINT, b.strings)) return false;
return true;
}
// /**
// * Returns true if none of the characters or strings in this UnicodeSet appears in the string.
// * For example, for the Unicode set [a{bc}{cd}]
// * containsNone is true for: "xy", "cb"
// * containsNone is false for: "a", "bc", "bcd"
// * @param c set to be checked for containment
// * @return true if the test condition is met
// * @stable ICU 2.0
// */
// public boolean containsNoneOld(UnicodeSet c) {
// // The specified set is a subset if all of its pairs are contained in
// // this set. It's possible to code this more efficiently in terms of
// // direct manipulation of the inversion lists if the need arises.
// int n = c.getRangeCount();
// for (int i=0; iunion of the two
* sets. The behavior of this operation is unspecified if the specified
* collection is modified while the operation is in progress.
*
* @param c set whose elements are to be added to this set.
* @stable ICU 2.0
*/
public UnicodeSet addAll(UnicodeSet c) {
checkFrozen();
add(c.list, c.len, 0);
if (c.hasStrings()) {
if (strings == EMPTY_STRINGS) {
strings = new TreeSet<>(c.strings);
} else {
strings.addAll(c.strings);
}
}
return this;
}
/**
* Retains only the elements in this set that are contained in the
* specified set. In other words, removes from this set all of
* its elements that are not contained in the specified set. This
* operation effectively modifies this set so that its value is
* the intersection of the two sets.
*
* @param c set that defines which elements this set will retain.
* @stable ICU 2.0
*/
public UnicodeSet retainAll(UnicodeSet c) {
checkFrozen();
retain(c.list, c.len, 0);
if (hasStrings()) {
if (!c.hasStrings()) {
strings.clear();
} else {
strings.retainAll(c.strings);
}
}
return this;
}
/**
* Removes from this set all of its elements that are contained in the
* specified set. This operation effectively modifies this
* set so that its value is the asymmetric set difference of
* the two sets.
*
* @param c set that defines which elements will be removed from
* this set.
* @stable ICU 2.0
*/
public UnicodeSet removeAll(UnicodeSet c) {
checkFrozen();
retain(c.list, c.len, 2);
if (hasStrings() && c.hasStrings()) {
strings.removeAll(c.strings);
}
return this;
}
/**
* Complements in this set all elements contained in the specified
* set. Any character in the other set will be removed if it is
* in this set, or will be added if it is not in this set.
*
* @param c set that defines which elements will be complemented from
* this set.
* @stable ICU 2.0
*/
public UnicodeSet complementAll(UnicodeSet c) {
checkFrozen();
xor(c.list, c.len, 0);
if (c.hasStrings()) {
if (strings == EMPTY_STRINGS) {
strings = new TreeSet<>(c.strings);
} else {
SortedSetRelation.doOperation(strings, SortedSetRelation.COMPLEMENTALL, c.strings);
}
}
return this;
}
/**
* Removes all of the elements from this set. This set will be
* empty after this call returns.
* @stable ICU 2.0
*/
public UnicodeSet clear() {
checkFrozen();
list[0] = HIGH;
len = 1;
pat = null;
if (hasStrings()) {
strings.clear();
}
return this;
}
/**
* Iteration method that returns the number of ranges contained in
* this set.
* @see #getRangeStart
* @see #getRangeEnd
* @stable ICU 2.0
*/
public int getRangeCount() {
return len/2;
}
/**
* Iteration method that returns the first character in the
* specified range of this set.
* @exception ArrayIndexOutOfBoundsException if index is outside
* the range 0..getRangeCount()-1
* @see #getRangeCount
* @see #getRangeEnd
* @stable ICU 2.0
*/
public int getRangeStart(int index) {
return list[index*2];
}
/**
* Iteration method that returns the last character in the
* specified range of this set.
* @exception ArrayIndexOutOfBoundsException if index is outside
* the range 0..getRangeCount()-1
* @see #getRangeStart
* @see #getRangeEnd
* @stable ICU 2.0
*/
public int getRangeEnd(int index) {
return (list[index*2 + 1] - 1);
}
/**
* Reallocate this objects internal structures to take up the least
* possible space, without changing this object's value.
* @stable ICU 2.0
*/
public UnicodeSet compact() {
checkFrozen();
if ((len + 7) < list.length) {
// If we have more than a little unused capacity, shrink it to len.
list = Arrays.copyOf(list, len);
}
rangeList = null;
buffer = null;
if (strings != EMPTY_STRINGS && strings.isEmpty()) {
strings = EMPTY_STRINGS;
}
return this;
}
/**
* Compares the specified object with this set for equality. Returns
* true if the specified object is also a set, the two sets
* have the same size, and every member of the specified set is
* contained in this set (or equivalently, every member of this set is
* contained in the specified set).
*
* @param o Object to be compared for equality with this set.
* @return true if the specified Object is equal to this set.
* @stable ICU 2.0
*/
@Override
public boolean equals(Object o) {
if (o == null) {
return false;
}
if (this == o) {
return true;
}
try {
UnicodeSet that = (UnicodeSet) o;
if (len != that.len) return false;
for (int i = 0; i < len; ++i) {
if (list[i] != that.list[i]) return false;
}
if (!strings.equals(that.strings)) return false;
} catch (Exception e) {
return false;
}
return true;
}
/**
* Returns the hash code value for this set.
*
* @return the hash code value for this set.
* @see java.lang.Object#hashCode()
* @stable ICU 2.0
*/
@Override
public int hashCode() {
int result = len;
for (int i = 0; i < len; ++i) {
result *= 1000003;
result += list[i];
}
return result;
}
/**
* Return a programmer-readable string representation of this object.
* @stable ICU 2.0
*/
@Override
public String toString() {
return toPattern(true);
}
//----------------------------------------------------------------
// Implementation: Pattern parsing
//----------------------------------------------------------------
/**
* Parses the given pattern, starting at the given position. The character
* at pattern.charAt(pos.getIndex()) must be '[', or the parse fails.
* Parsing continues until the corresponding closing ']'. If a syntax error
* is encountered between the opening and closing brace, the parse fails.
* Upon return from a successful parse, the ParsePosition is updated to
* point to the character following the closing ']', and an inversion
* list for the parsed pattern is returned. This method
* calls itself recursively to parse embedded subpatterns.
*
* @param 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.
* @param 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.
* @return an inversion list for the parsed substring
* of pattern
* @exception java.lang.IllegalArgumentException if the parse fails.
* @internal
* @deprecated This API is ICU internal only.
*/
@Deprecated
public UnicodeSet applyPattern(String pattern,
ParsePosition pos,
SymbolTable symbols,
int options) {
// Need to build the pattern in a temporary string because
// _applyPattern calls add() etc., which set pat to empty.
boolean parsePositionWasNull = pos == null;
if (parsePositionWasNull) {
pos = new ParsePosition(0);
}
StringBuilder rebuiltPat = new StringBuilder();
RuleCharacterIterator chars =
new RuleCharacterIterator(pattern, symbols, pos);
applyPattern(chars, symbols, rebuiltPat, options, 0);
if (chars.inVariable()) {
syntaxError(chars, "Extra chars in variable value");
}
pat = rebuiltPat.toString();
if (parsePositionWasNull) {
int i = pos.getIndex();
// Skip over trailing whitespace
if ((options & IGNORE_SPACE) != 0) {
i = PatternProps.skipWhiteSpace(pattern, i);
}
if (i != pattern.length()) {
throw new IllegalArgumentException("Parse of \"" + pattern +
"\" failed at " + i);
}
}
return this;
}
// Add constants to make the applyPattern() code easier to follow.
private static final int LAST0_START = 0,
LAST1_RANGE = 1,
LAST2_SET = 2;
private static final int MODE0_NONE = 0,
MODE1_INBRACKET = 1,
MODE2_OUTBRACKET = 2;
private static final int SETMODE0_NONE = 0,
SETMODE1_UNICODESET = 1,
SETMODE2_PROPERTYPAT = 2,
SETMODE3_PREPARSED = 3;
private static final int MAX_DEPTH = 100;
/**
* Parse the pattern from the given RuleCharacterIterator. The
* iterator is advanced over the parsed pattern.
* @param chars iterator over the pattern characters. Upon return
* it will be advanced to the first character after the parsed
* pattern, or the end of the iteration if all characters are
* parsed.
* @param symbols symbol table to use to parse and dereference
* variables, or null if none.
* @param rebuiltPat the pattern that was parsed, rebuilt or
* copied from the input pattern, as appropriate.
* @param options a bit mask of zero or more of the following:
* IGNORE_SPACE, CASE.
*/
private void applyPattern(RuleCharacterIterator chars, SymbolTable symbols,
Appendable rebuiltPat, int options, int depth) {
if (depth > MAX_DEPTH) {
syntaxError(chars, "Pattern nested too deeply");
}
// Syntax characters: [ ] ^ - & { }
// Recognized special forms for chars, sets: c-c s-s s&s
int opts = RuleCharacterIterator.PARSE_VARIABLES |
RuleCharacterIterator.PARSE_ESCAPES;
if ((options & IGNORE_SPACE) != 0) {
opts |= RuleCharacterIterator.SKIP_WHITESPACE;
}
StringBuilder patBuf = new StringBuilder(), buf = null;
boolean usePat = false;
UnicodeSet scratch = null;
RuleCharacterIterator.Position backup = null;
// mode: 0=before [, 1=between [...], 2=after ]
// lastItem: 0=none, 1=char, 2=set
int lastItem = LAST0_START, lastChar = 0, mode = MODE0_NONE;
char op = 0;
boolean invert = false;
clear();
String lastString = null;
while (mode != MODE2_OUTBRACKET && !chars.atEnd()) {
//Eclipse stated the following is "dead code"
/*
if (false) {
// Debugging assertion
if (!((lastItem == 0 && op == 0) ||
(lastItem == 1 && (op == 0 || op == '-')) ||
(lastItem == 2 && (op == 0 || op == '-' || op == '&')))) {
throw new IllegalArgumentException();
}
}*/
int c = 0;
boolean literal = false;
UnicodeSet nested = null;
// -------- Check for property pattern
// setMode: 0=none, 1=unicodeset, 2=propertypat, 3=preparsed
int setMode = SETMODE0_NONE;
if (resemblesPropertyPattern(chars, opts)) {
setMode = SETMODE2_PROPERTYPAT;
}
// -------- Parse '[' of opening delimiter OR nested set.
// If there is a nested set, use `setMode' to define how
// the set should be parsed. If the '[' is part of the
// opening delimiter for this pattern, parse special
// strings "[", "[^", "[-", and "[^-". Check for stand-in
// characters representing a nested set in the symbol
// table.
else {
// Prepare to backup if necessary
backup = chars.getPos(backup);
c = chars.next(opts);
literal = chars.isEscaped();
if (c == '[' && !literal) {
if (mode == MODE1_INBRACKET) {
chars.setPos(backup); // backup
setMode = SETMODE1_UNICODESET;
} else {
// Handle opening '[' delimiter
mode = MODE1_INBRACKET;
patBuf.append('[');
backup = chars.getPos(backup); // prepare to backup
c = chars.next(opts);
literal = chars.isEscaped();
if (c == '^' && !literal) {
invert = true;
patBuf.append('^');
backup = chars.getPos(backup); // prepare to backup
c = chars.next(opts);
literal = chars.isEscaped();
}
// Fall through to handle special leading '-';
// otherwise restart loop for nested [], \p{}, etc.
if (c == '-') {
literal = true;
// Fall through to handle literal '-' below
} else {
chars.setPos(backup); // backup
continue;
}
}
} else if (symbols != null) {
UnicodeMatcher m = symbols.lookupMatcher(c); // may be null
if (m != null) {
try {
nested = (UnicodeSet) m;
setMode = SETMODE3_PREPARSED;
} catch (ClassCastException e) {
syntaxError(chars, "Syntax error");
}
}
}
}
// -------- Handle a nested set. This either is inline in
// the pattern or represented by a stand-in that has
// previously been parsed and was looked up in the symbol
// table.
if (setMode != SETMODE0_NONE) {
if (lastItem == LAST1_RANGE) {
if (op != 0) {
syntaxError(chars, "Char expected after operator");
}
add_unchecked(lastChar, lastChar);
_appendToPat(patBuf, lastChar, false);
lastItem = LAST0_START;
op = 0;
}
if (op == '-' || op == '&') {
patBuf.append(op);
}
if (nested == null) {
if (scratch == null) scratch = new UnicodeSet();
nested = scratch;
}
switch (setMode) {
case SETMODE1_UNICODESET:
nested.applyPattern(chars, symbols, patBuf, options, depth + 1);
break;
case SETMODE2_PROPERTYPAT:
chars.skipIgnored(opts);
nested.applyPropertyPattern(chars, patBuf, symbols);
break;
case SETMODE3_PREPARSED: // `nested' already parsed
nested._toPattern(patBuf, false);
break;
}
usePat = true;
if (mode == MODE0_NONE) {
// Entire pattern is a category; leave parse loop
set(nested);
mode = MODE2_OUTBRACKET;
break;
}
switch (op) {
case '-':
removeAll(nested);
break;
case '&':
retainAll(nested);
break;
case 0:
addAll(nested);
break;
}
op = 0;
lastItem = LAST2_SET;
continue;
}
if (mode == MODE0_NONE) {
syntaxError(chars, "Missing '['");
}
// -------- Parse special (syntax) characters. If the
// current character is not special, or if it is escaped,
// then fall through and handle it below.
if (!literal) {
switch (c) {
case ']':
if (lastItem == LAST1_RANGE) {
add_unchecked(lastChar, lastChar);
_appendToPat(patBuf, lastChar, false);
}
// Treat final trailing '-' as a literal
if (op == '-') {
add_unchecked(op, op);
patBuf.append(op);
} else if (op == '&') {
syntaxError(chars, "Trailing '&'");
}
patBuf.append(']');
mode = MODE2_OUTBRACKET;
continue;
case '-':
if (op == 0) {
if (lastItem != LAST0_START) {
op = (char) c;
continue;
} else if (lastString != null) {
op = (char) c;
continue;
} else {
// Treat final trailing '-' as a literal
add_unchecked(c, c);
c = chars.next(opts);
literal = chars.isEscaped();
if (c == ']' && !literal) {
patBuf.append("-]");
mode = MODE2_OUTBRACKET;
continue;
}
}
}
syntaxError(chars, "'-' not after char, string, or set");
break;
case '&':
if (lastItem == LAST2_SET && op == 0) {
op = (char) c;
continue;
}
syntaxError(chars, "'&' not after set");
break;
case '^':
syntaxError(chars, "'^' not after '['");
break;
case '{':
if (op != 0 && op != '-') {
syntaxError(chars, "Missing operand after operator");
}
if (lastItem == LAST1_RANGE) {
add_unchecked(lastChar, lastChar);
_appendToPat(patBuf, lastChar, false);
}
lastItem = LAST0_START;
if (buf == null) {
buf = new StringBuilder();
} else {
buf.setLength(0);
}
boolean ok = false;
while (!chars.atEnd()) {
c = chars.next(opts);
literal = chars.isEscaped();
if (c == '}' && !literal) {
ok = true;
break;
}
appendCodePoint(buf, c);
}
if (!ok) {
syntaxError(chars, "Invalid multicharacter string");
}
// We have new string. Add it to set and continue;
// we don't need to drop through to the further
// processing
String curString = buf.toString();
if (op == '-') {
int lastSingle = CharSequences.getSingleCodePoint(lastString == null ? "" : lastString);
int curSingle = CharSequences.getSingleCodePoint(curString);
if (lastSingle != Integer.MAX_VALUE && curSingle != Integer.MAX_VALUE) {
add(lastSingle,curSingle);
} else {
if (strings == EMPTY_STRINGS) {
strings = new TreeSet<>();
}
try {
StringRange.expand(lastString, curString, true, strings);
} catch (Exception e) {
syntaxError(chars, e.getMessage());
}
}
lastString = null;
op = 0;
} else {
add(curString);
lastString = curString;
}
patBuf.append('{');
_appendToPat(patBuf, curString, false);
patBuf.append('}');
continue;
case SymbolTable.SYMBOL_REF:
// symbols nosymbols
// [a-$] error error (ambiguous)
// [a$] anchor anchor
// [a-$x] var "x"* literal '$'
// [a-$.] error literal '$'
// *We won't get here in the case of var "x"
backup = chars.getPos(backup);
c = chars.next(opts);
literal = chars.isEscaped();
boolean anchor = (c == ']' && !literal);
if (symbols == null && !anchor) {
c = SymbolTable.SYMBOL_REF;
chars.setPos(backup);
break; // literal '$'
}
if (anchor && op == 0) {
if (lastItem == LAST1_RANGE) {
add_unchecked(lastChar, lastChar);
_appendToPat(patBuf, lastChar, false);
}
add_unchecked(UnicodeMatcher.ETHER);
usePat = true;
patBuf.append(SymbolTable.SYMBOL_REF).append(']');
mode = MODE2_OUTBRACKET;
continue;
}
syntaxError(chars, "Unquoted '$'");
break;
default:
break;
}
}
// -------- Parse literal characters. This includes both
// escaped chars ("\u4E01") and non-syntax characters
// ("a").
switch (lastItem) {
case LAST0_START:
if (op == '-' && lastString != null) {
syntaxError(chars, "Invalid range");
}
lastItem = LAST1_RANGE;
lastChar = c;
lastString = null;
break;
case LAST1_RANGE:
if (op == '-') {
if (lastString != null) {
syntaxError(chars, "Invalid range");
}
if (lastChar >= c) {
// Don't allow redundant (a-a) or empty (b-a) ranges;
// these are most likely typos.
syntaxError(chars, "Invalid range");
}
add_unchecked(lastChar, c);
_appendToPat(patBuf, lastChar, false);
patBuf.append(op);
_appendToPat(patBuf, c, false);
lastItem = LAST0_START;
op = 0;
} else {
add_unchecked(lastChar, lastChar);
_appendToPat(patBuf, lastChar, false);
lastChar = c;
}
break;
case LAST2_SET:
if (op != 0) {
syntaxError(chars, "Set expected after operator");
}
lastChar = c;
lastItem = LAST1_RANGE;
break;
}
}
if (mode != MODE2_OUTBRACKET) {
syntaxError(chars, "Missing ']'");
}
chars.skipIgnored(opts);
/**
* Handle global flags (invert, case insensitivity). If this
* pattern should be compiled case-insensitive, then we need
* to close over case BEFORE COMPLEMENTING. This makes
* patterns like /[^abc]/i work.
*/
if ((options & CASE) != 0) {
closeOver(CASE);
}
if (invert) {
complement().removeAllStrings(); // code point complement
}
// Use the rebuilt pattern (pat) only if necessary. Prefer the
// generated pattern.
if (usePat) {
append(rebuiltPat, patBuf.toString());
} else {
appendNewPattern(rebuiltPat, false, true);
}
}
private static void syntaxError(RuleCharacterIterator chars, String msg) {
throw new IllegalArgumentException("Error: " + msg + " at \"" +
Utility.escape(chars.toString()) +
'"');
}
/**
* Add the contents of the UnicodeSet (as strings) into a collection.
* @param target collection to add into
* @stable ICU 4.4
*/
public > T addAllTo(T target) {
return addAllTo(this, target);
}
/**
* Add the contents of the UnicodeSet (as strings) into a collection.
* @param target collection to add into
* @stable ICU 4.4
*/
public String[] addAllTo(String[] target) {
return addAllTo(this, target);
}
/**
* Add the contents of the UnicodeSet (as strings) into an array.
* @stable ICU 4.4
*/
public static String[] toArray(UnicodeSet set) {
return addAllTo(set, new String[set.size()]);
}
/**
* Add the contents of the collection (as strings) into this UnicodeSet.
* The collection must not contain null.
* @param source the collection to add
* @return a reference to this object
* @stable ICU 4.4
*/
public UnicodeSet add(Iterable source) {
return addAll(source);
}
/**
* Add a collection (as strings) into this UnicodeSet.
* Uses standard naming convention.
* @param source collection to add into
* @return a reference to this object
* @stable ICU 4.4
*/
public UnicodeSet addAll(Iterable source) {
checkFrozen();
for (Object o : source) {
add(o.toString());
}
return this;
}
//----------------------------------------------------------------
// Implementation: Utility methods
//----------------------------------------------------------------
private int nextCapacity(int minCapacity) {
// Grow exponentially to reduce the frequency of allocations.
if (minCapacity < INITIAL_CAPACITY) {
return minCapacity + INITIAL_CAPACITY;
} else if (minCapacity <= 2500) {
return 5 * minCapacity;
} else {
int newCapacity = 2 * minCapacity;
if (newCapacity > MAX_LENGTH) {
newCapacity = MAX_LENGTH;
}
return newCapacity;
}
}
private void ensureCapacity(int newLen) {
if (newLen > MAX_LENGTH) {
newLen = MAX_LENGTH;
}
if (newLen <= list.length) return;
int newCapacity = nextCapacity(newLen);
int[] temp = new int[newCapacity];
// Copy only the actual contents.
System.arraycopy(list, 0, temp, 0, len);
list = temp;
}
private void ensureBufferCapacity(int newLen) {
if (newLen > MAX_LENGTH) {
newLen = MAX_LENGTH;
}
if (buffer != null && newLen <= buffer.length) return;
int newCapacity = nextCapacity(newLen);
buffer = new int[newCapacity];
// The buffer has no contents to be copied.
// It is always filled from scratch after this call.
}
/**
* Assumes start <= end.
*/
private int[] range(int start, int end) {
if (rangeList == null) {
rangeList = new int[] { start, end+1, HIGH };
} else {
rangeList[0] = start;
rangeList[1] = end+1;
}
return rangeList;
}
//----------------------------------------------------------------
// Implementation: Fundamental operations
//----------------------------------------------------------------
// polarity = 0, 3 is normal: x xor y
// polarity = 1, 2: x xor ~y == x === y
private UnicodeSet xor(int[] other, int otherLen, int polarity) {
ensureBufferCapacity(len + otherLen);
int i = 0, j = 0, k = 0;
int a = list[i++];
int b;
// TODO: Based on the call hierarchy, polarity of 1 or 2 is never used
// so the following if statement will not be called.
///CLOVER:OFF
if (polarity == 1 || polarity == 2) {
b = LOW;
if (other[j] == LOW) { // skip base if already LOW
++j;
b = other[j];
}
///CLOVER:ON
} else {
b = other[j++];
}
// simplest of all the routines
// sort the values, discarding identicals!
while (true) {
if (a < b) {
buffer[k++] = a;
a = list[i++];
} else if (b < a) {
buffer[k++] = b;
b = other[j++];
} else if (a != HIGH) { // at this point, a == b
// discard both values!
a = list[i++];
b = other[j++];
} else { // DONE!
buffer[k++] = HIGH;
len = k;
break;
}
}
// swap list and buffer
int[] temp = list;
list = buffer;
buffer = temp;
pat = null;
return this;
}
// polarity = 0 is normal: x union y
// polarity = 2: x union ~y
// polarity = 1: ~x union y
// polarity = 3: ~x union ~y
private UnicodeSet add(int[] other, int otherLen, int polarity) {
ensureBufferCapacity(len + otherLen);
int i = 0, j = 0, k = 0;
int a = list[i++];
int b = other[j++];
// change from xor is that we have to check overlapping pairs
// polarity bit 1 means a is second, bit 2 means b is.
main:
while (true) {
switch (polarity) {
case 0: // both first; take lower if unequal
if (a < b) { // take a
// Back up over overlapping ranges in buffer[]
if (k > 0 && a <= buffer[k-1]) {
// Pick latter end value in buffer[] vs. list[]
a = max(list[i], buffer[--k]);
} else {
// No overlap
buffer[k++] = a;
a = list[i];
}
i++; // Common if/else code factored out
polarity ^= 1;
} else if (b < a) { // take b
if (k > 0 && b <= buffer[k-1]) {
b = max(other[j], buffer[--k]);
} else {
buffer[k++] = b;
b = other[j];
}
j++;
polarity ^= 2;
} else { // a == b, take a, drop b
if (a == HIGH) break main;
// This is symmetrical; it doesn't matter if
// we backtrack with a or b. - liu
if (k > 0 && a <= buffer[k-1]) {
a = max(list[i], buffer[--k]);
} else {
// No overlap
buffer[k++] = a;
a = list[i];
}
i++;
polarity ^= 1;
b = other[j++]; polarity ^= 2;
}
break;
case 3: // both second; take higher if unequal, and drop other
if (b <= a) { // take a
if (a == HIGH) break main;
buffer[k++] = a;
} else { // take b
if (b == HIGH) break main;
buffer[k++] = b;
}
a = list[i++]; polarity ^= 1; // factored common code
b = other[j++]; polarity ^= 2;
break;
case 1: // a second, b first; if b < a, overlap
if (a < b) { // no overlap, take a
buffer[k++] = a; a = list[i++]; polarity ^= 1;
} else if (b < a) { // OVERLAP, drop b
b = other[j++]; polarity ^= 2;
} else { // a == b, drop both!
if (a == HIGH) break main;
a = list[i++]; polarity ^= 1;
b = other[j++]; polarity ^= 2;
}
break;
case 2: // a first, b second; if a < b, overlap
if (b < a) { // no overlap, take b
buffer[k++] = b; b = other[j++]; polarity ^= 2;
} else if (a < b) { // OVERLAP, drop a
a = list[i++]; polarity ^= 1;
} else { // a == b, drop both!
if (a == HIGH) break main;
a = list[i++]; polarity ^= 1;
b = other[j++]; polarity ^= 2;
}
break;
}
}
buffer[k++] = HIGH; // terminate
len = k;
// swap list and buffer
int[] temp = list;
list = buffer;
buffer = temp;
pat = null;
return this;
}
// polarity = 0 is normal: x intersect y
// polarity = 2: x intersect ~y == set-minus
// polarity = 1: ~x intersect y
// polarity = 3: ~x intersect ~y
private UnicodeSet retain(int[] other, int otherLen, int polarity) {
ensureBufferCapacity(len + otherLen);
int i = 0, j = 0, k = 0;
int a = list[i++];
int b = other[j++];
// change from xor is that we have to check overlapping pairs
// polarity bit 1 means a is second, bit 2 means b is.
main:
while (true) {
switch (polarity) {
case 0: // both first; drop the smaller
if (a < b) { // drop a
a = list[i++]; polarity ^= 1;
} else if (b < a) { // drop b
b = other[j++]; polarity ^= 2;
} else { // a == b, take one, drop other
if (a == HIGH) break main;
buffer[k++] = a; a = list[i++]; polarity ^= 1;
b = other[j++]; polarity ^= 2;
}
break;
case 3: // both second; take lower if unequal
if (a < b) { // take a
buffer[k++] = a; a = list[i++]; polarity ^= 1;
} else if (b < a) { // take b
buffer[k++] = b; b = other[j++]; polarity ^= 2;
} else { // a == b, take one, drop other
if (a == HIGH) break main;
buffer[k++] = a; a = list[i++]; polarity ^= 1;
b = other[j++]; polarity ^= 2;
}
break;
case 1: // a second, b first;
if (a < b) { // NO OVERLAP, drop a
a = list[i++]; polarity ^= 1;
} else if (b < a) { // OVERLAP, take b
buffer[k++] = b; b = other[j++]; polarity ^= 2;
} else { // a == b, drop both!
if (a == HIGH) break main;
a = list[i++]; polarity ^= 1;
b = other[j++]; polarity ^= 2;
}
break;
case 2: // a first, b second; if a < b, overlap
if (b < a) { // no overlap, drop b
b = other[j++]; polarity ^= 2;
} else if (a < b) { // OVERLAP, take a
buffer[k++] = a; a = list[i++]; polarity ^= 1;
} else { // a == b, drop both!
if (a == HIGH) break main;
a = list[i++]; polarity ^= 1;
b = other[j++]; polarity ^= 2;
}
break;
}
}
buffer[k++] = HIGH; // terminate
len = k;
// swap list and buffer
int[] temp = list;
list = buffer;
buffer = temp;
pat = null;
return this;
}
private static final int max(int a, int b) {
return (a > b) ? a : b;
}
//----------------------------------------------------------------
// Generic filter-based scanning code
//----------------------------------------------------------------
private static interface Filter {
boolean contains(int codePoint);
}
private static final class NumericValueFilter implements Filter {
double value;
NumericValueFilter(double value) { this.value = value; }
@Override
public boolean contains(int ch) {
return UCharacter.getUnicodeNumericValue(ch) == value;
}
}
private static final class GeneralCategoryMaskFilter implements Filter {
int mask;
GeneralCategoryMaskFilter(int mask) { this.mask = mask; }
@Override
public boolean contains(int ch) {
return ((1 << UCharacter.getType(ch)) & mask) != 0;
}
}
private static final class IntPropertyFilter implements Filter {
int prop;
int value;
IntPropertyFilter(int prop, int value) {
this.prop = prop;
this.value = value;
}
@Override
public boolean contains(int ch) {
return UCharacter.getIntPropertyValue(ch, prop) == value;
}
}
private static final class ScriptExtensionsFilter implements Filter {
int script;
ScriptExtensionsFilter(int script) { this.script = script; }
@Override
public boolean contains(int c) {
return UScript.hasScript(c, script);
}
}
// VersionInfo for unassigned characters
private static final VersionInfo NO_VERSION = VersionInfo.getInstance(0, 0, 0, 0);
private static final class VersionFilter implements Filter {
VersionInfo version;
VersionFilter(VersionInfo version) { this.version = version; }
@Override
public boolean contains(int ch) {
VersionInfo v = UCharacter.getAge(ch);
// Reference comparison ok; VersionInfo caches and reuses
// unique objects.
return !Utility.sameObjects(v, NO_VERSION) &&
v.compareTo(version) <= 0;
}
}
/**
* Generic filter-based scanning code for UCD property UnicodeSets.
*/
private void applyFilter(Filter filter, UnicodeSet inclusions) {
// Logically, walk through all Unicode characters, noting the start
// and end of each range for which filter.contain(c) is
// true. Add each range to a set.
//
// To improve performance, use an inclusions set which
// encodes information about character ranges that are known
// to have identical properties.
// inclusions contains the first characters of
// same-value ranges for the given property.
clear();
int startHasProperty = -1;
int limitRange = inclusions.getRangeCount();
for (int j=0; j= 0) {
add_unchecked(startHasProperty, ch-1);
startHasProperty = -1;
}
}
}
if (startHasProperty >= 0) {
add_unchecked(startHasProperty, 0x10FFFF);
}
}
/**
* Remove leading and trailing Pattern_White_Space and compress
* internal Pattern_White_Space to a single space character.
*/
private static String mungeCharName(String source) {
source = PatternProps.trimWhiteSpace(source);
StringBuilder buf = null;
for (int i=0; i 0) {
p = UCharacter.getPropertyEnum(propertyAlias);
// Treat gc as gcm
if (p == UProperty.GENERAL_CATEGORY) {
p = UProperty.GENERAL_CATEGORY_MASK;
}
if ((p >= UProperty.BINARY_START && p < UProperty.BINARY_LIMIT) ||
(p >= UProperty.INT_START && p < UProperty.INT_LIMIT) ||
(p >= UProperty.MASK_START && p < UProperty.MASK_LIMIT)) {
try {
v = UCharacter.getPropertyValueEnum(p, valueAlias);
} catch (IllegalArgumentException e) {
// Handle numeric CCC
if (p == UProperty.CANONICAL_COMBINING_CLASS ||
p == UProperty.LEAD_CANONICAL_COMBINING_CLASS ||
p == UProperty.TRAIL_CANONICAL_COMBINING_CLASS) {
v = Integer.parseInt(PatternProps.trimWhiteSpace(valueAlias));
// Anything between 0 and 255 is valid even if unused.
if (v < 0 || v > 255) throw e;
} else {
throw e;
}
}
}
else {
switch (p) {
case UProperty.NUMERIC_VALUE:
{
double value = Double.parseDouble(PatternProps.trimWhiteSpace(valueAlias));
applyFilter(new NumericValueFilter(value),
CharacterPropertiesImpl.getInclusionsForProperty(p));
return this;
}
case UProperty.NAME:
{
// Must munge name, since
// UCharacter.charFromName() does not do
// 'loose' matching.
String buf = mungeCharName(valueAlias);
int ch = UCharacter.getCharFromExtendedName(buf);
if (ch == -1) {
throw new IllegalArgumentException("Invalid character name");
}
clear();
add_unchecked(ch);
return this;
}
case UProperty.UNICODE_1_NAME:
// ICU 49 deprecates the Unicode_1_Name property APIs.
throw new IllegalArgumentException("Unicode_1_Name (na1) not supported");
case UProperty.AGE:
{
// Must munge name, since
// VersionInfo.getInstance() does not do
// 'loose' matching.
VersionInfo version = VersionInfo.getInstance(mungeCharName(valueAlias));
applyFilter(new VersionFilter(version),
CharacterPropertiesImpl.getInclusionsForProperty(p));
return this;
}
case UProperty.SCRIPT_EXTENSIONS:
v = UCharacter.getPropertyValueEnum(UProperty.SCRIPT, valueAlias);
// fall through to calling applyIntPropertyValue()
break;
default:
// p is a non-binary, non-enumerated property that we
// don't support (yet).
throw new IllegalArgumentException("Unsupported property");
}
}
}
else {
// valueAlias is empty. Interpret as General Category, Script,
// Binary property, or ANY or ASCII. Upon success, p and v will
// be set.
UPropertyAliases pnames = UPropertyAliases.INSTANCE;
p = UProperty.GENERAL_CATEGORY_MASK;
v = pnames.getPropertyValueEnum(p, propertyAlias);
if (v == UProperty.UNDEFINED) {
p = UProperty.SCRIPT;
v = pnames.getPropertyValueEnum(p, propertyAlias);
if (v == UProperty.UNDEFINED) {
p = pnames.getPropertyEnum(propertyAlias);
if (p == UProperty.UNDEFINED) {
p = -1;
}
if (p >= UProperty.BINARY_START && p < UProperty.BINARY_LIMIT) {
v = 1;
} else if (p == -1) {
if (0 == UPropertyAliases.compare(ANY_ID, propertyAlias)) {
set(MIN_VALUE, MAX_VALUE);
return this;
} else if (0 == UPropertyAliases.compare(ASCII_ID, propertyAlias)) {
set(0, 0x7F);
return this;
} else if (0 == UPropertyAliases.compare(ASSIGNED, propertyAlias)) {
// [:Assigned:]=[:^Cn:]
p = UProperty.GENERAL_CATEGORY_MASK;
v = (1< pattern.length()) {
return false;
}
// Look for an opening [:, [:^, \p, or \P
return pattern.regionMatches(pos, "[:", 0, 2) ||
pattern.regionMatches(true, pos, "\\p", 0, 2) ||
pattern.regionMatches(pos, "\\N", 0, 2);
}
/**
* Return true if the given iterator appears to point at a
* property pattern. Regardless of the result, return with the
* iterator unchanged.
* @param chars iterator over the pattern characters. Upon return
* it will be unchanged.
* @param iterOpts RuleCharacterIterator options
*/
private static boolean resemblesPropertyPattern(RuleCharacterIterator chars,
int iterOpts) {
boolean result = false;
iterOpts &= ~RuleCharacterIterator.PARSE_ESCAPES;
RuleCharacterIterator.Position pos = chars.getPos(null);
int c = chars.next(iterOpts);
if (c == '[' || c == '\\') {
int d = chars.next(iterOpts & ~RuleCharacterIterator.SKIP_WHITESPACE);
result = (c == '[') ? (d == ':') :
(d == 'N' || d == 'p' || d == 'P');
}
chars.setPos(pos);
return result;
}
/**
* Parse the given property pattern at the given parse position.
* @param symbols TODO
*/
private UnicodeSet applyPropertyPattern(String pattern, ParsePosition ppos, SymbolTable symbols) {
int pos = ppos.getIndex();
// On entry, ppos should point to one of the following locations:
// Minimum length is 5 characters, e.g. \p{L}
if ((pos+5) > pattern.length()) {
return null;
}
boolean posix = false; // true for [:pat:], false for \p{pat} \P{pat} \N{pat}
boolean isName = false; // true for \N{pat}, o/w false
boolean invert = false;
// Look for an opening [:, [:^, \p, or \P
if (pattern.regionMatches(pos, "[:", 0, 2)) {
posix = true;
pos = PatternProps.skipWhiteSpace(pattern, (pos+2));
if (pos < pattern.length() && pattern.charAt(pos) == '^') {
++pos;
invert = true;
}
} else if (pattern.regionMatches(true, pos, "\\p", 0, 2) ||
pattern.regionMatches(pos, "\\N", 0, 2)) {
char c = pattern.charAt(pos+1);
invert = (c == 'P');
isName = (c == 'N');
pos = PatternProps.skipWhiteSpace(pattern, (pos+2));
if (pos == pattern.length() || pattern.charAt(pos++) != '{') {
// Syntax error; "\p" or "\P" not followed by "{"
return null;
}
} else {
// Open delimiter not seen
return null;
}
// Look for the matching close delimiter, either :] or }
int close = pattern.indexOf(posix ? ":]" : "}", pos);
if (close < 0) {
// Syntax error; close delimiter missing
return null;
}
// Look for an '=' sign. If this is present, we will parse a
// medium \p{gc=Cf} or long \p{GeneralCategory=Format}
// pattern.
int equals = pattern.indexOf('=', pos);
String propName, valueName;
if (equals >= 0 && equals < close && !isName) {
// Equals seen; parse medium/long pattern
propName = pattern.substring(pos, equals);
valueName = pattern.substring(equals+1, close);
}
else {
// Handle case where no '=' is seen, and \N{}
propName = pattern.substring(pos, close);
valueName = "";
// Handle \N{name}
if (isName) {
// This is a little inefficient since it means we have to
// parse "na" back to UProperty.NAME even though we already
// know it's UProperty.NAME. If we refactor the API to
// support args of (int, String) then we can remove
// "na" and make this a little more efficient.
valueName = propName;
propName = "na";
}
}
applyPropertyAlias(propName, valueName, symbols);
if (invert) {
complement().removeAllStrings(); // code point complement
}
// Move to the limit position after the close delimiter
ppos.setIndex(close + (posix ? 2 : 1));
return this;
}
/**
* Parse a property pattern.
* @param chars iterator over the pattern characters. Upon return
* it will be advanced to the first character after the parsed
* pattern, or the end of the iteration if all characters are
* parsed.
* @param rebuiltPat the pattern that was parsed, rebuilt or
* copied from the input pattern, as appropriate.
* @param symbols TODO
*/
private void applyPropertyPattern(RuleCharacterIterator chars,
Appendable rebuiltPat, SymbolTable symbols) {
String patStr = chars.getCurrentBuffer();
int start = chars.getCurrentBufferPos();
ParsePosition pos = new ParsePosition(start);
applyPropertyPattern(patStr, pos, symbols);
int length = pos.getIndex() - start;
if (length == 0) {
syntaxError(chars, "Invalid property pattern");
}
chars.jumpahead(length);
append(rebuiltPat, patStr.substring(start, pos.getIndex()));
}
//----------------------------------------------------------------
// Case folding API
//----------------------------------------------------------------
/**
* Bitmask for constructor and applyPattern() indicating that
* white space should be ignored. If set, ignore Unicode Pattern_White_Space characters,
* unless they are quoted or escaped. This may be ORed together
* with other selectors.
* @stable ICU 3.8
*/
public static final int IGNORE_SPACE = 1;
/**
* Bitmask for constructor, applyPattern(), and closeOver()
* indicating letter case. This may be ORed together with other
* selectors.
*
* Enable case insensitive matching. E.g., "[ab]" with this flag
* will match 'a', 'A', 'b', and 'B'. "[^ab]" with this flag will
* match all except 'a', 'A', 'b', and 'B'. This performs a full
* closure over case mappings, e.g. U+017F for s.
*
* The resulting set is a superset of the input for the code points but
* not for the strings.
* It performs a case mapping closure of the code points and adds
* full case folding strings for the code points, and reduces strings of
* the original set to their full case folding equivalents.
*
* This is designed for case-insensitive matches, for example
* in regular expressions. The full code point case closure allows checking of
* an input character directly against the closure set.
* Strings are matched by comparing the case-folded form from the closure
* set with an incremental case folding of the string in question.
*
* The closure set will also contain single code points if the original
* set contained case-equivalent strings (like U+00DF for "ss" or "Ss" etc.).
* This is not necessary (that is, redundant) for the above matching method
* but results in the same closure sets regardless of whether the original
* set contained the code point or a string.
* @stable ICU 3.8
*/
public static final int CASE = 2;
/**
* Alias for UnicodeSet.CASE, for ease of porting from C++ where ICU4C
* also has both USET_CASE and USET_CASE_INSENSITIVE (see uset.h).
* @see #CASE
* @stable ICU 3.4
*/
public static final int CASE_INSENSITIVE = 2;
/**
* Bitmask for constructor, applyPattern(), and closeOver()
* indicating letter case. This may be ORed together with other
* selectors.
*
* Enable case insensitive matching. E.g., "[ab]" with this flag
* will match 'a', 'A', 'b', and 'B'. "[^ab]" with this flag will
* match all except 'a', 'A', 'b', and 'B'. This adds the lower-,
* title-, and uppercase mappings as well as the case folding
* of each existing element in the set.
* @stable ICU 3.4
*/
public static final int ADD_CASE_MAPPINGS = 4;
// add the result of a full case mapping to the set
// use str as a temporary string to avoid constructing one
private static final void addCaseMapping(UnicodeSet set, int result, StringBuilder full) {
if(result >= 0) {
if(result > UCaseProps.MAX_STRING_LENGTH) {
// add a single-code point case mapping
set.add(result);
} else {
// add a string case mapping from full with length result
set.add(full.toString());
full.setLength(0);
}
}
// result < 0: the code point mapped to itself, no need to add it
// see UCaseProps
}
/**
* Close this set over the given attribute. For the attribute
* CASE, the result is to modify this set so that:
*
* 1. For each character or string 'a' in this set, all strings
* 'b' such that foldCase(a) == foldCase(b) are added to this set.
* (For most 'a' that are single characters, 'b' will have
* b.length() == 1.)
*
* 2. For each string 'e' in the resulting set, if e !=
* foldCase(e), 'e' will be removed.
*
* Example: [aq\u00DF{Bc}{bC}{Fi}] => [aAqQ\u00DF\uFB01{ss}{bc}{fi}]
*
* (Here foldCase(x) refers to the operation
* UCharacter.foldCase(x, true), and a == b actually denotes
* a.equals(b), not pointer comparison.)
*
* @param attribute bitmask for attributes to close over.
* Currently only the CASE bit is supported. Any undefined bits
* are ignored.
* @return a reference to this set.
* @stable ICU 3.8
*/
public UnicodeSet closeOver(int attribute) {
checkFrozen();
if ((attribute & (CASE | ADD_CASE_MAPPINGS)) != 0) {
UCaseProps csp = UCaseProps.INSTANCE;
UnicodeSet foldSet = new UnicodeSet(this);
ULocale root = ULocale.ROOT;
// start with input set to guarantee inclusion
// CASE: remove strings because the strings will actually be reduced (folded);
// therefore, start with no strings and add only those needed
if((attribute & CASE) != 0 && foldSet.hasStrings()) {
foldSet.strings.clear();
}
int n = getRangeCount();
int result;
StringBuilder full = new StringBuilder();
for (int i=0; i
* This routine will be called whenever the parsing of a UnicodeSet pattern finds such a
* propertyName+propertyValue combination.
*
* @param propertyName
* the name of the property
* @param propertyValue
* the name of the property value
* @param result UnicodeSet value to change
* a set to which the characters having the propertyName+propertyValue are to be added.
* @return returns true if the propertyName+propertyValue combination is to be overridden, and the characters
* with that property have been added to the UnicodeSet, and returns false if the
* propertyName+propertyValue combination is not recognized (in which case result is unaltered).
* @draft ICU3.8 (retain)
*/
public boolean applyPropertyAlias(String propertyName, String propertyValue, UnicodeSet result) {
return false;
}
/**
* Supplies default implementation for SymbolTable (no action).
* @draft ICU3.8 (retain)
*/
@Override
public char[] lookup(String s) {
return null;
}
/**
* Supplies default implementation for SymbolTable (no action).
* @draft ICU3.8 (retain)
*/
@Override
public String parseReference(String text, ParsePosition pos, int limit) {
return null;
}
}
/**
* Is this frozen, according to the Freezable interface?
*
* @return value
* @stable ICU 3.8
*/
@Override
public boolean isFrozen() {
return (bmpSet != null || stringSpan != null);
}
/**
* Freeze this class, according to the Freezable interface.
*
* @return this
* @stable ICU 4.4
*/
@Override
public UnicodeSet freeze() {
if (!isFrozen()) {
compact();
// Optimize contains() and span() and similar functions.
if (hasStrings()) {
stringSpan = new UnicodeSetStringSpan(this, new ArrayList<>(strings), UnicodeSetStringSpan.ALL);
}
if (stringSpan == null || !stringSpan.needsStringSpanUTF16()) {
// Optimize for code point spans.
// There are no strings, or
// all strings are irrelevant for span() etc. because
// all of each string's code points are contained in this set.
// However, fully contained strings are relevant for spanAndCount(),
// so we create both objects.
bmpSet = new BMPSet(list, len);
}
}
return this;
}
/**
* Span a string using this UnicodeSet.
* To replace, count elements, or delete spans, see {@link com.ibm.icu.text.UnicodeSetSpanner UnicodeSetSpanner}.
* @param s The string to be spanned
* @param spanCondition The span condition
* @return the length of the span
* @stable ICU 4.4
*/
public int span(CharSequence s, SpanCondition spanCondition) {
return span(s, 0, spanCondition);
}
/**
* Span a string using this UnicodeSet.
* If the start index is less than 0, span will start from 0.
* If the start index is greater than the string length, span returns the string length.
*
To replace, count elements, or delete spans, see {@link com.ibm.icu.text.UnicodeSetSpanner UnicodeSetSpanner}.
* @param s The string to be spanned
* @param start The start index that the span begins
* @param spanCondition The span condition
* @return the string index which ends the span (i.e. exclusive)
* @stable ICU 4.4
*/
public int span(CharSequence s, int start, SpanCondition spanCondition) {
int end = s.length();
if (start < 0) {
start = 0;
} else if (start >= end) {
return end;
}
if (bmpSet != null) {
// Frozen set without strings, or no string is relevant for span().
return bmpSet.span(s, start, spanCondition, null);
}
if (stringSpan != null) {
return stringSpan.span(s, start, spanCondition);
} else if (hasStrings()) {
int which = spanCondition == SpanCondition.NOT_CONTAINED ? UnicodeSetStringSpan.FWD_UTF16_NOT_CONTAINED
: UnicodeSetStringSpan.FWD_UTF16_CONTAINED;
UnicodeSetStringSpan strSpan = new UnicodeSetStringSpan(this, new ArrayList<>(strings), which);
if (strSpan.needsStringSpanUTF16()) {
return strSpan.span(s, start, spanCondition);
}
}
return spanCodePointsAndCount(s, start, spanCondition, null);
}
/**
* Same as span() but also counts the smallest number of set elements on any path across the span.
*
To replace, count elements, or delete spans, see {@link com.ibm.icu.text.UnicodeSetSpanner UnicodeSetSpanner}.
* @param outCount An output-only object (must not be null) for returning the count.
* @return the limit (exclusive end) of the span
* @internal
* @deprecated This API is ICU internal only.
*/
@Deprecated
public int spanAndCount(CharSequence s, int start, SpanCondition spanCondition, OutputInt outCount) {
if (outCount == null) {
throw new IllegalArgumentException("outCount must not be null");
}
int end = s.length();
if (start < 0) {
start = 0;
} else if (start >= end) {
return end;
}
if (stringSpan != null) {
// We might also have bmpSet != null,
// but fully-contained strings are relevant for counting elements.
return stringSpan.spanAndCount(s, start, spanCondition, outCount);
} else if (bmpSet != null) {
return bmpSet.span(s, start, spanCondition, outCount);
} else if (hasStrings()) {
int which = spanCondition == SpanCondition.NOT_CONTAINED ? UnicodeSetStringSpan.FWD_UTF16_NOT_CONTAINED
: UnicodeSetStringSpan.FWD_UTF16_CONTAINED;
which |= UnicodeSetStringSpan.WITH_COUNT;
UnicodeSetStringSpan strSpan = new UnicodeSetStringSpan(this, new ArrayList<>(strings), which);
return strSpan.spanAndCount(s, start, spanCondition, outCount);
}
return spanCodePointsAndCount(s, start, spanCondition, outCount);
}
private int spanCodePointsAndCount(CharSequence s, int start,
SpanCondition spanCondition, OutputInt outCount) {
// Pin to 0/1 values.
boolean spanContained = (spanCondition != SpanCondition.NOT_CONTAINED);
int c;
int next = start;
int length = s.length();
int count = 0;
do {
c = Character.codePointAt(s, next);
if (spanContained != contains(c)) {
break;
}
++count;
next += Character.charCount(c);
} while (next < length);
if (outCount != null) { outCount.value = count; }
return next;
}
/**
* Span a string backwards (from the end) using this UnicodeSet.
*
To replace, count elements, or delete spans, see {@link com.ibm.icu.text.UnicodeSetSpanner UnicodeSetSpanner}.
* @param s The string to be spanned
* @param spanCondition The span condition
* @return The string index which starts the span (i.e. inclusive).
* @stable ICU 4.4
*/
public int spanBack(CharSequence s, SpanCondition spanCondition) {
return spanBack(s, s.length(), spanCondition);
}
/**
* Span a string backwards (from the fromIndex) using this UnicodeSet.
* If the fromIndex is less than 0, spanBack will return 0.
* If fromIndex is greater than the string length, spanBack will start from the string length.
*
To replace, count elements, or delete spans, see {@link com.ibm.icu.text.UnicodeSetSpanner UnicodeSetSpanner}.
* @param s The string to be spanned
* @param fromIndex The index of the char (exclusive) that the string should be spanned backwards
* @param spanCondition The span condition
* @return The string index which starts the span (i.e. inclusive).
* @stable ICU 4.4
*/
public int spanBack(CharSequence s, int fromIndex, SpanCondition spanCondition) {
if (fromIndex <= 0) {
return 0;
}
if (fromIndex > s.length()) {
fromIndex = s.length();
}
if (bmpSet != null) {
// Frozen set without strings, or no string is relevant for spanBack().
return bmpSet.spanBack(s, fromIndex, spanCondition);
}
if (stringSpan != null) {
return stringSpan.spanBack(s, fromIndex, spanCondition);
} else if (hasStrings()) {
int which = (spanCondition == SpanCondition.NOT_CONTAINED)
? UnicodeSetStringSpan.BACK_UTF16_NOT_CONTAINED
: UnicodeSetStringSpan.BACK_UTF16_CONTAINED;
UnicodeSetStringSpan strSpan = new UnicodeSetStringSpan(this, new ArrayList<>(strings), which);
if (strSpan.needsStringSpanUTF16()) {
return strSpan.spanBack(s, fromIndex, spanCondition);
}
}
// Pin to 0/1 values.
boolean spanContained = (spanCondition != SpanCondition.NOT_CONTAINED);
int c;
int prev = fromIndex;
do {
c = Character.codePointBefore(s, prev);
if (spanContained != contains(c)) {
break;
}
prev -= Character.charCount(c);
} while (prev > 0);
return prev;
}
/**
* Clone a thawed version of this class, according to the Freezable interface.
* @return the clone, not frozen
* @stable ICU 4.4
*/
@Override
public UnicodeSet cloneAsThawed() {
UnicodeSet result = new UnicodeSet(this);
assert !result.isFrozen();
return result;
}
// internal function
private void checkFrozen() {
if (isFrozen()) {
throw new UnsupportedOperationException("Attempt to modify frozen object");
}
}
// ************************
// Additional methods for integration with Generics and Collections
// ************************
/**
* A struct-like class used for iteration through ranges, for faster iteration than by String.
* Read about the restrictions on usage in {@link UnicodeSet#ranges()}.
*
* @stable ICU 54
*/
public static class EntryRange {
/**
* The starting code point of the range.
*
* @stable ICU 54
*/
public int codepoint;
/**
* The ending code point of the range
*
* @stable ICU 54
*/
public int codepointEnd;
EntryRange() {
}
/**
* {@inheritDoc}
*
* @stable ICU 54
*/
@Override
public String toString() {
StringBuilder b = new StringBuilder();
return (
codepoint == codepointEnd ? _appendToPat(b, codepoint, false)
: _appendToPat(_appendToPat(b, codepoint, false).append('-'), codepointEnd, false))
.toString();
}
}
/**
* Provide for faster iteration than by String. Returns an Iterable/Iterator over ranges of code points.
* The UnicodeSet must not be altered during the iteration.
* The EntryRange instance is the same each time; the contents are just reset.
*
*
Warning: To iterate over the full contents, you have to also iterate over the strings.
*
*
Warning: For speed, UnicodeSet iteration does not check for concurrent modification.
* Do not alter the UnicodeSet while iterating.
*
*
* // Sample code
* for (EntryRange range : us1.ranges()) {
* // do something with code points between range.codepoint and range.codepointEnd;
* }
* for (String s : us1.strings()) {
* // do something with each string;
* }
*
*
* @stable ICU 54
*/
public Iterable ranges() {
return new EntryRangeIterable();
}
private class EntryRangeIterable implements Iterable {
@Override
public Iterator iterator() {
return new EntryRangeIterator();
}
}
private class EntryRangeIterator implements Iterator {
int pos;
EntryRange result = new EntryRange();
@Override
public boolean hasNext() {
return pos < len-1;
}
@Override
public EntryRange next() {
if (pos < len-1) {
result.codepoint = list[pos++];
result.codepointEnd = list[pos++]-1;
} else {
throw new NoSuchElementException();
}
return result;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
/**
* Returns a string iterator. Uses the same order of iteration as {@link UnicodeSetIterator}.
* Warning: For speed, UnicodeSet iteration does not check for concurrent modification.
* Do not alter the UnicodeSet while iterating.
* @see java.util.Set#iterator()
* @stable ICU 4.4
*/
@Override
public Iterator iterator() {
return new UnicodeSetIterator2(this);
}
// Cover for string iteration.
private static class UnicodeSetIterator2 implements Iterator {
// Invariants:
// sourceList != null then sourceList[item] is a valid character
// sourceList == null then delegates to stringIterator
private int[] sourceList;
private int len;
private int item;
private int current;
private int limit;
private SortedSet sourceStrings;
private Iterator stringIterator;
private char[] buffer;
UnicodeSetIterator2(UnicodeSet source) {
// set according to invariants
len = source.len - 1;
if (len > 0) {
sourceStrings = source.strings;
sourceList = source.list;
current = sourceList[item++];
limit = sourceList[item++];
} else {
stringIterator = source.strings.iterator();
sourceList = null;
}
}
/* (non-Javadoc)
* @see java.util.Iterator#hasNext()
*/
@Override
public boolean hasNext() {
return sourceList != null || stringIterator.hasNext();
}
/* (non-Javadoc)
* @see java.util.Iterator#next()
*/
@Override
public String next() {
if (sourceList == null) {
return stringIterator.next();
}
int codepoint = current++;
// we have the codepoint we need, but we may need to adjust the state
if (current >= limit) {
if (item >= len) {
stringIterator = sourceStrings.iterator();
sourceList = null;
} else {
current = sourceList[item++];
limit = sourceList[item++];
}
}
// Now return. Single code point is easy
if (codepoint <= 0xFFFF) {
return String.valueOf((char)codepoint);
}
// But Java lacks a valueOfCodePoint, so we handle ourselves for speed
// allocate a buffer the first time, to make conversion faster.
if (buffer == null) {
buffer = new char[2];
}
// compute ourselves, to save tests and calls
int offset = codepoint - Character.MIN_SUPPLEMENTARY_CODE_POINT;
buffer[0] = (char)((offset >>> 10) + Character.MIN_HIGH_SURROGATE);
buffer[1] = (char)((offset & 0x3ff) + Character.MIN_LOW_SURROGATE);
return String.valueOf(buffer);
}
/* (non-Javadoc)
* @see java.util.Iterator#remove()
*/
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
/**
* @see #containsAll(com.ibm.icu.text.UnicodeSet)
* @stable ICU 4.4
*/
public boolean containsAll(Iterable collection) {
for (T o : collection) {
if (!contains(o)) {
return false;
}
}
return true;
}
/**
* @see #containsNone(com.ibm.icu.text.UnicodeSet)
* @stable ICU 4.4
*/
public boolean containsNone(Iterable collection) {
for (T o : collection) {
if (contains(o)) {
return false;
}
}
return true;
}
/**
* @see #containsAll(com.ibm.icu.text.UnicodeSet)
* @stable ICU 4.4
*/
public final boolean containsSome(Iterable collection) {
return !containsNone(collection);
}
/**
* @see #addAll(com.ibm.icu.text.UnicodeSet)
* @stable ICU 4.4
*/
@SuppressWarnings("unchecked") // See ticket #11395, this is safe.
public UnicodeSet addAll(T... collection) {
checkFrozen();
for (T str : collection) {
add(str);
}
return this;
}
/**
* @see #removeAll(com.ibm.icu.text.UnicodeSet)
* @stable ICU 4.4
*/
public UnicodeSet removeAll(Iterable collection) {
checkFrozen();
for (T o : collection) {
remove(o);
}
return this;
}
/**
* @see #retainAll(com.ibm.icu.text.UnicodeSet)
* @stable ICU 4.4
*/
public UnicodeSet retainAll(Iterable collection) {
checkFrozen();
// TODO optimize
UnicodeSet toRetain = new UnicodeSet();
toRetain.addAll(collection);
retainAll(toRetain);
return this;
}
/**
* Comparison style enums used by {@link UnicodeSet#compareTo(UnicodeSet, ComparisonStyle)}.
* @stable ICU 4.4
*/
public enum ComparisonStyle {
/**
* @stable ICU 4.4
*/
SHORTER_FIRST,
/**
* @stable ICU 4.4
*/
LEXICOGRAPHIC,
/**
* @stable ICU 4.4
*/
LONGER_FIRST
}
/**
* Compares UnicodeSets, where shorter come first, and otherwise lexicographically
* (according to the comparison of the first characters that differ).
* @see java.lang.Comparable#compareTo(java.lang.Object)
* @stable ICU 4.4
*/
@Override
public int compareTo(UnicodeSet o) {
return compareTo(o, ComparisonStyle.SHORTER_FIRST);
}
/**
* Compares UnicodeSets, in three different ways.
* @see java.lang.Comparable#compareTo(java.lang.Object)
* @stable ICU 4.4
*/
public int compareTo(UnicodeSet o, ComparisonStyle style) {
if (style != ComparisonStyle.LEXICOGRAPHIC) {
int diff = size() - o.size();
if (diff != 0) {
return (diff < 0) == (style == ComparisonStyle.SHORTER_FIRST) ? -1 : 1;
}
}
int result;
for (int i = 0; ; ++i) {
if (0 != (result = list[i] - o.list[i])) {
// if either list ran out, compare to the last string
if (list[i] == HIGH) {
if (!hasStrings()) return 1;
String item = strings.first();
return compare(item, o.list[i]);
}
if (o.list[i] == HIGH) {
if (!o.hasStrings()) return -1;
String item = o.strings.first();
int compareResult = compare(item, list[i]);
return compareResult > 0 ? -1 : compareResult < 0 ? 1 : 0; // Reverse the order.
}
// otherwise return the result if even index, or the reversal if not
return (i & 1) == 0 ? result : -result;
}
if (list[i] == HIGH) {
break;
}
}
return compare(strings, o.strings);
}
/**
* @stable ICU 4.4
*/
public int compareTo(Iterable other) {
return compare(this, other);
}
/**
* Utility to compare a string to a code point.
* Same results as turning the code point into a string (with the [ugly] new StringBuilder().appendCodePoint(codepoint).toString())
* and comparing, but much faster (no object creation).
* Actually, there is one difference; a null compares as less.
* Note that this (=String) order is UTF-16 order -- *not* code point order.
* @stable ICU 4.4
*/
public static int compare(CharSequence string, int codePoint) {
return CharSequences.compare(string, codePoint);
}
/**
* Utility to compare a string to a code point.
* Same results as turning the code point into a string and comparing, but much faster (no object creation).
* Actually, there is one difference; a null compares as less.
* Note that this (=String) order is UTF-16 order -- *not* code point order.
* @stable ICU 4.4
*/
public static int compare(int codePoint, CharSequence string) {
return -CharSequences.compare(string, codePoint);
}
/**
* Utility to compare two iterables. Warning: the ordering in iterables is important. For Collections that are ordered,
* like Lists, that is expected. However, Sets in Java violate Leibniz's law when it comes to iteration.
* That means that sets can't be compared directly with this method, unless they are TreeSets without
* (or with the same) comparator. Unfortunately, it is impossible to reliably detect in Java whether subclass of
* Collection satisfies the right criteria, so it is left to the user to avoid those circumstances.
* @stable ICU 4.4
*/
public static > int compare(Iterable collection1, Iterable collection2) {
return compare(collection1.iterator(), collection2.iterator());
}
/**
* Utility to compare two iterators. Warning: the ordering in iterables is important. For Collections that are ordered,
* like Lists, that is expected. However, Sets in Java violate Leibniz's law when it comes to iteration.
* That means that sets can't be compared directly with this method, unless they are TreeSets without
* (or with the same) comparator. Unfortunately, it is impossible to reliably detect in Java whether subclass of
* Collection satisfies the right criteria, so it is left to the user to avoid those circumstances.
* @internal
* @deprecated This API is ICU internal only.
*/
@Deprecated
public static > int compare(Iterator first, Iterator other) {
while (true) {
if (!first.hasNext()) {
return other.hasNext() ? -1 : 0;
} else if (!other.hasNext()) {
return 1;
}
T item1 = first.next();
T item2 = other.next();
int result = item1.compareTo(item2);
if (result != 0) {
return result;
}
}
}
/**
* Utility to compare two collections, optionally by size, and then lexicographically.
* @stable ICU 4.4
*/
public static > int compare(Collection collection1, Collection collection2, ComparisonStyle style) {
if (style != ComparisonStyle.LEXICOGRAPHIC) {
int diff = collection1.size() - collection2.size();
if (diff != 0) {
return (diff < 0) == (style == ComparisonStyle.SHORTER_FIRST) ? -1 : 1;
}
}
return compare(collection1, collection2);
}
/**
* Utility for adding the contents of an iterable to a collection.
* @stable ICU 4.4
*/
public static > U addAllTo(Iterable source, U target) {
for (T item : source) {
target.add(item);
}
return target;
}
/**
* Utility for adding the contents of an iterable to a collection.
* @stable ICU 4.4
*/
public static T[] addAllTo(Iterable source, T[] target) {
int i = 0;
for (T item : source) {
target[i++] = item;
}
return target;
}
/**
* For iterating through the strings in the set. Example:
*
* for (String key : myUnicodeSet.strings()) {
* doSomethingWith(key);
* }
*
* @stable ICU 4.4
*/
public Collection strings() {
if (hasStrings()) {
return Collections.unmodifiableSortedSet(strings);
} else {
return EMPTY_STRINGS;
}
}
/**
* Return the value of the first code point, if the string is exactly one code point. Otherwise return Integer.MAX_VALUE.
* @internal
* @deprecated This API is ICU internal only.
*/
@Deprecated
public static int getSingleCodePoint(CharSequence s) {
return CharSequences.getSingleCodePoint(s);
}
/**
* Simplify the ranges in a Unicode set by merging any ranges that are only separated by characters in the dontCare set.
* For example, the ranges: \\u2E80-\\u2E99\\u2E9B-\\u2EF3\\u2F00-\\u2FD5\\u2FF0-\\u2FFB\\u3000-\\u303E change to \\u2E80-\\u303E
* if the dontCare set includes unassigned characters (for a particular version of Unicode).
* @param dontCare Set with the don't-care characters for spanning
* @return the input set, modified
* @internal
* @deprecated This API is ICU internal only.
*/
@Deprecated
public UnicodeSet addBridges(UnicodeSet dontCare) {
UnicodeSet notInInput = new UnicodeSet(this).complement().removeAllStrings();
for (UnicodeSetIterator it = new UnicodeSetIterator(notInInput); it.nextRange();) {
if (it.codepoint != 0 && it.codepointEnd != 0x10FFFF &&
dontCare.contains(it.codepoint, it.codepointEnd)) {
add(it.codepoint,it.codepointEnd);
}
}
return this;
}
/**
* Find the first index at or after fromIndex where the UnicodeSet matches at that index.
* If findNot is true, then reverse the sense of the match: find the first place where the UnicodeSet doesn't match.
* If there is no match, length is returned.
* @internal
* @deprecated This API is ICU internal only. Use span instead.
*/
@Deprecated
public int findIn(CharSequence value, int fromIndex, boolean findNot) {
//TODO add strings, optimize, using ICU4C algorithms
int cp;
for (; fromIndex < value.length(); fromIndex += UTF16.getCharCount(cp)) {
cp = UTF16.charAt(value, fromIndex);
if (contains(cp) != findNot) {
break;
}
}
return fromIndex;
}
/**
* Find the last index before fromIndex where the UnicodeSet matches at that index.
* If findNot is true, then reverse the sense of the match: find the last place where the UnicodeSet doesn't match.
* If there is no match, -1 is returned.
* BEFORE index is not in the UnicodeSet.
* @internal
* @deprecated This API is ICU internal only. Use spanBack instead.
*/
@Deprecated
public int findLastIn(CharSequence value, int fromIndex, boolean findNot) {
//TODO add strings, optimize, using ICU4C algorithms
int cp;
fromIndex -= 1;
for (; fromIndex >= 0; fromIndex -= UTF16.getCharCount(cp)) {
cp = UTF16.charAt(value, fromIndex);
if (contains(cp) != findNot) {
break;
}
}
return fromIndex < 0 ? -1 : fromIndex;
}
/**
* Strips code points from source. If matches is true, script all that match this. If matches is false, then strip all that don't match.
* @param source The source of the CharSequence to strip from.
* @param matches A boolean to either strip all that matches or don't match with the current UnicodeSet object.
* @return The string after it has been stripped.
* @internal
* @deprecated This API is ICU internal only. Use replaceFrom.
*/
@Deprecated
public String stripFrom(CharSequence source, boolean matches) {
StringBuilder result = new StringBuilder();
for (int pos = 0; pos < source.length();) {
int inside = findIn(source, pos, !matches);
result.append(source.subSequence(pos, inside));
pos = findIn(source, inside, matches); // get next start
}
return result.toString();
}
/**
* Argument values for whether span() and similar functions continue while the current character is contained vs.
* not contained in the set.
*
* The functionality is straightforward for sets with only single code points, without strings (which is the common
* case):
*
* - CONTAINED and SIMPLE work the same.
*
- CONTAINED and SIMPLE are inverses of NOT_CONTAINED.
*
- span() and spanBack() partition any string the
* same way when alternating between span(NOT_CONTAINED) and span(either "contained" condition).
*
- Using a
* complemented (inverted) set and the opposite span conditions yields the same results.
*
* When a set contains multi-code point strings, then these statements may not be true, depending on the strings in
* the set (for example, whether they overlap with each other) and the string that is processed. For a set with
* strings:
*
* - The complement of the set contains the opposite set of code points, but the same set of strings.
* Therefore, complementing both the set and the span conditions may yield different results.
*
- When starting spans
* at different positions in a string (span(s, ...) vs. span(s+1, ...)) the ends of the spans may be different
* because a set string may start before the later position.
*
- span(SIMPLE) may be shorter than
* span(CONTAINED) because it will not recursively try all possible paths. For example, with a set which
* contains the three strings "xy", "xya" and "ax", span("xyax", CONTAINED) will return 4 but span("xyax",
* SIMPLE) will return 3. span(SIMPLE) will never be longer than span(CONTAINED).
*
- With either "contained" condition, span() and spanBack() may partition a string in different ways. For example,
* with a set which contains the two strings "ab" and "ba", and when processing the string "aba", span() will yield
* contained/not-contained boundaries of { 0, 2, 3 } while spanBack() will yield boundaries of { 0, 1, 3 }.
*
* Note: If it is important to get the same boundaries whether iterating forward or backward through a string, then
* either only span() should be used and the boundaries cached for backward operation, or an ICU BreakIterator could
* be used.
*
* Note: Unpaired surrogates are treated like surrogate code points. Similarly, set strings match only on code point
* boundaries, never in the middle of a surrogate pair.
*
* @stable ICU 4.4
*/
public enum SpanCondition {
/**
* Continues a span() while there is no set element at the current position.
* Increments by one code point at a time.
* Stops before the first set element (character or string).
* (For code points only, this is like while contains(current)==false).
*
* When span() returns, the substring between where it started and the position it returned consists only of
* characters that are not in the set, and none of its strings overlap with the span.
*
* @stable ICU 4.4
*/
NOT_CONTAINED,
/**
* Spans the longest substring that is a concatenation of set elements (characters or strings).
* (For characters only, this is like while contains(current)==true).
*
* When span() returns, the substring between where it started and the position it returned consists only of set
* elements (characters or strings) that are in the set.
*
* If a set contains strings, then the span will be the longest substring for which there
* exists at least one non-overlapping concatenation of set elements (characters or strings).
* This is equivalent to a POSIX regular expression for (OR of each set element)*.
* (Java/ICU/Perl regex stops at the first match of an OR.)
*
* @stable ICU 4.4
*/
CONTAINED,
/**
* Continues a span() while there is a set element at the current position.
* Increments by the longest matching element at each position.
* (For characters only, this is like while contains(current)==true).
*
* When span() returns, the substring between where it started and the position it returned consists only of set
* elements (characters or strings) that are in the set.
*
* If a set only contains single characters, then this is the same as CONTAINED.
*
* If a set contains strings, then the span will be the longest substring with a match at each position with the
* longest single set element (character or string).
*
* Use this span condition together with other longest-match algorithms, such as ICU converters
* (ucnv_getUnicodeSet()).
*
* @stable ICU 4.4
*/
SIMPLE,
/**
* One more than the last span condition.
*
* @stable ICU 4.4
*/
CONDITION_COUNT
}
/**
* Get the default symbol table. Null means ordinary processing. For internal use only.
* @return the symbol table
* @internal
* @deprecated This API is ICU internal only.
*/
@Deprecated
public static XSymbolTable getDefaultXSymbolTable() {
return XSYMBOL_TABLE;
}
/**
* Set the default symbol table. Null means ordinary processing. For internal use only. Will affect all subsequent parsing
* of UnicodeSets.
*
* WARNING: If this function is used with a UnicodeProperty, and the
* Unassigned characters (gc=Cn) are different than in ICU, you MUST call
* {@code UnicodeProperty.ResetCacheProperties} afterwards. If you then call {@code UnicodeSet.setDefaultXSymbolTable}
* with null to clear the value, you MUST also call {@code UnicodeProperty.ResetCacheProperties}.
*
* @param xSymbolTable the new default symbol table.
* @internal
* @deprecated This API is ICU internal only.
*/
@Deprecated
public static void setDefaultXSymbolTable(XSymbolTable xSymbolTable) {
// If the properties override inclusions, these have to be regenerated.
// TODO: Check if the Unicode Tools or Unicode Utilities really need this.
CharacterPropertiesImpl.clear();
XSYMBOL_TABLE = xSymbolTable;
}
}
//eof