/**@class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
 implements java.util.concurrent.locks.Condition

 implements java.io.Serializable

@extends java.lang.Object

 Condition implementation for a {@link java.util.concurrent.locks.AbstractQueuedLongSynchronizer} serving as the basis of a {@link java.util.concurrent.locks.Lock} implementation.

 <p>Method documentation for this class describes mechanics,
 not behavioral specifications from the point of view of Lock
 and Condition users. Exported versions of this class will in
 general need to be accompanied by documentation describing
 condition semantics that rely on those of the associated
 {@code AbstractQueuedLongSynchronizer}.

 <p>This class is Serializable, but all fields are transient,
 so deserialized conditions have no waiters.

 @since 1.6
*/
var ConditionObject = {

/**Moves the longest-waiting thread, if one exists, from the
 wait queue for this condition to the wait queue for the
 owning lock.
@throws IllegalMonitorStateException if {@link #isHeldExclusively}
         returns {@code false}
*/
signal : function(  ) {},

/**Moves all threads from the wait queue for this condition to
 the wait queue for the owning lock.
@throws IllegalMonitorStateException if {@link #isHeldExclusively}
         returns {@code false}
*/
signalAll : function(  ) {},

/**Implements uninterruptible condition wait.
 <ol>
 <li>Save lock state returned by {@link #getState}.
 <li>Invoke {@link #release} with saved state as argument,
     throwing IllegalMonitorStateException if it fails.
 <li>Block until signalled.
 <li>Reacquire by invoking specialized version of
     {@link #acquire} with saved state as argument.
 </ol>
*/
awaitUninterruptibly : function(  ) {},

/**Implements interruptible condition wait.
 <ol>
 <li>If current thread is interrupted, throw InterruptedException.
 <li>Save lock state returned by {@link #getState}.
 <li>Invoke {@link #release} with saved state as argument,
     throwing IllegalMonitorStateException if it fails.
 <li>Block until signalled or interrupted.
 <li>Reacquire by invoking specialized version of
     {@link #acquire} with saved state as argument.
 <li>If interrupted while blocked in step 4, throw InterruptedException.
 </ol>
*/
await : function(  ) {},

/**Implements timed condition wait.
 <ol>
 <li>If current thread is interrupted, throw InterruptedException.
 <li>Save lock state returned by {@link #getState}.
 <li>Invoke {@link #release} with saved state as argument,
     throwing IllegalMonitorStateException if it fails.
 <li>Block until signalled, interrupted, or timed out.
 <li>Reacquire by invoking specialized version of
     {@link #acquire} with saved state as argument.
 <li>If interrupted while blocked in step 4, throw InterruptedException.
 </ol>
*/
awaitNanos : function(  ) {},

/**Implements absolute timed condition wait.
 <ol>
 <li>If current thread is interrupted, throw InterruptedException.
 <li>Save lock state returned by {@link #getState}.
 <li>Invoke {@link #release} with saved state as argument,
     throwing IllegalMonitorStateException if it fails.
 <li>Block until signalled, interrupted, or timed out.
 <li>Reacquire by invoking specialized version of
     {@link #acquire} with saved state as argument.
 <li>If interrupted while blocked in step 4, throw InterruptedException.
 <li>If timed out while blocked in step 4, return false, else true.
 </ol>
*/
awaitUntil : function(  ) {},

/**Implements timed condition wait.
 <ol>
 <li>If current thread is interrupted, throw InterruptedException.
 <li>Save lock state returned by {@link #getState}.
 <li>Invoke {@link #release} with saved state as argument,
     throwing IllegalMonitorStateException if it fails.
 <li>Block until signalled, interrupted, or timed out.
 <li>Reacquire by invoking specialized version of
     {@link #acquire} with saved state as argument.
 <li>If interrupted while blocked in step 4, throw InterruptedException.
 <li>If timed out while blocked in step 4, return false, else true.
 </ol>
*/
await : function(  ) {},


};