package com.google.common.collect;

import com.google.common.base.Preconditions;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.annotation.Nullable;

public abstract class ImmutableMap<K, V>
  implements Serializable, Map<K, V>
{
  private transient ImmutableSet<Map.Entry<K, V>> entrySet;
  private transient ImmutableSet<K> keySet;
  private transient ImmutableCollection<V> values;

  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)
  {
    if (((paramMap instanceof ImmutableMap)) && (!(paramMap instanceof ImmutableSortedMap)))
    {
      ImmutableMap localImmutableMap = (ImmutableMap)paramMap;
      if (!localImmutableMap.isPartialView())
        return localImmutableMap;
    }
    else if ((paramMap instanceof EnumMap))
    {
      EnumMap localEnumMap = (EnumMap)paramMap;
      Iterator localIterator = localEnumMap.entrySet().iterator();
      while (localIterator.hasNext())
      {
        Map.Entry localEntry = (Map.Entry)localIterator.next();
        Preconditions.checkNotNull(localEntry.getKey());
        Preconditions.checkNotNull(localEntry.getValue());
      }
      return ImmutableEnumMap.asImmutable(new EnumMap(localEnumMap));
    }
    Map.Entry[] arrayOfEntry = (Map.Entry[])paramMap.entrySet().toArray(new Map.Entry[0]);
    int i;
    switch (arrayOfEntry.length)
    {
    default:
      i = 0;
    case 0:
    case 1:
    }
    while (i < arrayOfEntry.length)
    {
      arrayOfEntry[i] = entryOf(arrayOfEntry[i].getKey(), arrayOfEntry[i].getValue());
      i++;
      continue;
      return of();
      return new SingletonImmutableBiMap(entryOf(arrayOfEntry[0].getKey(), arrayOfEntry[0].getValue()));
    }
    return new RegularImmutableMap(arrayOfEntry);
  }

  static <K, V> Map.Entry<K, V> entryOf(K paramK, V paramV)
  {
    Preconditions.checkNotNull(paramK, "null key in entry: null=%s", new Object[] { paramV });
    Preconditions.checkNotNull(paramV, "null value in entry: %s=null", new Object[] { paramK });
    return Maps.immutableEntry(paramK, paramV);
  }

  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);
  }

  @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 (paramObject != null) && (Maps.containsValueImpl(this, paramObject));
  }

  abstract ImmutableSet<Map.Entry<K, V>> createEntrySet();

  ImmutableSet<K> createKeySet()
  {
    return new ImmutableMapKeySet(this);
  }

  public ImmutableSet<Map.Entry<K, V>> entrySet()
  {
    ImmutableSet localImmutableSet = this.entrySet;
    if (localImmutableSet == null)
    {
      localImmutableSet = createEntrySet();
      this.entrySet = localImmutableSet;
    }
    return localImmutableSet;
  }

  public boolean equals(@Nullable Object paramObject)
  {
    return Maps.equalsImpl(this, paramObject);
  }

  public abstract V get(@Nullable Object paramObject);

  public int hashCode()
  {
    return entrySet().hashCode();
  }

  public boolean isEmpty()
  {
    return size() == 0;
  }

  abstract boolean isPartialView();

  public ImmutableSet<K> keySet()
  {
    ImmutableSet localImmutableSet = this.keySet;
    if (localImmutableSet == null)
    {
      localImmutableSet = createKeySet();
      this.keySet = localImmutableSet;
    }
    return localImmutableSet;
  }

  @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.toStringImpl(this);
  }

  public ImmutableCollection<V> values()
  {
    Object localObject = this.values;
    if (localObject == null)
    {
      localObject = new ImmutableMapValues(this);
      this.values = ((ImmutableCollection)localObject);
    }
    return localObject;
  }

  public static class Builder<K, V>
  {
    final ArrayList<Map.Entry<K, V>> entries = Lists.newArrayList();

    private static <K, V> ImmutableMap<K, V> fromEntryList(List<Map.Entry<K, V>> paramList)
    {
      switch (paramList.size())
      {
      default:
        return new RegularImmutableMap((Map.Entry[])paramList.toArray(new Map.Entry[paramList.size()]));
      case 0:
        return ImmutableMap.of();
      case 1:
      }
      return new SingletonImmutableBiMap((Map.Entry)Iterables.getOnlyElement(paramList));
    }

    public ImmutableMap<K, V> build()
    {
      return fromEntryList(this.entries);
    }

    public Builder<K, V> put(K paramK, V paramV)
    {
      this.entries.add(ImmutableMap.entryOf(paramK, paramV));
      return this;
    }

    public Builder<K, V> putAll(Map<? extends K, ? extends V> paramMap)
    {
      this.entries.ensureCapacity(this.entries.size() + paramMap.size());
      Iterator localIterator = paramMap.entrySet().iterator();
      while (localIterator.hasNext())
      {
        Map.Entry localEntry = (Map.Entry)localIterator.next();
        put(localEntry.getKey(), localEntry.getValue());
      }
      return this;
    }
  }
}

/* Location:           C:\Documents and Settings\Cesar Cabello Cea\Mis documentos\Downloads\apk-downloader\com.ikea.kompis-6_dex2jar.jar
 * Qualified Name:     com.google.common.collect.ImmutableMap
 * JD-Core Version:    0.6.2
 */