package com.google.common.util.concurrent;

import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import javax.annotation.concurrent.GuardedBy;

@Beta
public final class Monitor
{
  private final boolean a;
  private final ReentrantLock b;
  @GuardedBy("lock")
  private Guard c = null;
  
  public Monitor()
  {
    this(false);
  }
  
  public Monitor(boolean paramBoolean)
  {
    this.a = paramBoolean;
    this.b = new ReentrantLock(paramBoolean);
  }
  
  @GuardedBy("lock")
  private void a()
  {
    for (Guard localGuard = this.c;; localGuard = localGuard.e) {
      if (localGuard != null)
      {
        if (a(localGuard)) {
          localGuard.c.signal();
        }
      }
      else {
        return;
      }
    }
  }
  
  @GuardedBy("lock")
  private void a(Guard paramGuard, boolean paramBoolean)
    throws InterruptedException
  {
    if (paramBoolean) {
      a();
    }
    b(paramGuard);
    try
    {
      do
      {
        paramGuard.c.await();
        paramBoolean = paramGuard.isSatisfied();
      } while (!paramBoolean);
      return;
    }
    finally
    {
      c(paramGuard);
    }
  }
  
  @GuardedBy("lock")
  private boolean a(Guard paramGuard)
  {
    try
    {
      boolean bool = paramGuard.isSatisfied();
      return bool;
    }
    catch (Throwable localThrowable)
    {
      for (paramGuard = this.c; paramGuard != null; paramGuard = paramGuard.e) {
        paramGuard.c.signalAll();
      }
      throw Throwables.propagate(localThrowable);
    }
  }
  
  @GuardedBy("lock")
  private boolean a(Guard paramGuard, long paramLong, boolean paramBoolean)
    throws InterruptedException
  {
    if (paramBoolean) {
      a();
    }
    b(paramGuard);
    for (;;)
    {
      if (paramLong < 0L)
      {
        c(paramGuard);
        return false;
      }
      try
      {
        paramLong = paramGuard.c.awaitNanos(paramLong);
        paramBoolean = paramGuard.isSatisfied();
        if (!paramBoolean) {
          continue;
        }
        return true;
      }
      finally
      {
        c(paramGuard);
      }
    }
  }
  
  @GuardedBy("lock")
  private void b(Guard paramGuard)
  {
    int i = paramGuard.d;
    paramGuard.d = (i + 1);
    if (i == 0)
    {
      paramGuard.e = this.c;
      this.c = paramGuard;
    }
  }
  
  @GuardedBy("lock")
  private void b(Guard paramGuard, boolean paramBoolean)
  {
    if (paramBoolean) {
      a();
    }
    b(paramGuard);
    try
    {
      do
      {
        paramGuard.c.awaitUninterruptibly();
        paramBoolean = paramGuard.isSatisfied();
      } while (!paramBoolean);
      return;
    }
    finally
    {
      c(paramGuard);
    }
  }
  
  @GuardedBy("lock")
  private void c(Guard paramGuard)
  {
    int i = paramGuard.d - 1;
    paramGuard.d = i;
    Object localObject1;
    Object localObject2;
    if (i == 0)
    {
      localObject1 = this.c;
      localObject2 = null;
    }
    for (;;)
    {
      if (localObject1 == paramGuard)
      {
        if (localObject2 == null) {
          this.c = ((Guard)localObject1).e;
        }
        for (;;)
        {
          ((Guard)localObject1).e = null;
          return;
          ((Guard)localObject2).e = ((Guard)localObject1).e;
        }
      }
      Guard localGuard = ((Guard)localObject1).e;
      localObject2 = localObject1;
      localObject1 = localGuard;
    }
  }
  
  public final void enter()
  {
    this.b.lock();
  }
  
  public final boolean enter(long paramLong, TimeUnit paramTimeUnit)
  {
    boolean bool2 = true;
    long l1 = paramTimeUnit.toNanos(paramLong);
    paramTimeUnit = this.b;
    if ((!this.a) && (paramTimeUnit.tryLock())) {}
    for (;;)
    {
      return bool2;
      long l2 = System.nanoTime();
      bool1 = Thread.interrupted();
      paramLong = l1;
      try
      {
        boolean bool3 = paramTimeUnit.tryLock(paramLong, TimeUnit.NANOSECONDS);
        bool2 = bool3;
        if (bool1)
        {
          Thread.currentThread().interrupt();
          return bool3;
        }
      }
      catch (InterruptedException localInterruptedException)
      {
        localInterruptedException = localInterruptedException;
      }
      finally
      {
        try
        {
          for (;;)
          {
            paramLong = System.nanoTime();
            paramLong = l2 + l1 - paramLong;
            bool1 = true;
          }
        }
        finally
        {
          bool1 = true;
        }
        paramTimeUnit = finally;
      }
    }
    if (bool1) {
      Thread.currentThread().interrupt();
    }
    throw paramTimeUnit;
  }
  
  public final boolean enterIf(Guard paramGuard)
  {
    if (paramGuard.b != this) {
      throw new IllegalMonitorStateException();
    }
    ReentrantLock localReentrantLock = this.b;
    localReentrantLock.lock();
    try
    {
      boolean bool = paramGuard.isSatisfied();
      if (!bool) {}
      return bool;
    }
    finally
    {
      localReentrantLock.unlock();
    }
  }
  
  public final boolean enterIf(Guard paramGuard, long paramLong, TimeUnit paramTimeUnit)
  {
    if (paramGuard.b != this) {
      throw new IllegalMonitorStateException();
    }
    boolean bool1;
    if (!enter(paramLong, paramTimeUnit)) {
      bool1 = false;
    }
    for (;;)
    {
      return bool1;
      try
      {
        boolean bool2 = paramGuard.isSatisfied();
        bool1 = bool2;
        if (bool2) {
          continue;
        }
        return bool2;
      }
      finally
      {
        this.b.unlock();
      }
    }
  }
  
  public final boolean enterIfInterruptibly(Guard paramGuard)
    throws InterruptedException
  {
    if (paramGuard.b != this) {
      throw new IllegalMonitorStateException();
    }
    ReentrantLock localReentrantLock = this.b;
    localReentrantLock.lockInterruptibly();
    try
    {
      boolean bool = paramGuard.isSatisfied();
      if (!bool) {}
      return bool;
    }
    finally
    {
      localReentrantLock.unlock();
    }
  }
  
  public final boolean enterIfInterruptibly(Guard paramGuard, long paramLong, TimeUnit paramTimeUnit)
    throws InterruptedException
  {
    if (paramGuard.b != this) {
      throw new IllegalMonitorStateException();
    }
    ReentrantLock localReentrantLock = this.b;
    boolean bool1;
    if (!localReentrantLock.tryLock(paramLong, paramTimeUnit)) {
      bool1 = false;
    }
    for (;;)
    {
      return bool1;
      try
      {
        boolean bool2 = paramGuard.isSatisfied();
        bool1 = bool2;
        if (bool2) {
          continue;
        }
        return bool2;
      }
      finally
      {
        localReentrantLock.unlock();
      }
    }
  }
  
  public final void enterInterruptibly()
    throws InterruptedException
  {
    this.b.lockInterruptibly();
  }
  
  public final boolean enterInterruptibly(long paramLong, TimeUnit paramTimeUnit)
    throws InterruptedException
  {
    return this.b.tryLock(paramLong, paramTimeUnit);
  }
  
  public final void enterWhen(Guard paramGuard)
    throws InterruptedException
  {
    if (paramGuard.b != this) {
      throw new IllegalMonitorStateException();
    }
    ReentrantLock localReentrantLock = this.b;
    boolean bool = localReentrantLock.isHeldByCurrentThread();
    localReentrantLock.lockInterruptibly();
    try
    {
      if (!paramGuard.isSatisfied()) {
        a(paramGuard, bool);
      }
      return;
    }
    finally
    {
      leave();
    }
  }
  
  /* Error */
  public final boolean enterWhen(Guard paramGuard, long paramLong, TimeUnit paramTimeUnit)
    throws InterruptedException
  {
    // Byte code:
    //   0: aload 4
    //   2: lload_2
    //   3: invokevirtual 100	java/util/concurrent/TimeUnit:toNanos	(J)J
    //   6: lstore 7
    //   8: aload_1
    //   9: getfield 131	com/google/common/util/concurrent/Monitor$Guard:b	Lcom/google/common/util/concurrent/Monitor;
    //   12: aload_0
    //   13: if_acmpeq +11 -> 24
    //   16: new 133	java/lang/IllegalMonitorStateException
    //   19: dup
    //   20: invokespecial 134	java/lang/IllegalMonitorStateException:<init>	()V
    //   23: athrow
    //   24: aload_0
    //   25: getfield 34	com/google/common/util/concurrent/Monitor:b	Ljava/util/concurrent/locks/ReentrantLock;
    //   28: astore 11
    //   30: aload 11
    //   32: invokevirtual 149	java/util/concurrent/locks/ReentrantLock:isHeldByCurrentThread	()Z
    //   35: istore 9
    //   37: aload_0
    //   38: getfield 29	com/google/common/util/concurrent/Monitor:a	Z
    //   41: ifne +15 -> 56
    //   44: lload 7
    //   46: lstore 5
    //   48: aload 11
    //   50: invokevirtual 103	java/util/concurrent/locks/ReentrantLock:tryLock	()Z
    //   53: ifne +32 -> 85
    //   56: invokestatic 109	java/lang/System:nanoTime	()J
    //   59: lstore 5
    //   61: aload 11
    //   63: lload_2
    //   64: aload 4
    //   66: invokevirtual 120	java/util/concurrent/locks/ReentrantLock:tryLock	(JLjava/util/concurrent/TimeUnit;)Z
    //   69: ifne +5 -> 74
    //   72: iconst_0
    //   73: ireturn
    //   74: lload 7
    //   76: lload 5
    //   78: ladd
    //   79: invokestatic 109	java/lang/System:nanoTime	()J
    //   82: lsub
    //   83: lstore 5
    //   85: aload_1
    //   86: invokevirtual 65	com/google/common/util/concurrent/Monitor$Guard:isSatisfied	()Z
    //   89: ifne +19 -> 108
    //   92: aload_0
    //   93: aload_1
    //   94: lload 5
    //   96: iload 9
    //   98: invokespecial 156	com/google/common/util/concurrent/Monitor:a	(Lcom/google/common/util/concurrent/Monitor$Guard;JZ)Z
    //   101: istore 10
    //   103: iload 10
    //   105: ifeq +19 -> 124
    //   108: iconst_1
    //   109: istore 9
    //   111: iload 9
    //   113: ifne +8 -> 121
    //   116: aload 11
    //   118: invokevirtual 137	java/util/concurrent/locks/ReentrantLock:unlock	()V
    //   121: iload 9
    //   123: ireturn
    //   124: iconst_0
    //   125: istore 9
    //   127: goto -16 -> 111
    //   130: astore_1
    //   131: iload 9
    //   133: ifne +7 -> 140
    //   136: aload_0
    //   137: invokespecial 55	com/google/common/util/concurrent/Monitor:a	()V
    //   140: aload 11
    //   142: invokevirtual 137	java/util/concurrent/locks/ReentrantLock:unlock	()V
    //   145: aload_1
    //   146: athrow
    //   147: astore_1
    //   148: aload 11
    //   150: invokevirtual 137	java/util/concurrent/locks/ReentrantLock:unlock	()V
    //   153: aload_1
    //   154: athrow
    // Local variable table:
    //   start	length	slot	name	signature
    //   0	155	0	this	Monitor
    //   0	155	1	paramGuard	Guard
    //   0	155	2	paramLong	long
    //   0	155	4	paramTimeUnit	TimeUnit
    //   46	49	5	l1	long
    //   6	69	7	l2	long
    //   35	97	9	bool1	boolean
    //   101	3	10	bool2	boolean
    //   28	121	11	localReentrantLock	ReentrantLock
    // Exception table:
    //   from	to	target	type
    //   85	103	130	finally
    //   136	140	147	finally
  }
  
  public final void enterWhenUninterruptibly(Guard paramGuard)
  {
    if (paramGuard.b != this) {
      throw new IllegalMonitorStateException();
    }
    ReentrantLock localReentrantLock = this.b;
    boolean bool = localReentrantLock.isHeldByCurrentThread();
    localReentrantLock.lock();
    try
    {
      if (!paramGuard.isSatisfied()) {
        b(paramGuard, bool);
      }
      return;
    }
    finally
    {
      leave();
    }
  }
  
  public final boolean enterWhenUninterruptibly(Guard paramGuard, long paramLong, TimeUnit paramTimeUnit)
  {
    l1 = paramTimeUnit.toNanos(paramLong);
    if (paramGuard.b != this) {
      throw new IllegalMonitorStateException();
    }
    paramTimeUnit = this.b;
    long l2 = System.nanoTime() + l1;
    boolean bool4 = paramTimeUnit.isHeldByCurrentThread();
    boolean bool2 = Thread.interrupted();
    boolean bool1 = bool2;
    try
    {
      if (!this.a)
      {
        bool1 = bool2;
        bool3 = paramTimeUnit.tryLock();
        paramLong = l1;
        bool1 = bool2;
        if (bool3) {
          break label151;
        }
      }
      bool3 = false;
    }
    finally
    {
      for (;;)
      {
        boolean bool3;
        label125:
        label129:
        label151:
        label185:
        label228:
        continue;
        l1 = paramLong;
      }
    }
    bool1 = bool2;
    try
    {
      bool5 = paramTimeUnit.tryLock(l1, TimeUnit.NANOSECONDS);
      if (bool5) {
        break label125;
      }
      if (bool2) {
        Thread.currentThread().interrupt();
      }
      bool3 = false;
    }
    catch (InterruptedException localInterruptedException1)
    {
      try
      {
        boolean bool5;
        if (paramGuard.isSatisfied()) {
          break label185;
        }
        bool2 = bool1;
        bool3 = a(paramGuard, paramLong, bool3);
        if (!bool3) {
          break label228;
        }
        for (bool2 = true;; bool2 = false)
        {
          if (!bool2) {
            bool3 = bool1;
          }
          try
          {
            paramTimeUnit.unlock();
            bool3 = bool2;
            if (!bool1) {
              break;
            }
            Thread.currentThread().interrupt();
            return bool2;
          }
          finally
          {
            bool1 = bool3;
          }
          localInterruptedException1 = localInterruptedException1;
          bool2 = true;
          break label129;
        }
      }
      catch (InterruptedException localInterruptedException2)
      {
        for (;;)
        {
          bool2 = true;
          bool1 = true;
          bool3 = false;
          paramLong = System.nanoTime();
          paramLong = l2 - paramLong;
        }
      }
      finally
      {
        bool3 = bool2;
        paramTimeUnit.unlock();
        bool3 = bool2;
      }
    }
    return bool3;
    bool3 = bool5;
    bool1 = bool2;
    paramLong = System.nanoTime();
    paramLong = l2 - paramLong;
    if (bool3)
    {
      bool1 = bool2;
      bool3 = bool4;
      bool2 = bool1;
      if (bool1) {
        Thread.currentThread().interrupt();
      }
      throw paramGuard;
    }
  }
  
  public final int getOccupiedDepth()
  {
    return this.b.getHoldCount();
  }
  
  public final int getQueueLength()
  {
    return this.b.getQueueLength();
  }
  
  public final int getWaitQueueLength(Guard paramGuard)
  {
    if (paramGuard.b != this) {
      throw new IllegalMonitorStateException();
    }
    this.b.lock();
    try
    {
      int i = paramGuard.d;
      return i;
    }
    finally
    {
      this.b.unlock();
    }
  }
  
  public final boolean hasQueuedThread(Thread paramThread)
  {
    return this.b.hasQueuedThread(paramThread);
  }
  
  public final boolean hasQueuedThreads()
  {
    return this.b.hasQueuedThreads();
  }
  
  public final boolean hasWaiters(Guard paramGuard)
  {
    return getWaitQueueLength(paramGuard) > 0;
  }
  
  public final boolean isFair()
  {
    return this.a;
  }
  
  public final boolean isOccupied()
  {
    return this.b.isLocked();
  }
  
  public final boolean isOccupiedByCurrentThread()
  {
    return this.b.isHeldByCurrentThread();
  }
  
  public final void leave()
  {
    ReentrantLock localReentrantLock = this.b;
    try
    {
      if (localReentrantLock.getHoldCount() == 1) {
        a();
      }
      return;
    }
    finally
    {
      localReentrantLock.unlock();
    }
  }
  
  public final boolean tryEnter()
  {
    return this.b.tryLock();
  }
  
  public final boolean tryEnterIf(Guard paramGuard)
  {
    if (paramGuard.b != this) {
      throw new IllegalMonitorStateException();
    }
    ReentrantLock localReentrantLock = this.b;
    boolean bool1;
    if (!localReentrantLock.tryLock()) {
      bool1 = false;
    }
    for (;;)
    {
      return bool1;
      try
      {
        boolean bool2 = paramGuard.isSatisfied();
        bool1 = bool2;
        if (bool2) {
          continue;
        }
        return bool2;
      }
      finally
      {
        localReentrantLock.unlock();
      }
    }
  }
  
  public final void waitFor(Guard paramGuard)
    throws InterruptedException
  {
    if (paramGuard.b == this) {}
    for (int i = 1; (i & this.b.isHeldByCurrentThread()) == 0; i = 0) {
      throw new IllegalMonitorStateException();
    }
    if (!paramGuard.isSatisfied()) {
      a(paramGuard, true);
    }
  }
  
  public final boolean waitFor(Guard paramGuard, long paramLong, TimeUnit paramTimeUnit)
    throws InterruptedException
  {
    boolean bool = false;
    paramLong = paramTimeUnit.toNanos(paramLong);
    if (paramGuard.b == this) {}
    for (int i = 1; (i & this.b.isHeldByCurrentThread()) == 0; i = 0) {
      throw new IllegalMonitorStateException();
    }
    if ((paramGuard.isSatisfied()) || (a(paramGuard, paramLong, true))) {
      bool = true;
    }
    return bool;
  }
  
  public final void waitForUninterruptibly(Guard paramGuard)
  {
    if (paramGuard.b == this) {}
    for (int i = 1; (i & this.b.isHeldByCurrentThread()) == 0; i = 0) {
      throw new IllegalMonitorStateException();
    }
    if (!paramGuard.isSatisfied()) {
      b(paramGuard, true);
    }
  }
  
  /* Error */
  public final boolean waitForUninterruptibly(Guard paramGuard, long paramLong, TimeUnit paramTimeUnit)
  {
    // Byte code:
    //   0: iconst_1
    //   1: istore 12
    //   3: iconst_1
    //   4: istore 11
    //   6: aload 4
    //   8: lload_2
    //   9: invokevirtual 100	java/util/concurrent/TimeUnit:toNanos	(J)J
    //   12: lstore 6
    //   14: aload_1
    //   15: getfield 131	com/google/common/util/concurrent/Monitor$Guard:b	Lcom/google/common/util/concurrent/Monitor;
    //   18: aload_0
    //   19: if_acmpne +27 -> 46
    //   22: iconst_1
    //   23: istore 5
    //   25: iload 5
    //   27: aload_0
    //   28: getfield 34	com/google/common/util/concurrent/Monitor:b	Ljava/util/concurrent/locks/ReentrantLock;
    //   31: invokevirtual 149	java/util/concurrent/locks/ReentrantLock:isHeldByCurrentThread	()Z
    //   34: iand
    //   35: ifne +17 -> 52
    //   38: new 133	java/lang/IllegalMonitorStateException
    //   41: dup
    //   42: invokespecial 134	java/lang/IllegalMonitorStateException:<init>	()V
    //   45: athrow
    //   46: iconst_0
    //   47: istore 5
    //   49: goto -24 -> 25
    //   52: aload_1
    //   53: invokevirtual 65	com/google/common/util/concurrent/Monitor$Guard:isSatisfied	()Z
    //   56: ifeq +6 -> 62
    //   59: iload 11
    //   61: ireturn
    //   62: invokestatic 109	java/lang/System:nanoTime	()J
    //   65: lstore 8
    //   67: invokestatic 114	java/lang/Thread:interrupted	()Z
    //   70: istore 10
    //   72: iconst_1
    //   73: istore 11
    //   75: lload 6
    //   77: lstore_2
    //   78: aload_0
    //   79: aload_1
    //   80: lload_2
    //   81: iload 11
    //   83: invokespecial 156	com/google/common/util/concurrent/Monitor:a	(Lcom/google/common/util/concurrent/Monitor$Guard;JZ)Z
    //   86: istore 11
    //   88: iload 11
    //   90: istore 12
    //   92: iload 12
    //   94: istore 11
    //   96: iload 10
    //   98: ifeq -39 -> 59
    //   101: invokestatic 124	java/lang/Thread:currentThread	()Ljava/lang/Thread;
    //   104: invokevirtual 127	java/lang/Thread:interrupt	()V
    //   107: iload 12
    //   109: ireturn
    //   110: astore 4
    //   112: aload_1
    //   113: invokevirtual 65	com/google/common/util/concurrent/Monitor$Guard:isSatisfied	()Z
    //   116: istore 10
    //   118: iload 10
    //   120: ifeq +11 -> 131
    //   123: invokestatic 124	java/lang/Thread:currentThread	()Ljava/lang/Thread;
    //   126: invokevirtual 127	java/lang/Thread:interrupt	()V
    //   129: iconst_1
    //   130: ireturn
    //   131: invokestatic 109	java/lang/System:nanoTime	()J
    //   134: lstore_2
    //   135: lload 8
    //   137: lload 6
    //   139: ladd
    //   140: lload_2
    //   141: lsub
    //   142: lstore_2
    //   143: iconst_1
    //   144: istore 10
    //   146: iconst_0
    //   147: istore 11
    //   149: goto -71 -> 78
    //   152: astore_1
    //   153: iload 10
    //   155: ifeq +9 -> 164
    //   158: invokestatic 124	java/lang/Thread:currentThread	()Ljava/lang/Thread;
    //   161: invokevirtual 127	java/lang/Thread:interrupt	()V
    //   164: aload_1
    //   165: athrow
    //   166: astore_1
    //   167: iload 12
    //   169: istore 10
    //   171: goto -18 -> 153
    // Local variable table:
    //   start	length	slot	name	signature
    //   0	174	0	this	Monitor
    //   0	174	1	paramGuard	Guard
    //   0	174	2	paramLong	long
    //   0	174	4	paramTimeUnit	TimeUnit
    //   23	25	5	i	int
    //   12	126	6	l1	long
    //   65	71	8	l2	long
    //   70	100	10	bool1	boolean
    //   4	144	11	bool2	boolean
    //   1	167	12	bool3	boolean
    // Exception table:
    //   from	to	target	type
    //   78	88	110	java/lang/InterruptedException
    //   78	88	152	finally
    //   112	118	166	finally
    //   131	135	166	finally
  }
  
  @Beta
  public static abstract class Guard
  {
    final Monitor b;
    final Condition c;
    @GuardedBy("monitor.lock")
    int d = 0;
    @GuardedBy("monitor.lock")
    Guard e;
    
    protected Guard(Monitor paramMonitor)
    {
      this.b = ((Monitor)Preconditions.checkNotNull(paramMonitor, "monitor"));
      this.c = Monitor.a(paramMonitor).newCondition();
    }
    
    public abstract boolean isSatisfied();
  }
}


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