Register a FutureEventListener to be invoked when the computation completes.
Register a FutureEventListener to be invoked when the computation completes. This method is typically used by Java programs because it avoids the use of small Function objects.
Compare this method to transformedBy
. The difference is that
addEventListener
is used to perform a simple action when a
computation completes, such as recording data in a log-file. It
analogous to a void
method in Java: it has side-effects and no
return value. transformedBy
, on the other hand, is used to
transform values from one type to another, or to chain a series
of asynchronous calls and return the result. It is analogous to
methods in Java that have a return-type. Note that
transformedBy
and addEventListener
are not mutually
exclusive and may be profitably combined.
Sequentially compose this
with f
.
Sequentially compose this
with f
. This is as flatMap
, but
discards the result of this
. Note that this applies only
Unit
-valued Futures -- i.e. side-effects..
Delay the completion of this Future for at least
howlong
from now.
Delay the completion of this Future for at least
howlong
from now.
Invoked regardless of whether the computation completed successfully or unsuccessfully.
Invoked regardless of whether the computation completed successfully or unsuccessfully.
Implemented in terms of respond
so that subclasses control evaluation order. Returns a
chained Future.
If this, the original future, succeeds, run f on the result.
If this, the original future, succeeds, run f on the result.
The returned result is a Future that is satisfied when the original future and the callback, f, are done. If the original future fails, this one will also fail, without executing f.
map()
Converts a Future[Future[B]] into a Future[B]
Converts a Future[Future[B]] into a Future[B]
Invoke the callback only if the Future returns successfully.
Invoke the callback only if the Future returns successfully. Useful for Scala for
comprehensions. Use onSuccess
instead of this method for more readable code.
Makes a derivative Future which will be satisfied with the result of the parent.
Makes a derivative Future which will be satisfied with the result of the parent. However, if it's interrupted, it will detach from the parent Future, satisfy itself with the exception raised to it, and won't propagate the interruption back to the parent Future.
This is useful for when a Future is shared between many contexts, where it may not be useful to discard the underlying computation if just one context is no longer interested in the result. In particular, this is different from Future#masked in that it will prevent memory leaks if the parent Future will never be satisfied, because closures that are attached to this derivative Future will not be held onto by the killer Future.
Is the result of the Future available yet?
Is the result of the Future available yet?
Checks whether a Unit-typed Future is done.
Checks whether a Unit-typed Future is done. By convention, futures of type Future[Unit] are used for signalling.
Is this Awaitable ready? In other words: would calling Awaitable.ready block?
Is this Awaitable ready? In other words: would calling Awaitable.ready block?
Combines two Futures into one Future of the Tuple of the two results.
Combines two Futures into one Future of the Tuple of the two results.
Returns the result of the computation as a Future[Try[A]].
Returns the result of the computation as a Future[Try[A]].
If this, the original future, succeeds, run f on the result.
If this, the original future, succeeds, run f on the result.
The returned result is a Future that is satisfied when the original future and the callback, f, are done. If the original future fails, this one will also fail, without executing f.
flatMap()
Returns an identical future except that it ignores interrupts which match a predicate
Returns an identical future except that it ignores interrupts which match a predicate
Returns an identical future that ignores all interrupts
Returns an identical future that ignores all interrupts
Invoke the function on the error, if the computation was unsuccessful.
Invoke the function on the error, if the computation was
unsuccessful. Returns a chained Future as in respond
.
chained Future
Invoke the function on the result, if the computation was successful.
Invoke the function on the result, if the computation was
successful. Returns a chained Future as in respond
.
chained Future
A synonym for select(): Choose the first Future to be satisfied.
A synonym for select(): Choose the first Future to be satisfied.
Polls for an available result.
Send updates from this Future to the other.
Send updates from this Future to the other.
other
must not yet be satisfied at the time of the call.
After this call, nobody else should satisfy other
.
Raise the given throwable as an interrupt.
Raise the given throwable as an interrupt. Interrupts are
one-shot and latest-interrupt wins. That is, the last interrupt
to have been raised is delivered exactly once to the Promise
responsible for making progress on the future (multiple such
promises may be involved in flatMap
chains).
Raising an interrupt does not alter the externally observable state of the Future. They are used to signal to the producer of the future's value that the result is no longer desired (for whatever reason given in the passed Throwable).
Returns a new Future that will error if this Future does not return in time.
Returns a new Future that will error if this Future does not return in time.
Note: On timeout, the underlying future is interrupted.
Same as the other raiseWithin, but with an implicit timer.
Same as the other raiseWithin, but with an implicit timer. Sometimes this is more convenient.
Note: On timeout, the underlying future is interrupted.
Same as the other raiseWithin, but with an implicit timer.
Same as the other raiseWithin, but with an implicit timer. Sometimes this is more convenient.
Note: On timeout, the underlying future is interrupted.
Support for Await.ready
.
When the computation completes, invoke the given callback function.
When the computation completes, invoke the given callback function. Respond() yields a Try (either a Return or a Throw). This method is most useful for very generic code (like libraries). Otherwise, it is a best practice to use one of the alternatives (onSuccess(), onFailure(), etc.). Note that almost all methods on Future[_] are written in terms of respond(), so this is the essential template method for use in concrete subclasses.
a chained Future[A]
Support for Await.result
.
Choose the first Future to be satisfied.
Choose the first Future to be satisfied.
another Future
a new Future whose result is that of the first of this and other to return
Convert a Twitter Future to a Java native Future.
Convert a Twitter Future to a Java native Future. This should match the semantics of a Java Future as closely as possible to avoid issues with the way another API might use them. See:
http://download.oracle.com/javase/6/docs/api/java/util/concurrent/Future.html#cancel(boolean)
An offer for this future.
An offer for this future. The offer is activated when the future is satisfied.
Transform the Future[A] into a Future[B] using the FutureTransformer.
Transform the Future[A] into a Future[B] using the FutureTransformer. The FutureTransformer handles both success (Return) and failure (Throw) values by implementing map/flatMap and handle/rescue. This method is typically used by Java programs because it avoids the use of small Function objects.
Compare this method to addEventListener
. The difference is
that addEventListener
is used to perform a simple action when
a computation completes, such as recording data in a log-file.
It analogous to a void
method in Java: it has side-effects and
no return value. transformedBy
, on the other hand, is used to
transform values from one type to another, or to chain a series
of asynchronous calls and return the result. It is analogous to
methods in Java that have a return-type. Note that
transformedBy
and addEventListener
are not mutually
exclusive and may be profitably combined.
Note: The FutureTransformer must implement either flatMap
or map
and may optionally implement handle
. Failing to
implement a method will result in a run-time (AbstractMethod)
error.
Convert this Future[A] to a Future[Unit] by discarding the result.
Convert this Future[A] to a Future[Unit] by discarding the result.
Convert this Future[A] to a Future[Void] by discarding the result.
Convert this Future[A] to a Future[Void] by discarding the result.
Returns a Future[Boolean] indicating whether two Futures are equivalent.
Returns a Future[Boolean] indicating whether two Futures are equivalent. Note that Future.exception(e).willEqual(Future.exception(e)) == Future.value(true).
Returns a new Future that will error if this Future does not return in time.
Returns a new Future that will error if this Future does not return in time.
Note: On timeout, the underlying future is not interrupted.
to run timeout on.
indicates how long you are willing to wait for the result to be available.
exception to throw.
Returns a new Future that will error if this Future does not return in time.
Returns a new Future that will error if this Future does not return in time.
Note: On timeout, the underlying future is not interrupted.
Same as the other within, but with an implicit timer.
Same as the other within, but with an implicit timer. Sometimes this is more convenient.
Note: On timeout, the underlying future is not interrupted.
Block, but only as long as the given Timeout.
Block, but only as long as the given Timeout.
(Since version 6.2.x) Use Await.result
Block indefinitely, wait for the result of the Future to be available.
Block indefinitely, wait for the result of the Future to be available.
(Since version 6.2.x) Use Await.result
(Since version 6.0.0) Provided for API compatibility; use raise() instead.
Demands that the result of the future be available within
timeout
.
Demands that the result of the future be available within
timeout
. The result is a Return[_] or Throw[_] depending upon
whether the computation finished in time.
(Since version 6.2.x) Use Await.result(future.liftToTry)
Alias for apply().
Alias for apply().
(Since version 6.2.x) Use Await.result
(Since version 6.2.x) Use Await.result(future.liftToTry).isReturn
(Since version 6.2.x) Use Await.result(future.liftToTry).isThrow
(Since version 5.x) 'void' is a reserved word in javac.
A future with no future (never completes).