package com.google.common.util.concurrent;

import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.base.Stopwatch;
import java.util.concurrent.TimeUnit;
import javax.annotation.concurrent.ThreadSafe;
import rq.a;
import rq.b;

@Beta
@ThreadSafe
public abstract class RateLimiter
{
  private final a a;
  private volatile Object b;
  
  protected RateLimiter(a parama)
  {
    this.a = ((a)Preconditions.checkNotNull(parama));
  }
  
  private long a(int paramInt)
  {
    b(paramInt);
    synchronized (c())
    {
      long l = b(paramInt, this.a.a());
      return l;
    }
  }
  
  private static int b(int paramInt)
  {
    if (paramInt > 0) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "Requested permits (%s) must be positive", new Object[] { Integer.valueOf(paramInt) });
      return paramInt;
    }
  }
  
  private long b(int paramInt, long paramLong)
  {
    return Math.max(a(paramInt, paramLong) - paramLong, 0L);
  }
  
  private Object c()
  {
    Object localObject1 = this.b;
    if (localObject1 == null) {
      try
      {
        Object localObject3 = this.b;
        localObject1 = localObject3;
        if (localObject3 == null)
        {
          localObject1 = new Object();
          this.b = localObject1;
        }
        return localObject1;
      }
      finally {}
    }
    return localObject2;
  }
  
  public static RateLimiter create(double paramDouble)
  {
    rq.a locala = new rq.a(new RateLimiter.a.1());
    locala.setRate(paramDouble);
    return locala;
  }
  
  public static RateLimiter create(double paramDouble, long paramLong, TimeUnit paramTimeUnit)
  {
    if (paramLong >= 0L) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "warmupPeriod must not be negative: %s", new Object[] { Long.valueOf(paramLong) });
      paramTimeUnit = new rq.b(new RateLimiter.a.1(), paramLong, paramTimeUnit);
      paramTimeUnit.setRate(paramDouble);
      return paramTimeUnit;
    }
  }
  
  protected abstract double a();
  
  protected abstract long a(int paramInt, long paramLong);
  
  protected abstract void a(double paramDouble, long paramLong);
  
  public double acquire()
  {
    return acquire(1);
  }
  
  public double acquire(int paramInt)
  {
    long l = a(paramInt);
    this.a.a(l);
    return l * 1.0D / TimeUnit.SECONDS.toMicros(1L);
  }
  
  protected abstract long b();
  
  public final double getRate()
  {
    synchronized (c())
    {
      double d = a();
      return d;
    }
  }
  
  public final void setRate(double paramDouble)
  {
    if ((paramDouble > 0.0D) && (!Double.isNaN(paramDouble))) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "rate must be positive");
      synchronized (c())
      {
        a(paramDouble, this.a.a());
        return;
      }
    }
  }
  
  public String toString()
  {
    return String.format("RateLimiter[stableRate=%3.1fqps]", new Object[] { Double.valueOf(getRate()) });
  }
  
  public boolean tryAcquire()
  {
    return tryAcquire(1, 0L, TimeUnit.MICROSECONDS);
  }
  
  public boolean tryAcquire(int paramInt)
  {
    return tryAcquire(paramInt, 0L, TimeUnit.MICROSECONDS);
  }
  
  public boolean tryAcquire(int paramInt, long paramLong, TimeUnit arg4)
  {
    paramLong = Math.max(???.toMicros(paramLong), 0L);
    b(paramInt);
    for (;;)
    {
      synchronized (c())
      {
        long l = this.a.a();
        if (b() - paramLong <= l)
        {
          i = 1;
          if (i == 0) {
            return false;
          }
          paramLong = b(paramInt, l);
          this.a.a(paramLong);
          return true;
        }
      }
      int i = 0;
    }
  }
  
  public boolean tryAcquire(long paramLong, TimeUnit paramTimeUnit)
  {
    return tryAcquire(1, paramLong, paramTimeUnit);
  }
  
  @VisibleForTesting
  public static abstract class a
  {
    abstract long a();
    
    abstract void a(long paramLong);
  }
}


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