play.libs

## Class F.Promise<V>

- java.lang.Object
- - play.libs.F.Promise<V>

All Implemented Interfaces:
  java.util.concurrent.Future<V>, F.Action<V>

Direct Known Subclasses:
  F.Timeout

Enclosing class:
  F

    public static class F.Promise<V>
    extends java.lang.Object
    implements java.util.concurrent.Future<V>, F.Action<V>

### Field Summary

Fields
`protected java.util.List<F.Action<F.Promise<V>>>` `callbacks`
`protected boolean` `cancelled`
`protected java.lang.Throwable` `exception`
`protected boolean` `invoked`
`protected V` `result`
`protected java.util.concurrent.CountDownLatch` `taskLock`

### Constructor Summary

Constructors
Constructor and Description
`Promise()`

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`boolean` `cancel(boolean mayInterruptIfRunning)`
`V` `get()`
`V` `get(long timeout, java.util.concurrent.TimeUnit unit)`
`V` `getOrNull()`
`void` `invoke(V result)`
`void` `invokeWithException(java.lang.Throwable t)`
`protected void` `invokeWithResultOrException(V result, java.lang.Throwable t)`
`boolean` `isCancelled()`
`boolean` `isDone()`
`void` `onRedeem(F.Action<F.Promise<V>> callback)` Registers an action that is to be invoked after this promise is invoked.
`static <A,B> F.Promise<F.Tuple<A,B>>` `wait2(F.Promise<A> tA, F.Promise<B> tB)`
`static <A,B,C> F.Promise<F.T3<A,B,C>>` `wait3(F.Promise<A> tA, F.Promise<B> tB, F.Promise<C> tC)`
`static <A,B,C,D> F.Promise<F.T4<A,B,C,D>>` `wait4(F.Promise<A> tA, F.Promise<B> tB, F.Promise<C> tC, F.Promise<D> tD)`
`static <A,B,C,D,E> F.Promise<F.T5<A,B,C,D,E>>` `wait5(F.Promise<A> tA, F.Promise<B> tB, F.Promise<C> tC, F.Promise<D> tD, F.Promise<E> tE)`
`static <T> F.Promise<java.util.List<T>>` `waitAll(java.util.Collection<F.Promise<T>> promises)`
`static <T> F.Promise<java.util.List<T>>` `waitAll(F.Promise<T>... promises)`
`static <T> F.Promise<T>` `waitAny(F.Promise<T>... futures)`
`static <A,B> F.Promise<F.Either<A,B>>` `waitEither(F.Promise<A> tA, F.Promise<B> tB)`
`static <A,B,C> F.Promise<F.E3<A,B,C>>` `waitEither(F.Promise<A> tA, F.Promise<B> tB, F.Promise<C> tC)`
`static <A,B,C,D> F.Promise<F.E4<A,B,C,D>>` `waitEither(F.Promise<A> tA, F.Promise<B> tB, F.Promise<C> tC, F.Promise<D> tD)`
`static <A,B,C,D,E> F.Promise<F.E5<A,B,C,D,E>>` `waitEither(F.Promise<A> tA, F.Promise<B> tB, F.Promise<C> tC, F.Promise<D> tD, F.Promise<E> tE)`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### taskLock

    protected final java.util.concurrent.CountDownLatch taskLock

#### cancelled

    protected boolean cancelled

#### callbacks

    protected java.util.List<F.Action<F.Promise<V>>> callbacks

#### invoked

    protected boolean invoked

#### result

    protected V result

#### exception

    protected java.lang.Throwable exception

### Constructor Detail

#### Promise

    public Promise()

### Method Detail

#### cancel

    public boolean cancel(boolean mayInterruptIfRunning)

Specified by:
  `cancel` in interface `java.util.concurrent.Future<V>`

#### isCancelled

    public boolean isCancelled()

Specified by:
  `isCancelled` in interface `java.util.concurrent.Future<V>`

#### isDone

    public boolean isDone()

Specified by:
  `isDone` in interface `java.util.concurrent.Future<V>`

#### getOrNull

    public V getOrNull()

#### get

    public V get()
          throws java.lang.InterruptedException,
                 java.util.concurrent.ExecutionException

Specified by:
  `get` in interface `java.util.concurrent.Future<V>`
Throws:
  `java.lang.InterruptedException`
  `java.util.concurrent.ExecutionException`

#### get

    public V get(long timeout,
                 java.util.concurrent.TimeUnit unit)
          throws java.lang.InterruptedException,
                 java.util.concurrent.ExecutionException,
                 java.util.concurrent.TimeoutException

Specified by:
  `get` in interface `java.util.concurrent.Future<V>`
Throws:
  `java.lang.InterruptedException`
  `java.util.concurrent.ExecutionException`
  `java.util.concurrent.TimeoutException`

#### invoke

    public void invoke(V result)

Specified by:
  `invoke` in interface `F.Action<V>`

#### invokeWithException

    public void invokeWithException(java.lang.Throwable t)

#### invokeWithResultOrException

    protected void invokeWithResultOrException(V result,
                                               java.lang.Throwable t)

#### onRedeem

    public void onRedeem(F.Action<F.Promise<V>> callback)

Registers an action that is to be invoked after this promise is invoked. You may register more than one "onRedeem" callback. Each registered callback is guaranteed to be invoked exactly once after this promise has been invoked.

The thread from which the "onRedeem" callback is invoked is not defined.

Parameters:
  `callback` - The callback action to invoke when this promise.

#### waitAll

    public static <T> F.Promise<java.util.List<T>> waitAll(F.Promise<T>... promises)

#### waitAll

    public static <T> F.Promise<java.util.List<T>> waitAll(java.util.Collection<F.Promise<T>> promises)

#### wait2

    public static <A,B> F.Promise<F.Tuple<A,B>> wait2(F.Promise<A> tA,
                                                      F.Promise<B> tB)

#### wait3

    public static <A,B,C> F.Promise<F.T3<A,B,C>> wait3(F.Promise<A> tA,
                                                       F.Promise<B> tB,
                                                       F.Promise<C> tC)

#### wait4

    public static <A,B,C,D> F.Promise<F.T4<A,B,C,D>> wait4(F.Promise<A> tA,
                                                           F.Promise<B> tB,
                                                           F.Promise<C> tC,
                                                           F.Promise<D> tD)

#### wait5

    public static <A,B,C,D,E> F.Promise<F.T5<A,B,C,D,E>> wait5(F.Promise<A> tA,
                                                               F.Promise<B> tB,
                                                               F.Promise<C> tC,
                                                               F.Promise<D> tD,
                                                               F.Promise<E> tE)

#### waitEither

    public static <A,B> F.Promise<F.Either<A,B>> waitEither(F.Promise<A> tA,
                                                            F.Promise<B> tB)

#### waitEither

    public static <A,B,C> F.Promise<F.E3<A,B,C>> waitEither(F.Promise<A> tA,
                                                            F.Promise<B> tB,
                                                            F.Promise<C> tC)

#### waitEither

    public static <A,B,C,D> F.Promise<F.E4<A,B,C,D>> waitEither(F.Promise<A> tA,
                                                                F.Promise<B> tB,
                                                                F.Promise<C> tC,
                                                                F.Promise<D> tD)

#### waitEither

    public static <A,B,C,D,E> F.Promise<F.E5<A,B,C,D,E>> waitEither(F.Promise<A> tA,
                                                                    F.Promise<B> tB,
                                                                    F.Promise<C> tC,
                                                                    F.Promise<D> tD,
                                                                    F.Promise<E> tE)

#### waitAny

    public static <T> F.Promise<T> waitAny(F.Promise<T>... futures)