package com.google.common.util.concurrent;

import com.google.common.base.Preconditions;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import javax.annotation.Nullable;

public abstract class AbstractFuture<V>
  implements ListenableFuture<V>
{
  private final a<V> a = new a();
  private final ExecutionList b = new ExecutionList();
  
  static final CancellationException a(@Nullable String paramString, @Nullable Throwable paramThrowable)
  {
    paramString = new CancellationException(paramString);
    paramString.initCause(paramThrowable);
    return paramString;
  }
  
  public void addListener(Runnable paramRunnable, Executor paramExecutor)
  {
    this.b.add(paramRunnable, paramExecutor);
  }
  
  public boolean cancel(boolean paramBoolean)
  {
    a locala = this.a;
    if (paramBoolean) {}
    for (int i = 8; !locala.a(null, null, i); i = 4) {
      return false;
    }
    this.b.execute();
    if (paramBoolean) {
      interruptTask();
    }
    return true;
  }
  
  public V get()
    throws InterruptedException, ExecutionException
  {
    a locala = this.a;
    locala.acquireSharedInterruptibly(-1);
    return (V)locala.a();
  }
  
  public V get(long paramLong, TimeUnit paramTimeUnit)
    throws InterruptedException, TimeoutException, ExecutionException
  {
    a locala = this.a;
    if (!locala.tryAcquireSharedNanos(-1, paramTimeUnit.toNanos(paramLong))) {
      throw new TimeoutException("Timeout waiting for task.");
    }
    return (V)locala.a();
  }
  
  protected void interruptTask() {}
  
  public boolean isCancelled()
  {
    return this.a.c();
  }
  
  public boolean isDone()
  {
    return this.a.b();
  }
  
  protected boolean set(@Nullable V paramV)
  {
    boolean bool = this.a.a(paramV, null, 2);
    if (bool) {
      this.b.execute();
    }
    return bool;
  }
  
  protected boolean setException(Throwable paramThrowable)
  {
    boolean bool = this.a.a(null, (Throwable)Preconditions.checkNotNull(paramThrowable), 2);
    if (bool) {
      this.b.execute();
    }
    return bool;
  }
  
  protected final boolean wasInterrupted()
  {
    return this.a.d();
  }
  
  static final class a<V>
    extends AbstractQueuedSynchronizer
  {
    private static final long serialVersionUID = 0L;
    private V a;
    private Throwable b;
    
    final V a()
      throws CancellationException, ExecutionException
    {
      int i = getState();
      switch (i)
      {
      default: 
        throw new IllegalStateException(49 + "Error, synchronizer in invalid state: " + i);
      case 2: 
        if (this.b != null) {
          throw new ExecutionException(this.b);
        }
        return (V)this.a;
      }
      throw AbstractFuture.a("Task was cancelled.", this.b);
    }
    
    final boolean a(@Nullable V paramV, @Nullable Throwable paramThrowable, int paramInt)
    {
      boolean bool = compareAndSetState(0, 1);
      if (bool)
      {
        this.a = paramV;
        if ((paramInt & 0xC) != 0) {
          paramThrowable = new CancellationException("Future.cancel() was called.");
        }
        this.b = paramThrowable;
        releaseShared(paramInt);
      }
      while (getState() != 1) {
        return bool;
      }
      acquireShared(-1);
      return bool;
    }
    
    final boolean b()
    {
      return (getState() & 0xE) != 0;
    }
    
    final boolean c()
    {
      return (getState() & 0xC) != 0;
    }
    
    final boolean d()
    {
      return getState() == 8;
    }
    
    protected final int tryAcquireShared(int paramInt)
    {
      if (b()) {
        return 1;
      }
      return -1;
    }
    
    protected final boolean tryReleaseShared(int paramInt)
    {
      setState(paramInt);
      return true;
    }
  }
}


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