org.esbtools.eventhandler

Class NestedTransformableFuture<U>

java.lang.Object

org.esbtools.eventhandler.NestedTransformableFuture<U>

All Implemented Interfaces:

Future<U>, TransformableFuture<U>

public class NestedTransformableFuture<U>
extends Object
implements TransformableFuture<U>

Constructor Summary

Constructors

Constructor and Description
NestedTransformableFuture(TransformableFuture<TransformableFuture<U>> nestedFuture)

Method Summary

Modifier and Type	Method and Description
boolean	cancel(boolean mayInterruptIfRunning)
U	get()
U	get(long timeout, TimeUnit unit)
boolean	isCancelled()
boolean	isDone()
<V> TransformableFuture<V>	transformAsync(FutureTransform<U,TransformableFuture<V>> futureTransform) Creates a new Future which is backed by the Future returned from the provided futureTransform function.
TransformableFuture<Void>	transformAsyncIgnoringReturn(FutureTransform<U,TransformableFuture<?>> futureTransform) Like TransformableFuture.transformAsync(FutureTransform), except useful in cases where you intentionally do not care about the result value contained in the transform functions returned Future.
<V> TransformableFuture<V>	transformSync(FutureTransform<U,V> futureTransform) Creates a new Future which is completed immediately when this Future completes, with a value that is the result of applying the provided futureTransform function to this Future's result.
TransformableFuture<U>	whenDoneOrCancelled(FutureDoneCallback callback) Because the result in this context is the result of a nested future, and "done" implies having a result, we put off calling the callbacks until the nested future is done to coincide with when this future has a result.

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.esbtools.eventhandler.TransformableFuture

immediate, immediateFailed

Constructor Detail

NestedTransformableFuture

public NestedTransformableFuture(TransformableFuture<TransformableFuture<U>> nestedFuture)

Method Detail

cancel

public boolean cancel(boolean mayInterruptIfRunning)

Specified by:

cancel in interface Future<U>

isCancelled

public boolean isCancelled()

Specified by:

isCancelled in interface Future<U>

isDone

public boolean isDone()

Specified by:

isDone in interface Future<U>

get

public U get()
      throws InterruptedException,
             ExecutionException

Specified by:

get in interface Future<U>

Throws:

InterruptedException

ExecutionException

get

public U get(long timeout,
             TimeUnit unit)
      throws InterruptedException,
             ExecutionException,
             TimeoutException

Specified by:

get in interface Future<U>

Throws:

InterruptedException

ExecutionException

TimeoutException

transformSync

public <V> TransformableFuture<V> transformSync(FutureTransform<U,V> futureTransform)

Description copied from interface: TransformableFuture

Creates a new Future which is completed immediately when this Future completes, with a value that is the result of applying the provided futureTransform function to this Future's result.

Terminology inspired by Guava's Futures extensions.

Specified by:

transformSync in interface TransformableFuture<U>

Type Parameters:

V - The type of new result.

Parameters:

futureTransform - Function which accepts the result from this future and returns a new result or throws an exception if a result cannot be computed. This new result is what will be returned from the returned Future.

transformAsync

public <V> TransformableFuture<V> transformAsync(FutureTransform<U,TransformableFuture<V>> futureTransform)

Description copied from interface: TransformableFuture

Creates a new Future which is backed by the Future returned from the provided futureTransform function.

Use this when you need to add a callback on an existing TransformableFuture which returns yet another Future, chaining several asynchronous actions together into one final result Future. If you just used TransformableFuture.transformSync(FutureTransform) you'd end up with a Future<Future<U>> (a future who's result is another future) which is difficult to work with. By using this API, the result Future is "unwrapped" and you get a more intuitive Future<U> to work with.

Terminology inspired by Guava's Futures extensions such as AsyncFunction.

Specified by:

transformAsync in interface TransformableFuture<U>

Type Parameters:

V - The type of the result within the returned Future of the transform function.

Parameters:

futureTransform - Function which accepts the result from this future and returns either a new Future or null.

transformAsyncIgnoringReturn

public TransformableFuture<Void> transformAsyncIgnoringReturn(FutureTransform<U,TransformableFuture<?>> futureTransform)

Description copied from interface: TransformableFuture

Like TransformableFuture.transformAsync(FutureTransform), except useful in cases where you intentionally do not care about the result value contained in the transform functions returned Future.

APIs like Message.process() may intentionally require the parameterized type of Future<Void> to clearly document that both the result of the Future is unused (we only care if it succeeded or not) and to prevent an implementor from accidentally returning a Future<Future> which would never have its result Future examined because the consumer is ignoring the return value. This would definitely be a bug.

Specified by:

transformAsyncIgnoringReturn in interface TransformableFuture<U>

whenDoneOrCancelled

public TransformableFuture<U> whenDoneOrCancelled(FutureDoneCallback callback)

Because the result in this context is the result of a nested future, and "done" implies having a result, we put off calling the callbacks until the nested future is done to coincide with when this future has a result.

Specified by:

whenDoneOrCancelled in interface TransformableFuture<U>