package com.google.common.util.concurrent;

import com.google.common.annotations.Beta;
import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;
import com.google.common.collect.Queues;
import com.google.common.collect.Sets;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.Future;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.Nullable;
import rn;
import rn.a;
import rp;

@Beta
public final class Futures
{
  private static final AsyncFunction<ListenableFuture<Object>, Object> a = new AsyncFunction() {};
  private static final Ordering<Constructor<?>> b = Ordering.natural().onResultOf(new Function() {}).reverse();
  
  private static <I, O> AsyncFunction<I, O> a(Function<? super I, ? extends O> paramFunction)
  {
    new AsyncFunction()
    {
      public final ListenableFuture<O> apply(I paramAnonymousI)
      {
        return Futures.immediateFuture(this.a.apply(paramAnonymousI));
      }
    };
  }
  
  private static <V> ListenableFuture<List<V>> a(ImmutableList<ListenableFuture<? extends V>> paramImmutableList, boolean paramBoolean, Executor paramExecutor)
  {
    new b(paramImmutableList, paramBoolean, paramExecutor, new d() {});
  }
  
  private static <X extends Exception> X a(Class<X> paramClass, Throwable paramThrowable)
  {
    Object localObject = Arrays.asList(paramClass.getConstructors());
    localObject = b.sortedCopy((Iterable)localObject).iterator();
    while (((Iterator)localObject).hasNext())
    {
      Exception localException = (Exception)a((Constructor)((Iterator)localObject).next(), paramThrowable);
      if (localException != null)
      {
        if (localException.getCause() == null) {
          localException.initCause(paramThrowable);
        }
        return localException;
      }
    }
    paramClass = String.valueOf(String.valueOf(paramClass));
    throw new IllegalArgumentException(paramClass.length() + 82 + "No appropriate constructor for exception of type " + paramClass + " in response to chained exception", paramThrowable);
  }
  
  @Nullable
  private static <X> X a(Constructor<X> paramConstructor, Throwable paramThrowable)
  {
    Class[] arrayOfClass = paramConstructor.getParameterTypes();
    Object[] arrayOfObject = new Object[arrayOfClass.length];
    int i = 0;
    if (i < arrayOfClass.length)
    {
      Class localClass = arrayOfClass[i];
      if (localClass.equals(String.class)) {
        arrayOfObject[i] = paramThrowable.toString();
      }
      for (;;)
      {
        i += 1;
        break;
        if (!localClass.equals(Throwable.class)) {
          break label68;
        }
        arrayOfObject[i] = paramThrowable;
      }
      label68:
      return null;
    }
    try
    {
      paramConstructor = paramConstructor.newInstance(arrayOfObject);
      return paramConstructor;
    }
    catch (IllegalArgumentException paramConstructor)
    {
      return null;
    }
    catch (InstantiationException paramConstructor)
    {
      return null;
    }
    catch (IllegalAccessException paramConstructor)
    {
      return null;
    }
    catch (InvocationTargetException paramConstructor) {}
    return null;
  }
  
  private static <X extends Exception> void a(Throwable paramThrowable, Class<X> paramClass)
    throws Exception
  {
    if ((paramThrowable instanceof Error)) {
      throw new ExecutionError((Error)paramThrowable);
    }
    if ((paramThrowable instanceof RuntimeException)) {
      throw new UncheckedExecutionException(paramThrowable);
    }
    throw a(paramClass, paramThrowable);
  }
  
  public static <V> void addCallback(ListenableFuture<V> paramListenableFuture, FutureCallback<? super V> paramFutureCallback)
  {
    addCallback(paramListenableFuture, paramFutureCallback, MoreExecutors.directExecutor());
  }
  
  public static <V> void addCallback(ListenableFuture<V> paramListenableFuture, final FutureCallback<? super V> paramFutureCallback, Executor paramExecutor)
  {
    Preconditions.checkNotNull(paramFutureCallback);
    paramListenableFuture.addListener(new Runnable()
    {
      public final void run()
      {
        try
        {
          Object localObject = Uninterruptibles.getUninterruptibly(this.a);
          paramFutureCallback.onSuccess(localObject);
          return;
        }
        catch (ExecutionException localExecutionException)
        {
          paramFutureCallback.onFailure(localExecutionException.getCause());
          return;
        }
        catch (RuntimeException localRuntimeException)
        {
          paramFutureCallback.onFailure(localRuntimeException);
          return;
        }
        catch (Error localError)
        {
          paramFutureCallback.onFailure(localError);
        }
      }
    }, paramExecutor);
  }
  
  @Beta
  public static <V> ListenableFuture<List<V>> allAsList(Iterable<? extends ListenableFuture<? extends V>> paramIterable)
  {
    return a(ImmutableList.copyOf(paramIterable), true, MoreExecutors.directExecutor());
  }
  
  @Beta
  public static <V> ListenableFuture<List<V>> allAsList(ListenableFuture<? extends V>... paramVarArgs)
  {
    return a(ImmutableList.copyOf(paramVarArgs), true, MoreExecutors.directExecutor());
  }
  
  public static <V> ListenableFuture<V> dereference(ListenableFuture<? extends ListenableFuture<? extends V>> paramListenableFuture)
  {
    return transform(paramListenableFuture, a);
  }
  
  public static <V, X extends Exception> V get(Future<V> paramFuture, long paramLong, TimeUnit paramTimeUnit, Class<X> paramClass)
    throws Exception
  {
    Preconditions.checkNotNull(paramFuture);
    Preconditions.checkNotNull(paramTimeUnit);
    if (!RuntimeException.class.isAssignableFrom(paramClass)) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "Futures.get exception type (%s) must not be a RuntimeException", new Object[] { paramClass });
      try
      {
        paramFuture = paramFuture.get(paramLong, paramTimeUnit);
        return paramFuture;
      }
      catch (InterruptedException paramFuture)
      {
        Thread.currentThread().interrupt();
        throw a(paramClass, paramFuture);
      }
      catch (TimeoutException paramFuture)
      {
        throw a(paramClass, paramFuture);
      }
      catch (ExecutionException paramFuture)
      {
        a(paramFuture.getCause(), paramClass);
        throw new AssertionError();
      }
    }
  }
  
  public static <V, X extends Exception> V get(Future<V> paramFuture, Class<X> paramClass)
    throws Exception
  {
    Preconditions.checkNotNull(paramFuture);
    if (!RuntimeException.class.isAssignableFrom(paramClass)) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "Futures.get exception type (%s) must not be a RuntimeException", new Object[] { paramClass });
      try
      {
        paramFuture = paramFuture.get();
        return paramFuture;
      }
      catch (InterruptedException paramFuture)
      {
        Thread.currentThread().interrupt();
        throw a(paramClass, paramFuture);
      }
      catch (ExecutionException paramFuture)
      {
        a(paramFuture.getCause(), paramClass);
        throw new AssertionError();
      }
    }
  }
  
  public static <V> V getUnchecked(Future<V> paramFuture)
  {
    Preconditions.checkNotNull(paramFuture);
    try
    {
      paramFuture = Uninterruptibles.getUninterruptibly(paramFuture);
      return paramFuture;
    }
    catch (ExecutionException paramFuture)
    {
      paramFuture = paramFuture.getCause();
      if ((paramFuture instanceof Error)) {
        throw new ExecutionError((Error)paramFuture);
      }
      throw new UncheckedExecutionException(paramFuture);
    }
  }
  
  public static <V> ListenableFuture<V> immediateCancelledFuture()
  {
    return new e();
  }
  
  public static <V, X extends Exception> CheckedFuture<V, X> immediateCheckedFuture(@Nullable V paramV)
  {
    return new i(paramV);
  }
  
  public static <V, X extends Exception> CheckedFuture<V, X> immediateFailedCheckedFuture(X paramX)
  {
    Preconditions.checkNotNull(paramX);
    return new f(paramX);
  }
  
  public static <V> ListenableFuture<V> immediateFailedFuture(Throwable paramThrowable)
  {
    Preconditions.checkNotNull(paramThrowable);
    return new g(paramThrowable);
  }
  
  public static <V> ListenableFuture<V> immediateFuture(@Nullable V paramV)
  {
    return new j(paramV);
  }
  
  @Beta
  public static <T> ImmutableList<ListenableFuture<T>> inCompletionOrder(Iterable<? extends ListenableFuture<? extends T>> paramIterable)
  {
    ConcurrentLinkedQueue localConcurrentLinkedQueue = Queues.newConcurrentLinkedQueue();
    ImmutableList.Builder localBuilder = ImmutableList.builder();
    rp localrp = new rp(MoreExecutors.directExecutor());
    paramIterable = paramIterable.iterator();
    while (paramIterable.hasNext())
    {
      final ListenableFuture localListenableFuture = (ListenableFuture)paramIterable.next();
      rn localrn = rn.a();
      localConcurrentLinkedQueue.add(localrn);
      localListenableFuture.addListener(new Runnable()
      {
        public final void run()
        {
          rn localrn = (rn)this.a.remove();
          ListenableFuture localListenableFuture = localListenableFuture;
          localrn.a.a((ListenableFuture)Preconditions.checkNotNull(localListenableFuture));
        }
      }, localrp);
      localBuilder.add(localrn);
    }
    return localBuilder.build();
  }
  
  public static <I, O> Future<O> lazyTransform(Future<I> paramFuture, final Function<? super I, ? extends O> paramFunction)
  {
    Preconditions.checkNotNull(paramFuture);
    Preconditions.checkNotNull(paramFunction);
    new Future()
    {
      private O a(I paramAnonymousI)
        throws ExecutionException
      {
        try
        {
          paramAnonymousI = paramFunction.apply(paramAnonymousI);
          return paramAnonymousI;
        }
        catch (Throwable paramAnonymousI)
        {
          throw new ExecutionException(paramAnonymousI);
        }
      }
      
      public final boolean cancel(boolean paramAnonymousBoolean)
      {
        return this.a.cancel(paramAnonymousBoolean);
      }
      
      public final O get()
        throws InterruptedException, ExecutionException
      {
        return (O)a(this.a.get());
      }
      
      public final O get(long paramAnonymousLong, TimeUnit paramAnonymousTimeUnit)
        throws InterruptedException, ExecutionException, TimeoutException
      {
        return (O)a(this.a.get(paramAnonymousLong, paramAnonymousTimeUnit));
      }
      
      public final boolean isCancelled()
      {
        return this.a.isCancelled();
      }
      
      public final boolean isDone()
      {
        return this.a.isDone();
      }
    };
  }
  
  public static <V, X extends Exception> CheckedFuture<V, X> makeChecked(ListenableFuture<V> paramListenableFuture, Function<? super Exception, X> paramFunction)
  {
    return new k((ListenableFuture)Preconditions.checkNotNull(paramListenableFuture), paramFunction);
  }
  
  public static <V> ListenableFuture<V> nonCancellationPropagating(ListenableFuture<V> paramListenableFuture)
  {
    return new l(paramListenableFuture);
  }
  
  @Beta
  public static <V> ListenableFuture<List<V>> successfulAsList(Iterable<? extends ListenableFuture<? extends V>> paramIterable)
  {
    return a(ImmutableList.copyOf(paramIterable), false, MoreExecutors.directExecutor());
  }
  
  @Beta
  public static <V> ListenableFuture<List<V>> successfulAsList(ListenableFuture<? extends V>... paramVarArgs)
  {
    return a(ImmutableList.copyOf(paramVarArgs), false, MoreExecutors.directExecutor());
  }
  
  public static <I, O> ListenableFuture<O> transform(ListenableFuture<I> paramListenableFuture, Function<? super I, ? extends O> paramFunction)
  {
    Preconditions.checkNotNull(paramFunction);
    paramFunction = new a(a(paramFunction), paramListenableFuture, (byte)0);
    paramListenableFuture.addListener(paramFunction, MoreExecutors.directExecutor());
    return paramFunction;
  }
  
  public static <I, O> ListenableFuture<O> transform(ListenableFuture<I> paramListenableFuture, Function<? super I, ? extends O> paramFunction, Executor paramExecutor)
  {
    Preconditions.checkNotNull(paramFunction);
    return transform(paramListenableFuture, a(paramFunction), paramExecutor);
  }
  
  public static <I, O> ListenableFuture<O> transform(ListenableFuture<I> paramListenableFuture, AsyncFunction<? super I, ? extends O> paramAsyncFunction)
  {
    paramAsyncFunction = new a(paramAsyncFunction, paramListenableFuture, (byte)0);
    paramListenableFuture.addListener(paramAsyncFunction, MoreExecutors.directExecutor());
    return paramAsyncFunction;
  }
  
  public static <I, O> ListenableFuture<O> transform(ListenableFuture<I> paramListenableFuture, final AsyncFunction<? super I, ? extends O> paramAsyncFunction, Executor paramExecutor)
  {
    Preconditions.checkNotNull(paramExecutor);
    paramAsyncFunction = new a(paramAsyncFunction, paramListenableFuture, (byte)0);
    paramListenableFuture.addListener(new Runnable()
    {
      public final void run()
      {
        final AtomicBoolean localAtomicBoolean = new AtomicBoolean(true);
        try
        {
          this.a.execute(new Runnable()
          {
            public final void run()
            {
              localAtomicBoolean.set(false);
              Futures.1.this.b.run();
            }
          });
          return;
        }
        catch (RejectedExecutionException localRejectedExecutionException)
        {
          while (!localAtomicBoolean.get()) {}
          paramAsyncFunction.setException(localRejectedExecutionException);
        }
      }
    }, MoreExecutors.directExecutor());
    return paramAsyncFunction;
  }
  
  public static <V> ListenableFuture<V> withFallback(ListenableFuture<? extends V> paramListenableFuture, FutureFallback<? extends V> paramFutureFallback)
  {
    return withFallback(paramListenableFuture, paramFutureFallback, MoreExecutors.directExecutor());
  }
  
  public static <V> ListenableFuture<V> withFallback(ListenableFuture<? extends V> paramListenableFuture, FutureFallback<? extends V> paramFutureFallback, Executor paramExecutor)
  {
    Preconditions.checkNotNull(paramFutureFallback);
    return new c(paramListenableFuture, paramFutureFallback, paramExecutor);
  }
  
  static final class a<I, O>
    extends AbstractFuture<O>
    implements Runnable
  {
    private AsyncFunction<? super I, ? extends O> a;
    private ListenableFuture<? extends I> b;
    private volatile ListenableFuture<? extends O> c;
    
    private a(AsyncFunction<? super I, ? extends O> paramAsyncFunction, ListenableFuture<? extends I> paramListenableFuture)
    {
      this.a = ((AsyncFunction)Preconditions.checkNotNull(paramAsyncFunction));
      this.b = ((ListenableFuture)Preconditions.checkNotNull(paramListenableFuture));
    }
    
    private static void a(@Nullable Future<?> paramFuture, boolean paramBoolean)
    {
      if (paramFuture != null) {
        paramFuture.cancel(paramBoolean);
      }
    }
    
    public final boolean cancel(boolean paramBoolean)
    {
      if (super.cancel(paramBoolean))
      {
        a(this.b, paramBoolean);
        a(this.c, paramBoolean);
        return true;
      }
      return false;
    }
    
    public final void run()
    {
      try
      {
        Object localObject1 = Uninterruptibles.getUninterruptibly(this.b);
        localObject1 = (ListenableFuture)Preconditions.checkNotNull(this.a.apply(localObject1), "AsyncFunction may not return null.");
        this.c = ((ListenableFuture)localObject1);
        if (isCancelled())
        {
          ((ListenableFuture)localObject1).cancel(wasInterrupted());
          this.c = null;
          return;
        }
      }
      catch (CancellationException localCancellationException)
      {
        cancel(false);
        return;
      }
      catch (ExecutionException localExecutionException)
      {
        setException(localExecutionException.getCause());
        return;
        localExecutionException.addListener(new Runnable()
        {
          public final void run()
          {
            try
            {
              Futures.a.this.set(Uninterruptibles.getUninterruptibly(localExecutionException));
              return;
            }
            catch (CancellationException localCancellationException)
            {
              Futures.a.this.cancel(false);
              return;
            }
            catch (ExecutionException localExecutionException)
            {
              Futures.a.this.setException(localExecutionException.getCause());
              return;
            }
            finally
            {
              Futures.a.a(Futures.a.this);
            }
          }
        }, MoreExecutors.directExecutor());
        return;
      }
      catch (UndeclaredThrowableException localUndeclaredThrowableException)
      {
        setException(localUndeclaredThrowableException.getCause());
        return;
      }
      catch (Throwable localThrowable)
      {
        setException(localThrowable);
        return;
      }
      finally
      {
        this.a = null;
        this.b = null;
      }
    }
  }
  
  static class b<V, C>
    extends AbstractFuture<C>
  {
    private static final Logger h = Logger.getLogger(b.class.getName());
    ImmutableCollection<? extends ListenableFuture<? extends V>> a;
    final boolean b;
    final AtomicInteger c;
    Futures.d<V, C> d;
    List<Optional<V>> e;
    final Object f = new Object();
    Set<Throwable> g;
    
    b(ImmutableCollection<? extends ListenableFuture<? extends V>> paramImmutableCollection, boolean paramBoolean, Executor paramExecutor, Futures.d<V, C> paramd)
    {
      this.a = paramImmutableCollection;
      this.b = paramBoolean;
      this.c = new AtomicInteger(paramImmutableCollection.size());
      this.d = paramd;
      this.e = Lists.newArrayListWithCapacity(paramImmutableCollection.size());
      a(paramExecutor);
    }
    
    private void a(Throwable paramThrowable)
    {
      boolean bool2 = false;
      boolean bool1 = true;
      if (this.b) {
        bool2 = super.setException(paramThrowable);
      }
      synchronized (this.f)
      {
        if (this.g == null) {
          this.g = Sets.newHashSet();
        }
        bool1 = this.g.add(paramThrowable);
        if (((paramThrowable instanceof Error)) || ((this.b) && (!bool2) && (bool1))) {
          h.log(Level.SEVERE, "input future failed.", paramThrowable);
        }
        return;
      }
    }
    
    private void a(Executor paramExecutor)
    {
      int j = 0;
      addListener(new Runnable()
      {
        public final void run()
        {
          if (Futures.b.this.isCancelled())
          {
            Iterator localIterator = Futures.b.this.a.iterator();
            while (localIterator.hasNext()) {
              ((ListenableFuture)localIterator.next()).cancel(Futures.b.this.wasInterrupted());
            }
          }
          Futures.b.this.a = null;
          Futures.b.this.e = null;
          Futures.b.this.d = null;
        }
      }, MoreExecutors.directExecutor());
      if (this.a.isEmpty()) {
        set(this.d.a(ImmutableList.of()));
      }
      for (;;)
      {
        return;
        final int i = 0;
        while (i < this.a.size())
        {
          this.e.add(null);
          i += 1;
        }
        Iterator localIterator = this.a.iterator();
        i = j;
        while (localIterator.hasNext())
        {
          final ListenableFuture localListenableFuture = (ListenableFuture)localIterator.next();
          localListenableFuture.addListener(new Runnable()
          {
            public final void run()
            {
              Futures.b.a(Futures.b.this, i, localListenableFuture);
            }
          }, paramExecutor);
          i += 1;
        }
      }
    }
  }
  
  static final class c<V>
    extends AbstractFuture<V>
  {
    private volatile ListenableFuture<? extends V> a;
    
    c(ListenableFuture<? extends V> paramListenableFuture, final FutureFallback<? extends V> paramFutureFallback, Executor paramExecutor)
    {
      this.a = paramListenableFuture;
      Futures.addCallback(this.a, new FutureCallback()
      {
        public final void onFailure(Throwable paramAnonymousThrowable)
        {
          if (Futures.c.this.isCancelled()) {
            return;
          }
          try
          {
            Futures.c.a(Futures.c.this, paramFutureFallback.create(paramAnonymousThrowable));
            if (Futures.c.this.isCancelled())
            {
              Futures.c.a(Futures.c.this).cancel(Futures.c.this.wasInterrupted());
              return;
            }
          }
          catch (Throwable paramAnonymousThrowable)
          {
            Futures.c.this.setException(paramAnonymousThrowable);
            return;
          }
          Futures.addCallback(Futures.c.a(Futures.c.this), new FutureCallback()
          {
            public final void onFailure(Throwable paramAnonymous2Throwable)
            {
              if (Futures.c.a(Futures.c.this).isCancelled())
              {
                Futures.c.this.cancel(false);
                return;
              }
              Futures.c.this.setException(paramAnonymous2Throwable);
            }
            
            public final void onSuccess(V paramAnonymous2V)
            {
              Futures.c.this.set(paramAnonymous2V);
            }
          }, MoreExecutors.directExecutor());
        }
        
        public final void onSuccess(V paramAnonymousV)
        {
          Futures.c.this.set(paramAnonymousV);
        }
      }, paramExecutor);
    }
    
    public final boolean cancel(boolean paramBoolean)
    {
      if (super.cancel(paramBoolean))
      {
        this.a.cancel(paramBoolean);
        return true;
      }
      return false;
    }
  }
  
  static abstract interface d<V, C>
  {
    public abstract C a(List<Optional<V>> paramList);
  }
  
  static final class e<V>
    extends Futures.h<V>
  {
    private final CancellationException a = new CancellationException("Immediate cancelled future.");
    
    e()
    {
      super();
    }
    
    public final V get()
    {
      throw AbstractFuture.a("Task was cancelled.", this.a);
    }
    
    public final boolean isCancelled()
    {
      return true;
    }
  }
  
  static final class f<V, X extends Exception>
    extends Futures.h<V>
    implements CheckedFuture<V, X>
  {
    private final X a;
    
    f(X paramX)
    {
      super();
      this.a = paramX;
    }
    
    public final V checkedGet()
      throws Exception
    {
      throw this.a;
    }
    
    public final V checkedGet(long paramLong, TimeUnit paramTimeUnit)
      throws Exception
    {
      Preconditions.checkNotNull(paramTimeUnit);
      throw this.a;
    }
    
    public final V get()
      throws ExecutionException
    {
      throw new ExecutionException(this.a);
    }
  }
  
  static final class g<V>
    extends Futures.h<V>
  {
    private final Throwable a;
    
    g(Throwable paramThrowable)
    {
      super();
      this.a = paramThrowable;
    }
    
    public final V get()
      throws ExecutionException
    {
      throw new ExecutionException(this.a);
    }
  }
  
  static abstract class h<V>
    implements ListenableFuture<V>
  {
    private static final Logger a = Logger.getLogger(h.class.getName());
    
    public void addListener(Runnable paramRunnable, Executor paramExecutor)
    {
      Preconditions.checkNotNull(paramRunnable, "Runnable was null.");
      Preconditions.checkNotNull(paramExecutor, "Executor was null.");
      try
      {
        paramExecutor.execute(paramRunnable);
        return;
      }
      catch (RuntimeException localRuntimeException)
      {
        Logger localLogger = a;
        Level localLevel = Level.SEVERE;
        paramRunnable = String.valueOf(String.valueOf(paramRunnable));
        paramExecutor = String.valueOf(String.valueOf(paramExecutor));
        localLogger.log(localLevel, paramRunnable.length() + 57 + paramExecutor.length() + "RuntimeException while executing runnable " + paramRunnable + " with executor " + paramExecutor, localRuntimeException);
      }
    }
    
    public boolean cancel(boolean paramBoolean)
    {
      return false;
    }
    
    public abstract V get()
      throws ExecutionException;
    
    public V get(long paramLong, TimeUnit paramTimeUnit)
      throws ExecutionException
    {
      Preconditions.checkNotNull(paramTimeUnit);
      return (V)get();
    }
    
    public boolean isCancelled()
    {
      return false;
    }
    
    public boolean isDone()
    {
      return true;
    }
  }
  
  static final class i<V, X extends Exception>
    extends Futures.h<V>
    implements CheckedFuture<V, X>
  {
    @Nullable
    private final V a;
    
    i(@Nullable V paramV)
    {
      super();
      this.a = paramV;
    }
    
    public final V checkedGet()
    {
      return (V)this.a;
    }
    
    public final V checkedGet(long paramLong, TimeUnit paramTimeUnit)
    {
      Preconditions.checkNotNull(paramTimeUnit);
      return (V)this.a;
    }
    
    public final V get()
    {
      return (V)this.a;
    }
  }
  
  static final class j<V>
    extends Futures.h<V>
  {
    @Nullable
    private final V a;
    
    j(@Nullable V paramV)
    {
      super();
      this.a = paramV;
    }
    
    public final V get()
    {
      return (V)this.a;
    }
  }
  
  static final class k<V, X extends Exception>
    extends AbstractCheckedFuture<V, X>
  {
    final Function<? super Exception, X> a;
    
    k(ListenableFuture<V> paramListenableFuture, Function<? super Exception, X> paramFunction)
    {
      super();
      this.a = ((Function)Preconditions.checkNotNull(paramFunction));
    }
    
    protected final X mapException(Exception paramException)
    {
      return (Exception)this.a.apply(paramException);
    }
  }
  
  static final class l<V>
    extends AbstractFuture<V>
  {
    l(final ListenableFuture<V> paramListenableFuture)
    {
      Preconditions.checkNotNull(paramListenableFuture);
      Futures.addCallback(paramListenableFuture, new FutureCallback()
      {
        public final void onFailure(Throwable paramAnonymousThrowable)
        {
          if (paramListenableFuture.isCancelled())
          {
            Futures.l.this.cancel(false);
            return;
          }
          Futures.l.this.setException(paramAnonymousThrowable);
        }
        
        public final void onSuccess(V paramAnonymousV)
        {
          Futures.l.this.set(paramAnonymousV);
        }
      }, MoreExecutors.directExecutor());
    }
  }
}


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