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.Supplier;
import com.google.common.base.Throwables;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import rs;

public final class MoreExecutors
{
  static Thread a(String paramString, Runnable paramRunnable)
  {
    Preconditions.checkNotNull(paramString);
    Preconditions.checkNotNull(paramRunnable);
    paramRunnable = platformThreadFactory().newThread(paramRunnable);
    try
    {
      paramRunnable.setName(paramString);
      return paramRunnable;
    }
    catch (SecurityException paramString) {}
    return paramRunnable;
  }
  
  static Executor a(Executor paramExecutor, final Supplier<String> paramSupplier)
  {
    Preconditions.checkNotNull(paramExecutor);
    Preconditions.checkNotNull(paramSupplier);
    if (a()) {
      return paramExecutor;
    }
    new Executor()
    {
      public final void execute(Runnable paramAnonymousRunnable)
      {
        this.a.execute(Callables.a(paramAnonymousRunnable, paramSupplier));
      }
    };
  }
  
  static ScheduledExecutorService a(ScheduledExecutorService paramScheduledExecutorService, final Supplier<String> paramSupplier)
  {
    Preconditions.checkNotNull(paramScheduledExecutorService);
    Preconditions.checkNotNull(paramSupplier);
    if (a()) {
      return paramScheduledExecutorService;
    }
    new rs(paramScheduledExecutorService)
    {
      protected final Runnable a(Runnable paramAnonymousRunnable)
      {
        return Callables.a(paramAnonymousRunnable, paramSupplier);
      }
      
      protected final <T> Callable<T> a(Callable<T> paramAnonymousCallable)
      {
        return Callables.a(paramAnonymousCallable, paramSupplier);
      }
    };
  }
  
  private static boolean a()
  {
    if (System.getProperty("com.google.appengine.runtime.environment") == null) {}
    for (;;)
    {
      return false;
      try
      {
        Object localObject = Class.forName("com.google.apphosting.api.ApiProxy").getMethod("getCurrentEnvironment", new Class[0]).invoke(null, new Object[0]);
        if (localObject != null) {
          return true;
        }
      }
      catch (NoSuchMethodException localNoSuchMethodException)
      {
        return false;
      }
      catch (IllegalAccessException localIllegalAccessException)
      {
        return false;
      }
      catch (InvocationTargetException localInvocationTargetException)
      {
        return false;
      }
      catch (ClassNotFoundException localClassNotFoundException) {}
    }
    return false;
  }
  
  @Beta
  public static void addDelayedShutdownHook(ExecutorService paramExecutorService, long paramLong, TimeUnit paramTimeUnit)
  {
    new a().a(paramExecutorService, paramLong, paramTimeUnit);
  }
  
  public static Executor directExecutor()
  {
    return b.a;
  }
  
  @Beta
  public static ExecutorService getExitingExecutorService(ThreadPoolExecutor paramThreadPoolExecutor)
  {
    return new a().a(paramThreadPoolExecutor, 120L, TimeUnit.SECONDS);
  }
  
  @Beta
  public static ExecutorService getExitingExecutorService(ThreadPoolExecutor paramThreadPoolExecutor, long paramLong, TimeUnit paramTimeUnit)
  {
    return new a().a(paramThreadPoolExecutor, paramLong, paramTimeUnit);
  }
  
  @Beta
  public static ScheduledExecutorService getExitingScheduledExecutorService(ScheduledThreadPoolExecutor paramScheduledThreadPoolExecutor)
  {
    return new a().a(paramScheduledThreadPoolExecutor, 120L, TimeUnit.SECONDS);
  }
  
  @Beta
  public static ScheduledExecutorService getExitingScheduledExecutorService(ScheduledThreadPoolExecutor paramScheduledThreadPoolExecutor, long paramLong, TimeUnit paramTimeUnit)
  {
    return new a().a(paramScheduledThreadPoolExecutor, paramLong, paramTimeUnit);
  }
  
  public static ListeningExecutorService listeningDecorator(ExecutorService paramExecutorService)
  {
    if ((paramExecutorService instanceof ListeningExecutorService)) {
      return (ListeningExecutorService)paramExecutorService;
    }
    if ((paramExecutorService instanceof ScheduledExecutorService)) {
      return new e((ScheduledExecutorService)paramExecutorService);
    }
    return new d(paramExecutorService);
  }
  
  public static ListeningScheduledExecutorService listeningDecorator(ScheduledExecutorService paramScheduledExecutorService)
  {
    if ((paramScheduledExecutorService instanceof ListeningScheduledExecutorService)) {
      return (ListeningScheduledExecutorService)paramScheduledExecutorService;
    }
    return new e(paramScheduledExecutorService);
  }
  
  public static ListeningExecutorService newDirectExecutorService()
  {
    return new c((byte)0);
  }
  
  @Beta
  public static ThreadFactory platformThreadFactory()
  {
    if (!a()) {
      return Executors.defaultThreadFactory();
    }
    try
    {
      ThreadFactory localThreadFactory = (ThreadFactory)Class.forName("com.google.appengine.api.ThreadManager").getMethod("currentRequestThreadFactory", new Class[0]).invoke(null, new Object[0]);
      return localThreadFactory;
    }
    catch (IllegalAccessException localIllegalAccessException)
    {
      throw new RuntimeException("Couldn't invoke ThreadManager.currentRequestThreadFactory", localIllegalAccessException);
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new RuntimeException("Couldn't invoke ThreadManager.currentRequestThreadFactory", localClassNotFoundException);
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new RuntimeException("Couldn't invoke ThreadManager.currentRequestThreadFactory", localNoSuchMethodException);
    }
    catch (InvocationTargetException localInvocationTargetException)
    {
      throw Throwables.propagate(localInvocationTargetException.getCause());
    }
  }
  
  @Deprecated
  public static ListeningExecutorService sameThreadExecutor()
  {
    return new c((byte)0);
  }
  
  @Beta
  public static boolean shutdownAndAwaitTermination(ExecutorService paramExecutorService, long paramLong, TimeUnit paramTimeUnit)
  {
    Preconditions.checkNotNull(paramTimeUnit);
    paramExecutorService.shutdown();
    try
    {
      paramLong = TimeUnit.NANOSECONDS.convert(paramLong, paramTimeUnit) / 2L;
      if (!paramExecutorService.awaitTermination(paramLong, TimeUnit.NANOSECONDS))
      {
        paramExecutorService.shutdownNow();
        paramExecutorService.awaitTermination(paramLong, TimeUnit.NANOSECONDS);
      }
      return paramExecutorService.isTerminated();
    }
    catch (InterruptedException paramTimeUnit)
    {
      for (;;)
      {
        Thread.currentThread().interrupt();
        paramExecutorService.shutdownNow();
      }
    }
  }
  
  @VisibleForTesting
  static final class a
  {
    final ExecutorService a(ThreadPoolExecutor paramThreadPoolExecutor, long paramLong, TimeUnit paramTimeUnit)
    {
      MoreExecutors.a(paramThreadPoolExecutor);
      paramThreadPoolExecutor = Executors.unconfigurableExecutorService(paramThreadPoolExecutor);
      a(paramThreadPoolExecutor, paramLong, paramTimeUnit);
      return paramThreadPoolExecutor;
    }
    
    final ScheduledExecutorService a(ScheduledThreadPoolExecutor paramScheduledThreadPoolExecutor, long paramLong, TimeUnit paramTimeUnit)
    {
      MoreExecutors.a(paramScheduledThreadPoolExecutor);
      paramScheduledThreadPoolExecutor = Executors.unconfigurableScheduledExecutorService(paramScheduledThreadPoolExecutor);
      a(paramScheduledThreadPoolExecutor, paramLong, paramTimeUnit);
      return paramScheduledThreadPoolExecutor;
    }
    
    final void a(final ExecutorService paramExecutorService, final long paramLong, TimeUnit paramTimeUnit)
    {
      Preconditions.checkNotNull(paramExecutorService);
      Preconditions.checkNotNull(paramTimeUnit);
      String str = String.valueOf(String.valueOf(paramExecutorService));
      paramExecutorService = MoreExecutors.a(str.length() + 24 + "DelayedShutdownHook-for-" + str, new Runnable()
      {
        public final void run()
        {
          try
          {
            paramExecutorService.shutdown();
            paramExecutorService.awaitTermination(paramLong, this.c);
            return;
          }
          catch (InterruptedException localInterruptedException) {}
        }
      });
      Runtime.getRuntime().addShutdownHook(paramExecutorService);
    }
  }
  
  static enum b
    implements Executor
  {
    private b() {}
    
    public final void execute(Runnable paramRunnable)
    {
      paramRunnable.run();
    }
  }
  
  static final class c
    extends AbstractListeningExecutorService
  {
    private final Lock a = new ReentrantLock();
    private final Condition b = this.a.newCondition();
    private int c = 0;
    private boolean d = false;
    
    private void a()
    {
      this.a.lock();
      try
      {
        this.c -= 1;
        if (isTerminated()) {
          this.b.signalAll();
        }
        return;
      }
      finally
      {
        this.a.unlock();
      }
    }
    
    /* Error */
    public final boolean awaitTermination(long paramLong, TimeUnit paramTimeUnit)
      throws InterruptedException
    {
      // Byte code:
      //   0: aload_3
      //   1: lload_1
      //   2: invokevirtual 63	java/util/concurrent/TimeUnit:toNanos	(J)J
      //   5: lstore_1
      //   6: aload_0
      //   7: getfield 23	com/google/common/util/concurrent/MoreExecutors$c:a	Ljava/util/concurrent/locks/Lock;
      //   10: invokeinterface 41 1 0
      //   15: aload_0
      //   16: invokevirtual 45	com/google/common/util/concurrent/MoreExecutors$c:isTerminated	()Z
      //   19: istore 4
      //   21: iload 4
      //   23: ifeq +14 -> 37
      //   26: aload_0
      //   27: getfield 23	com/google/common/util/concurrent/MoreExecutors$c:a	Ljava/util/concurrent/locks/Lock;
      //   30: invokeinterface 53 1 0
      //   35: iconst_1
      //   36: ireturn
      //   37: lload_1
      //   38: lconst_0
      //   39: lcmp
      //   40: ifgt +14 -> 54
      //   43: aload_0
      //   44: getfield 23	com/google/common/util/concurrent/MoreExecutors$c:a	Ljava/util/concurrent/locks/Lock;
      //   47: invokeinterface 53 1 0
      //   52: iconst_0
      //   53: ireturn
      //   54: aload_0
      //   55: getfield 31	com/google/common/util/concurrent/MoreExecutors$c:b	Ljava/util/concurrent/locks/Condition;
      //   58: lload_1
      //   59: invokeinterface 66 3 0
      //   64: lstore_1
      //   65: goto -50 -> 15
      //   68: astore_3
      //   69: aload_0
      //   70: getfield 23	com/google/common/util/concurrent/MoreExecutors$c:a	Ljava/util/concurrent/locks/Lock;
      //   73: invokeinterface 53 1 0
      //   78: aload_3
      //   79: athrow
      // Local variable table:
      //   start	length	slot	name	signature
      //   0	80	0	this	c
      //   0	80	1	paramLong	long
      //   0	80	3	paramTimeUnit	TimeUnit
      //   19	3	4	bool	boolean
      // Exception table:
      //   from	to	target	type
      //   15	21	68	finally
      //   54	65	68	finally
    }
    
    public final void execute(Runnable paramRunnable)
    {
      this.a.lock();
      try
      {
        if (isShutdown()) {
          throw new RejectedExecutionException("Executor already shutdown");
        }
      }
      finally
      {
        this.a.unlock();
      }
      this.c += 1;
      this.a.unlock();
      try
      {
        paramRunnable.run();
        return;
      }
      finally
      {
        a();
      }
    }
    
    public final boolean isShutdown()
    {
      this.a.lock();
      try
      {
        boolean bool = this.d;
        return bool;
      }
      finally
      {
        this.a.unlock();
      }
    }
    
    /* Error */
    public final boolean isTerminated()
    {
      // Byte code:
      //   0: aload_0
      //   1: getfield 23	com/google/common/util/concurrent/MoreExecutors$c:a	Ljava/util/concurrent/locks/Lock;
      //   4: invokeinterface 41 1 0
      //   9: aload_0
      //   10: getfield 35	com/google/common/util/concurrent/MoreExecutors$c:d	Z
      //   13: ifeq +25 -> 38
      //   16: aload_0
      //   17: getfield 33	com/google/common/util/concurrent/MoreExecutors$c:c	I
      //   20: istore_1
      //   21: iload_1
      //   22: ifne +16 -> 38
      //   25: iconst_1
      //   26: istore_2
      //   27: aload_0
      //   28: getfield 23	com/google/common/util/concurrent/MoreExecutors$c:a	Ljava/util/concurrent/locks/Lock;
      //   31: invokeinterface 53 1 0
      //   36: iload_2
      //   37: ireturn
      //   38: iconst_0
      //   39: istore_2
      //   40: goto -13 -> 27
      //   43: astore_3
      //   44: aload_0
      //   45: getfield 23	com/google/common/util/concurrent/MoreExecutors$c:a	Ljava/util/concurrent/locks/Lock;
      //   48: invokeinterface 53 1 0
      //   53: aload_3
      //   54: athrow
      // Local variable table:
      //   start	length	slot	name	signature
      //   0	55	0	this	c
      //   20	2	1	i	int
      //   26	14	2	bool	boolean
      //   43	11	3	localObject	Object
      // Exception table:
      //   from	to	target	type
      //   9	21	43	finally
    }
    
    public final void shutdown()
    {
      this.a.lock();
      try
      {
        this.d = true;
        return;
      }
      finally
      {
        this.a.unlock();
      }
    }
    
    public final List<Runnable> shutdownNow()
    {
      shutdown();
      return Collections.emptyList();
    }
  }
  
  static class d
    extends AbstractListeningExecutorService
  {
    private final ExecutorService a;
    
    d(ExecutorService paramExecutorService)
    {
      this.a = ((ExecutorService)Preconditions.checkNotNull(paramExecutorService));
    }
    
    public boolean awaitTermination(long paramLong, TimeUnit paramTimeUnit)
      throws InterruptedException
    {
      return this.a.awaitTermination(paramLong, paramTimeUnit);
    }
    
    public void execute(Runnable paramRunnable)
    {
      this.a.execute(paramRunnable);
    }
    
    public boolean isShutdown()
    {
      return this.a.isShutdown();
    }
    
    public boolean isTerminated()
    {
      return this.a.isTerminated();
    }
    
    public void shutdown()
    {
      this.a.shutdown();
    }
    
    public List<Runnable> shutdownNow()
    {
      return this.a.shutdownNow();
    }
  }
  
  static final class e
    extends MoreExecutors.d
    implements ListeningScheduledExecutorService
  {
    final ScheduledExecutorService a;
    
    e(ScheduledExecutorService paramScheduledExecutorService)
    {
      super();
      this.a = ((ScheduledExecutorService)Preconditions.checkNotNull(paramScheduledExecutorService));
    }
    
    public final ListenableScheduledFuture<?> schedule(Runnable paramRunnable, long paramLong, TimeUnit paramTimeUnit)
    {
      paramRunnable = ListenableFutureTask.create(paramRunnable, null);
      return new a(paramRunnable, this.a.schedule(paramRunnable, paramLong, paramTimeUnit));
    }
    
    public final <V> ListenableScheduledFuture<V> schedule(Callable<V> paramCallable, long paramLong, TimeUnit paramTimeUnit)
    {
      paramCallable = ListenableFutureTask.create(paramCallable);
      return new a(paramCallable, this.a.schedule(paramCallable, paramLong, paramTimeUnit));
    }
    
    public final ListenableScheduledFuture<?> scheduleAtFixedRate(Runnable paramRunnable, long paramLong1, long paramLong2, TimeUnit paramTimeUnit)
    {
      paramRunnable = new b(paramRunnable);
      return new a(paramRunnable, this.a.scheduleAtFixedRate(paramRunnable, paramLong1, paramLong2, paramTimeUnit));
    }
    
    public final ListenableScheduledFuture<?> scheduleWithFixedDelay(Runnable paramRunnable, long paramLong1, long paramLong2, TimeUnit paramTimeUnit)
    {
      paramRunnable = new b(paramRunnable);
      return new a(paramRunnable, this.a.scheduleWithFixedDelay(paramRunnable, paramLong1, paramLong2, paramTimeUnit));
    }
    
    static final class a<V>
      extends ForwardingListenableFuture.SimpleForwardingListenableFuture<V>
      implements ListenableScheduledFuture<V>
    {
      private final ScheduledFuture<?> a;
      
      public a(ListenableFuture<V> paramListenableFuture, ScheduledFuture<?> paramScheduledFuture)
      {
        super();
        this.a = paramScheduledFuture;
      }
      
      public final boolean cancel(boolean paramBoolean)
      {
        boolean bool = super.cancel(paramBoolean);
        if (bool) {
          this.a.cancel(paramBoolean);
        }
        return bool;
      }
      
      public final long getDelay(TimeUnit paramTimeUnit)
      {
        return this.a.getDelay(paramTimeUnit);
      }
    }
    
    static final class b
      extends AbstractFuture<Void>
      implements Runnable
    {
      private final Runnable a;
      
      public b(Runnable paramRunnable)
      {
        this.a = ((Runnable)Preconditions.checkNotNull(paramRunnable));
      }
      
      public final void run()
      {
        try
        {
          this.a.run();
          return;
        }
        catch (Throwable localThrowable)
        {
          setException(localThrowable);
          throw Throwables.propagate(localThrowable);
        }
      }
    }
  }
}


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