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

Modifier and Type	Field and Description
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

Modifier and Type	Method and Description
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)
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)

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)