package com.google.common.cache;

import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.TimeUnit;
import javax.annotation.Nullable;
import mm.s;

@Beta
public final class CacheBuilderSpec
{
  private static final Splitter n = Splitter.on(',').trimResults();
  private static final Splitter o = Splitter.on('=').trimResults();
  private static final ImmutableMap<String, l> p = ImmutableMap.builder().put("initialCapacity", new d()).put("maximumSize", new h()).put("maximumWeight", new i()).put("concurrencyLevel", new b()).put("weakKeys", new f(mm.s.c)).put("softValues", new m(mm.s.b)).put("weakValues", new m(mm.s.c)).put("recordStats", new j()).put("expireAfterAccess", new a()).put("expireAfterWrite", new n()).put("refreshAfterWrite", new k()).put("refreshInterval", new k()).build();
  @VisibleForTesting
  Integer a;
  @VisibleForTesting
  Long b;
  @VisibleForTesting
  Long c;
  @VisibleForTesting
  Integer d;
  @VisibleForTesting
  mm.s e;
  @VisibleForTesting
  mm.s f;
  @VisibleForTesting
  Boolean g;
  @VisibleForTesting
  long h;
  @VisibleForTesting
  TimeUnit i;
  @VisibleForTesting
  long j;
  @VisibleForTesting
  TimeUnit k;
  @VisibleForTesting
  long l;
  @VisibleForTesting
  TimeUnit m;
  private final String q;
  
  private CacheBuilderSpec(String paramString)
  {
    this.q = paramString;
  }
  
  @Nullable
  private static Long a(long paramLong, @Nullable TimeUnit paramTimeUnit)
  {
    if (paramTimeUnit == null) {
      return null;
    }
    return Long.valueOf(paramTimeUnit.toNanos(paramLong));
  }
  
  public static CacheBuilderSpec disableCaching()
  {
    return parse("maximumSize=0");
  }
  
  public static CacheBuilderSpec parse(String paramString)
  {
    CacheBuilderSpec localCacheBuilderSpec = new CacheBuilderSpec(paramString);
    if (!paramString.isEmpty())
    {
      Iterator localIterator = n.split(paramString).iterator();
      if (localIterator.hasNext())
      {
        String str = (String)localIterator.next();
        paramString = ImmutableList.copyOf(o.split(str));
        boolean bool;
        label72:
        label90:
        l locall;
        if (!paramString.isEmpty())
        {
          bool = true;
          Preconditions.checkArgument(bool, "blank key-value pair");
          if (paramString.size() > 2) {
            break label183;
          }
          bool = true;
          Preconditions.checkArgument(bool, "key-value pair %s with more than one equals sign", new Object[] { str });
          str = (String)paramString.get(0);
          locall = (l)p.get(str);
          if (locall == null) {
            break label188;
          }
          bool = true;
          label137:
          Preconditions.checkArgument(bool, "unknown key %s", new Object[] { str });
          if (paramString.size() != 1) {
            break label193;
          }
        }
        label183:
        label188:
        label193:
        for (paramString = null;; paramString = (String)paramString.get(1))
        {
          locall.a(localCacheBuilderSpec, str, paramString);
          break;
          bool = false;
          break label72;
          bool = false;
          break label90;
          bool = false;
          break label137;
        }
      }
    }
    return localCacheBuilderSpec;
  }
  
  public final boolean equals(@Nullable Object paramObject)
  {
    if (this == paramObject) {}
    do
    {
      return true;
      if (!(paramObject instanceof CacheBuilderSpec)) {
        return false;
      }
      paramObject = (CacheBuilderSpec)paramObject;
    } while ((Objects.equal(this.a, ((CacheBuilderSpec)paramObject).a)) && (Objects.equal(this.b, ((CacheBuilderSpec)paramObject).b)) && (Objects.equal(this.c, ((CacheBuilderSpec)paramObject).c)) && (Objects.equal(this.d, ((CacheBuilderSpec)paramObject).d)) && (Objects.equal(this.e, ((CacheBuilderSpec)paramObject).e)) && (Objects.equal(this.f, ((CacheBuilderSpec)paramObject).f)) && (Objects.equal(this.g, ((CacheBuilderSpec)paramObject).g)) && (Objects.equal(a(this.h, this.i), a(((CacheBuilderSpec)paramObject).h, ((CacheBuilderSpec)paramObject).i))) && (Objects.equal(a(this.j, this.k), a(((CacheBuilderSpec)paramObject).j, ((CacheBuilderSpec)paramObject).k))) && (Objects.equal(a(this.l, this.m), a(((CacheBuilderSpec)paramObject).l, ((CacheBuilderSpec)paramObject).m))));
    return false;
  }
  
  public final int hashCode()
  {
    return Objects.hashCode(new Object[] { this.a, this.b, this.c, this.d, this.e, this.f, this.g, a(this.h, this.i), a(this.j, this.k), a(this.l, this.m) });
  }
  
  public final String toParsableString()
  {
    return this.q;
  }
  
  public final String toString()
  {
    return MoreObjects.toStringHelper(this).addValue(toParsableString()).toString();
  }
  
  static final class a
    extends CacheBuilderSpec.c
  {
    protected final void a(CacheBuilderSpec paramCacheBuilderSpec, long paramLong, TimeUnit paramTimeUnit)
    {
      if (paramCacheBuilderSpec.k == null) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "expireAfterAccess already set");
        paramCacheBuilderSpec.j = paramLong;
        paramCacheBuilderSpec.k = paramTimeUnit;
        return;
      }
    }
  }
  
  static final class b
    extends CacheBuilderSpec.e
  {
    protected final void a(CacheBuilderSpec paramCacheBuilderSpec, int paramInt)
    {
      if (paramCacheBuilderSpec.d == null) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "concurrency level was already set to ", new Object[] { paramCacheBuilderSpec.d });
        paramCacheBuilderSpec.d = Integer.valueOf(paramInt);
        return;
      }
    }
  }
  
  static abstract class c
    implements CacheBuilderSpec.l
  {
    protected abstract void a(CacheBuilderSpec paramCacheBuilderSpec, long paramLong, TimeUnit paramTimeUnit);
    
    public final void a(CacheBuilderSpec paramCacheBuilderSpec, String paramString1, String paramString2)
    {
      boolean bool;
      if ((paramString2 != null) && (!paramString2.isEmpty()))
      {
        bool = true;
        Preconditions.checkArgument(bool, "value of key %s omitted", new Object[] { paramString1 });
      }
      for (;;)
      {
        try
        {
          switch (paramString2.charAt(paramString2.length() - 1))
          {
          case 'd': 
            throw new IllegalArgumentException(String.format("key %s invalid format.  was %s, must end with one of [dDhHmMsS]", new Object[] { paramString1, paramString2 }));
          }
        }
        catch (NumberFormatException paramCacheBuilderSpec)
        {
          throw new IllegalArgumentException(String.format("key %s value set to %s, must be integer", new Object[] { paramString1, paramString2 }));
        }
        bool = false;
        break;
        TimeUnit localTimeUnit = TimeUnit.DAYS;
        for (;;)
        {
          a(paramCacheBuilderSpec, Long.parseLong(paramString2.substring(0, paramString2.length() - 1)), localTimeUnit);
          return;
          localTimeUnit = TimeUnit.HOURS;
          continue;
          localTimeUnit = TimeUnit.MINUTES;
          continue;
          localTimeUnit = TimeUnit.SECONDS;
        }
      }
    }
  }
  
  static final class d
    extends CacheBuilderSpec.e
  {
    protected final void a(CacheBuilderSpec paramCacheBuilderSpec, int paramInt)
    {
      if (paramCacheBuilderSpec.a == null) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "initial capacity was already set to ", new Object[] { paramCacheBuilderSpec.a });
        paramCacheBuilderSpec.a = Integer.valueOf(paramInt);
        return;
      }
    }
  }
  
  static abstract class e
    implements CacheBuilderSpec.l
  {
    protected abstract void a(CacheBuilderSpec paramCacheBuilderSpec, int paramInt);
    
    public final void a(CacheBuilderSpec paramCacheBuilderSpec, String paramString1, String paramString2)
    {
      if ((paramString2 != null) && (!paramString2.isEmpty())) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "value of key %s omitted", new Object[] { paramString1 });
        try
        {
          a(paramCacheBuilderSpec, Integer.parseInt(paramString2));
          return;
        }
        catch (NumberFormatException paramCacheBuilderSpec)
        {
          throw new IllegalArgumentException(String.format("key %s value set to %s, must be integer", new Object[] { paramString1, paramString2 }), paramCacheBuilderSpec);
        }
      }
    }
  }
  
  static final class f
    implements CacheBuilderSpec.l
  {
    private final mm.s a;
    
    public f(mm.s params)
    {
      this.a = params;
    }
    
    public final void a(CacheBuilderSpec paramCacheBuilderSpec, String paramString1, @Nullable String paramString2)
    {
      if (paramString2 == null)
      {
        bool = true;
        Preconditions.checkArgument(bool, "key %s does not take values", new Object[] { paramString1 });
        if (paramCacheBuilderSpec.e != null) {
          break label69;
        }
      }
      label69:
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "%s was already set to %s", new Object[] { paramString1, paramCacheBuilderSpec.e });
        paramCacheBuilderSpec.e = this.a;
        return;
        bool = false;
        break;
      }
    }
  }
  
  static abstract class g
    implements CacheBuilderSpec.l
  {
    protected abstract void a(CacheBuilderSpec paramCacheBuilderSpec, long paramLong);
    
    public final void a(CacheBuilderSpec paramCacheBuilderSpec, String paramString1, String paramString2)
    {
      if ((paramString2 != null) && (!paramString2.isEmpty())) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "value of key %s omitted", new Object[] { paramString1 });
        try
        {
          a(paramCacheBuilderSpec, Long.parseLong(paramString2));
          return;
        }
        catch (NumberFormatException paramCacheBuilderSpec)
        {
          throw new IllegalArgumentException(String.format("key %s value set to %s, must be integer", new Object[] { paramString1, paramString2 }), paramCacheBuilderSpec);
        }
      }
    }
  }
  
  static final class h
    extends CacheBuilderSpec.g
  {
    protected final void a(CacheBuilderSpec paramCacheBuilderSpec, long paramLong)
    {
      if (paramCacheBuilderSpec.b == null)
      {
        bool = true;
        Preconditions.checkArgument(bool, "maximum size was already set to ", new Object[] { paramCacheBuilderSpec.b });
        if (paramCacheBuilderSpec.c != null) {
          break label71;
        }
      }
      label71:
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "maximum weight was already set to ", new Object[] { paramCacheBuilderSpec.c });
        paramCacheBuilderSpec.b = Long.valueOf(paramLong);
        return;
        bool = false;
        break;
      }
    }
  }
  
  static final class i
    extends CacheBuilderSpec.g
  {
    protected final void a(CacheBuilderSpec paramCacheBuilderSpec, long paramLong)
    {
      if (paramCacheBuilderSpec.c == null)
      {
        bool = true;
        Preconditions.checkArgument(bool, "maximum weight was already set to ", new Object[] { paramCacheBuilderSpec.c });
        if (paramCacheBuilderSpec.b != null) {
          break label71;
        }
      }
      label71:
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "maximum size was already set to ", new Object[] { paramCacheBuilderSpec.b });
        paramCacheBuilderSpec.c = Long.valueOf(paramLong);
        return;
        bool = false;
        break;
      }
    }
  }
  
  static final class j
    implements CacheBuilderSpec.l
  {
    public final void a(CacheBuilderSpec paramCacheBuilderSpec, String paramString1, @Nullable String paramString2)
    {
      boolean bool2 = false;
      if (paramString2 == null) {}
      for (boolean bool1 = true;; bool1 = false)
      {
        Preconditions.checkArgument(bool1, "recordStats does not take values");
        bool1 = bool2;
        if (paramCacheBuilderSpec.g == null) {
          bool1 = true;
        }
        Preconditions.checkArgument(bool1, "recordStats already set");
        paramCacheBuilderSpec.g = Boolean.valueOf(true);
        return;
      }
    }
  }
  
  static final class k
    extends CacheBuilderSpec.c
  {
    protected final void a(CacheBuilderSpec paramCacheBuilderSpec, long paramLong, TimeUnit paramTimeUnit)
    {
      if (paramCacheBuilderSpec.m == null) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "refreshAfterWrite already set");
        paramCacheBuilderSpec.l = paramLong;
        paramCacheBuilderSpec.m = paramTimeUnit;
        return;
      }
    }
  }
  
  static abstract interface l
  {
    public abstract void a(CacheBuilderSpec paramCacheBuilderSpec, String paramString1, @Nullable String paramString2);
  }
  
  static final class m
    implements CacheBuilderSpec.l
  {
    private final mm.s a;
    
    public m(mm.s params)
    {
      this.a = params;
    }
    
    public final void a(CacheBuilderSpec paramCacheBuilderSpec, String paramString1, @Nullable String paramString2)
    {
      if (paramString2 == null)
      {
        bool = true;
        Preconditions.checkArgument(bool, "key %s does not take values", new Object[] { paramString1 });
        if (paramCacheBuilderSpec.f != null) {
          break label69;
        }
      }
      label69:
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "%s was already set to %s", new Object[] { paramString1, paramCacheBuilderSpec.f });
        paramCacheBuilderSpec.f = this.a;
        return;
        bool = false;
        break;
      }
    }
  }
  
  static final class n
    extends CacheBuilderSpec.c
  {
    protected final void a(CacheBuilderSpec paramCacheBuilderSpec, long paramLong, TimeUnit paramTimeUnit)
    {
      if (paramCacheBuilderSpec.i == null) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "expireAfterWrite already set");
        paramCacheBuilderSpec.h = paramLong;
        paramCacheBuilderSpec.i = paramTimeUnit;
        return;
      }
    }
  }
}


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