package com.google.common.cache;

import com.google.common.base.Ascii;
import com.google.common.base.Equivalence;
import com.google.common.base.Objects;
import com.google.common.base.Objects.ToStringHelper;
import com.google.common.base.Preconditions;
import com.google.common.base.Supplier;
import com.google.common.base.Suppliers;
import com.google.common.base.Ticker;
import java.util.logging.Level;
import java.util.logging.Logger;

public final class CacheBuilder<K, V>
{
  static final Supplier<AbstractCache.StatsCounter> CACHE_STATS_COUNTER = new Supplier()
  {
    public AbstractCache.StatsCounter get()
    {
      return new AbstractCache.SimpleStatsCounter();
    }
  };
  static final CacheStats EMPTY_STATS;
  static final Supplier<? extends AbstractCache.StatsCounter> NULL_STATS_COUNTER = Suppliers.ofInstance(new AbstractCache.StatsCounter()
  {
    public void recordEviction()
    {
    }

    public void recordHits(int paramAnonymousInt)
    {
    }

    public void recordLoadException(long paramAnonymousLong)
    {
    }

    public void recordLoadSuccess(long paramAnonymousLong)
    {
    }

    public void recordMisses(int paramAnonymousInt)
    {
    }
  });
  static final Ticker NULL_TICKER = new Ticker()
  {
    public long read()
    {
      return 0L;
    }
  };
  private static final Logger logger = Logger.getLogger(CacheBuilder.class.getName());
  int concurrencyLevel = -1;
  long expireAfterAccessNanos = -1L;
  long expireAfterWriteNanos = -1L;
  int initialCapacity = -1;
  Equivalence<Object> keyEquivalence;
  LocalCache.Strength keyStrength;
  long maximumSize = -1L;
  long maximumWeight = -1L;
  long refreshNanos = -1L;
  RemovalListener<? super K, ? super V> removalListener;
  Supplier<? extends AbstractCache.StatsCounter> statsCounterSupplier = NULL_STATS_COUNTER;
  boolean strictParsing = true;
  Ticker ticker;
  Equivalence<Object> valueEquivalence;
  LocalCache.Strength valueStrength;
  Weigher<? super K, ? super V> weigher;

  static
  {
    EMPTY_STATS = new CacheStats(0L, 0L, 0L, 0L, 0L, 0L);
  }

  private void checkWeightWithWeigher()
  {
    boolean bool = true;
    if (this.weigher == null)
      if (this.maximumWeight == -1L)
        Preconditions.checkState(bool, "maximumWeight requires weigher");
    do
    {
      return;
      bool = false;
      break;
      if (this.strictParsing)
      {
        if (this.maximumWeight != -1L);
        while (true)
        {
          Preconditions.checkState(bool, "weigher requires maximumWeight");
          return;
          bool = false;
        }
      }
    }
    while (this.maximumWeight != -1L);
    logger.log(Level.WARNING, "ignoring weigher specified without maximumWeight");
  }

  public static CacheBuilder<Object, Object> newBuilder()
  {
    return new CacheBuilder();
  }

  public <K1 extends K, V1 extends V> LoadingCache<K1, V1> build(CacheLoader<? super K1, V1> paramCacheLoader)
  {
    checkWeightWithWeigher();
    return new LocalCache.LocalLoadingCache(this, paramCacheLoader);
  }

  int getConcurrencyLevel()
  {
    if (this.concurrencyLevel == -1)
      return 4;
    return this.concurrencyLevel;
  }

  long getExpireAfterAccessNanos()
  {
    if (this.expireAfterAccessNanos == -1L)
      return 0L;
    return this.expireAfterAccessNanos;
  }

  long getExpireAfterWriteNanos()
  {
    if (this.expireAfterWriteNanos == -1L)
      return 0L;
    return this.expireAfterWriteNanos;
  }

  int getInitialCapacity()
  {
    if (this.initialCapacity == -1)
      return 16;
    return this.initialCapacity;
  }

  Equivalence<Object> getKeyEquivalence()
  {
    return (Equivalence)Objects.firstNonNull(this.keyEquivalence, getKeyStrength().defaultEquivalence());
  }

  LocalCache.Strength getKeyStrength()
  {
    return (LocalCache.Strength)Objects.firstNonNull(this.keyStrength, LocalCache.Strength.STRONG);
  }

  long getMaximumWeight()
  {
    if ((this.expireAfterWriteNanos == 0L) || (this.expireAfterAccessNanos == 0L))
      return 0L;
    if (this.weigher == null)
      return this.maximumSize;
    return this.maximumWeight;
  }

  long getRefreshNanos()
  {
    if (this.refreshNanos == -1L)
      return 0L;
    return this.refreshNanos;
  }

  <K1 extends K, V1 extends V> RemovalListener<K1, V1> getRemovalListener()
  {
    return (RemovalListener)Objects.firstNonNull(this.removalListener, NullListener.INSTANCE);
  }

  Supplier<? extends AbstractCache.StatsCounter> getStatsCounterSupplier()
  {
    return this.statsCounterSupplier;
  }

  Ticker getTicker(boolean paramBoolean)
  {
    if (this.ticker != null)
      return this.ticker;
    if (paramBoolean)
      return Ticker.systemTicker();
    return NULL_TICKER;
  }

  Equivalence<Object> getValueEquivalence()
  {
    return (Equivalence)Objects.firstNonNull(this.valueEquivalence, getValueStrength().defaultEquivalence());
  }

  LocalCache.Strength getValueStrength()
  {
    return (LocalCache.Strength)Objects.firstNonNull(this.valueStrength, LocalCache.Strength.STRONG);
  }

  <K1 extends K, V1 extends V> Weigher<K1, V1> getWeigher()
  {
    return (Weigher)Objects.firstNonNull(this.weigher, OneWeigher.INSTANCE);
  }

  CacheBuilder<K, V> setKeyStrength(LocalCache.Strength paramStrength)
  {
    if (this.keyStrength == null);
    for (boolean bool = true; ; bool = false)
    {
      Object[] arrayOfObject = new Object[1];
      arrayOfObject[0] = this.keyStrength;
      Preconditions.checkState(bool, "Key strength was already set to %s", arrayOfObject);
      this.keyStrength = ((LocalCache.Strength)Preconditions.checkNotNull(paramStrength));
      return this;
    }
  }

  public String toString()
  {
    Objects.ToStringHelper localToStringHelper = Objects.toStringHelper(this);
    if (this.initialCapacity != -1)
      localToStringHelper.add("initialCapacity", this.initialCapacity);
    if (this.concurrencyLevel != -1)
      localToStringHelper.add("concurrencyLevel", this.concurrencyLevel);
    if (this.maximumSize != -1L)
      localToStringHelper.add("maximumSize", this.maximumSize);
    if (this.maximumWeight != -1L)
      localToStringHelper.add("maximumWeight", this.maximumWeight);
    if (this.expireAfterWriteNanos != -1L)
      localToStringHelper.add("expireAfterWrite", this.expireAfterWriteNanos + "ns");
    if (this.expireAfterAccessNanos != -1L)
      localToStringHelper.add("expireAfterAccess", this.expireAfterAccessNanos + "ns");
    if (this.keyStrength != null)
      localToStringHelper.add("keyStrength", Ascii.toLowerCase(this.keyStrength.toString()));
    if (this.valueStrength != null)
      localToStringHelper.add("valueStrength", Ascii.toLowerCase(this.valueStrength.toString()));
    if (this.keyEquivalence != null)
      localToStringHelper.addValue("keyEquivalence");
    if (this.valueEquivalence != null)
      localToStringHelper.addValue("valueEquivalence");
    if (this.removalListener != null)
      localToStringHelper.addValue("removalListener");
    return localToStringHelper.toString();
  }

  public CacheBuilder<K, V> weakKeys()
  {
    return setKeyStrength(LocalCache.Strength.WEAK);
  }

  static enum NullListener
    implements RemovalListener<Object, Object>
  {
    static
    {
      NullListener[] arrayOfNullListener = new NullListener[1];
      arrayOfNullListener[0] = INSTANCE;
    }

    public void onRemoval(RemovalNotification<Object, Object> paramRemovalNotification)
    {
    }
  }

  static enum OneWeigher
    implements Weigher<Object, Object>
  {
    static
    {
      OneWeigher[] arrayOfOneWeigher = new OneWeigher[1];
      arrayOfOneWeigher[0] = INSTANCE;
    }

    public int weigh(Object paramObject1, Object paramObject2)
    {
      return 1;
    }
  }
}

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