package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.base.Ascii;
import com.google.common.base.Equivalence;
import com.google.common.base.Function;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import com.google.common.base.Ticker;
import java.io.Serializable;
import java.util.AbstractMap;
import java.util.Collections;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import javax.annotation.Nullable;
import nm;
import on;
import oq;
import pc;
import pc.p;

@GwtCompatible(emulated=true)
public final class MapMaker
  extends on<Object, Object>
{
  public boolean b;
  int c = -1;
  int d = -1;
  public int e = -1;
  pc.p f;
  public pc.p g;
  public long h = -1L;
  public long i = -1L;
  public d j;
  public Equivalence<Object> k;
  public Ticker l;
  
  @GwtIncompatible("To be supported")
  public final MapMaker a(Equivalence<Object> paramEquivalence)
  {
    if (this.k == null) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkState(bool, "key equivalence was already set to %s", new Object[] { this.k });
      this.k = ((Equivalence)Preconditions.checkNotNull(paramEquivalence));
      this.b = true;
      return this;
    }
  }
  
  public final MapMaker a(pc.p paramp)
  {
    boolean bool2 = false;
    if (this.f == null) {}
    for (boolean bool1 = true;; bool1 = false)
    {
      Preconditions.checkState(bool1, "Key strength was already set to %s", new Object[] { this.f });
      this.f = ((pc.p)Preconditions.checkNotNull(paramp));
      bool1 = bool2;
      if (this.f != pc.p.b) {
        bool1 = true;
      }
      Preconditions.checkArgument(bool1, "Soft keys are not supported");
      if (paramp != pc.p.a) {
        this.b = true;
      }
      return this;
    }
  }
  
  @Deprecated
  public final <K, V> ConcurrentMap<K, V> a(Function<? super K, ? extends V> paramFunction)
  {
    if (this.j == null) {}
    for (paramFunction = new a(this, paramFunction);; paramFunction = new b(this, paramFunction)) {
      return (ConcurrentMap)paramFunction;
    }
  }
  
  public final void a(long paramLong, TimeUnit paramTimeUnit)
  {
    if (this.h == -1L)
    {
      bool = true;
      Preconditions.checkState(bool, "expireAfterWrite was already set to %s ns", new Object[] { Long.valueOf(this.h) });
      if (this.i != -1L) {
        break label108;
      }
      bool = true;
      label49:
      Preconditions.checkState(bool, "expireAfterAccess was already set to %s ns", new Object[] { Long.valueOf(this.i) });
      if (paramLong < 0L) {
        break label114;
      }
    }
    label108:
    label114:
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "duration cannot be negative: %s %s", new Object[] { Long.valueOf(paramLong), paramTimeUnit });
      return;
      bool = false;
      break;
      bool = false;
      break label49;
    }
  }
  
  public final int b()
  {
    if (this.c == -1) {
      return 16;
    }
    return this.c;
  }
  
  public final MapMaker b(pc.p paramp)
  {
    if (this.g == null) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkState(bool, "Value strength was already set to %s", new Object[] { this.g });
      this.g = ((pc.p)Preconditions.checkNotNull(paramp));
      if (paramp != pc.p.a) {
        this.b = true;
      }
      return this;
    }
  }
  
  public final int c()
  {
    if (this.d == -1) {
      return 4;
    }
    return this.d;
  }
  
  public final MapMaker concurrencyLevel(int paramInt)
  {
    boolean bool2 = true;
    if (this.d == -1)
    {
      bool1 = true;
      Preconditions.checkState(bool1, "concurrency level was already set to %s", new Object[] { Integer.valueOf(this.d) });
      if (paramInt <= 0) {
        break label54;
      }
    }
    label54:
    for (boolean bool1 = bool2;; bool1 = false)
    {
      Preconditions.checkArgument(bool1);
      this.d = paramInt;
      return this;
      bool1 = false;
      break;
    }
  }
  
  public final pc.p d()
  {
    return (pc.p)MoreObjects.firstNonNull(this.f, pc.p.a);
  }
  
  public final MapMaker initialCapacity(int paramInt)
  {
    boolean bool2 = true;
    if (this.c == -1)
    {
      bool1 = true;
      Preconditions.checkState(bool1, "initial capacity was already set to %s", new Object[] { Integer.valueOf(this.c) });
      if (paramInt < 0) {
        break label54;
      }
    }
    label54:
    for (boolean bool1 = bool2;; bool1 = false)
    {
      Preconditions.checkArgument(bool1);
      this.c = paramInt;
      return this;
      bool1 = false;
      break;
    }
  }
  
  public final <K, V> ConcurrentMap<K, V> makeMap()
  {
    if (!this.b) {
      return new ConcurrentHashMap(b(), 0.75F, c());
    }
    if (this.j == null) {}
    for (Object localObject = new pc(this);; localObject = new c(this)) {
      return (ConcurrentMap)localObject;
    }
  }
  
  @Deprecated
  @GwtIncompatible("java.lang.ref.SoftReference")
  public final MapMaker softValues()
  {
    return b(pc.p.b);
  }
  
  public final String toString()
  {
    MoreObjects.ToStringHelper localToStringHelper = MoreObjects.toStringHelper(this);
    if (this.c != -1) {
      localToStringHelper.add("initialCapacity", this.c);
    }
    if (this.d != -1) {
      localToStringHelper.add("concurrencyLevel", this.d);
    }
    if (this.e != -1) {
      localToStringHelper.add("maximumSize", this.e);
    }
    long l1;
    if (this.h != -1L)
    {
      l1 = this.h;
      localToStringHelper.add("expireAfterWrite", 22 + l1 + "ns");
    }
    if (this.i != -1L)
    {
      l1 = this.i;
      localToStringHelper.add("expireAfterAccess", 22 + l1 + "ns");
    }
    if (this.f != null) {
      localToStringHelper.add("keyStrength", Ascii.toLowerCase(this.f.toString()));
    }
    if (this.g != null) {
      localToStringHelper.add("valueStrength", Ascii.toLowerCase(this.g.toString()));
    }
    if (this.k != null) {
      localToStringHelper.addValue("keyEquivalence");
    }
    if (this.a != null) {
      localToStringHelper.addValue("removalListener");
    }
    return localToStringHelper.toString();
  }
  
  @GwtIncompatible("java.lang.ref.WeakReference")
  public final MapMaker weakKeys()
  {
    return a(pc.p.c);
  }
  
  @GwtIncompatible("java.lang.ref.WeakReference")
  public final MapMaker weakValues()
  {
    return b(pc.p.c);
  }
  
  static final class a<K, V>
    extends nm<K, V>
    implements Serializable
  {
    private static final long serialVersionUID = 0L;
    
    a(MapMaker paramMapMaker, Function<? super K, ? extends V> paramFunction)
    {
      super(paramFunction);
    }
    
    public final V get(Object paramObject)
    {
      Object localObject;
      try
      {
        localObject = a(paramObject);
        if (localObject == null)
        {
          localObject = String.valueOf(String.valueOf(this.a));
          paramObject = String.valueOf(String.valueOf(paramObject));
          throw new NullPointerException(((String)localObject).length() + 24 + ((String)paramObject).length() + (String)localObject + " returned null for key " + (String)paramObject + ".");
        }
      }
      catch (ExecutionException paramObject)
      {
        paramObject = ((ExecutionException)paramObject).getCause();
        Throwables.propagateIfInstanceOf((Throwable)paramObject, ComputationException.class);
        throw new ComputationException((Throwable)paramObject);
      }
      return (V)localObject;
    }
  }
  
  static final class b<K, V>
    extends MapMaker.c<K, V>
  {
    private static final long serialVersionUID = 0L;
    final Function<? super K, ? extends V> a;
    
    b(MapMaker paramMapMaker, Function<? super K, ? extends V> paramFunction)
    {
      super();
      this.a = ((Function)Preconditions.checkNotNull(paramFunction));
    }
    
    private V a(K paramK)
    {
      Preconditions.checkNotNull(paramK);
      try
      {
        paramK = this.a.apply(paramK);
        return paramK;
      }
      catch (ComputationException paramK)
      {
        throw paramK;
      }
      catch (Throwable paramK)
      {
        throw new ComputationException(paramK);
      }
    }
    
    public final V get(Object paramObject)
    {
      Object localObject = a(paramObject);
      Preconditions.checkNotNull(localObject, "%s returned null for key %s.", new Object[] { this.a, paramObject });
      a(paramObject, localObject);
      return (V)localObject;
    }
  }
  
  static class c<K, V>
    extends AbstractMap<K, V>
    implements Serializable, ConcurrentMap<K, V>
  {
    private static final long serialVersionUID = 0L;
    private final MapMaker.e<K, V> a;
    private final MapMaker.d b;
    
    c(MapMaker paramMapMaker)
    {
      this.a = paramMapMaker.a();
      this.b = paramMapMaker.j;
    }
    
    final void a(K paramK, V paramV)
    {
      new MapMaker.f(paramK, paramV, this.b);
    }
    
    public boolean containsKey(@Nullable Object paramObject)
    {
      return false;
    }
    
    public boolean containsValue(@Nullable Object paramObject)
    {
      return false;
    }
    
    public Set<Map.Entry<K, V>> entrySet()
    {
      return Collections.emptySet();
    }
    
    public V get(@Nullable Object paramObject)
    {
      return null;
    }
    
    public V put(K paramK, V paramV)
    {
      Preconditions.checkNotNull(paramK);
      Preconditions.checkNotNull(paramV);
      a(paramK, paramV);
      return null;
    }
    
    public V putIfAbsent(K paramK, V paramV)
    {
      return (V)put(paramK, paramV);
    }
    
    public V remove(@Nullable Object paramObject)
    {
      return null;
    }
    
    public boolean remove(@Nullable Object paramObject1, @Nullable Object paramObject2)
    {
      return false;
    }
    
    public V replace(K paramK, V paramV)
    {
      Preconditions.checkNotNull(paramK);
      Preconditions.checkNotNull(paramV);
      return null;
    }
    
    public boolean replace(K paramK, @Nullable V paramV1, V paramV2)
    {
      Preconditions.checkNotNull(paramK);
      Preconditions.checkNotNull(paramV2);
      return false;
    }
  }
  
  public static abstract enum d
  {
    private d() {}
  }
  
  public static abstract interface e<K, V> {}
  
  public static final class f<K, V>
    extends oq<K, V>
  {
    private static final long serialVersionUID = 0L;
    private final MapMaker.d a;
    
    public f(@Nullable K paramK, @Nullable V paramV, MapMaker.d paramd)
    {
      super(paramV);
      this.a = paramd;
    }
  }
}


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