001/*
002 * Copyright (C) 2008 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
005 * in compliance with the License. You may obtain a copy of the License at
006 *
007 * http://www.apache.org/licenses/LICENSE-2.0
008 *
009 * Unless required by applicable law or agreed to in writing, software distributed under the License
010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
011 * or implied. See the License for the specific language governing permissions and limitations under
012 * the License.
013 */
014
015package com.google.common.base;
016
017import static com.google.common.base.Preconditions.checkArgument;
018import static com.google.common.base.Preconditions.checkNotNull;
019import static com.google.common.base.Preconditions.checkPositionIndex;
020
021import com.google.common.annotations.GwtCompatible;
022import com.google.common.annotations.GwtIncompatible;
023import com.google.common.annotations.VisibleForTesting;
024import java.util.Arrays;
025import java.util.BitSet;
026
027/**
028 * Determines a true or false value for any Java {@code char} value, just as {@link Predicate} does
029 * for any {@link Object}. Also offers basic text processing methods based on this function.
030 * Implementations are strongly encouraged to be side-effect-free and immutable.
031 *
032 * <p>Throughout the documentation of this class, the phrase "matching character" is used to mean
033 * "any {@code char} value {@code c} for which {@code this.matches(c)} returns {@code true}".
034 *
035 * <p><b>Warning:</b> This class deals only with {@code char} values, that is, <a
036 * href="http://www.unicode.org/glossary/#BMP_character">BMP characters</a>. It does not understand
037 * <a href="http://www.unicode.org/glossary/#supplementary_code_point">supplementary Unicode code
038 * points</a> in the range {@code 0x10000} to {@code 0x10FFFF} which includes the majority of
039 * assigned characters, including important CJK characters and emoji.
040 *
041 * <p>Supplementary characters are <a
042 * href="https://docs.oracle.com/javase/8/docs/api/java/lang/Character.html#supplementary">encoded
043 * into a {@code String} using surrogate pairs</a>, and a {@code CharMatcher} treats these just as
044 * two separate characters. {@link #countIn} counts each supplementary character as 2 {@code char}s.
045 *
046 * <p>For up-to-date Unicode character properties (digit, letter, etc.) and support for
047 * supplementary code points, use ICU4J UCharacter and UnicodeSet (freeze() after building). For
048 * basic text processing based on UnicodeSet use the ICU4J UnicodeSetSpanner.
049 *
050 * <p>Example usages:
051 *
052 * <pre>
053 *   String trimmed = {@link #whitespace() whitespace()}.{@link #trimFrom trimFrom}(userInput);
054 *   if ({@link #ascii() ascii()}.{@link #matchesAllOf matchesAllOf}(s)) { ... }</pre>
055 *
056 * <p>See the Guava User Guide article on <a
057 * href="https://github.com/google/guava/wiki/StringsExplained#charmatcher">{@code CharMatcher}
058 * </a>.
059 *
060 * @author Kevin Bourrillion
061 * @since 1.0
062 */
063@GwtCompatible(emulated = true)
064@ElementTypesAreNonnullByDefault
065public abstract class CharMatcher implements Predicate<Character> {
066  /*
067   *           N777777777NO
068   *         N7777777777777N
069   *        M777777777777777N
070   *        $N877777777D77777M
071   *       N M77777777ONND777M
072   *       MN777777777NN  D777
073   *     N7ZN777777777NN ~M7778
074   *    N777777777777MMNN88777N
075   *    N777777777777MNZZZ7777O
076   *    DZN7777O77777777777777
077   *     N7OONND7777777D77777N
078   *      8$M++++?N???$77777$
079   *       M7++++N+M77777777N
080   *        N77O777777777777$                              M
081   *          DNNM$$$$777777N                              D
082   *         N$N:=N$777N7777M                             NZ
083   *        77Z::::N777777777                          ODZZZ
084   *       77N::::::N77777777M                         NNZZZ$
085   *     $777:::::::77777777MN                        ZM8ZZZZZ
086   *     777M::::::Z7777777Z77                        N++ZZZZNN
087   *    7777M:::::M7777777$777M                       $++IZZZZM
088   *   M777$:::::N777777$M7777M                       +++++ZZZDN
089   *     NN$::::::7777$$M777777N                      N+++ZZZZNZ
090   *       N::::::N:7$O:77777777                      N++++ZZZZN
091   *       M::::::::::::N77777777+                   +?+++++ZZZM
092   *       8::::::::::::D77777777M                    O+++++ZZ
093   *        ::::::::::::M777777777N                      O+?D
094   *        M:::::::::::M77777777778                     77=
095   *        D=::::::::::N7777777777N                    777
096   *       INN===::::::=77777777777N                  I777N
097   *      ?777N========N7777777777787M               N7777
098   *      77777$D======N77777777777N777N?         N777777
099   *     I77777$$$N7===M$$77777777$77777777$MMZ77777777N
100   *      $$$$$$$$$$$NIZN$$$$$$$$$M$$7777777777777777ON
101   *       M$$$$$$$$M    M$$$$$$$$N=N$$$$7777777$$$ND
102   *      O77Z$$$$$$$     M$$$$$$$$MNI==$DNNNNM=~N
103   *   7 :N MNN$$$$M$      $$$777$8      8D8I
104   *     NMM.:7O           777777778
105   *                       7777777MN
106   *                       M NO .7:
107   *                       M   :   M
108   *                            8
109   */
110
111  // Constant matcher factory methods
112
113  /**
114   * Matches any character.
115   *
116   * @since 19.0 (since 1.0 as constant {@code ANY})
117   */
118  public static CharMatcher any() {
119    return Any.INSTANCE;
120  }
121
122  /**
123   * Matches no characters.
124   *
125   * @since 19.0 (since 1.0 as constant {@code NONE})
126   */
127  public static CharMatcher none() {
128    return None.INSTANCE;
129  }
130
131  /**
132   * Determines whether a character is whitespace according to the latest Unicode standard, as
133   * illustrated <a
134   * href="http://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5Cp%7Bwhitespace%7D">here</a>.
135   * This is not the same definition used by other Java APIs. (See a <a
136   * href="https://goo.gl/Y6SLWx">comparison of several definitions of "whitespace"</a>.)
137   *
138   * <p>All Unicode White_Space characters are on the BMP and thus supported by this API.
139   *
140   * <p><b>Note:</b> as the Unicode definition evolves, we will modify this matcher to keep it up to
141   * date.
142   *
143   * @since 19.0 (since 1.0 as constant {@code WHITESPACE})
144   */
145  public static CharMatcher whitespace() {
146    return Whitespace.INSTANCE;
147  }
148
149  /**
150   * Determines whether a character is a breaking whitespace (that is, a whitespace which can be
151   * interpreted as a break between words for formatting purposes). See {@link #whitespace()} for a
152   * discussion of that term.
153   *
154   * @since 19.0 (since 2.0 as constant {@code BREAKING_WHITESPACE})
155   */
156  public static CharMatcher breakingWhitespace() {
157    return BreakingWhitespace.INSTANCE;
158  }
159
160  /**
161   * Determines whether a character is ASCII, meaning that its code point is less than 128.
162   *
163   * @since 19.0 (since 1.0 as constant {@code ASCII})
164   */
165  public static CharMatcher ascii() {
166    return Ascii.INSTANCE;
167  }
168
169  /**
170   * Determines whether a character is a BMP digit according to <a
171   * href="http://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5Cp%7Bdigit%7D">Unicode</a>. If
172   * you only care to match ASCII digits, you can use {@code inRange('0', '9')}.
173   *
174   * @deprecated Many digits are supplementary characters; see the class documentation.
175   * @since 19.0 (since 1.0 as constant {@code DIGIT})
176   */
177  @Deprecated
178  public static CharMatcher digit() {
179    return Digit.INSTANCE;
180  }
181
182  /**
183   * Determines whether a character is a BMP digit according to {@linkplain Character#isDigit(char)
184   * Java's definition}. If you only care to match ASCII digits, you can use {@code inRange('0',
185   * '9')}.
186   *
187   * @deprecated Many digits are supplementary characters; see the class documentation.
188   * @since 19.0 (since 1.0 as constant {@code JAVA_DIGIT})
189   */
190  @Deprecated
191  public static CharMatcher javaDigit() {
192    return JavaDigit.INSTANCE;
193  }
194
195  /**
196   * Determines whether a character is a BMP letter according to {@linkplain
197   * Character#isLetter(char) Java's definition}. If you only care to match letters of the Latin
198   * alphabet, you can use {@code inRange('a', 'z').or(inRange('A', 'Z'))}.
199   *
200   * @deprecated Most letters are supplementary characters; see the class documentation.
201   * @since 19.0 (since 1.0 as constant {@code JAVA_LETTER})
202   */
203  @Deprecated
204  public static CharMatcher javaLetter() {
205    return JavaLetter.INSTANCE;
206  }
207
208  /**
209   * Determines whether a character is a BMP letter or digit according to {@linkplain
210   * Character#isLetterOrDigit(char) Java's definition}.
211   *
212   * @deprecated Most letters and digits are supplementary characters; see the class documentation.
213   * @since 19.0 (since 1.0 as constant {@code JAVA_LETTER_OR_DIGIT}).
214   */
215  @Deprecated
216  public static CharMatcher javaLetterOrDigit() {
217    return JavaLetterOrDigit.INSTANCE;
218  }
219
220  /**
221   * Determines whether a BMP character is upper case according to {@linkplain
222   * Character#isUpperCase(char) Java's definition}.
223   *
224   * @deprecated Some uppercase characters are supplementary characters; see the class
225   *     documentation.
226   * @since 19.0 (since 1.0 as constant {@code JAVA_UPPER_CASE})
227   */
228  @Deprecated
229  public static CharMatcher javaUpperCase() {
230    return JavaUpperCase.INSTANCE;
231  }
232
233  /**
234   * Determines whether a BMP character is lower case according to {@linkplain
235   * Character#isLowerCase(char) Java's definition}.
236   *
237   * @deprecated Some lowercase characters are supplementary characters; see the class
238   *     documentation.
239   * @since 19.0 (since 1.0 as constant {@code JAVA_LOWER_CASE})
240   */
241  @Deprecated
242  public static CharMatcher javaLowerCase() {
243    return JavaLowerCase.INSTANCE;
244  }
245
246  /**
247   * Determines whether a character is an ISO control character as specified by {@link
248   * Character#isISOControl(char)}.
249   *
250   * <p>All ISO control codes are on the BMP and thus supported by this API.
251   *
252   * @since 19.0 (since 1.0 as constant {@code JAVA_ISO_CONTROL})
253   */
254  public static CharMatcher javaIsoControl() {
255    return JavaIsoControl.INSTANCE;
256  }
257
258  /**
259   * Determines whether a character is invisible; that is, if its Unicode category is any of
260   * SPACE_SEPARATOR, LINE_SEPARATOR, PARAGRAPH_SEPARATOR, CONTROL, FORMAT, SURROGATE, and
261   * PRIVATE_USE according to ICU4J.
262   *
263   * <p>See also the Unicode Default_Ignorable_Code_Point property (available via ICU).
264   *
265   * @deprecated Most invisible characters are supplementary characters; see the class
266   *     documentation.
267   * @since 19.0 (since 1.0 as constant {@code INVISIBLE})
268   */
269  @Deprecated
270  public static CharMatcher invisible() {
271    return Invisible.INSTANCE;
272  }
273
274  /**
275   * Determines whether a character is single-width (not double-width). When in doubt, this matcher
276   * errs on the side of returning {@code false} (that is, it tends to assume a character is
277   * double-width).
278   *
279   * <p><b>Note:</b> as the reference file evolves, we will modify this matcher to keep it up to
280   * date.
281   *
282   * <p>See also <a href="http://www.unicode.org/reports/tr11/">UAX #11 East Asian Width</a>.
283   *
284   * @deprecated Many such characters are supplementary characters; see the class documentation.
285   * @since 19.0 (since 1.0 as constant {@code SINGLE_WIDTH})
286   */
287  @Deprecated
288  public static CharMatcher singleWidth() {
289    return SingleWidth.INSTANCE;
290  }
291
292  // Static factories
293
294  /** Returns a {@code char} matcher that matches only one specified BMP character. */
295  public static CharMatcher is(final char match) {
296    return new Is(match);
297  }
298
299  /**
300   * Returns a {@code char} matcher that matches any character except the BMP character specified.
301   *
302   * <p>To negate another {@code CharMatcher}, use {@link #negate()}.
303   */
304  public static CharMatcher isNot(final char match) {
305    return new IsNot(match);
306  }
307
308  /**
309   * Returns a {@code char} matcher that matches any BMP character present in the given character
310   * sequence. Returns a bogus matcher if the sequence contains supplementary characters.
311   */
312  public static CharMatcher anyOf(final CharSequence sequence) {
313    switch (sequence.length()) {
314      case 0:
315        return none();
316      case 1:
317        return is(sequence.charAt(0));
318      case 2:
319        return isEither(sequence.charAt(0), sequence.charAt(1));
320      default:
321        // TODO(lowasser): is it potentially worth just going ahead and building a precomputed
322        // matcher?
323        return new AnyOf(sequence);
324    }
325  }
326
327  /**
328   * Returns a {@code char} matcher that matches any BMP character not present in the given
329   * character sequence. Returns a bogus matcher if the sequence contains supplementary characters.
330   */
331  public static CharMatcher noneOf(CharSequence sequence) {
332    return anyOf(sequence).negate();
333  }
334
335  /**
336   * Returns a {@code char} matcher that matches any character in a given BMP range (both endpoints
337   * are inclusive). For example, to match any lowercase letter of the English alphabet, use {@code
338   * CharMatcher.inRange('a', 'z')}.
339   *
340   * @throws IllegalArgumentException if {@code endInclusive < startInclusive}
341   */
342  public static CharMatcher inRange(final char startInclusive, final char endInclusive) {
343    return new InRange(startInclusive, endInclusive);
344  }
345
346  /**
347   * Returns a matcher with identical behavior to the given {@link Character}-based predicate, but
348   * which operates on primitive {@code char} instances instead.
349   */
350  public static CharMatcher forPredicate(final Predicate<? super Character> predicate) {
351    return predicate instanceof CharMatcher ? (CharMatcher) predicate : new ForPredicate(predicate);
352  }
353
354  // Constructors
355
356  /**
357   * Constructor for use by subclasses. When subclassing, you may want to override {@code
358   * toString()} to provide a useful description.
359   */
360  protected CharMatcher() {}
361
362  // Abstract methods
363
364  /** Determines a true or false value for the given character. */
365  public abstract boolean matches(char c);
366
367  // Non-static factories
368
369  /** Returns a matcher that matches any character not matched by this matcher. */
370  // @Override under Java 8 but not under Java 7
371  @Override
372  public CharMatcher negate() {
373    return new Negated(this);
374  }
375
376  /**
377   * Returns a matcher that matches any character matched by both this matcher and {@code other}.
378   */
379  public CharMatcher and(CharMatcher other) {
380    return new And(this, other);
381  }
382
383  /**
384   * Returns a matcher that matches any character matched by either this matcher or {@code other}.
385   */
386  public CharMatcher or(CharMatcher other) {
387    return new Or(this, other);
388  }
389
390  /**
391   * Returns a {@code char} matcher functionally equivalent to this one, but which may be faster to
392   * query than the original; your mileage may vary. Precomputation takes time and is likely to be
393   * worthwhile only if the precomputed matcher is queried many thousands of times.
394   *
395   * <p>This method has no effect (returns {@code this}) when called in GWT: it's unclear whether a
396   * precomputed matcher is faster, but it certainly consumes more memory, which doesn't seem like a
397   * worthwhile tradeoff in a browser.
398   */
399  public CharMatcher precomputed() {
400    return Platform.precomputeCharMatcher(this);
401  }
402
403  private static final int DISTINCT_CHARS = Character.MAX_VALUE - Character.MIN_VALUE + 1;
404
405  /**
406   * This is the actual implementation of {@link #precomputed}, but we bounce calls through a method
407   * on {@link Platform} so that we can have different behavior in GWT.
408   *
409   * <p>This implementation tries to be smart in a number of ways. It recognizes cases where the
410   * negation is cheaper to precompute than the matcher itself; it tries to build small hash tables
411   * for matchers that only match a few characters, and so on. In the worst-case scenario, it
412   * constructs an eight-kilobyte bit array and queries that. In many situations this produces a
413   * matcher which is faster to query than the original.
414   */
415  @GwtIncompatible // SmallCharMatcher
416  CharMatcher precomputedInternal() {
417    final BitSet table = new BitSet();
418    setBits(table);
419    int totalCharacters = table.cardinality();
420    if (totalCharacters * 2 <= DISTINCT_CHARS) {
421      return precomputedPositive(totalCharacters, table, toString());
422    } else {
423      // TODO(lowasser): is it worth it to worry about the last character of large matchers?
424      table.flip(Character.MIN_VALUE, Character.MAX_VALUE + 1);
425      int negatedCharacters = DISTINCT_CHARS - totalCharacters;
426      String suffix = ".negate()";
427      final String description = toString();
428      String negatedDescription =
429          description.endsWith(suffix)
430              ? description.substring(0, description.length() - suffix.length())
431              : description + suffix;
432      return new NegatedFastMatcher(
433          precomputedPositive(negatedCharacters, table, negatedDescription)) {
434        @Override
435        public String toString() {
436          return description;
437        }
438      };
439    }
440  }
441
442  /**
443   * Helper method for {@link #precomputedInternal} that doesn't test if the negation is cheaper.
444   */
445  @GwtIncompatible // SmallCharMatcher
446  private static CharMatcher precomputedPositive(
447      int totalCharacters, BitSet table, String description) {
448    switch (totalCharacters) {
449      case 0:
450        return none();
451      case 1:
452        return is((char) table.nextSetBit(0));
453      case 2:
454        char c1 = (char) table.nextSetBit(0);
455        char c2 = (char) table.nextSetBit(c1 + 1);
456        return isEither(c1, c2);
457      default:
458        return isSmall(totalCharacters, table.length())
459            ? SmallCharMatcher.from(table, description)
460            : new BitSetMatcher(table, description);
461    }
462  }
463
464  @GwtIncompatible // SmallCharMatcher
465  private static boolean isSmall(int totalCharacters, int tableLength) {
466    return totalCharacters <= SmallCharMatcher.MAX_SIZE
467        && tableLength > (totalCharacters * 4 * Character.SIZE);
468    // err on the side of BitSetMatcher
469  }
470
471  /** Sets bits in {@code table} matched by this matcher. */
472  @GwtIncompatible // used only from other GwtIncompatible code
473  void setBits(BitSet table) {
474    for (int c = Character.MAX_VALUE; c >= Character.MIN_VALUE; c--) {
475      if (matches((char) c)) {
476        table.set(c);
477      }
478    }
479  }
480
481  // Text processing routines
482
483  /**
484   * Returns {@code true} if a character sequence contains at least one matching BMP character.
485   * Equivalent to {@code !matchesNoneOf(sequence)}.
486   *
487   * <p>The default implementation iterates over the sequence, invoking {@link #matches} for each
488   * character, until this returns {@code true} or the end is reached.
489   *
490   * @param sequence the character sequence to examine, possibly empty
491   * @return {@code true} if this matcher matches at least one character in the sequence
492   * @since 8.0
493   */
494  public boolean matchesAnyOf(CharSequence sequence) {
495    return !matchesNoneOf(sequence);
496  }
497
498  /**
499   * Returns {@code true} if a character sequence contains only matching BMP characters.
500   *
501   * <p>The default implementation iterates over the sequence, invoking {@link #matches} for each
502   * character, until this returns {@code false} or the end is reached.
503   *
504   * @param sequence the character sequence to examine, possibly empty
505   * @return {@code true} if this matcher matches every character in the sequence, including when
506   *     the sequence is empty
507   */
508  public boolean matchesAllOf(CharSequence sequence) {
509    for (int i = sequence.length() - 1; i >= 0; i--) {
510      if (!matches(sequence.charAt(i))) {
511        return false;
512      }
513    }
514    return true;
515  }
516
517  /**
518   * Returns {@code true} if a character sequence contains no matching BMP characters. Equivalent to
519   * {@code !matchesAnyOf(sequence)}.
520   *
521   * <p>The default implementation iterates over the sequence, invoking {@link #matches} for each
522   * character, until this returns {@code true} or the end is reached.
523   *
524   * @param sequence the character sequence to examine, possibly empty
525   * @return {@code true} if this matcher matches no characters in the sequence, including when the
526   *     sequence is empty
527   */
528  public boolean matchesNoneOf(CharSequence sequence) {
529    return indexIn(sequence) == -1;
530  }
531
532  /**
533   * Returns the index of the first matching BMP character in a character sequence, or {@code -1} if
534   * no matching character is present.
535   *
536   * <p>The default implementation iterates over the sequence in forward order calling {@link
537   * #matches} for each character.
538   *
539   * @param sequence the character sequence to examine from the beginning
540   * @return an index, or {@code -1} if no character matches
541   */
542  public int indexIn(CharSequence sequence) {
543    return indexIn(sequence, 0);
544  }
545
546  /**
547   * Returns the index of the first matching BMP character in a character sequence, starting from a
548   * given position, or {@code -1} if no character matches after that position.
549   *
550   * <p>The default implementation iterates over the sequence in forward order, beginning at {@code
551   * start}, calling {@link #matches} for each character.
552   *
553   * @param sequence the character sequence to examine
554   * @param start the first index to examine; must be nonnegative and no greater than {@code
555   *     sequence.length()}
556   * @return the index of the first matching character, guaranteed to be no less than {@code start},
557   *     or {@code -1} if no character matches
558   * @throws IndexOutOfBoundsException if start is negative or greater than {@code
559   *     sequence.length()}
560   */
561  public int indexIn(CharSequence sequence, int start) {
562    int length = sequence.length();
563    checkPositionIndex(start, length);
564    for (int i = start; i < length; i++) {
565      if (matches(sequence.charAt(i))) {
566        return i;
567      }
568    }
569    return -1;
570  }
571
572  /**
573   * Returns the index of the last matching BMP character in a character sequence, or {@code -1} if
574   * no matching character is present.
575   *
576   * <p>The default implementation iterates over the sequence in reverse order calling {@link
577   * #matches} for each character.
578   *
579   * @param sequence the character sequence to examine from the end
580   * @return an index, or {@code -1} if no character matches
581   */
582  public int lastIndexIn(CharSequence sequence) {
583    for (int i = sequence.length() - 1; i >= 0; i--) {
584      if (matches(sequence.charAt(i))) {
585        return i;
586      }
587    }
588    return -1;
589  }
590
591  /**
592   * Returns the number of matching {@code char}s found in a character sequence.
593   *
594   * <p>Counts 2 per supplementary character, such as for {@link #whitespace}().{@link #negate}().
595   */
596  public int countIn(CharSequence sequence) {
597    int count = 0;
598    for (int i = 0; i < sequence.length(); i++) {
599      if (matches(sequence.charAt(i))) {
600        count++;
601      }
602    }
603    return count;
604  }
605
606  /**
607   * Returns a string containing all non-matching characters of a character sequence, in order. For
608   * example:
609   *
610   * <pre>{@code
611   * CharMatcher.is('a').removeFrom("bazaar")
612   * }</pre>
613   *
614   * ... returns {@code "bzr"}.
615   */
616  public String removeFrom(CharSequence sequence) {
617    String string = sequence.toString();
618    int pos = indexIn(string);
619    if (pos == -1) {
620      return string;
621    }
622
623    char[] chars = string.toCharArray();
624    int spread = 1;
625
626    // This unusual loop comes from extensive benchmarking
627    OUT:
628    while (true) {
629      pos++;
630      while (true) {
631        if (pos == chars.length) {
632          break OUT;
633        }
634        if (matches(chars[pos])) {
635          break;
636        }
637        chars[pos - spread] = chars[pos];
638        pos++;
639      }
640      spread++;
641    }
642    return new String(chars, 0, pos - spread);
643  }
644
645  /**
646   * Returns a string containing all matching BMP characters of a character sequence, in order. For
647   * example:
648   *
649   * <pre>{@code
650   * CharMatcher.is('a').retainFrom("bazaar")
651   * }</pre>
652   *
653   * ... returns {@code "aaa"}.
654   */
655  public String retainFrom(CharSequence sequence) {
656    return negate().removeFrom(sequence);
657  }
658
659  /**
660   * Returns a string copy of the input character sequence, with each matching BMP character
661   * replaced by a given replacement character. For example:
662   *
663   * <pre>{@code
664   * CharMatcher.is('a').replaceFrom("radar", 'o')
665   * }</pre>
666   *
667   * ... returns {@code "rodor"}.
668   *
669   * <p>The default implementation uses {@link #indexIn(CharSequence)} to find the first matching
670   * character, then iterates the remainder of the sequence calling {@link #matches(char)} for each
671   * character.
672   *
673   * @param sequence the character sequence to replace matching characters in
674   * @param replacement the character to append to the result string in place of each matching
675   *     character in {@code sequence}
676   * @return the new string
677   */
678  public String replaceFrom(CharSequence sequence, char replacement) {
679    String string = sequence.toString();
680    int pos = indexIn(string);
681    if (pos == -1) {
682      return string;
683    }
684    char[] chars = string.toCharArray();
685    chars[pos] = replacement;
686    for (int i = pos + 1; i < chars.length; i++) {
687      if (matches(chars[i])) {
688        chars[i] = replacement;
689      }
690    }
691    return new String(chars);
692  }
693
694  /**
695   * Returns a string copy of the input character sequence, with each matching BMP character
696   * replaced by a given replacement sequence. For example:
697   *
698   * <pre>{@code
699   * CharMatcher.is('a').replaceFrom("yaha", "oo")
700   * }</pre>
701   *
702   * ... returns {@code "yoohoo"}.
703   *
704   * <p><b>Note:</b> If the replacement is a fixed string with only one character, you are better
705   * off calling {@link #replaceFrom(CharSequence, char)} directly.
706   *
707   * @param sequence the character sequence to replace matching characters in
708   * @param replacement the characters to append to the result string in place of each matching
709   *     character in {@code sequence}
710   * @return the new string
711   */
712  public String replaceFrom(CharSequence sequence, CharSequence replacement) {
713    int replacementLen = replacement.length();
714    if (replacementLen == 0) {
715      return removeFrom(sequence);
716    }
717    if (replacementLen == 1) {
718      return replaceFrom(sequence, replacement.charAt(0));
719    }
720
721    String string = sequence.toString();
722    int pos = indexIn(string);
723    if (pos == -1) {
724      return string;
725    }
726
727    int len = string.length();
728    StringBuilder buf = new StringBuilder((len * 3 / 2) + 16);
729
730    int oldpos = 0;
731    do {
732      buf.append(string, oldpos, pos);
733      buf.append(replacement);
734      oldpos = pos + 1;
735      pos = indexIn(string, oldpos);
736    } while (pos != -1);
737
738    buf.append(string, oldpos, len);
739    return buf.toString();
740  }
741
742  /**
743   * Returns a substring of the input character sequence that omits all matching BMP characters from
744   * the beginning and from the end of the string. For example:
745   *
746   * <pre>{@code
747   * CharMatcher.anyOf("ab").trimFrom("abacatbab")
748   * }</pre>
749   *
750   * ... returns {@code "cat"}.
751   *
752   * <p>Note that:
753   *
754   * <pre>{@code
755   * CharMatcher.inRange('\0', ' ').trimFrom(str)
756   * }</pre>
757   *
758   * ... is equivalent to {@link String#trim()}.
759   */
760  public String trimFrom(CharSequence sequence) {
761    int len = sequence.length();
762    int first;
763    int last;
764
765    for (first = 0; first < len; first++) {
766      if (!matches(sequence.charAt(first))) {
767        break;
768      }
769    }
770    for (last = len - 1; last > first; last--) {
771      if (!matches(sequence.charAt(last))) {
772        break;
773      }
774    }
775
776    return sequence.subSequence(first, last + 1).toString();
777  }
778
779  /**
780   * Returns a substring of the input character sequence that omits all matching BMP characters from
781   * the beginning of the string. For example:
782   *
783   * <pre>{@code
784   * CharMatcher.anyOf("ab").trimLeadingFrom("abacatbab")
785   * }</pre>
786   *
787   * ... returns {@code "catbab"}.
788   */
789  public String trimLeadingFrom(CharSequence sequence) {
790    int len = sequence.length();
791    for (int first = 0; first < len; first++) {
792      if (!matches(sequence.charAt(first))) {
793        return sequence.subSequence(first, len).toString();
794      }
795    }
796    return "";
797  }
798
799  /**
800   * Returns a substring of the input character sequence that omits all matching BMP characters from
801   * the end of the string. For example:
802   *
803   * <pre>{@code
804   * CharMatcher.anyOf("ab").trimTrailingFrom("abacatbab")
805   * }</pre>
806   *
807   * ... returns {@code "abacat"}.
808   */
809  public String trimTrailingFrom(CharSequence sequence) {
810    int len = sequence.length();
811    for (int last = len - 1; last >= 0; last--) {
812      if (!matches(sequence.charAt(last))) {
813        return sequence.subSequence(0, last + 1).toString();
814      }
815    }
816    return "";
817  }
818
819  /**
820   * Returns a string copy of the input character sequence, with each group of consecutive matching
821   * BMP characters replaced by a single replacement character. For example:
822   *
823   * <pre>{@code
824   * CharMatcher.anyOf("eko").collapseFrom("bookkeeper", '-')
825   * }</pre>
826   *
827   * ... returns {@code "b-p-r"}.
828   *
829   * <p>The default implementation uses {@link #indexIn(CharSequence)} to find the first matching
830   * character, then iterates the remainder of the sequence calling {@link #matches(char)} for each
831   * character.
832   *
833   * @param sequence the character sequence to replace matching groups of characters in
834   * @param replacement the character to append to the result string in place of each group of
835   *     matching characters in {@code sequence}
836   * @return the new string
837   */
838  public String collapseFrom(CharSequence sequence, char replacement) {
839    // This implementation avoids unnecessary allocation.
840    int len = sequence.length();
841    for (int i = 0; i < len; i++) {
842      char c = sequence.charAt(i);
843      if (matches(c)) {
844        if (c == replacement && (i == len - 1 || !matches(sequence.charAt(i + 1)))) {
845          // a no-op replacement
846          i++;
847        } else {
848          StringBuilder builder = new StringBuilder(len).append(sequence, 0, i).append(replacement);
849          return finishCollapseFrom(sequence, i + 1, len, replacement, builder, true);
850        }
851      }
852    }
853    // no replacement needed
854    return sequence.toString();
855  }
856
857  /**
858   * Collapses groups of matching characters exactly as {@link #collapseFrom} does, except that
859   * groups of matching BMP characters at the start or end of the sequence are removed without
860   * replacement.
861   */
862  public String trimAndCollapseFrom(CharSequence sequence, char replacement) {
863    // This implementation avoids unnecessary allocation.
864    int len = sequence.length();
865    int first = 0;
866    int last = len - 1;
867
868    while (first < len && matches(sequence.charAt(first))) {
869      first++;
870    }
871
872    while (last > first && matches(sequence.charAt(last))) {
873      last--;
874    }
875
876    return (first == 0 && last == len - 1)
877        ? collapseFrom(sequence, replacement)
878        : finishCollapseFrom(
879            sequence, first, last + 1, replacement, new StringBuilder(last + 1 - first), false);
880  }
881
882  private String finishCollapseFrom(
883      CharSequence sequence,
884      int start,
885      int end,
886      char replacement,
887      StringBuilder builder,
888      boolean inMatchingGroup) {
889    for (int i = start; i < end; i++) {
890      char c = sequence.charAt(i);
891      if (matches(c)) {
892        if (!inMatchingGroup) {
893          builder.append(replacement);
894          inMatchingGroup = true;
895        }
896      } else {
897        builder.append(c);
898        inMatchingGroup = false;
899      }
900    }
901    return builder.toString();
902  }
903
904  /**
905   * @deprecated Provided only to satisfy the {@link Predicate} interface; use {@link #matches}
906   *     instead.
907   */
908  @Deprecated
909  @Override
910  public boolean apply(Character character) {
911    return matches(character);
912  }
913
914  /**
915   * Returns a string representation of this {@code CharMatcher}, such as {@code
916   * CharMatcher.or(WHITESPACE, JAVA_DIGIT)}.
917   */
918  @Override
919  public String toString() {
920    return super.toString();
921  }
922
923  /**
924   * Returns the Java Unicode escape sequence for the given {@code char}, in the form "\u12AB" where
925   * "12AB" is the four hexadecimal digits representing the 16-bit code unit.
926   */
927  private static String showCharacter(char c) {
928    String hex = "0123456789ABCDEF";
929    char[] tmp = {'\\', 'u', '\0', '\0', '\0', '\0'};
930    for (int i = 0; i < 4; i++) {
931      tmp[5 - i] = hex.charAt(c & 0xF);
932      c = (char) (c >> 4);
933    }
934    return String.copyValueOf(tmp);
935  }
936
937  // Fast matchers
938
939  /** A matcher for which precomputation will not yield any significant benefit. */
940  abstract static class FastMatcher extends CharMatcher {
941
942    @Override
943    public final CharMatcher precomputed() {
944      return this;
945    }
946
947    @Override
948    public CharMatcher negate() {
949      return new NegatedFastMatcher(this);
950    }
951  }
952
953  /** {@link FastMatcher} which overrides {@code toString()} with a custom name. */
954  abstract static class NamedFastMatcher extends FastMatcher {
955
956    private final String description;
957
958    NamedFastMatcher(String description) {
959      this.description = checkNotNull(description);
960    }
961
962    @Override
963    public final String toString() {
964      return description;
965    }
966  }
967
968  /** Negation of a {@link FastMatcher}. */
969  static class NegatedFastMatcher extends Negated {
970
971    NegatedFastMatcher(CharMatcher original) {
972      super(original);
973    }
974
975    @Override
976    public final CharMatcher precomputed() {
977      return this;
978    }
979  }
980
981  /** Fast matcher using a {@link BitSet} table of matching characters. */
982  @GwtIncompatible // used only from other GwtIncompatible code
983  private static final class BitSetMatcher extends NamedFastMatcher {
984
985    private final BitSet table;
986
987    private BitSetMatcher(BitSet table, String description) {
988      super(description);
989      if (table.length() + Long.SIZE < table.size()) {
990        table = (BitSet) table.clone();
991        // If only we could actually call BitSet.trimToSize() ourselves...
992      }
993      this.table = table;
994    }
995
996    @Override
997    public boolean matches(char c) {
998      return table.get(c);
999    }
1000
1001    @Override
1002    void setBits(BitSet bitSet) {
1003      bitSet.or(table);
1004    }
1005  }
1006
1007  // Static constant implementation classes
1008
1009  /** Implementation of {@link #any()}. */
1010  private static final class Any extends NamedFastMatcher {
1011
1012    static final Any INSTANCE = new Any();
1013
1014    private Any() {
1015      super("CharMatcher.any()");
1016    }
1017
1018    @Override
1019    public boolean matches(char c) {
1020      return true;
1021    }
1022
1023    @Override
1024    public int indexIn(CharSequence sequence) {
1025      return (sequence.length() == 0) ? -1 : 0;
1026    }
1027
1028    @Override
1029    public int indexIn(CharSequence sequence, int start) {
1030      int length = sequence.length();
1031      checkPositionIndex(start, length);
1032      return (start == length) ? -1 : start;
1033    }
1034
1035    @Override
1036    public int lastIndexIn(CharSequence sequence) {
1037      return sequence.length() - 1;
1038    }
1039
1040    @Override
1041    public boolean matchesAllOf(CharSequence sequence) {
1042      checkNotNull(sequence);
1043      return true;
1044    }
1045
1046    @Override
1047    public boolean matchesNoneOf(CharSequence sequence) {
1048      return sequence.length() == 0;
1049    }
1050
1051    @Override
1052    public String removeFrom(CharSequence sequence) {
1053      checkNotNull(sequence);
1054      return "";
1055    }
1056
1057    @Override
1058    public String replaceFrom(CharSequence sequence, char replacement) {
1059      char[] array = new char[sequence.length()];
1060      Arrays.fill(array, replacement);
1061      return new String(array);
1062    }
1063
1064    @Override
1065    public String replaceFrom(CharSequence sequence, CharSequence replacement) {
1066      StringBuilder result = new StringBuilder(sequence.length() * replacement.length());
1067      for (int i = 0; i < sequence.length(); i++) {
1068        result.append(replacement);
1069      }
1070      return result.toString();
1071    }
1072
1073    @Override
1074    public String collapseFrom(CharSequence sequence, char replacement) {
1075      return (sequence.length() == 0) ? "" : String.valueOf(replacement);
1076    }
1077
1078    @Override
1079    public String trimFrom(CharSequence sequence) {
1080      checkNotNull(sequence);
1081      return "";
1082    }
1083
1084    @Override
1085    public int countIn(CharSequence sequence) {
1086      return sequence.length();
1087    }
1088
1089    @Override
1090    public CharMatcher and(CharMatcher other) {
1091      return checkNotNull(other);
1092    }
1093
1094    @Override
1095    public CharMatcher or(CharMatcher other) {
1096      checkNotNull(other);
1097      return this;
1098    }
1099
1100    @Override
1101    public CharMatcher negate() {
1102      return none();
1103    }
1104  }
1105
1106  /** Implementation of {@link #none()}. */
1107  private static final class None extends NamedFastMatcher {
1108
1109    static final None INSTANCE = new None();
1110
1111    private None() {
1112      super("CharMatcher.none()");
1113    }
1114
1115    @Override
1116    public boolean matches(char c) {
1117      return false;
1118    }
1119
1120    @Override
1121    public int indexIn(CharSequence sequence) {
1122      checkNotNull(sequence);
1123      return -1;
1124    }
1125
1126    @Override
1127    public int indexIn(CharSequence sequence, int start) {
1128      int length = sequence.length();
1129      checkPositionIndex(start, length);
1130      return -1;
1131    }
1132
1133    @Override
1134    public int lastIndexIn(CharSequence sequence) {
1135      checkNotNull(sequence);
1136      return -1;
1137    }
1138
1139    @Override
1140    public boolean matchesAllOf(CharSequence sequence) {
1141      return sequence.length() == 0;
1142    }
1143
1144    @Override
1145    public boolean matchesNoneOf(CharSequence sequence) {
1146      checkNotNull(sequence);
1147      return true;
1148    }
1149
1150    @Override
1151    public String removeFrom(CharSequence sequence) {
1152      return sequence.toString();
1153    }
1154
1155    @Override
1156    public String replaceFrom(CharSequence sequence, char replacement) {
1157      return sequence.toString();
1158    }
1159
1160    @Override
1161    public String replaceFrom(CharSequence sequence, CharSequence replacement) {
1162      checkNotNull(replacement);
1163      return sequence.toString();
1164    }
1165
1166    @Override
1167    public String collapseFrom(CharSequence sequence, char replacement) {
1168      return sequence.toString();
1169    }
1170
1171    @Override
1172    public String trimFrom(CharSequence sequence) {
1173      return sequence.toString();
1174    }
1175
1176    @Override
1177    public String trimLeadingFrom(CharSequence sequence) {
1178      return sequence.toString();
1179    }
1180
1181    @Override
1182    public String trimTrailingFrom(CharSequence sequence) {
1183      return sequence.toString();
1184    }
1185
1186    @Override
1187    public int countIn(CharSequence sequence) {
1188      checkNotNull(sequence);
1189      return 0;
1190    }
1191
1192    @Override
1193    public CharMatcher and(CharMatcher other) {
1194      checkNotNull(other);
1195      return this;
1196    }
1197
1198    @Override
1199    public CharMatcher or(CharMatcher other) {
1200      return checkNotNull(other);
1201    }
1202
1203    @Override
1204    public CharMatcher negate() {
1205      return any();
1206    }
1207  }
1208
1209  /** Implementation of {@link #whitespace()}. */
1210  @VisibleForTesting
1211  static final class Whitespace extends NamedFastMatcher {
1212
1213    // TABLE is a precomputed hashset of whitespace characters. MULTIPLIER serves as a hash function
1214    // whose key property is that it maps 25 characters into the 32-slot table without collision.
1215    // Basically this is an opportunistic fast implementation as opposed to "good code". For most
1216    // other use-cases, the reduction in readability isn't worth it.
1217    static final String TABLE =
1218        "\u2002\u3000\r\u0085\u200A\u2005\u2000\u3000"
1219            + "\u2029\u000B\u3000\u2008\u2003\u205F\u3000\u1680"
1220            + "\u0009\u0020\u2006\u2001\u202F\u00A0\u000C\u2009"
1221            + "\u3000\u2004\u3000\u3000\u2028\n\u2007\u3000";
1222    static final int MULTIPLIER = 1682554634;
1223    static final int SHIFT = Integer.numberOfLeadingZeros(TABLE.length() - 1);
1224
1225    static final Whitespace INSTANCE = new Whitespace();
1226
1227    Whitespace() {
1228      super("CharMatcher.whitespace()");
1229    }
1230
1231    @Override
1232    public boolean matches(char c) {
1233      return TABLE.charAt((MULTIPLIER * c) >>> SHIFT) == c;
1234    }
1235
1236    @GwtIncompatible // used only from other GwtIncompatible code
1237    @Override
1238    void setBits(BitSet table) {
1239      for (int i = 0; i < TABLE.length(); i++) {
1240        table.set(TABLE.charAt(i));
1241      }
1242    }
1243  }
1244
1245  /** Implementation of {@link #breakingWhitespace()}. */
1246  private static final class BreakingWhitespace extends CharMatcher {
1247
1248    static final CharMatcher INSTANCE = new BreakingWhitespace();
1249
1250    @Override
1251    public boolean matches(char c) {
1252      switch (c) {
1253        case '\t':
1254        case '\n':
1255        case '\013':
1256        case '\f':
1257        case '\r':
1258        case ' ':
1259        case '\u0085':
1260        case '\u1680':
1261        case '\u2028':
1262        case '\u2029':
1263        case '\u205f':
1264        case '\u3000':
1265          return true;
1266        case '\u2007':
1267          return false;
1268        default:
1269          return c >= '\u2000' && c <= '\u200a';
1270      }
1271    }
1272
1273    @Override
1274    public String toString() {
1275      return "CharMatcher.breakingWhitespace()";
1276    }
1277  }
1278
1279  /** Implementation of {@link #ascii()}. */
1280  private static final class Ascii extends NamedFastMatcher {
1281
1282    static final Ascii INSTANCE = new Ascii();
1283
1284    Ascii() {
1285      super("CharMatcher.ascii()");
1286    }
1287
1288    @Override
1289    public boolean matches(char c) {
1290      return c <= '\u007f';
1291    }
1292  }
1293
1294  /** Implementation that matches characters that fall within multiple ranges. */
1295  private static class RangesMatcher extends CharMatcher {
1296
1297    private final String description;
1298    private final char[] rangeStarts;
1299    private final char[] rangeEnds;
1300
1301    RangesMatcher(String description, char[] rangeStarts, char[] rangeEnds) {
1302      this.description = description;
1303      this.rangeStarts = rangeStarts;
1304      this.rangeEnds = rangeEnds;
1305      checkArgument(rangeStarts.length == rangeEnds.length);
1306      for (int i = 0; i < rangeStarts.length; i++) {
1307        checkArgument(rangeStarts[i] <= rangeEnds[i]);
1308        if (i + 1 < rangeStarts.length) {
1309          checkArgument(rangeEnds[i] < rangeStarts[i + 1]);
1310        }
1311      }
1312    }
1313
1314    @Override
1315    public boolean matches(char c) {
1316      int index = Arrays.binarySearch(rangeStarts, c);
1317      if (index >= 0) {
1318        return true;
1319      } else {
1320        index = ~index - 1;
1321        return index >= 0 && c <= rangeEnds[index];
1322      }
1323    }
1324
1325    @Override
1326    public String toString() {
1327      return description;
1328    }
1329  }
1330
1331  /** Implementation of {@link #digit()}. */
1332  private static final class Digit extends RangesMatcher {
1333    // Plug the following UnicodeSet pattern into
1334    // https://unicode.org/cldr/utility/list-unicodeset.jsp
1335    // [[:Nd:]&[:nv=0:]&[\u0000-\uFFFF]]
1336    // and get the zeroes from there.
1337
1338    // Must be in ascending order.
1339    private static final String ZEROES =
1340        "0\u0660\u06f0\u07c0\u0966\u09e6\u0a66\u0ae6\u0b66\u0be6\u0c66\u0ce6\u0d66\u0de6"
1341            + "\u0e50\u0ed0\u0f20\u1040\u1090\u17e0\u1810\u1946\u19d0\u1a80\u1a90\u1b50\u1bb0"
1342            + "\u1c40\u1c50\ua620\ua8d0\ua900\ua9d0\ua9f0\uaa50\uabf0\uff10";
1343
1344    private static char[] zeroes() {
1345      return ZEROES.toCharArray();
1346    }
1347
1348    private static char[] nines() {
1349      char[] nines = new char[ZEROES.length()];
1350      for (int i = 0; i < ZEROES.length(); i++) {
1351        nines[i] = (char) (ZEROES.charAt(i) + 9);
1352      }
1353      return nines;
1354    }
1355
1356    static final Digit INSTANCE = new Digit();
1357
1358    private Digit() {
1359      super("CharMatcher.digit()", zeroes(), nines());
1360    }
1361  }
1362
1363  /** Implementation of {@link #javaDigit()}. */
1364  private static final class JavaDigit extends CharMatcher {
1365
1366    static final JavaDigit INSTANCE = new JavaDigit();
1367
1368    @Override
1369    public boolean matches(char c) {
1370      return Character.isDigit(c);
1371    }
1372
1373    @Override
1374    public String toString() {
1375      return "CharMatcher.javaDigit()";
1376    }
1377  }
1378
1379  /** Implementation of {@link #javaLetter()}. */
1380  private static final class JavaLetter extends CharMatcher {
1381
1382    static final JavaLetter INSTANCE = new JavaLetter();
1383
1384    @Override
1385    public boolean matches(char c) {
1386      return Character.isLetter(c);
1387    }
1388
1389    @Override
1390    public String toString() {
1391      return "CharMatcher.javaLetter()";
1392    }
1393  }
1394
1395  /** Implementation of {@link #javaLetterOrDigit()}. */
1396  private static final class JavaLetterOrDigit extends CharMatcher {
1397
1398    static final JavaLetterOrDigit INSTANCE = new JavaLetterOrDigit();
1399
1400    @Override
1401    public boolean matches(char c) {
1402      return Character.isLetterOrDigit(c);
1403    }
1404
1405    @Override
1406    public String toString() {
1407      return "CharMatcher.javaLetterOrDigit()";
1408    }
1409  }
1410
1411  /** Implementation of {@link #javaUpperCase()}. */
1412  private static final class JavaUpperCase extends CharMatcher {
1413
1414    static final JavaUpperCase INSTANCE = new JavaUpperCase();
1415
1416    @Override
1417    public boolean matches(char c) {
1418      return Character.isUpperCase(c);
1419    }
1420
1421    @Override
1422    public String toString() {
1423      return "CharMatcher.javaUpperCase()";
1424    }
1425  }
1426
1427  /** Implementation of {@link #javaLowerCase()}. */
1428  private static final class JavaLowerCase extends CharMatcher {
1429
1430    static final JavaLowerCase INSTANCE = new JavaLowerCase();
1431
1432    @Override
1433    public boolean matches(char c) {
1434      return Character.isLowerCase(c);
1435    }
1436
1437    @Override
1438    public String toString() {
1439      return "CharMatcher.javaLowerCase()";
1440    }
1441  }
1442
1443  /** Implementation of {@link #javaIsoControl()}. */
1444  private static final class JavaIsoControl extends NamedFastMatcher {
1445
1446    static final JavaIsoControl INSTANCE = new JavaIsoControl();
1447
1448    private JavaIsoControl() {
1449      super("CharMatcher.javaIsoControl()");
1450    }
1451
1452    @Override
1453    public boolean matches(char c) {
1454      return c <= '\u001f' || (c >= '\u007f' && c <= '\u009f');
1455    }
1456  }
1457
1458  /** Implementation of {@link #invisible()}. */
1459  private static final class Invisible extends RangesMatcher {
1460    // Plug the following UnicodeSet pattern into
1461    // https://unicode.org/cldr/utility/list-unicodeset.jsp
1462    // [[[:Zs:][:Zl:][:Zp:][:Cc:][:Cf:][:Cs:][:Co:]]&[\u0000-\uFFFF]]
1463    // with the "Abbreviate" option, and get the ranges from there.
1464    private static final String RANGE_STARTS =
1465        "\u0000\u007f\u00ad\u0600\u061c\u06dd\u070f\u0890\u08e2\u1680\u180e\u2000\u2028\u205f\u2066"
1466            + "\u3000\ud800\ufeff\ufff9";
1467    private static final String RANGE_ENDS = // inclusive ends
1468        "\u0020\u00a0\u00ad\u0605\u061c\u06dd\u070f\u0891\u08e2\u1680\u180e\u200f\u202f\u2064\u206f"
1469            + "\u3000\uf8ff\ufeff\ufffb";
1470
1471    static final Invisible INSTANCE = new Invisible();
1472
1473    private Invisible() {
1474      super("CharMatcher.invisible()", RANGE_STARTS.toCharArray(), RANGE_ENDS.toCharArray());
1475    }
1476  }
1477
1478  /** Implementation of {@link #singleWidth()}. */
1479  private static final class SingleWidth extends RangesMatcher {
1480
1481    static final SingleWidth INSTANCE = new SingleWidth();
1482
1483    private SingleWidth() {
1484      super(
1485          "CharMatcher.singleWidth()",
1486          "\u0000\u05be\u05d0\u05f3\u0600\u0750\u0e00\u1e00\u2100\ufb50\ufe70\uff61".toCharArray(),
1487          "\u04f9\u05be\u05ea\u05f4\u06ff\u077f\u0e7f\u20af\u213a\ufdff\ufeff\uffdc".toCharArray());
1488    }
1489  }
1490
1491  // Non-static factory implementation classes
1492
1493  /** Implementation of {@link #negate()}. */
1494  private static class Negated extends CharMatcher {
1495
1496    final CharMatcher original;
1497
1498    Negated(CharMatcher original) {
1499      this.original = checkNotNull(original);
1500    }
1501
1502    @Override
1503    public boolean matches(char c) {
1504      return !original.matches(c);
1505    }
1506
1507    @Override
1508    public boolean matchesAllOf(CharSequence sequence) {
1509      return original.matchesNoneOf(sequence);
1510    }
1511
1512    @Override
1513    public boolean matchesNoneOf(CharSequence sequence) {
1514      return original.matchesAllOf(sequence);
1515    }
1516
1517    @Override
1518    public int countIn(CharSequence sequence) {
1519      return sequence.length() - original.countIn(sequence);
1520    }
1521
1522    @GwtIncompatible // used only from other GwtIncompatible code
1523    @Override
1524    void setBits(BitSet table) {
1525      BitSet tmp = new BitSet();
1526      original.setBits(tmp);
1527      tmp.flip(Character.MIN_VALUE, Character.MAX_VALUE + 1);
1528      table.or(tmp);
1529    }
1530
1531    @Override
1532    public CharMatcher negate() {
1533      return original;
1534    }
1535
1536    @Override
1537    public String toString() {
1538      return original + ".negate()";
1539    }
1540  }
1541
1542  /** Implementation of {@link #and(CharMatcher)}. */
1543  private static final class And extends CharMatcher {
1544
1545    final CharMatcher first;
1546    final CharMatcher second;
1547
1548    And(CharMatcher a, CharMatcher b) {
1549      first = checkNotNull(a);
1550      second = checkNotNull(b);
1551    }
1552
1553    @Override
1554    public boolean matches(char c) {
1555      return first.matches(c) && second.matches(c);
1556    }
1557
1558    @GwtIncompatible // used only from other GwtIncompatible code
1559    @Override
1560    void setBits(BitSet table) {
1561      BitSet tmp1 = new BitSet();
1562      first.setBits(tmp1);
1563      BitSet tmp2 = new BitSet();
1564      second.setBits(tmp2);
1565      tmp1.and(tmp2);
1566      table.or(tmp1);
1567    }
1568
1569    @Override
1570    public String toString() {
1571      return "CharMatcher.and(" + first + ", " + second + ")";
1572    }
1573  }
1574
1575  /** Implementation of {@link #or(CharMatcher)}. */
1576  private static final class Or extends CharMatcher {
1577
1578    final CharMatcher first;
1579    final CharMatcher second;
1580
1581    Or(CharMatcher a, CharMatcher b) {
1582      first = checkNotNull(a);
1583      second = checkNotNull(b);
1584    }
1585
1586    @GwtIncompatible // used only from other GwtIncompatible code
1587    @Override
1588    void setBits(BitSet table) {
1589      first.setBits(table);
1590      second.setBits(table);
1591    }
1592
1593    @Override
1594    public boolean matches(char c) {
1595      return first.matches(c) || second.matches(c);
1596    }
1597
1598    @Override
1599    public String toString() {
1600      return "CharMatcher.or(" + first + ", " + second + ")";
1601    }
1602  }
1603
1604  // Static factory implementations
1605
1606  /** Implementation of {@link #is(char)}. */
1607  private static final class Is extends FastMatcher {
1608
1609    private final char match;
1610
1611    Is(char match) {
1612      this.match = match;
1613    }
1614
1615    @Override
1616    public boolean matches(char c) {
1617      return c == match;
1618    }
1619
1620    @Override
1621    public String replaceFrom(CharSequence sequence, char replacement) {
1622      return sequence.toString().replace(match, replacement);
1623    }
1624
1625    @Override
1626    public CharMatcher and(CharMatcher other) {
1627      return other.matches(match) ? this : none();
1628    }
1629
1630    @Override
1631    public CharMatcher or(CharMatcher other) {
1632      return other.matches(match) ? other : super.or(other);
1633    }
1634
1635    @Override
1636    public CharMatcher negate() {
1637      return isNot(match);
1638    }
1639
1640    @GwtIncompatible // used only from other GwtIncompatible code
1641    @Override
1642    void setBits(BitSet table) {
1643      table.set(match);
1644    }
1645
1646    @Override
1647    public String toString() {
1648      return "CharMatcher.is('" + showCharacter(match) + "')";
1649    }
1650  }
1651
1652  /** Implementation of {@link #isNot(char)}. */
1653  private static final class IsNot extends FastMatcher {
1654
1655    private final char match;
1656
1657    IsNot(char match) {
1658      this.match = match;
1659    }
1660
1661    @Override
1662    public boolean matches(char c) {
1663      return c != match;
1664    }
1665
1666    @Override
1667    public CharMatcher and(CharMatcher other) {
1668      return other.matches(match) ? super.and(other) : other;
1669    }
1670
1671    @Override
1672    public CharMatcher or(CharMatcher other) {
1673      return other.matches(match) ? any() : this;
1674    }
1675
1676    @GwtIncompatible // used only from other GwtIncompatible code
1677    @Override
1678    void setBits(BitSet table) {
1679      table.set(0, match);
1680      table.set(match + 1, Character.MAX_VALUE + 1);
1681    }
1682
1683    @Override
1684    public CharMatcher negate() {
1685      return is(match);
1686    }
1687
1688    @Override
1689    public String toString() {
1690      return "CharMatcher.isNot('" + showCharacter(match) + "')";
1691    }
1692  }
1693
1694  private static CharMatcher.IsEither isEither(char c1, char c2) {
1695    return new CharMatcher.IsEither(c1, c2);
1696  }
1697
1698  /** Implementation of {@link #anyOf(CharSequence)} for exactly two characters. */
1699  private static final class IsEither extends FastMatcher {
1700
1701    private final char match1;
1702    private final char match2;
1703
1704    IsEither(char match1, char match2) {
1705      this.match1 = match1;
1706      this.match2 = match2;
1707    }
1708
1709    @Override
1710    public boolean matches(char c) {
1711      return c == match1 || c == match2;
1712    }
1713
1714    @GwtIncompatible // used only from other GwtIncompatible code
1715    @Override
1716    void setBits(BitSet table) {
1717      table.set(match1);
1718      table.set(match2);
1719    }
1720
1721    @Override
1722    public String toString() {
1723      return "CharMatcher.anyOf(\"" + showCharacter(match1) + showCharacter(match2) + "\")";
1724    }
1725  }
1726
1727  /** Implementation of {@link #anyOf(CharSequence)} for three or more characters. */
1728  private static final class AnyOf extends CharMatcher {
1729
1730    private final char[] chars;
1731
1732    public AnyOf(CharSequence chars) {
1733      this.chars = chars.toString().toCharArray();
1734      Arrays.sort(this.chars);
1735    }
1736
1737    @Override
1738    public boolean matches(char c) {
1739      return Arrays.binarySearch(chars, c) >= 0;
1740    }
1741
1742    @Override
1743    @GwtIncompatible // used only from other GwtIncompatible code
1744    void setBits(BitSet table) {
1745      for (char c : chars) {
1746        table.set(c);
1747      }
1748    }
1749
1750    @Override
1751    public String toString() {
1752      StringBuilder description = new StringBuilder("CharMatcher.anyOf(\"");
1753      for (char c : chars) {
1754        description.append(showCharacter(c));
1755      }
1756      description.append("\")");
1757      return description.toString();
1758    }
1759  }
1760
1761  /** Implementation of {@link #inRange(char, char)}. */
1762  private static final class InRange extends FastMatcher {
1763
1764    private final char startInclusive;
1765    private final char endInclusive;
1766
1767    InRange(char startInclusive, char endInclusive) {
1768      checkArgument(endInclusive >= startInclusive);
1769      this.startInclusive = startInclusive;
1770      this.endInclusive = endInclusive;
1771    }
1772
1773    @Override
1774    public boolean matches(char c) {
1775      return startInclusive <= c && c <= endInclusive;
1776    }
1777
1778    @GwtIncompatible // used only from other GwtIncompatible code
1779    @Override
1780    void setBits(BitSet table) {
1781      table.set(startInclusive, endInclusive + 1);
1782    }
1783
1784    @Override
1785    public String toString() {
1786      return "CharMatcher.inRange('"
1787          + showCharacter(startInclusive)
1788          + "', '"
1789          + showCharacter(endInclusive)
1790          + "')";
1791    }
1792  }
1793
1794  /** Implementation of {@link #forPredicate(Predicate)}. */
1795  private static final class ForPredicate extends CharMatcher {
1796
1797    private final Predicate<? super Character> predicate;
1798
1799    ForPredicate(Predicate<? super Character> predicate) {
1800      this.predicate = checkNotNull(predicate);
1801    }
1802
1803    @Override
1804    public boolean matches(char c) {
1805      return predicate.apply(c);
1806    }
1807
1808    @SuppressWarnings("deprecation") // intentional; deprecation is for callers primarily
1809    @Override
1810    public boolean apply(Character character) {
1811      return predicate.apply(checkNotNull(character));
1812    }
1813
1814    @Override
1815    public String toString() {
1816      return "CharMatcher.forPredicate(" + predicate + ")";
1817    }
1818  }
1819}