Future (qi Java bindings for Android 4.0.0 API)

java.lang.Object
- com.aldebaran.qi.Future<T>

Type Parameters:
T - The type of the result

All Implemented Interfaces:

Future<T>
```
public class Future<T>
extends Object
implements Future<T>
```
Future extends the standard Java Future and represents the result of an asynchronous computation.
Promise and Future are two complementary concepts. They are designed to synchronize data between multiples threads. The Future holds the result of an asynchronous computation, from which you can retrieve the value of the result; the Promise sets the value of this computation, which resolves the associated Future.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface Future.Callback<T>

Nested Classes
Modifier and Type	Class and Description
`static interface`	`Future.Callback<T>`

Method Summary

Methods
Modifier and Type	Method and Description
`<R> Future<R>`	`andThenApply(Function<T,R> function)` Launch a task when the task link when this future succeed only
`<R> Future<R>`	`andThenCompose(Function<T,Future<R>> function)` Launch a task when the task link when this future succeed only. Instead of return a Future>, it will automatically unwrap the result to have a Future<R>
`Future<Void>`	`andThenConsume(Consumer<T> consumer)` Launch a task when the task link when this future succeed only
`boolean`	`cancel()` Deprecated.
`boolean`	`cancel(boolean mayInterruptIfRunning)`
`static <T> Future<T>`	`cancelled()`
`void`	`connect(Future.Callback<T> callback)`
`void`	`connect(Future.Callback<T> callback, FutureCallbackType futureCallbackType)` Prefer `#then(FutureFunction, FutureCallbackType)` instead (e.g.
`protected void`	`finalize()` Called by garbage collector Finalize is overridden to manually delete C++ data
`static <T> Future<T>`	`fromError(String errorMessage)`
`T`	`get()`
`T`	`get(long timeout, TimeUnit unit)`
`ExecutionException`	`getError()`
`String`	`getErrorMessage()`
`T`	`getValue()` Same as `get()`, but does not throw checked exceptions.
`boolean`	`hasError()`
`boolean`	`isCancelled()`
`boolean`	`isDone()`
`boolean`	`isSuccess()`
`static <T> Future<T>`	`of(T value)`
`void`	`requestCancellation()` Sends asynchronously a request to cancel the execution of this task.
`void`	`sync()`
`void`	`sync(long timeout, TimeUnit unit)`
`<R> Future<R>`	`thenApply(Function<Future<T>,R> function)` Launch a task when the task link when this future finished (succeed, error or cancelled)
`<R> Future<R>`	`thenCompose(Function<Future<T>,Future<R>> function)` Launch a task when the task link when this future finished (succeed, error or cancelled). Instead of return a Future>, it will automatically unwrap the result to have a Future<R>
`Future<Void>`	`thenConsume(Consumer<Future<T>> consumer)` Launch a task when the task link when this future finished (succeed, error or cancelled)
`static Future<Void>`	`waitAll(Future<?>... futures)` Wait for all `futures` to complete.
`Future<T>`	`waitFor(Future<?>... futures)` Return a version of `this` future that waits until `futures` to finish.

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - of
```
public static <T> Future<T> of(T value)
```
  - cancelled
```
public static <T> Future<T> cancelled()
```
  - fromError
```
public static <T> Future<T> fromError(String errorMessage)
```
  - sync
```
public void sync(long timeout,
        TimeUnit unit)
```
  - sync
```
public void sync()
```
  - connect
```
public void connect(Future.Callback<T> callback,
           FutureCallbackType futureCallbackType)
```
    Prefer #then(FutureFunction, FutureCallbackType) instead (e.g.
  - connect
```
public void connect(Future.Callback<T> callback)
```
  - cancel
```
public boolean cancel(boolean mayInterruptIfRunning)
```
    Specified by:
    
    cancel in interface Future<T>
  - requestCancellation
```
public void requestCancellation()
```
    Sends asynchronously a request to cancel the execution of this task.
  - cancel
```
@Deprecated
public boolean cancel()
```
    Deprecated.
  - get
```
public T get()
      throws ExecutionException
```
    Specified by:
    
    get in interface Future<T>
    
    Throws:
    
    ExecutionException
  - get
```
public T get(long timeout,
    TimeUnit unit)
      throws ExecutionException,
             TimeoutException
```
    Specified by:
    
    get in interface Future<T>
    
    Throws:
    
    ExecutionException
    
    TimeoutException
  - getValue
```
public T getValue()
```
    Same as get(), but does not throw checked exceptions.
    This is especially useful for getting the value of a future that we know is complete with success.
    
    Returns:
    the future value
  - getError
```
public ExecutionException getError()
```
  - hasError
```
public boolean hasError()
```
  - getErrorMessage
```
public String getErrorMessage()
```
  - isCancelled
```
public boolean isCancelled()
```
    Specified by:
    
    isCancelled in interface Future<T>
  - isDone
```
public boolean isDone()
```
    Specified by:
    
    isDone in interface Future<T>
  - isSuccess
```
public boolean isSuccess()
```
  - thenApply
```
public <R> Future<R> thenApply(Function<Future<T>,R> function)
```
    Launch a task when the task link when this future finished (succeed, error or cancelled)
    
    Type Parameters:
    R - Function result type
    Parameters:
    function - Function to call when action the task link when this future finished
    
    Returns:
    Future for able to link to the end of the global execution (the task link to this future and given function) status
  - thenConsume
```
public Future<Void> thenConsume(Consumer<Future<T>> consumer)
```
    Launch a task when the task link when this future finished (succeed, error or cancelled)
    
    Parameters:
    consumer - Consumer to call when action the task link when this future finished
    
    Returns:
    Future for able to link to the end of the global execution (the task link to this future and given ) status
  - thenCompose
```
public <R> Future<R> thenCompose(Function<Future<T>,Future<R>> function)
```
    Launch a task when the task link when this future finished (succeed, error or cancelled).
    Instead of return a Future>, it will automatically unwrap the result to have a Future<R>
    
    Type Parameters:
    R - Function result type
    Parameters:
    function - Function to call when action the task link when this future finished
    
    Returns:
    Future for able to link to the end of the global execution (the task link to this future and given ) status
  - andThenApply
```
public <R> Future<R> andThenApply(Function<T,R> function)
```
    Launch a task when the task link when this future succeed only
    
    Type Parameters:
    R - Function result type
    Parameters:
    function - Function to call when action the task link when this future succeed only
    
    Returns:
    Future for able to link to the end of the global execution (the task link to this future and given function) status
  - andThenConsume
```
public Future<Void> andThenConsume(Consumer<T> consumer)
```
    Launch a task when the task link when this future succeed only
    
    Parameters:
    consumer - Consumer to call when action the task link when this future succeed only
    
    Returns:
    Future for able to link to the end of the global execution (the task link to this future and given ) status
  - andThenCompose
```
public <R> Future<R> andThenCompose(Function<T,Future<R>> function)
```
    Launch a task when the task link when this future succeed only.
    Instead of return a Future>, it will automatically unwrap the result to have a Future<R>
    
    Type Parameters:
    R - Function result type
    Parameters:
    function - Function to call when action the task link when this future succeed only
    
    Returns:
    Future for able to link to the end of the global execution (the task link to this future and given ) status
  - waitAll
```
public static Future<Void> waitAll(Future<?>... futures)
```
    Wait for all futures to complete.
    The returning future finishes successfully if and only if all of the futures it waits for finish successfully.
    Otherwise, it takes the state of the first failing future (due to cancellation or error).
    
    Parameters:
    futures - the futures to wait for
    
    Returns:
    a future waiting for all the others
  - waitFor
```
public Future<T> waitFor(Future<?>... futures)
```
    Return a version of this future that waits until futures to finish.
    The returning future finishes successfully if and only if this future and futures finish successfully.
    Otherwise, it takes the state of this if it failed, or the first failing future from futures.
    If this future does not finish successfully, it does not wait for futures.
    
    Parameters:
    futures - the futures to wait for
    
    Returns:
    future returning this future value when all futures are finished successfully
  - finalize
```
protected void finalize()
                 throws Throwable
```
    Called by garbage collector Finalize is overridden to manually delete C++ data
    
    Overrides:
    
    finalize in class Object
    
    Throws:
    
    Throwable

Class Future<T>

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

of

cancelled

fromError

sync

sync

connect

connect

cancel

requestCancellation

cancel

get

get

getValue

getError

hasError

getErrorMessage

isCancelled

isDone

isSuccess

thenApply

thenConsume

thenCompose

andThenApply

andThenConsume

andThenCompose

waitAll

waitFor

finalize