guava-14.0

16:36:13.686 INFO  jd.cli.Main - Decompiling guava-14.0.jar
package com.google.common.annotations;

import java.lang.annotation.Annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.CLASS)
@Target({java.lang.annotation.ElementType.ANNOTATION_TYPE, java.lang.annotation.ElementType.CONSTRUCTOR, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.TYPE})
@Documented
@GwtCompatible
public @interface Beta {}

/* Location:
 * Qualified Name:     com.google.common.annotations.Beta
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.annotations;

import java.lang.annotation.Annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.CLASS)
@Target({java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.METHOD})
@Documented
@GwtCompatible
public @interface GwtCompatible
{
  boolean serializable() default false;
  
  boolean emulated() default false;
}

/* Location:
 * Qualified Name:     com.google.common.annotations.GwtCompatible
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.annotations;

import java.lang.annotation.Annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.CLASS)
@Target({java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.CONSTRUCTOR, java.lang.annotation.ElementType.FIELD})
@Documented
@GwtCompatible
public @interface GwtIncompatible
{
  String value();
}

/* Location:
 * Qualified Name:     com.google.common.annotations.GwtIncompatible
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.annotations;

import java.lang.annotation.Annotation;

@GwtCompatible
public @interface VisibleForTesting {}

/* Location:
 * Qualified Name:     com.google.common.annotations.VisibleForTesting
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import com.google.common.annotations.GwtCompatible;
import java.util.Collections;
import java.util.Set;
import javax.annotation.Nullable;

@GwtCompatible
final class Absent
  extends Optional<Object>
{
  static final Absent INSTANCE = new Absent();
  private static final long serialVersionUID = 0L;
  
  public boolean isPresent()
  {
    return false;
  }
  
  public Object get()
  {
    throw new IllegalStateException("Optional.get() cannot be called on an absent value");
  }
  
  public Object or(Object defaultValue)
  {
    return Preconditions.checkNotNull(defaultValue, "use Optional.orNull() instead of Optional.or(null)");
  }
  
  public Optional<Object> or(Optional<?> secondChoice)
  {
    return (Optional)Preconditions.checkNotNull(secondChoice);
  }
  
  public Object or(Supplier<?> supplier)
  {
    return Preconditions.checkNotNull(supplier.get(), "use Optional.orNull() instead of a Supplier that returns null");
  }
  
  @Nullable
  public Object orNull()
  {
    return null;
  }
  
  public Set<Object> asSet()
  {
    return Collections.emptySet();
  }
  
  public <V> Optional<V> transform(Function<Object, V> function)
  {
    Preconditions.checkNotNull(function);
    return Optional.absent();
  }
  
  public boolean equals(@Nullable Object object)
  {
    return object == this;
  }
  
  public int hashCode()
  {
    return 1502476572;
  }
  
  public String toString()
  {
    return "Optional.absent()";
  }
  
  private Object readResolve()
  {
    return INSTANCE;
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.Absent
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

class AbstractIterator$1 {}

/* Location:
 * Qualified Name:     com.google.common.base.AbstractIterator.1
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

 enum AbstractIterator$State
{
  READY,  NOT_READY,  DONE,  FAILED;
  
  private AbstractIterator$State() {}
}

/* Location:
 * Qualified Name:     com.google.common.base.AbstractIterator.State
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import com.google.common.annotations.GwtCompatible;
import java.util.Iterator;
import java.util.NoSuchElementException;

@GwtCompatible
abstract class AbstractIterator<T>
  implements Iterator<T>
{
  private State state = State.NOT_READY;
  private T next;
  protected abstract T computeNext();
  
  private static enum State
  {
    READY,  NOT_READY,  DONE,  FAILED;
    
    private State() {}
  }
  
  protected final T endOfData()
  {
    state = State.DONE;
    return null;
  }
  
  public final boolean hasNext()
  {
    Preconditions.checkState(state != State.FAILED);
    switch (state)
    {
    case DONE: 
      return false;
    case READY: 
      return true;
    }
    return tryToComputeNext();
  }
  
  private boolean tryToComputeNext()
  {
    state = State.FAILED;
    next = computeNext();
    if (state != State.DONE)
    {
      state = State.READY;
      return true;
    }
    return false;
  }
  
  public final T next()
  {
    if (!hasNext()) {
      throw new NoSuchElementException();
    }
    state = State.NOT_READY;
    return (T)next;
  }
  
  public final void remove()
  {
    throw new UnsupportedOperationException();
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.AbstractIterator
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import com.google.common.annotations.GwtCompatible;

@GwtCompatible
public final class Ascii
{
  public static final byte NUL = 0;
  public static final byte SOH = 1;
  public static final byte STX = 2;
  public static final byte ETX = 3;
  public static final byte EOT = 4;
  public static final byte ENQ = 5;
  public static final byte ACK = 6;
  public static final byte BEL = 7;
  public static final byte BS = 8;
  public static final byte HT = 9;
  public static final byte LF = 10;
  public static final byte NL = 10;
  public static final byte VT = 11;
  public static final byte FF = 12;
  public static final byte CR = 13;
  public static final byte SO = 14;
  public static final byte SI = 15;
  public static final byte DLE = 16;
  public static final byte DC1 = 17;
  public static final byte XON = 17;
  public static final byte DC2 = 18;
  public static final byte DC3 = 19;
  public static final byte XOFF = 19;
  public static final byte DC4 = 20;
  public static final byte NAK = 21;
  public static final byte SYN = 22;
  public static final byte ETB = 23;
  public static final byte CAN = 24;
  public static final byte EM = 25;
  public static final byte SUB = 26;
  public static final byte ESC = 27;
  public static final byte FS = 28;
  public static final byte GS = 29;
  public static final byte RS = 30;
  public static final byte US = 31;
  public static final byte SP = 32;
  public static final byte SPACE = 32;
  public static final byte DEL = 127;
  public static final char MIN = '\000';
  public static final char MAX = '';
  
  public static String toLowerCase(String string)
  {
    return toLowerCase(string);
  }
  
  public static String toLowerCase(CharSequence chars)
  {
    int length = chars.length();
    StringBuilder builder = new StringBuilder(length);
    for (int i = 0; i < length; i++) {
      builder.append(toLowerCase(chars.charAt(i)));
    }
    return builder.toString();
  }
  
  public static char toLowerCase(char c)
  {
    return isUpperCase(c) ? (char)(c ^ 0x20) : c;
  }
  
  public static String toUpperCase(String string)
  {
    return toUpperCase(string);
  }
  
  public static String toUpperCase(CharSequence chars)
  {
    int length = chars.length();
    StringBuilder builder = new StringBuilder(length);
    for (int i = 0; i < length; i++) {
      builder.append(toUpperCase(chars.charAt(i)));
    }
    return builder.toString();
  }
  
  public static char toUpperCase(char c)
  {
    return isLowerCase(c) ? (char)(c & 0x5F) : c;
  }
  
  public static boolean isLowerCase(char c)
  {
    return (c >= 'a') && (c <= 'z');
  }
  
  public static boolean isUpperCase(char c)
  {
    return (c >= 'A') && (c <= 'Z');
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.Ascii
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

 enum CaseFormat$1
{
  CaseFormat$1(CharMatcher x0, String x1)
  {
    super(paramString, paramInt, x0, x1, null);
  }
  
  String normalizeWord(String word)
  {
    return Ascii.toLowerCase(word);
  }
  
  String convert(CaseFormat format, String s)
  {
    if (format == LOWER_UNDERSCORE) {
      return s.replace('-', '_');
    }
    if (format == UPPER_UNDERSCORE) {
      return Ascii.toUpperCase(s.replace('-', '_'));
    }
    return super.convert(format, s);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CaseFormat.1
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

 enum CaseFormat$2
{
  CaseFormat$2(CharMatcher x0, String x1)
  {
    super(paramString, paramInt, x0, x1, null);
  }
  
  String normalizeWord(String word)
  {
    return Ascii.toLowerCase(word);
  }
  
  String convert(CaseFormat format, String s)
  {
    if (format == LOWER_HYPHEN) {
      return s.replace('_', '-');
    }
    if (format == UPPER_UNDERSCORE) {
      return Ascii.toUpperCase(s);
    }
    return super.convert(format, s);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CaseFormat.2
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

 enum CaseFormat$3
{
  CaseFormat$3(CharMatcher x0, String x1)
  {
    super(paramString, paramInt, x0, x1, null);
  }
  
  String normalizeWord(String word)
  {
    return CaseFormat.access$100(word);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CaseFormat.3
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

 enum CaseFormat$4
{
  CaseFormat$4(CharMatcher x0, String x1)
  {
    super(paramString, paramInt, x0, x1, null);
  }
  
  String normalizeWord(String word)
  {
    return CaseFormat.access$100(word);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CaseFormat.4
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

 enum CaseFormat$5
{
  CaseFormat$5(CharMatcher x0, String x1)
  {
    super(paramString, paramInt, x0, x1, null);
  }
  
  String normalizeWord(String word)
  {
    return Ascii.toUpperCase(word);
  }
  
  String convert(CaseFormat format, String s)
  {
    if (format == LOWER_HYPHEN) {
      return Ascii.toLowerCase(s.replace('_', '-'));
    }
    if (format == LOWER_UNDERSCORE) {
      return Ascii.toLowerCase(s);
    }
    return super.convert(format, s);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CaseFormat.5
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import com.google.common.annotations.GwtCompatible;

@GwtCompatible
public enum CaseFormat
{
  LOWER_HYPHEN(CharMatcher.is('-'), "-"),  LOWER_UNDERSCORE(CharMatcher.is('_'), "_"),  LOWER_CAMEL(CharMatcher.inRange('A', 'Z'), ""),  UPPER_CAMEL(CharMatcher.inRange('A', 'Z'), ""),  UPPER_UNDERSCORE(CharMatcher.is('_'), "_");
  
  private final CharMatcher wordBoundary;
  private final String wordSeparator;
  
  private CaseFormat(CharMatcher wordBoundary, String wordSeparator)
  {
    this.wordBoundary = wordBoundary;
    this.wordSeparator = wordSeparator;
  }
  
  public final String to(CaseFormat format, String str)
  {
    Preconditions.checkNotNull(format);
    Preconditions.checkNotNull(str);
    return format == this ? str : convert(format, str);
  }
  
  String convert(CaseFormat format, String s)
  {
    StringBuilder out = null;
    int i = 0;
    int j = -1;
    while ((j = wordBoundary.indexIn(s, ++j)) != -1)
    {
      if (i == 0)
      {
        out = new StringBuilder(s.length() + 4 * wordSeparator.length());
        out.append(format.normalizeFirstWord(s.substring(i, j)));
      }
      else
      {
        out.append(format.normalizeWord(s.substring(i, j)));
      }
      out.append(wordSeparator);
      i = j + wordSeparator.length();
    }
    return format.normalizeWord(s.substring(i));
  }
  
  abstract String normalizeWord(String paramString);
  
  private String normalizeFirstWord(String word)
  {
    return this == LOWER_CAMEL ? Ascii.toLowerCase(word) : normalizeWord(word);
  }
  
  private static String firstCharOnlyToUpper(String word)
  {
    return word.length() + Ascii.toUpperCase(word.charAt(0)) + Ascii.toLowerCase(word.substring(1));
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CaseFormat
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

final class CharMatcher$1
  extends CharMatcher
{
  public boolean matches(char c)
  {
    switch (c)
    {
    case '\t': 
    case '\n': 
    case '\013': 
    case '\f': 
    case '\r': 
    case ' ': 
    case '?': 
    case '?': 
    case '?': 
    case '?': 
    case '?': 
    case '?': 
      return true;
    case '?': 
      return false;
    }
    return (c >= '?') && (c <= '?');
  }
  
  public String toString()
  {
    return "CharMatcher.BREAKING_WHITESPACE";
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.1
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import com.google.common.annotations.GwtIncompatible;
import java.util.BitSet;

final class CharMatcher$10
  extends CharMatcher.FastMatcher
{
  CharMatcher$10(String x0, char paramChar)
  {
    super(x0);
  }
  
  public boolean matches(char c)
  {
    return c != val$match;
  }
  
  public CharMatcher and(CharMatcher other)
  {
    return other.matches(val$match) ? super.and(other) : other;
  }
  
  public CharMatcher or(CharMatcher other)
  {
    return other.matches(val$match) ? ANY : this;
  }
  
  @GwtIncompatible("java.util.BitSet")
  void setBits(BitSet table)
  {
    table.set(0, val$match);
    table.set(val$match + '\001', 65536);
  }
  
  public CharMatcher negate()
  {
    return is(val$match);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.10
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import com.google.common.annotations.GwtIncompatible;
import java.util.Arrays;
import java.util.BitSet;

final class CharMatcher$11
  extends CharMatcher
{
  CharMatcher$11(String x0, char[] paramArrayOfChar)
  {
    super(x0);
  }
  
  public boolean matches(char c)
  {
    return Arrays.binarySearch(val$chars, c) >= 0;
  }
  
  @GwtIncompatible("java.util.BitSet")
  void setBits(BitSet table)
  {
    for (char c : val$chars) {
      table.set(c);
    }
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.11
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import com.google.common.annotations.GwtIncompatible;
import java.util.BitSet;

final class CharMatcher$12
  extends CharMatcher.FastMatcher
{
  CharMatcher$12(String x0, char paramChar1, char paramChar2)
  {
    super(x0);
  }
  
  public boolean matches(char c)
  {
    return (c == val$match1) || (c == val$match2);
  }
  
  @GwtIncompatible("java.util.BitSet")
  void setBits(BitSet table)
  {
    table.set(val$match1);
    table.set(val$match2);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.12
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import com.google.common.annotations.GwtIncompatible;
import java.util.BitSet;

final class CharMatcher$13
  extends CharMatcher.FastMatcher
{
  CharMatcher$13(String x0, char paramChar1, char paramChar2)
  {
    super(x0);
  }
  
  public boolean matches(char c)
  {
    return (val$startInclusive <= c) && (c <= val$endInclusive);
  }
  
  @GwtIncompatible("java.util.BitSet")
  void setBits(BitSet table)
  {
    table.set(val$startInclusive, val$endInclusive + '\001');
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.13
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

final class CharMatcher$14
  extends CharMatcher
{
  CharMatcher$14(String x0, Predicate paramPredicate)
  {
    super(x0);
  }
  
  public boolean matches(char c)
  {
    return val$predicate.apply(Character.valueOf(c));
  }
  
  public boolean apply(Character character)
  {
    return val$predicate.apply(Preconditions.checkNotNull(character));
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.14
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

final class CharMatcher$15
  extends CharMatcher.FastMatcher
{
  CharMatcher$15(String x0)
  {
    super(x0);
  }
  
  public boolean matches(char c)
  {
    return "\001\000�\000\000\000\000\000\000\t\n\013\f\r\000\000??\000\000\000\000\000?\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000?\000\000\000\000\000\000\000\000\000\000????????????\000\000\000\000\000??\000\000?\000\000\000".charAt(c % 'O') == c;
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.15
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

final class CharMatcher$2
  extends CharMatcher
{
  CharMatcher$2(String x0)
  {
    super(x0);
  }
  
  public boolean matches(char c)
  {
    return Character.isDigit(c);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.2
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

final class CharMatcher$3
  extends CharMatcher
{
  CharMatcher$3(String x0)
  {
    super(x0);
  }
  
  public boolean matches(char c)
  {
    return Character.isLetter(c);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.3
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

final class CharMatcher$4
  extends CharMatcher
{
  CharMatcher$4(String x0)
  {
    super(x0);
  }
  
  public boolean matches(char c)
  {
    return Character.isLetterOrDigit(c);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.4
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

final class CharMatcher$5
  extends CharMatcher
{
  CharMatcher$5(String x0)
  {
    super(x0);
  }
  
  public boolean matches(char c)
  {
    return Character.isUpperCase(c);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.5
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

final class CharMatcher$6
  extends CharMatcher
{
  CharMatcher$6(String x0)
  {
    super(x0);
  }
  
  public boolean matches(char c)
  {
    return Character.isLowerCase(c);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.6
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import java.util.Arrays;

final class CharMatcher$7
  extends CharMatcher.FastMatcher
{
  CharMatcher$7(String x0)
  {
    super(x0);
  }
  
  public boolean matches(char c)
  {
    return true;
  }
  
  public int indexIn(CharSequence sequence)
  {
    return sequence.length() == 0 ? -1 : 0;
  }
  
  public int indexIn(CharSequence sequence, int start)
  {
    int length = sequence.length();
    Preconditions.checkPositionIndex(start, length);
    return start == length ? -1 : start;
  }
  
  public int lastIndexIn(CharSequence sequence)
  {
    return sequence.length() - 1;
  }
  
  public boolean matchesAllOf(CharSequence sequence)
  {
    Preconditions.checkNotNull(sequence);
    return true;
  }
  
  public boolean matchesNoneOf(CharSequence sequence)
  {
    return sequence.length() == 0;
  }
  
  public String removeFrom(CharSequence sequence)
  {
    Preconditions.checkNotNull(sequence);
    return "";
  }
  
  public String replaceFrom(CharSequence sequence, char replacement)
  {
    char[] array = new char[sequence.length()];
    Arrays.fill(array, replacement);
    return new String(array);
  }
  
  public String replaceFrom(CharSequence sequence, CharSequence replacement)
  {
    StringBuilder retval = new StringBuilder(sequence.length() * replacement.length());
    for (int i = 0; i < sequence.length(); i++) {
      retval.append(replacement);
    }
    return retval.toString();
  }
  
  public String collapseFrom(CharSequence sequence, char replacement)
  {
    return sequence.length() == 0 ? "" : String.valueOf(replacement);
  }
  
  public String trimFrom(CharSequence sequence)
  {
    Preconditions.checkNotNull(sequence);
    return "";
  }
  
  public int countIn(CharSequence sequence)
  {
    return sequence.length();
  }
  
  public CharMatcher and(CharMatcher other)
  {
    return (CharMatcher)Preconditions.checkNotNull(other);
  }
  
  public CharMatcher or(CharMatcher other)
  {
    Preconditions.checkNotNull(other);
    return this;
  }
  
  public CharMatcher negate()
  {
    return NONE;
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.7
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

final class CharMatcher$8
  extends CharMatcher.FastMatcher
{
  CharMatcher$8(String x0)
  {
    super(x0);
  }
  
  public boolean matches(char c)
  {
    return false;
  }
  
  public int indexIn(CharSequence sequence)
  {
    Preconditions.checkNotNull(sequence);
    return -1;
  }
  
  public int indexIn(CharSequence sequence, int start)
  {
    int length = sequence.length();
    Preconditions.checkPositionIndex(start, length);
    return -1;
  }
  
  public int lastIndexIn(CharSequence sequence)
  {
    Preconditions.checkNotNull(sequence);
    return -1;
  }
  
  public boolean matchesAllOf(CharSequence sequence)
  {
    return sequence.length() == 0;
  }
  
  public boolean matchesNoneOf(CharSequence sequence)
  {
    Preconditions.checkNotNull(sequence);
    return true;
  }
  
  public String removeFrom(CharSequence sequence)
  {
    return sequence.toString();
  }
  
  public String replaceFrom(CharSequence sequence, char replacement)
  {
    return sequence.toString();
  }
  
  public String replaceFrom(CharSequence sequence, CharSequence replacement)
  {
    Preconditions.checkNotNull(replacement);
    return sequence.toString();
  }
  
  public String collapseFrom(CharSequence sequence, char replacement)
  {
    return sequence.toString();
  }
  
  public String trimFrom(CharSequence sequence)
  {
    return sequence.toString();
  }
  
  public String trimLeadingFrom(CharSequence sequence)
  {
    return sequence.toString();
  }
  
  public String trimTrailingFrom(CharSequence sequence)
  {
    return sequence.toString();
  }
  
  public int countIn(CharSequence sequence)
  {
    Preconditions.checkNotNull(sequence);
    return 0;
  }
  
  public CharMatcher and(CharMatcher other)
  {
    Preconditions.checkNotNull(other);
    return this;
  }
  
  public CharMatcher or(CharMatcher other)
  {
    return (CharMatcher)Preconditions.checkNotNull(other);
  }
  
  public CharMatcher negate()
  {
    return ANY;
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.8
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import com.google.common.annotations.GwtIncompatible;
import java.util.BitSet;

final class CharMatcher$9
  extends CharMatcher.FastMatcher
{
  CharMatcher$9(String x0, char paramChar)
  {
    super(x0);
  }
  
  public boolean matches(char c)
  {
    return c == val$match;
  }
  
  public String replaceFrom(CharSequence sequence, char replacement)
  {
    return sequence.toString().replace(val$match, replacement);
  }
  
  public CharMatcher and(CharMatcher other)
  {
    return other.matches(val$match) ? this : NONE;
  }
  
  public CharMatcher or(CharMatcher other)
  {
    return other.matches(val$match) ? other : super.or(other);
  }
  
  public CharMatcher negate()
  {
    return isNot(val$match);
  }
  
  @GwtIncompatible("java.util.BitSet")
  void setBits(BitSet table)
  {
    table.set(val$match);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.9
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import com.google.common.annotations.GwtIncompatible;
import java.util.BitSet;

class CharMatcher$And
  extends CharMatcher
{
  final CharMatcher first;
  final CharMatcher second;
  
  CharMatcher$And(CharMatcher a, CharMatcher b)
  {
    this(a, b, "CharMatcher.and(" + a + ", " + b + ")");
  }
  
  CharMatcher$And(CharMatcher a, CharMatcher b, String description)
  {
    super(description);
    first = ((CharMatcher)Preconditions.checkNotNull(a));
    second = ((CharMatcher)Preconditions.checkNotNull(b));
  }
  
  public boolean matches(char c)
  {
    return (first.matches(c)) && (second.matches(c));
  }
  
  @GwtIncompatible("java.util.BitSet")
  void setBits(BitSet table)
  {
    BitSet tmp1 = new BitSet();
    first.setBits(tmp1);
    BitSet tmp2 = new BitSet();
    second.setBits(tmp2);
    tmp1.and(tmp2);
    table.or(tmp1);
  }
  
  CharMatcher withToString(String description)
  {
    return new And(first, second, description);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.And
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import com.google.common.annotations.GwtIncompatible;
import java.util.BitSet;

@GwtIncompatible("java.util.BitSet")
class CharMatcher$BitSetMatcher
  extends CharMatcher.FastMatcher
{
  private final BitSet table;
  
  private CharMatcher$BitSetMatcher(BitSet table, String description)
  {
    super(description);
    if (table.length() + 64 < table.size()) {
      table = (BitSet)table.clone();
    }
    this.table = table;
  }
  
  public boolean matches(char c)
  {
    return table.get(c);
  }
  
  void setBits(BitSet bitSet)
  {
    bitSet.or(table);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.BitSetMatcher
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

abstract class CharMatcher$FastMatcher
  extends CharMatcher
{
  CharMatcher$FastMatcher() {}
  
  CharMatcher$FastMatcher(String description)
  {
    super(description);
  }
  
  public final CharMatcher precomputed()
  {
    return this;
  }
  
  public CharMatcher negate()
  {
    return new CharMatcher.NegatedFastMatcher(this);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.FastMatcher
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

final class CharMatcher$NegatedFastMatcher
  extends CharMatcher.NegatedMatcher
{
  CharMatcher$NegatedFastMatcher(CharMatcher original)
  {
    super(original);
  }
  
  CharMatcher$NegatedFastMatcher(String toString, CharMatcher original)
  {
    super(toString, original);
  }
  
  public final CharMatcher precomputed()
  {
    return this;
  }
  
  CharMatcher withToString(String description)
  {
    return new NegatedFastMatcher(description, original);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.NegatedFastMatcher
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import com.google.common.annotations.GwtIncompatible;
import java.util.BitSet;

class CharMatcher$NegatedMatcher
  extends CharMatcher
{
  final CharMatcher original;
  
  CharMatcher$NegatedMatcher(String toString, CharMatcher original)
  {
    super(toString);
    this.original = original;
  }
  
  CharMatcher$NegatedMatcher(CharMatcher original)
  {
    this(original + ".negate()", original);
  }
  
  public boolean matches(char c)
  {
    return !original.matches(c);
  }
  
  public boolean matchesAllOf(CharSequence sequence)
  {
    return original.matchesNoneOf(sequence);
  }
  
  public boolean matchesNoneOf(CharSequence sequence)
  {
    return original.matchesAllOf(sequence);
  }
  
  public int countIn(CharSequence sequence)
  {
    return sequence.length() - original.countIn(sequence);
  }
  
  @GwtIncompatible("java.util.BitSet")
  void setBits(BitSet table)
  {
    BitSet tmp = new BitSet();
    original.setBits(tmp);
    tmp.flip(0, 65536);
    table.or(tmp);
  }
  
  public CharMatcher negate()
  {
    return original;
  }
  
  CharMatcher withToString(String description)
  {
    return new NegatedMatcher(description, original);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.NegatedMatcher
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import com.google.common.annotations.GwtIncompatible;
import java.util.BitSet;

class CharMatcher$Or
  extends CharMatcher
{
  final CharMatcher first;
  final CharMatcher second;
  
  CharMatcher$Or(CharMatcher a, CharMatcher b, String description)
  {
    super(description);
    first = ((CharMatcher)Preconditions.checkNotNull(a));
    second = ((CharMatcher)Preconditions.checkNotNull(b));
  }
  
  CharMatcher$Or(CharMatcher a, CharMatcher b)
  {
    this(a, b, "CharMatcher.or(" + a + ", " + b + ")");
  }
  
  @GwtIncompatible("java.util.BitSet")
  void setBits(BitSet table)
  {
    first.setBits(table);
    second.setBits(table);
  }
  
  public boolean matches(char c)
  {
    return (first.matches(c)) || (second.matches(c));
  }
  
  CharMatcher withToString(String description)
  {
    return new Or(first, second, description);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.Or
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import java.util.Arrays;

class CharMatcher$RangesMatcher
  extends CharMatcher
{
  private final char[] rangeStarts;
  private final char[] rangeEnds;
  
  CharMatcher$RangesMatcher(String description, char[] rangeStarts, char[] rangeEnds)
  {
    super(description);
    this.rangeStarts = rangeStarts;
    this.rangeEnds = rangeEnds;
    Preconditions.checkArgument(rangeStarts.length == rangeEnds.length);
    for (int i = 0; i < rangeStarts.length; i++)
    {
      Preconditions.checkArgument(rangeStarts[i] <= rangeEnds[i]);
      if (i + 1 < rangeStarts.length) {
        Preconditions.checkArgument(rangeEnds[i] < rangeStarts[(i + 1)]);
      }
    }
  }
  
  public boolean matches(char c)
  {
    int index = Arrays.binarySearch(rangeStarts, c);
    if (index >= 0) {
      return true;
    }
    index = (index ^ 0xFFFFFFFF) - 1;
    return (index >= 0) && (c <= rangeEnds[index]);
  }
}

/* Location:
 * Qualified Name:     com.google.common.base.CharMatcher.RangesMatcher
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.google.common.base;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import java.util.Arrays;
import java.util.BitSet;
import javax.annotation.CheckReturnValue;

@Beta
@GwtCompatible(emulated=true)
public abstract class CharMatcher
  implements Predicate<Character>
{
  public static final CharMatcher BREAKING_WHITESPACE = new CharMatcher()
  {
    public boolean matches(char c)
    {
      switch (c)
      {
      case '\t': 
      case '\n': 
      case '\013': 
      case '\f': 
      case '\r': 
      case ' ': 
      case '?': 
      case '?': 
      case '?': 
      case '?': 
      case '?': 
      case '?': 
        return true;
      case '?': 
        return false;
      }
      return (c >= '?') && (c <= '?');
    }
    
    public String toString()
    {
      return "CharMatcher.BREAKING_WHITESPACE";
    }
  };
  public static final CharMatcher ASCII = inRange('\000', '', "CharMatcher.ASCII");
  private static final String ZEROES = "0??????????????????????????????";
  private static final String NINES;
  
  private static class RangesMatcher
    extends CharMatcher
  {
    private final char[] rangeStarts;
    private final char[] rangeEnds;
    
    RangesMatcher(String description, char[] rangeStarts, char[] rangeEnds)
    {
      super();
      this.rangeStarts = rangeStarts;
      this.rangeEnds = rangeEnds;
      Preconditions.checkArgument(rangeStarts.length == rangeEnds.length);
      for (int i = 0; i < rangeStarts.length; i++)
      {
        Preconditions.checkArgument(rangeStarts[i] <= rangeEnds[i]);
        if (i + 1 < rangeStarts.length) {
          Preconditions.checkArgument(rangeEnds[i] < rangeStarts[(i + 1)]);
        }
      }
    }
    
    public boolean matches(char c)
    {
      int index = Arrays.binarySearch(rangeStarts, c);
      if (index >= 0) {
        return true;
      }
      index = (index ^ 0xFFFFFFFF) - 1;
      return (index >= 0) && (c <= rangeEnds[index]);
    }
  }
  
  static
  {
    StringBuilder builder = new StringBuilder("0??????????????????????????????".length());
    for (int i = 0; i < "0??????????????????????????????".length(); i++) {
      builder.append((char)("0??????????????????????????????".charAt(i) + '\t'));
    }
    NINES = builder.toString();
  }
  
  public static final CharMatcher DIGIT = new RangesMatcher("CharMatcher.DIGIT", "0??????????????????????????????".toCharArray(), NINES.toCharArray());
  public static final CharMatcher JAVA_DIGIT = new CharMatcher("CharMatcher.JAVA_DIGIT")
  {
    public boolean matches(char c)
    {
      return Character.isDigit(c);
    }
  };
  public static final CharMatcher JAVA_LETTER = new CharMatcher("CharMatcher.JAVA_LETTER")
  {
    public boolean matches(char c)
    {
      return Character.isLetter(c);
    }
  };
  public static final CharMatcher JAVA_LETTER_OR_DIGIT = new CharMatcher("CharMatcher.JAVA_LETTER_OR_DIGIT")
  {
    public boolean matches(char c)
    {
      return Character.isLetterOrDigit(c);
    }
  };
  public static final CharMatcher JAVA_UPPER_CASE = new CharMatcher("CharMatcher.JAVA_UPPER_CASE")
  {
    public boolean matches(char c)
    {
      return Character.isUpperCase(c);
    }
  };
  public static final CharMatcher JAVA_LOWER_CASE = new CharMatcher("CharMatcher.JAVA_LOWER_CASE")
  {
    public boolean matches(char c)
    {
      return Character.isLowerCase(c);
    }
  };
  public static final CharMatcher JAVA_ISO_CONTROL = inRange('\000', '\037').or(inRange('', '?')).withToString("CharMatcher.JAVA_ISO_CONTROL");
  public static final CharMatcher INVISIBLE = new RangesMatcher("CharMatcher.INVISIBLE", "\000�??????????????".toCharArray(), " ��??????????????".toCharArray());
  
  private static String showCharacter(char c)
  {
    String hex = "0123456789ABCDEF";
    char[] tmp = { '\\', 'u', '\000', '\000', '\000', '\000' };
    for (int i = 0; i < 4; i++)
    {
      tmp[(5 - i)] = hex.charAt(c & 0xF);
      c = (char)(c >> '\004');
    }
    return String.copyValueOf(tmp);
  }
  
  public static final CharMatcher SINGLE_WIDTH = new RangesMatcher("CharMatcher.SINGLE_WIDTH", "\000???????????".toCharArray(), "????????????".toCharArray());
  public static final CharMatcher ANY = new FastMatcher("CharMatcher.ANY")
  {
    public boolean matches(char c)
    {
      return true;
    }
    
    public int indexIn(CharSequence sequence)
    {
      return sequence.length() == 0 ? -1 : 0;
    }
    
    public int indexIn(CharSequence sequence, int start)
    {
      int length = sequence.length();
      Preconditions.checkPositionIndex(start, length);
      return start == length ? -1 : start;
    }
    
    public int lastIndexIn(CharSequence sequence)
    {
      return sequence.length() - 1;
    }
    
    public boolean matchesAllOf(CharSequence sequence)
    {
      Preconditions.checkNotNull(sequence);
      return true;
    }
    
    public boolean matchesNoneOf(CharSequence sequence)
    {
      return sequence.length() == 0;
    }
    
    public String removeFrom(CharSequence sequence)
    {
      Preconditions.checkNotNull(sequence);
      return "";
    }
    
    public String replaceFrom(CharSequence sequence, char replacement)
    {
      char[] array = new char[sequence.length()];
      Arrays.fill(array, replacement);
      return new String(array);
    }
    
    public String replaceFrom(CharSequence sequence, CharSequence replacement)
    {
      StringBuilder retval = new StringBuilder(sequence.length() * replacement.length());
      for (int i = 0; i < sequence.length(); i++) {
        retval.append(replacement);
      }
      return retval.toString();
    }
    
    public String collapseFrom(CharSequence sequence, char replacement)
    {
      return sequence.length() == 0 ? "" : String.valueOf(replacement);
    }
    
    public String trimFrom(CharSequence sequence)
    {
      Preconditions.checkNotNull(sequence);
      return "";
    }
    
    public int countIn(CharSequence sequence)
    {
      return sequence.length();
    }
    
    public CharMatcher and(CharMatcher other)
    {
      return (CharMatcher)Preconditions.checkNotNull(other);
    }
    
    public CharMatcher or(CharMatcher other)
    {
      Preconditions.checkNotNull(other);
      return this;
    }
    
    public CharMatcher negate()
    {
      return NONE;
    }
  };
  public static final CharMatcher NONE = new FastMatcher("CharMatcher.NONE")
  {
    public boolean matches(char c)
    {
      return false;
    }
    
    public int indexIn(CharSequence sequence)
    {
      Preconditions.checkNotNull(sequence);
      return -1;
    }
    
    public int indexIn(CharSequence sequence, int start)
    {
      int length = sequence.length();
      Preconditions.checkPositionIndex(start, length);
      return -1;
    }
    
    public int lastIndexIn(CharSequence sequence)
    {
      Preconditions.checkNotNull(sequence);
      return -1;
    }
    
    public boolean matchesAllOf(CharSequence sequence)
    {
      return sequence.length() == 0;
    }
    
    public boolean matchesNoneOf(CharSequence sequence)
    {
      Preconditions.checkNotNull(sequence);
      return true;
    }
    
    public String removeFrom(CharSequence sequence)
    {
      return sequence.toString();
    }
    
    public String replaceFrom(CharSequence sequence, char replacement)
    {
      return sequence.toString();
    }
    
    public String replaceFrom(CharSequence sequence, CharSequence replacement)
    {
      Preconditions.checkNotNull(replacement);
      return sequence.toString();
    }
    
    public String collapseFrom(CharSequence sequence, char replacement)
    {
      return sequence.toString();
    }
    
    public String trimFrom(CharSequence sequence)
    {
      return sequence.toString();
    }
    
    public String trimLeadingFrom(CharSequence sequence)
    {
      return sequence.toString();
    }
    
    public String trimTrailingFrom(CharSequence sequence)
    {
      return sequence.toString();
    }
    
    public int countIn(CharSequence sequence)
    {
      Preconditions.checkNotNull(sequence);
      return 0;
    }
    
    public CharMatcher and(CharMatcher other)
    {
      Preconditions.checkNotNull(other);
      return this;
    }
    
    public CharMatcher or(CharMatcher other)
    {
      return (CharMatc
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2017. Infinite Loop Ltd