Map<K, V> map()
    {
      return WellBehavedMap.this;
    }
    
    public Iterator<Map.Entry<K, V>> iterator()
    {
      new TransformedIterator(keySet().iterator())
      {
        Map.Entry<K, V> transform(final K key)
        {
          new AbstractMapEntry()
          {
            public K getKey()
            {
              return (K)key;
            }
            
            public V getValue()
            {
              return (V)get(key);
            }
            
            public V setValue(V value)
            {
              return (V)put(key, value);
            }
          };
        }
      };
    }
  }
}

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

import javax.annotation.ParametersAreNonnullByDefault;

@ParametersAreNonnullByDefault
abstract interface package-info {}

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

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import java.util.Map;

@Beta
@GwtCompatible
public abstract class ArrayBasedCharEscaper
  extends CharEscaper
{
  private final char[][] replacements;
  private final int replacementsLength;
  private final char safeMin;
  private final char safeMax;
  
  protected ArrayBasedCharEscaper(Map<Character, String> replacementMap, char safeMin, char safeMax)
  {
    this(ArrayBasedEscaperMap.create(replacementMap), safeMin, safeMax);
  }
  
  protected ArrayBasedCharEscaper(ArrayBasedEscaperMap escaperMap, char safeMin, char safeMax)
  {
    Preconditions.checkNotNull(escaperMap);
    replacements = escaperMap.getReplacementArray();
    replacementsLength = replacements.length;
    if (safeMax < safeMin)
    {
      safeMax = '\000';
      safeMin = 65535;
    }
    this.safeMin = safeMin;
    this.safeMax = safeMax;
  }
  
  public final String escape(String s)
  {
    Preconditions.checkNotNull(s);
    for (int i = 0; i < s.length(); i++)
    {
      char c = s.charAt(i);
      if (((c < replacementsLength) && (replacements[c] != null)) || (c > safeMax) || (c < safeMin)) {
        return escapeSlow(s, i);
      }
    }
    return s;
  }
  
  protected final char[] escape(char c)
  {
    if (c < replacementsLength)
    {
      char[] chars = replacements[c];
      if (chars != null) {
        return chars;
      }
    }
    if ((c >= safeMin) && (c <= safeMax)) {
      return null;
    }
    return escapeUnsafe(c);
  }
  
  protected abstract char[] escapeUnsafe(char paramChar);
}

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

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

@Beta
@GwtCompatible
public final class ArrayBasedEscaperMap
{
  private final char[][] replacementArray;
  
  public static ArrayBasedEscaperMap create(Map<Character, String> replacements)
  {
    return new ArrayBasedEscaperMap(createReplacementArray(replacements));
  }
  
  private ArrayBasedEscaperMap(char[][] replacementArray)
  {
    this.replacementArray = replacementArray;
  }
  
  char[][] getReplacementArray()
  {
    return replacementArray;
  }
  
  @VisibleForTesting
  static char[][] createReplacementArray(Map<Character, String> map)
  {
    Preconditions.checkNotNull(map);
    if (map.isEmpty()) {
      return EMPTY_REPLACEMENT_ARRAY;
    }
    char max = ((Character)Collections.max(map.keySet())).charValue();
    char[][] replacements = new char[max + '\001'][];
    for (Iterator i$ = map.keySet().iterator(); i$.hasNext();)
    {
      char c = ((Character)i$.next()).charValue();
      replacements[c] = ((String)map.get(Character.valueOf(c))).toCharArray();
    }
    return replacements;
  }
  
  private static final char[][] EMPTY_REPLACEMENT_ARRAY = new char[0][0];
}

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

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import java.util.Map;
import javax.annotation.Nullable;

@Beta
@GwtCompatible
public abstract class ArrayBasedUnicodeEscaper
  extends UnicodeEscaper
{
  private final char[][] replacements;
  private final int replacementsLength;
  private final int safeMin;
  private final int safeMax;
  private final char safeMinChar;
  private final char safeMaxChar;
  
  protected ArrayBasedUnicodeEscaper(Map<Character, String> replacementMap, int safeMin, int safeMax, @Nullable String unsafeReplacement)
  {
    this(ArrayBasedEscaperMap.create(replacementMap), safeMin, safeMax, unsafeReplacement);
  }
  
  protected ArrayBasedUnicodeEscaper(ArrayBasedEscaperMap escaperMap, int safeMin, int safeMax, @Nullable String unsafeReplacement)
  {
    Preconditions.checkNotNull(escaperMap);
    replacements = escaperMap.getReplacementArray();
    replacementsLength = replacements.length;
    if (safeMax < safeMin)
    {
      safeMax = -1;
      safeMin = Integer.MAX_VALUE;
    }
    this.safeMin = safeMin;
    this.safeMax = safeMax;
    if (safeMin >= 55296)
    {
      safeMinChar = 65535;
      safeMaxChar = '\000';
    }
    else
    {
      safeMinChar = ((char)safeMin);
      safeMaxChar = ((char)Math.min(safeMax, 55295));
    }
  }
  
  public final String escape(String s)
  {
    Preconditions.checkNotNull(s);
    for (int i = 0; i < s.length(); i++)
    {
      char c = s.charAt(i);
      if (((c < replacementsLength) && (replacements[c] != null)) || (c > safeMaxChar) || (c < safeMinChar)) {
        return escapeSlow(s, i);
      }
    }
    return s;
  }
  
  protected final int nextEscapeIndex(CharSequence csq, int index, int end)
  {
    while (index < end)
    {
      char c = csq.charAt(index);
      if (((c < replacementsLength) && (replacements[c] != null)) || (c > safeMaxChar) || (c < safeMinChar)) {
        break;
      }
      index++;
    }
    return index;
  }
  
  protected final char[] escape(int cp)
  {
    if (cp < replacementsLength)
    {
      char[] chars = replacements[cp];
      if (chars != null) {
        return chars;
      }
    }
    if ((cp >= safeMin) && (cp <= safeMax)) {
      return null;
    }
    return escapeUnsafe(cp);
  }
  
  protected abstract char[] escapeUnsafe(int paramInt);
}

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

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;

@Beta
@GwtCompatible
public abstract class CharEscaper
  extends Escaper
{
  private static final int DEST_PAD = 32;
  
  public String escape(String string)
  {
    Preconditions.checkNotNull(string);
    
    int length = string.length();
    for (int index = 0; index < length; index++) {
      if (escape(string.charAt(index)) != null) {
        return escapeSlow(string, index);
      }
    }
    return string;
  }
  
  protected final String escapeSlow(String s, int index)
  {
    int slen = s.length();
    
    char[] dest = Platform.charBufferFromThreadLocal();
    int destSize = dest.length;
    int destIndex = 0;
    int lastEscape = 0;
    for (; index < slen; index++)
    {
      char[] r = escape(s.charAt(index));
      if (r != null)
      {
        int rlen = r.length;
        int charsSkipped = index - lastEscape;
        
        int sizeNeeded = destIndex + charsSkipped + rlen;
        if (destSize < sizeNeeded)
        {
          destSize = sizeNeeded + (slen - index) + 32;
          dest = growBuffer(dest, destIndex, destSize);
        }
        if (charsSkipped > 0)
        {
          s.getChars(lastEscape, index, dest, destIndex);
          destIndex += charsSkipped;
        }
        if (rlen > 0)
        {
          System.arraycopy(r, 0, dest, destIndex, rlen);
          destIndex += rlen;
        }
        lastEscape = index + 1;
      }
    }
    int charsLeft = slen - lastEscape;
    if (charsLeft > 0)
    {
      int sizeNeeded = destIndex + charsLeft;
      if (destSize < sizeNeeded) {
        dest = growBuffer(dest, destIndex, sizeNeeded);
      }
      s.getChars(lastEscape, slen, dest, destIndex);
      destIndex = sizeNeeded;
    }
    return new String(dest, 0, destIndex);
  }
  
  protected abstract char[] escape(char paramChar);
  
  private static char[] growBuffer(char[] dest, int index, int size)
  {
    char[] copy = new char[size];
    if (index > 0) {
      System.arraycopy(dest, 0, copy, 0, index);
    }
    return copy;
  }
}

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

class CharEscaperBuilder$CharArrayDecorator
  extends CharEscaper
{
  private final char[][] replacements;
  private final int replaceLength;
  
  CharEscaperBuilder$CharArrayDecorator(char[][] replacements)
  {
    this.replacements = replacements;
    replaceLength = replacements.length;
  }
  
  public String escape(String s)
  {
    int slen = s.length();
    for (int index = 0; index < slen; index++)
    {
      char c = s.charAt(index);
      if ((c < replacements.length) && (replacements[c] != null)) {
        return escapeSlow(s, index);
      }
    }
    return s;
  }
  
  protected char[] escape(char c)
  {
    return c < replaceLength ? replacements[c] : null;
  }
}

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

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

@Beta
@GwtCompatible
public final class CharEscaperBuilder
{
  private final Map<Character, String> map;
  
  private static class CharArrayDecorator
    extends CharEscaper
  {
    private final char[][] replacements;
    private final int replaceLength;
    
    CharArrayDecorator(char[][] replacements)
    {
      this.replacements = replacements;
      replaceLength = replacements.length;
    }
    
    public String escape(String s)
    {
      int slen = s.length();
      for (int index = 0; index < slen; index++)
      {
        char c = s.charAt(index);
        if ((c < replacements.length) && (replacements[c] != null)) {
          return escapeSlow(s, index);
        }
      }
      return s;
    }
    
    protected char[] escape(char c)
    {
      return c < replaceLength ? replacements[c] : null;
    }
  }
  
  private int max = -1;
  
  public CharEscaperBuilder()
  {
    map = new HashMap();
  }
  
  public CharEscaperBuilder addEscape(char c, String r)
  {
    map.put(Character.valueOf(c), Preconditions.checkNotNull(r));
    if (c > max) {
      max = c;
    }
    return this;
  }
  
  public CharEscaperBuilder addEscapes(char[] cs, String r)
  {
    Preconditions.checkNotNull(r);
    for (char c : cs) {
      addEscape(c, r);
    }
    return this;
  }
  
  public char[][] toArray()
  {
    char[][] result = new char[max + 1][];
    for (Map.Entry<Character, String> entry : map.entrySet()) {
      result[((Character)entry.getKey()).charValue()] = ((String)entry.getValue()).toCharArray();
    }
    return result;
  }
  
  public Escaper toEscaper()
  {
    return new CharArrayDecorator(toArray());
  }
}

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

import com.google.common.base.Function;

class Escaper$1
  implements Function<String, String>
{
  Escaper$1(Escaper paramEscaper) {}
  
  public String apply(String from)
  {
    return this$0.escape(from);
  }
}

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

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Function;

@Beta
@GwtCompatible
public abstract class Escaper
{
  private final Function<String, String> asFunction = new Function()
  {
    public String apply(String from)
    {
      return escape(from);
    }
  };
  
  public abstract String escape(String paramString);
  
  public final Function<String, String> asFunction()
  {
    return asFunction;
  }
}

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

import com.google.common.base.Preconditions;

final class Escapers$1
  extends CharEscaper
{
  public String escape(String string)
  {
    return (String)Preconditions.checkNotNull(string);
  }
  
  protected char[] escape(char c)
  {
    return null;
  }
}

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

final class Escapers$2
  extends UnicodeEscaper
{
  Escapers$2(CharEscaper paramCharEscaper) {}
  
  protected char[] escape(int cp)
  {
    if (cp < 65536) {
      return val$escaper.escape((char)cp);
    }
    char[] surrogateChars = new char[2];
    Character.toChars(cp, surrogateChars, 0);
    char[] hiChars = val$escaper.escape(surrogateChars[0]);
    char[] loChars = val$escaper.escape(surrogateChars[1]);
    if ((hiChars == null) && (loChars == null)) {
      return null;
    }
    int hiCount = hiChars != null ? hiChars.length : 1;
    int loCount = loChars != null ? loChars.length : 1;
    char[] output = new char[hiCount + loCount];
    if (hiChars != null) {
      for (int n = 0; n < hiChars.length; n++) {
        output[n] = hiChars[n];
      }
    } else {
      output[0] = surrogateChars[0];
    }
    if (loChars != null) {
      for (int n = 0; n < loChars.length; n++) {
        output[(hiCount + n)] = loChars[n];
      }
    } else {
      output[hiCount] = surrogateChars[1];
    }
    return output;
  }
}

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

import java.util.Map;

class Escapers$Builder$1
  extends ArrayBasedCharEscaper
{
  Escapers$Builder$1(Escapers.Builder paramBuilder, Map x0, char x1, char x2)
  {
    super(x0, x1, x2);
  }
  
  private final char[] replacementChars = Escapers.Builder.access$100(this$0) != null ? Escapers.Builder.access$100(this$0).toCharArray() : null;
  
  protected char[] escapeUnsafe(char c)
  {
    return replacementChars;
  }
}

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

import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nullable;

@Beta
public final class Escapers$Builder
{
  private final Map<Character, String> replacementMap = new HashMap();
  private char safeMin = '\000';
  private char safeMax = 65535;
  private String unsafeReplacement = null;
  
  public Builder setSafeRange(char safeMin, char safeMax)
  {
    this.safeMin = safeMin;
    this.safeMax = safeMax;
    return this;
  }
  
  public Builder setUnsafeReplacement(@Nullable String unsafeReplacement)
  {
    this.unsafeReplacement = unsafeReplacement;
    return this;
  }
  
  public Builder addEscape(char c, String replacement)
  {
    Preconditions.checkNotNull(replacement);
    
    replacementMap.put(Character.valueOf(c), replacement);
    return this;
  }
  
  public Escaper build()
  {
    new ArrayBasedCharEscaper(replacementMap, safeMin, safeMax)
    {
      private final char[] replacementChars = unsafeReplacement != null ? unsafeReplacement.toCharArray() : null;
      
      protected char[] escapeUnsafe(char c)
      {
        return replacementChars;
      }
    };
  }
}

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

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nullable;

@Beta
@GwtCompatible
public final class Escapers
{
  public static Escaper nullEscaper()
  {
    return NULL_ESCAPER;
  }
  
  private static final Escaper NULL_ESCAPER = new CharEscaper()
  {
    public String escape(String string)
    {
      return (String)Preconditions.checkNotNull(string);
    }
    
    protected char[] escape(char c)
    {
      return null;
    }
  };
  
  public static Builder builder()
  {
    return new Builder(null);
  }
  
  @Beta
  public static final class Builder
  {
    private final Map<Character, String> replacementMap = new HashMap();
    private char safeMin = '\000';
    private char safeMax = 65535;
    private String unsafeReplacement = null;
    
    public Builder setSafeRange(char safeMin, char safeMax)
    {
      this.safeMin = safeMin;
      this.safeMax = safeMax;
      return this;
    }
    
    public Builder setUnsafeReplacement(@Nullable String unsafeReplacement)
    {
      this.unsafeReplacement = unsafeReplacement;
      return this;
    }
    
    public Builder addEscape(char c, String replacement)
    {
      Preconditions.checkNotNull(replacement);
      
      replacementMap.put(Character.valueOf(c), replacement);
      return this;
    }
    
    public Escaper build()
    {
      new ArrayBasedCharEscaper(replacementMap, safeMin, safeMax)
      {
        private final char[] replacementChars = unsafeReplacement != null ? unsafeReplacement.toCharArray() : null;
        
        protected char[] escapeUnsafe(char c)
        {
          return replacementChars;
        }
      };
    }
  }
  
  static UnicodeEscaper asUnicodeEscaper(Escaper escaper)
  {
    Preconditions.checkNotNull(escaper);
    if ((escaper instanceof UnicodeEscaper)) {
      return (UnicodeEscaper)escaper;
    }
    if ((escaper instanceof CharEscaper)) {
      return wrap((CharEscaper)escaper);
    }
    throw new IllegalArgumentException("Cannot create a UnicodeEscaper from: " + escaper.getClass().getName());
  }
  
  public static String computeReplacement(CharEscaper escaper, char c)
  {
    return stringOrNull(escaper.escape(c));
  }
  
  public static String computeReplacement(UnicodeEscaper escaper, int cp)
  {
    return stringOrNull(escaper.escape(cp));
  }
  
  private static String stringOrNull(char[] in)
  {
    return in == null ? null : new String(in);
  }
  
  private static UnicodeEscaper wrap(CharEscaper escaper)
  {
    new UnicodeEscaper()
    {
      protected char[] escape(int cp)
      {
        if (cp < 65536) {
          return val$escaper.escape((char)cp);
        }
        char[] surrogateChars = new char[2];
        Character.toChars(cp, surrogateChars, 0);
        char[] hiChars = val$escaper.escape(surrogateChars[0]);
        char[] loChars = val$escaper.escape(surrogateChars[1]);
        if ((hiChars == null) && (loChars == null)) {
          return null;
        }
        int hiCount = hiChars != null ? hiChars.length : 1;
        int loCount = loChars != null ? loChars.length : 1;
        char[] output = new char[hiCount + loCount];
        if (hiChars != null) {
          for (int n = 0; n < hiChars.length; n++) {
            output[n] = hiChars[n];
          }
        } else {
          output[0] = surrogateChars[0];
        }
        if (loChars != null) {
          for (int n = 0; n < loChars.length; n++) {
            output[(hiCount + n)] = loChars[n];
          }
        } else {
          output[hiCount] = surrogateChars[1];
        }
        return output;
      }
    };
  }
}

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

final class Platform$1
  extends ThreadLocal<char[]>
{
  protected char[] initialValue()
  {
    return new char['?'];
  }
}

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

import com.google.common.annotations.GwtCompatible;

@GwtCompatible(emulated=true)
final class Platform
{
  static char[] charBufferFromThreadLocal()
  {
    return (char[])DEST_TL.get();
  }
  
  private static final ThreadLocal<char[]> DEST_TL = new ThreadLocal()
  {
    protected char[] initialValue()
    {
      return new char['?'];
    }
  };
}

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

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;

@Beta
@GwtCompatible
public abstract class UnicodeEscaper
  extends Escaper
{
  private static final int DEST_PAD = 32;
  
  protected abstract char[] escape(int paramInt);
  
  protected int nextEscapeIndex(CharSequence csq, int start, int end)
  {
    int index = start;
    while (index < end)
    {
      int cp = codePointAt(csq, index, end);
      if ((cp < 0) || (escape(cp) != null)) {
        break;
      }
      index += (Character.isSupplementaryCodePoint(cp) ? 2 : 1);
    }
    return index;
  }
  
  public String escape(String string)
  {
    Preconditions.checkNotNull(string);
    int end = string.length();
    int index = nextEscapeIndex(string, 0, end);
    return index == end ? string : escapeSlow(string, index);
  }
  
  protected final String escapeSlow(String s, int index)
  {
    int end = s.length();
    
    char[] dest = Platform.charBufferFromThreadLocal();
    int destIndex = 0;
    int unescapedChunkStart = 0;
    while (index < end)
    {
      int cp = codePointAt(s, index, end);
      if (cp < 0) {
        throw new IllegalArgumentException("Trailing high surrogate at end of input");
      }
      char[] escaped = escape(cp);
      int nextIndex = index + (Character.isSupplementaryCodePoint(cp) ? 2 : 1);
      if (escaped != null)
      {
        int charsSkipped = index - unescapedChunkStart;
        
        int sizeNeeded = destIndex + charsSkipped + escaped.length;
        if (dest.length < sizeNeeded)
        {
          int destLength = sizeNeeded + (end - index) + 32;
          dest = growBuffer(dest, destIndex, destLength);
        }
        if (charsSkipped > 0)
        {
          s.getChars(unescapedChunkStart, index, dest, destIndex);
          destIndex += charsSkipped;
        }
        if (escaped.length > 0)
        {
          System.arraycopy(escaped, 0, dest, destIndex, escaped.length);
          destIndex += escaped.length;
        }
        unescapedChunkStart = nextIndex;
      }
      index = nextEscapeIndex(s, nextIndex, end);
    }
    int charsSkipped = end - unescapedChunkStart;
    if (charsSkipped > 0)
    {
      int endIndex = destIndex + charsSkipped;
      if (dest.length < endIndex) {
        dest = growBuffer(dest, destIndex, endIndex);
      }
      s.getChars(unescapedChunkStart, end, dest, destIndex);
      destIndex = endIndex;
    }
    return new String(dest, 0, destIndex);
  }
  
  protected static int codePointAt(CharSequence seq, int index, int end)
  {
    Preconditions.checkNotNull(seq);
    if (index < end)
    {
      char c1 = seq.charAt(index++);
      if ((c1 < 55296) || (c1 > 57343)) {
        return c1;
      }
      if (c1 <= 56319)
      {
        if (index == end) {
          return -c1;
        }
        char c2 = seq.charAt(index);
        if (Character.isLowSurrogate(c2)) {
          return Character.toCodePoint(c1, c2);
        }
        throw new IllegalArgumentException("Expected low surrogate but got char '" + c2 + "' with value " + c2 + " at index " + index + " in '" + seq + "'");
      }
      throw new IllegalArgumentException("Unexpected low surrogate character '" + c1 + "' with value " + c1 + " at index " + (index - 1) + " in '" + seq + "'");
    }
    throw new IndexOutOfBoundsException("Index exceeds specified range");
  }
  
  private static char[] growBuffer(char[] dest, int index, int size)
  {
    char[] copy = new char[size];
    if (index > 0) {
      System.arraycopy(dest, 0, copy, 0, index);
    }
    return copy;
  }
}

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

import javax.annotation.ParametersAreNonnullByDefault;

@ParametersAreNonnullByDefault
abstract interface package-info {}

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

import com.google.common.annotations.Beta;
import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({java.lang.annotation.ElementType.METHOD})
@Beta
public @interface AllowConcurrentEvents {}

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

import com.google.common.cache.CacheLoader;
import com.google.common.collect.ImmutableList;
import java.lang.reflect.Method;

final class AnnotatedHandlerFinder$1
  extends CacheLoader<Class<?>, ImmutableList<Method>>
{
  public ImmutableList<Method> load(Class<?> concreteClass)
    throws Exception
  {
    return AnnotatedHandlerFinder.access$000(concreteClass);
  }
}

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

import com.google.common.base.Objects;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import javax.annotation.Nullable;

final class AnnotatedHandlerFinder$MethodIdentifier
{
  private final String name;
  private final List<Class<?>> parameterTypes;
  
  AnnotatedHandlerFinder$MethodIdentifier(Method method)
  {
    name = method.getName();
    parameterTypes = Arrays.asList(method.getParameterTypes());
  }
  
  public int hashCode()
  {
    return Objects.hashCode(new Object[] { name, parameterTypes });
  }
  
  public boolean equals(@Nullable Object o)
  {
    if ((o instanceof MethodIdentifier))
    {
      MethodIdentifier ident = (MethodIdentifier)o;
      return (name.equals(name)) && (parameterTypes.equals(parameterTypes));
    }
    return false;
  }
}

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

import com.google.common.base.Objects;
import com.google.common.base.Throwables;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import com.google.common.reflect.TypeToken;
import com.google.common.reflect.TypeToken.TypeSet;
import com.google.common.util.concurrent.UncheckedExecutionException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nullable;

class AnnotatedHandlerFinder
  implements HandlerFindingStrategy
{
  private static final LoadingCache<Class<?>, ImmutableList<Method>> handlerMethodsCache = CacheBuilder.newBuilder().weakKeys().build(new CacheLoader()
  {
    public ImmutableList<Method> load(Class<?> concreteClass)
      throws Exception
    {
      return AnnotatedHandlerFinder.getAnnotatedMethodsInternal(concreteClass);
    }
  });
  
  public Multimap<Class<?>, EventHandler> findAllHandlers(Object listener)
  {
    Multimap<Class<?>, EventHandler> methodsInListener = HashMultimap.create();
    Class<?> clazz = listener.getClass();
    for (Method method : getAnnotatedMethods(clazz))
    {
      Class<?>[] parameterTypes = method.getParameterTypes();
      Class<?> eventType = parameterTypes[0];
      EventHandler handler = makeHandler(listener, method);
      methodsInListener.put(eventType, handler);
    }
    return methodsInListener;
  }
  
  private static ImmutableList<Method> getAnnotatedMethods(Class<?> clazz)
  {
    try
    {
      return (ImmutableList)handlerMethodsCache.getUnchecked(clazz);
    }
    catch (UncheckedExecutionException e)
    {
      throw Throwables.propagate(e.getCause());
    }
  }
  
  private static final class MethodIdentifier
  {
    private final String name;
    private final List<Class<?>> parameterTypes;
    
    MethodIdentifier(Method method)
    {
      name = method.getName();
      parameterTypes = Arrays.asList(method.getParameterTypes());
    }
    
    public int hashCode()
    {
      return Objects.hashCode(new Object[] { name, parameterTypes });
    }
    
    public boolean equals(@Nullable Object o)
    {
      if ((o instanceof MethodIdentifier))
      {
        MethodIdentifier ident = (MethodIdentifier)o;
        return (name.equals(name)) && (parameterTypes.equals(parameterTypes));
      }
      return false;
    }
  }
  
  private static ImmutableList<Method> getAnnotatedMethodsInternal(Class<?> clazz)
  {
    Set<? extends Class<?>> supers = TypeToken.of(clazz).getTypes().rawTypes();
    Map<MethodIdentifier, Method> identifiers = Maps.newHashMap();
    for (Class<?> superClazz : supers) {
      for (Method superClazzMethod : superClazz.getMethods()) {
        if (superClazzMethod.isAnnotationPresent(Subscribe.class))
        {
          Class<?>[] parameterTypes = superClazzMethod.getParameterTypes();
          if (parameterTypes.length != 1) {
            throw new IllegalArgumentException("Method " + superClazzMethod + " has @Subscribe annotation, but requires " + parameterTypes.length + " arguments.  Event handler methods must require a single argument.");
          }
          MethodIdentifier ident = new MethodIdentifier(superClazzMethod);
          if (!identifiers.containsKey(ident)) {
            identifiers.put(ident, superClazzMethod);
          }
        }
      }
    }
    return ImmutableList.copyOf(identifiers.values());
  }
  
  private static EventHandler makeHandler(Object listener, Method method)
  {
    EventHandler wrapper;
    EventHandler wrapper;
    if (methodIsDeclaredThreadSafe(method)) {
      wrapper = new EventHandler(listener, method);
    } else {
      wrapper = new SynchronizedEventHandler(listener, method);
    }
    return wrapper;
  }
  
  private static boolean methodIsDeclaredThreadSafe(Method method)
  {
    return method.getAnnotation(AllowConcurrentEvents.class) != null;
  }
}

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

class AsyncEventBus$1
  implements Runnable
{
  AsyncEventBus$1(AsyncEventBus paramAsyncEventBus, Object paramObject, EventHandler paramEventHandler) {}
  
  public void run()
  {
    AsyncEventBus.access$001(this$0, val$event, val$handler);
  }
}

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

import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.Executor;

@Beta
public class AsyncEventBus
  extends EventBus
{
  private final Executor executor;
  private final ConcurrentLinkedQueue<EventBus.EventWithHandler> eventsToDispatch = new ConcurrentLinkedQueue();
  
  public AsyncEventBus(String identifier, Executor executor)
  {
    super(identifier);
    this.executor = ((Executor)Preconditions.checkNotNull(executor));
  }
  
  public AsyncEventBus(Executor executor)
  {
    this.executor = ((Executor)Preconditions.checkNotNull(executor));
  }
  
  void enqueueEvent(Object event, EventHandler handler)
  {
    eventsToDispatch.offer(new EventBus.EventWithHandler(event, handler));
  }
  
  protected void dispatchQueuedEvents()
  {
    for (;;)
    {
      EventBus.EventWithHandler eventWithHandler = (EventBus.EventWithHandler)eventsToDispatch.poll();
      if (eventWithHandler == null) {
        break;
      }
      dispatch(event, handler);
    }
  }
  
  void dispatch(final Object event, final EventHandler handler)
  {
    Preconditions.checkNotNull(event);
    Preconditions.checkNotNull(handler);
    executor.execute(new Runnable()
    {
      public void run()
      {
        AsyncEventBus.this.dispatch(event, handler);
      }
    });
  }
}

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

import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;

@Beta
public class DeadEvent
{
  private final Object source;
  private final Object event;
  
  public DeadEvent(Object source, Object event)
  {
    this.source = Preconditions.checkNotNull(source);
    this.event = Preconditions.checkNotNull(event);
  }
  
  public Object getSource()
  {
    return source;
  }
  
  public Object getEvent()
  {
    return event;
  }
}

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

import com.google.common.cache.CacheLoader;
import com.google.common.reflect.TypeToken;
import com.google.common.reflect.TypeToken.TypeSet;
import java.util.Set;

final class EventBus$1
  extends CacheLoader<Class<?>, Set<Class<?>>>
{
  public Set<Class<?>> load(Class<?> concreteClass)
  {
    return TypeToken.of(concreteClass).getTypes().rawTypes();
  }
}

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

import java.util.LinkedList;
import java.util.Queue;

class EventBus$2
  extends ThreadLocal<Queue<EventBus.EventWithHandler>>
{
  EventBus$2(EventBus paramEventBus) {}
  
  protected Queue<EventBus.EventWithHandler> initialValue()
  {
    return new LinkedList();
  }
}

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

class EventBus$3
  extends ThreadLocal<Boolean>
{
  EventBus$3(EventBus paramEventBus) {}
  
  protected Boolean initialValue()
  {
    return Boolean.valueOf(false);
  }
}

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

import com.google.common.base.Preconditions;

class EventBus$EventWithHandler
{
  final Object event;
  final EventHandler handler;
  
  public EventBus$EventWithHandler(Object event, EventHandler handler)
  {
    this.event = Preconditions.checkNotNull(event);
    this.handler = ((EventHandler)Preconditions.checkNotNull(handler));
  }
}

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

import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
import com.google.common.collect.SetMultimap;
import com.google.common.reflect.TypeToken;
import com.google.common.reflect.TypeToken.TypeSet;
import com.google.common.util.concurrent.UncheckedExecutionException;
import java.lang.reflect.InvocationTargetException;
import java.util.Collection;
import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.logging.Level;
import java.util.logging.Logger;

@Beta
public class EventBus
{
  private static final LoadingCache<Class<?>, Set<Class<?>>> flattenHierarchyCache = CacheBuilder.newBuilder().weakKeys().build(new CacheLoader()
  {
    public Set<Class<?>> load(Class<?> concreteClass)
    {
      return TypeToken.of(concreteClass).getTypes().rawTypes();
    }
  });
  private final SetMultimap<Class<?>, EventHandler> handlersByType = HashMultimap.create();
  private final ReadWriteLock handlersByTypeLock = new ReentrantReadWriteLock();
  private final Logger logger;
  private final HandlerFindingStrategy finder = new AnnotatedHandlerFinder();
  private final ThreadLocal<Queue<EventWithHandler>> eventsToDispatch = new ThreadLocal()
  {
    protected Queue<EventBus.EventWithHandler> initialValue()
    {
      return new LinkedList();
    }
  };
  private final ThreadLocal<Boolean> isDispatching = new ThreadLocal()
  {
    protected Boolean initialValue()
    {
      return Boolean.valueOf(false);
    }
  };
  
  public EventBus()
  {
    this("default");
  }
  
  public EventBus(String identifier)
  {
    logger = Logger.getLogger(EventBus.class.getName() + "." + (String)Preconditions.checkNotNull(identifier));
  }
  
  public void register(Object object)
  {
    Multimap<Class<?>, EventHandler> methodsInListener = finder.findAllHandlers(object);
    
    handlersByTypeLock.writeLock().lock();
    try
    {
      handlersByType.putAll(methodsInListener);
    }
    finally
    {
      handlersByTypeLock.writeLock().unlock();
    }
  }
  
  public void unregister(Object object)
  {
    Multimap<Class<?>, EventHandler> methodsInListener = finder.findAllHandlers(object);
    for (Map.Entry<Class<?>, Collection<EventHandler>> entry : methodsInListener.asMap().entrySet())
    {
      Class<?> eventType = (Class)entry.getKey();
      Collection<EventHandler> eventMethodsInListener = (Collection)entry.getValue();
      
      handlersByTypeLock.writeLock().lock();
      try
      {
        Set<EventHandler> currentHandlers = handlersByType.get(eventType);
        if (!currentHandlers.containsAll(eventMethodsInListener)) {
          throw new IllegalArgumentException("missing even