package com.google.common.collect;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import java.io.Serializable;
import java.util.EnumMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.annotation.Nullable;
import mw;
import nj;
import or;
import ot.a;
import ou;
import ov;
import ow;
import pk;

@GwtCompatible(emulated=true, serializable=true)
public abstract class ImmutableMap<K, V>
  implements Serializable, Map<K, V>
{
  private static final Map.Entry<?, ?>[] a = new Map.Entry[0];
  private transient ImmutableSet<Map.Entry<K, V>> b;
  private transient ImmutableSet<K> c;
  private transient ImmutableCollection<V> d;
  private transient ImmutableSetMultimap<K, V> e;
  
  static <K, V> ot.a<K, V> a(K paramK, V paramV)
  {
    nj.a(paramK, paramV);
    return new ot.a(paramK, paramV);
  }
  
  protected static void a(boolean paramBoolean, String paramString, Map.Entry<?, ?> paramEntry1, Map.Entry<?, ?> paramEntry2)
  {
    if (!paramBoolean)
    {
      paramString = String.valueOf(String.valueOf(paramString));
      paramEntry1 = String.valueOf(String.valueOf(paramEntry1));
      paramEntry2 = String.valueOf(String.valueOf(paramEntry2));
      throw new IllegalArgumentException(paramString.length() + 34 + paramEntry1.length() + paramEntry2.length() + "Multiple entries with same " + paramString + ": " + paramEntry1 + " and " + paramEntry2);
    }
  }
  
  public static <K, V> Builder<K, V> builder()
  {
    return new Builder();
  }
  
  public static <K, V> ImmutableMap<K, V> copyOf(Map<? extends K, ? extends V> paramMap)
  {
    Object localObject;
    if (((paramMap instanceof ImmutableMap)) && (!(paramMap instanceof ImmutableSortedMap)))
    {
      localObject = (ImmutableMap)paramMap;
      if (!((ImmutableMap)localObject).b()) {
        return (ImmutableMap<K, V>)localObject;
      }
    }
    else if ((paramMap instanceof EnumMap))
    {
      paramMap = new EnumMap((EnumMap)paramMap);
      localObject = paramMap.entrySet().iterator();
      while (((Iterator)localObject).hasNext())
      {
        Map.Entry localEntry = (Map.Entry)((Iterator)localObject).next();
        nj.a(localEntry.getKey(), localEntry.getValue());
      }
      return or.a(paramMap);
    }
    paramMap = (Map.Entry[])paramMap.entrySet().toArray(a);
    switch (paramMap.length)
    {
    default: 
      return new pk(paramMap);
    case 0: 
      return of();
    }
    paramMap = paramMap[0];
    return of(paramMap.getKey(), paramMap.getValue());
  }
  
  public static <K, V> ImmutableMap<K, V> of()
  {
    return ImmutableBiMap.of();
  }
  
  public static <K, V> ImmutableMap<K, V> of(K paramK, V paramV)
  {
    return ImmutableBiMap.of(paramK, paramV);
  }
  
  public static <K, V> ImmutableMap<K, V> of(K paramK1, V paramV1, K paramK2, V paramV2)
  {
    return new pk(new ot.a[] { a(paramK1, paramV1), a(paramK2, paramV2) });
  }
  
  public static <K, V> ImmutableMap<K, V> of(K paramK1, V paramV1, K paramK2, V paramV2, K paramK3, V paramV3)
  {
    return new pk(new ot.a[] { a(paramK1, paramV1), a(paramK2, paramV2), a(paramK3, paramV3) });
  }
  
  public static <K, V> ImmutableMap<K, V> of(K paramK1, V paramV1, K paramK2, V paramV2, K paramK3, V paramV3, K paramK4, V paramV4)
  {
    return new pk(new ot.a[] { a(paramK1, paramV1), a(paramK2, paramV2), a(paramK3, paramV3), a(paramK4, paramV4) });
  }
  
  public static <K, V> ImmutableMap<K, V> of(K paramK1, V paramV1, K paramK2, V paramV2, K paramK3, V paramV3, K paramK4, V paramV4, K paramK5, V paramV5)
  {
    return new pk(new ot.a[] { a(paramK1, paramV1), a(paramK2, paramV2), a(paramK3, paramV3), a(paramK4, paramV4), a(paramK5, paramV5) });
  }
  
  @Beta
  public ImmutableSetMultimap<K, V> asMultimap()
  {
    ImmutableSetMultimap localImmutableSetMultimap = this.e;
    Object localObject = localImmutableSetMultimap;
    if (localImmutableSetMultimap == null)
    {
      localObject = new a(this);
      localObject = new ImmutableSetMultimap((ImmutableMap)localObject, ((ImmutableMap)localObject).size(), null);
      this.e = ((ImmutableSetMultimap)localObject);
    }
    return (ImmutableSetMultimap<K, V>)localObject;
  }
  
  public abstract boolean b();
  
  public ImmutableSet<K> c()
  {
    return new ov(this);
  }
  
  @Deprecated
  public final void clear()
  {
    throw new UnsupportedOperationException();
  }
  
  public boolean containsKey(@Nullable Object paramObject)
  {
    return get(paramObject) != null;
  }
  
  public boolean containsValue(@Nullable Object paramObject)
  {
    return values().contains(paramObject);
  }
  
  public abstract ImmutableSet<Map.Entry<K, V>> d();
  
  public ImmutableSet<Map.Entry<K, V>> entrySet()
  {
    ImmutableSet localImmutableSet2 = this.b;
    ImmutableSet localImmutableSet1 = localImmutableSet2;
    if (localImmutableSet2 == null)
    {
      localImmutableSet1 = d();
      this.b = localImmutableSet1;
    }
    return localImmutableSet1;
  }
  
  public boolean equals(@Nullable Object paramObject)
  {
    return Maps.f(this, paramObject);
  }
  
  public abstract V get(@Nullable Object paramObject);
  
  public int hashCode()
  {
    return entrySet().hashCode();
  }
  
  public boolean isEmpty()
  {
    return size() == 0;
  }
  
  public ImmutableSet<K> keySet()
  {
    ImmutableSet localImmutableSet2 = this.c;
    ImmutableSet localImmutableSet1 = localImmutableSet2;
    if (localImmutableSet2 == null)
    {
      localImmutableSet1 = c();
      this.c = localImmutableSet1;
    }
    return localImmutableSet1;
  }
  
  @Deprecated
  public final V put(K paramK, V paramV)
  {
    throw new UnsupportedOperationException();
  }
  
  @Deprecated
  public final void putAll(Map<? extends K, ? extends V> paramMap)
  {
    throw new UnsupportedOperationException();
  }
  
  @Deprecated
  public final V remove(Object paramObject)
  {
    throw new UnsupportedOperationException();
  }
  
  public String toString()
  {
    return Maps.a(this);
  }
  
  public ImmutableCollection<V> values()
  {
    ImmutableCollection localImmutableCollection = this.d;
    Object localObject = localImmutableCollection;
    if (localImmutableCollection == null)
    {
      localObject = new ow(this);
      this.d = ((ImmutableCollection)localObject);
    }
    return (ImmutableCollection<V>)localObject;
  }
  
  public Object writeReplace()
  {
    return new b(this);
  }
  
  public static class Builder<K, V>
  {
    ot.a<K, V>[] a = new ot.a[4];
    int b = 0;
    
    public Builder()
    {
      this((byte)0);
    }
    
    private Builder(byte paramByte) {}
    
    private void a(int paramInt)
    {
      if (paramInt > this.a.length) {
        this.a = ((ot.a[])ObjectArrays.a(this.a, ImmutableCollection.Builder.a(this.a.length, paramInt)));
      }
    }
    
    public ImmutableMap<K, V> build()
    {
      switch (this.b)
      {
      default: 
        return new pk(this.b, this.a);
      case 0: 
        return ImmutableMap.of();
      }
      return ImmutableMap.of(this.a[0].getKey(), this.a[0].getValue());
    }
    
    public Builder<K, V> put(K paramK, V paramV)
    {
      a(this.b + 1);
      paramK = ImmutableMap.a(paramK, paramV);
      paramV = this.a;
      int i = this.b;
      this.b = (i + 1);
      paramV[i] = paramK;
      return this;
    }
    
    public Builder<K, V> put(Map.Entry<? extends K, ? extends V> paramEntry)
    {
      return put(paramEntry.getKey(), paramEntry.getValue());
    }
    
    public Builder<K, V> putAll(Map<? extends K, ? extends V> paramMap)
    {
      a(this.b + paramMap.size());
      paramMap = paramMap.entrySet().iterator();
      while (paramMap.hasNext()) {
        put((Map.Entry)paramMap.next());
      }
      return this;
    }
  }
  
  static final class a<K, V>
    extends ImmutableMap<K, ImmutableSet<V>>
  {
    private final ImmutableMap<K, V> a;
    
    a(ImmutableMap<K, V> paramImmutableMap)
    {
      this.a = ((ImmutableMap)Preconditions.checkNotNull(paramImmutableMap));
    }
    
    final boolean b()
    {
      return false;
    }
    
    public final boolean containsKey(@Nullable Object paramObject)
    {
      return this.a.containsKey(paramObject);
    }
    
    final ImmutableSet<Map.Entry<K, ImmutableSet<V>>> d()
    {
      new ou()
      {
        final ImmutableMap<K, ImmutableSet<V>> b()
        {
          return ImmutableMap.a.this;
        }
        
        public final UnmodifiableIterator<Map.Entry<K, ImmutableSet<V>>> iterator()
        {
          new UnmodifiableIterator()
          {
            public final boolean hasNext()
            {
              return this.a.hasNext();
            }
          };
        }
      };
    }
    
    public final int size()
    {
      return this.a.size();
    }
  }
  
  static class b
    implements Serializable
  {
    private static final long serialVersionUID = 0L;
    private final Object[] a;
    private final Object[] b;
    
    b(ImmutableMap<?, ?> paramImmutableMap)
    {
      this.a = new Object[paramImmutableMap.size()];
      this.b = new Object[paramImmutableMap.size()];
      paramImmutableMap = paramImmutableMap.entrySet().iterator();
      int i = 0;
      while (paramImmutableMap.hasNext())
      {
        Map.Entry localEntry = (Map.Entry)paramImmutableMap.next();
        this.a[i] = localEntry.getKey();
        this.b[i] = localEntry.getValue();
        i += 1;
      }
    }
    
    final Object a(ImmutableMap.Builder<Object, Object> paramBuilder)
    {
      int i = 0;
      while (i < this.a.length)
      {
        paramBuilder.put(this.a[i], this.b[i]);
        i += 1;
      }
      return paramBuilder.build();
    }
    
    Object readResolve()
    {
      return a(new ImmutableMap.Builder());
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/com/google/common/collect/ImmutableMap.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */