class Future[T] extends AnyRef
Represents the result of an action that may, or may not, have occurred yet.
- Alphabetic
- By Inheritance
- Future
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
- new Future(_asJava: AnyRef)(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T])
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
- def asJava: AnyRef
-
def
cause(): Throwable
A Throwable describing failure.
A Throwable describing failure. This will be null if the operation succeeded. * @return the cause or null if the operation succeeded.
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
complete(): Unit
Set a null result.
Set a null result. Any handler will be called, if there is one, and the future will be marked as completed.
-
def
complete(result: T): Unit
Set the result.
Set the result. Any handler will be called, if there is one, and the future will be marked as completed. * @param result the result
-
def
completer(): Handler[AsyncResult[T]]
- returns
an handler completing this future
-
def
compose[U](successMapper: (T) ⇒ Future[U], failureMapper: (Throwable) ⇒ Future[U])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[U]): Future[U]
Compose this future with a
successMapper
andfailureMapper
functions.Compose this future with a
successMapper
andfailureMapper
functions.When this future (the one on which
compose
is called) succeeds, thesuccessMapper
will be called with the completed value and this mapper returns another future object. This returned future completion will complete the future returned by this method call.When this future (the one on which
compose
is called) fails, thefailureMapper
will be called with the failure and this mapper returns another future object. This returned future completion will complete the future returned by this method call.If any mapper function throws an exception, the returned future will be failed with this exception. * @param successMapper the function mapping the success
- failureMapper
the function mapping the failure
- returns
the composed future
-
def
compose[U](mapper: (T) ⇒ Future[U])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[U]): Future[U]
Compose this future with a
mapper
function.Compose this future with a
mapper
function.When this future (the one on which
compose
is called) succeeds, themapper
will be called with the completed value and this mapper returns another future object. This returned future completion will complete the future returned by this method call.If the
mapper
throws an exception, the returned future will be failed with this exception.When this future fails, the failure will be propagated to the returned future and the
mapper
will not be called. * @param mapper the mapper function- returns
the composed future
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
fail(failureMessage: String): Unit
Try to set the failure.
Try to set the failure. When it happens, any handler will be called, if there is one, and the future will be marked as completed. * @param failureMessage the failure message
-
def
fail(cause: Throwable): Unit
Set the failure.
Set the failure. Any handler will be called, if there is one, and the future will be marked as completed. * @param cause the failure cause
-
def
failed(): Boolean
Did it fail? * @return true if it failed or false otherwise
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
flatMap[U](mapper: (T) ⇒ Future[U])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[U]): Future[U]
Alias for io.vertx.scala.core.Future#compose.
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
isComplete(): Boolean
Has the future completed?
Has the future completed?
It's completed if it's either succeeded or failed. * @return true if completed, false if not
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
map[V](value: V)(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[V]): Future[V]
Map the result of a future to a specific
value
.Map the result of a future to a specific
value
.When this future succeeds, this
value
will complete the future returned by this method call.When this future fails, the failure will be propagated to the returned future. * @param value the value that eventually completes the mapped future
- returns
the mapped future
-
def
map[U](mapper: (T) ⇒ U)(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[U]): Future[U]
Apply a
mapper
function on this future.Apply a
mapper
function on this future.When this future succeeds, the
mapper
will be called with the completed value and this mapper returns a value. This value will complete the future returned by this method call.If the
mapper
throws an exception, the returned future will be failed with this exception.When this future fails, the failure will be propagated to the returned future and the
mapper
will not be called. * @param mapper the mapper function- returns
the mapped future
-
def
mapEmpty[V]()(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[V]): Future[V]
Map the result of a future to
null
.Map the result of a future to
null
.This is a conveniency for
future.map((T) null)
orfuture.map((Void) null)
.When this future succeeds,
null
will complete the future returned by this method call.When this future fails, the failure will be propagated to the returned future. * @return the mapped future
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
onComplete(handler: Handler[AsyncResult[T]]): Future[T]
Add a handler to be notified of the result.
Add a handler to be notified of the result.
* @param handler the handler that will be called with the result- returns
a reference to this, so it can be used fluently
-
def
onFailure(handler: Handler[Throwable]): Future[T]
Add a handler to be notified of the failed result.
Add a handler to be notified of the failed result.
* @param handler the handler that will be called with the failed result- returns
a reference to this, so it can be used fluently
-
def
onSuccess(handler: Handler[T]): Future[T]
Add a handler to be notified of the succeeded result.
Add a handler to be notified of the succeeded result.
* @param handler the handler that will be called with the succeeded result- returns
a reference to this, so it can be used fluently
-
def
otherwise(value: T): Future[T]
Map the failure of a future to a specific
value
.Map the failure of a future to a specific
value
.When this future fails, this
value
will complete the future returned by this method call.When this future succeeds, the result will be propagated to the returned future. * @param value the value that eventually completes the mapped future
- returns
the mapped future
-
def
otherwise(mapper: (Throwable) ⇒ T): Future[T]
Apply a
mapper
function on this future.Apply a
mapper
function on this future.When this future fails, the
mapper
will be called with the completed value and this mapper returns a value. This value will complete the future returned by this method call.If the
mapper
throws an exception, the returned future will be failed with this exception.When this future succeeds, the result will be propagated to the returned future and the
mapper
will not be called. * @param mapper the mapper function- returns
the mapped future
-
def
otherwiseEmpty(): Future[T]
Map the failure of a future to
null
.Map the failure of a future to
null
.This is a convenience for
future.otherwise((T) null)
.When this future fails, the
null
value will complete the future returned by this method call.When this future succeeds, the result will be propagated to the returned future. * @return the mapped future
-
def
recover(mapper: (Throwable) ⇒ Future[T]): Future[T]
Handles a failure of this Future by returning the result of another Future.
Handles a failure of this Future by returning the result of another Future. If the mapper fails, then the returned future will be failed with this failure. * @param mapper A function which takes the exception of a failure and returns a new future.
- returns
A recovered future
-
def
result(): T
The result of the operation.
The result of the operation. This will be null if the operation failed. * @return the result or null if the operation failed.
- def setHandler(handler: Handler[AsyncResult[T]]): Future[T]
-
def
succeeded(): Boolean
Did it succeed? * @return true if it succeded or false otherwise
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
tryComplete(): Boolean
Try to set the result.
Try to set the result. When it happens, any handler will be called, if there is one, and the future will be marked as completed. * @return false when the future is already completed
-
def
tryComplete(result: T): Boolean
Set the failure.
Set the failure. Any handler will be called, if there is one, and the future will be marked as completed. * @param result the result
- returns
false when the future is already completed
-
def
tryFail(failureMessage: String): Boolean
Try to set the failure.
Try to set the failure. When it happens, any handler will be called, if there is one, and the future will be marked as completed. * @param failureMessage the failure message
- returns
false when the future is already completed
-
def
tryFail(cause: Throwable): Boolean
Try to set the failure.
Try to set the failure. When it happens, any handler will be called, if there is one, and the future will be marked as completed. * @param cause the failure cause
- returns
false when the future is already completed
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )