bolts

Class Task<TResult>

java.lang.Object

bolts.Task<TResult>

Type Parameters:

TResult - The type of the result of the task.

public class Task<TResult>
extends java.lang.Object

Represents the result of an asynchronous operation.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	Task.TaskCompletionSource Allows safe orchestration of a task's completion, preventing the consumer from prematurely completing the task.

Field Summary

Fields

Modifier and Type	Field and Description
static java.util.concurrent.ExecutorService	BACKGROUND_EXECUTOR An Executor that executes tasks in parallel.
static java.util.concurrent.Executor	UI_THREAD_EXECUTOR An Executor that executes tasks on the UI thread.

Method Summary

Methods

Modifier and Type	Method and Description
static <TResult> Task<TResult>	call(java.util.concurrent.Callable<TResult> callable) Invokes the callable on the current thread, producing a Task.
static <TResult> Task<TResult>	call(java.util.concurrent.Callable<TResult> callable, java.util.concurrent.Executor executor) Invokes the callable using the given executor, returning a Task to represent the operation.
static <TResult> Task<TResult>	callInBackground(java.util.concurrent.Callable<TResult> callable) Invokes the callable on a background thread, returning a Task to represent the operation.
static <TResult> Task<TResult>	cancelled() Creates a cancelled task.
<TOut> Task<TOut>	cast() Makes a fluent cast of a Task's result possible, avoiding an extra continuation just to cast the type of the result.
Task<java.lang.Void>	continueWhile(java.util.concurrent.Callable<java.lang.Boolean> predicate, Continuation<java.lang.Void,Task<java.lang.Void>> continuation) Continues a task with the equivalent of a Task-based while loop, where the body of the loop is a task continuation.
Task<java.lang.Void>	continueWhile(java.util.concurrent.Callable<java.lang.Boolean> predicate, Continuation<java.lang.Void,Task<java.lang.Void>> continuation, java.util.concurrent.Executor executor) Continues a task with the equivalent of a Task-based while loop, where the body of the loop is a task continuation.
<TContinuationResult> Task<TContinuationResult>	continueWith(Continuation<TResult,TContinuationResult> continuation) Adds a synchronous continuation to this task, returning a new task that completes after the continuation has finished running.
<TContinuationResult> Task<TContinuationResult>	continueWith(Continuation<TResult,TContinuationResult> continuation, java.util.concurrent.Executor executor) Adds a continuation that will be scheduled using the executor, returning a new task that completes after the continuation has finished running.
<TContinuationResult> Task<TContinuationResult>	continueWithTask(Continuation<TResult,Task<TContinuationResult>> continuation) Adds an asynchronous continuation to this task, returning a new task that completes after the task returned by the continuation has completed.
<TContinuationResult> Task<TContinuationResult>	continueWithTask(Continuation<TResult,Task<TContinuationResult>> continuation, java.util.concurrent.Executor executor) Adds an Task-based continuation to this task that will be scheduled using the executor, returning a new task that completes after the task returned by the continuation has completed.
static <TResult> Task.TaskCompletionSource	create() Creates a TaskCompletionSource that orchestrates a Task.
static <TResult> Task<TResult>	forError(java.lang.Exception error) Creates a faulted task with the given error.
static <TResult> Task<TResult>	forResult(TResult value) Creates a completed task with the given value.
java.lang.Exception	getError()
TResult	getResult()
boolean	isCancelled()
boolean	isCompleted()
boolean	isFaulted()
Task<java.lang.Void>	makeVoid() Turns a Task into a Task, dropping any result.
<TContinuationResult> Task<TContinuationResult>	onSuccess(Continuation<TResult,TContinuationResult> continuation) Runs a continuation when a task completes successfully, forwarding along Exceptions or cancellation.
<TContinuationResult> Task<TContinuationResult>	onSuccess(Continuation<TResult,TContinuationResult> continuation, java.util.concurrent.Executor executor) Runs a continuation when a task completes successfully, forwarding along Exception or cancellation.
<TContinuationResult> Task<TContinuationResult>	onSuccessTask(Continuation<TResult,Task<TContinuationResult>> continuation) Runs a continuation when a task completes successfully, forwarding along Exceptions or cancellation.
<TContinuationResult> Task<TContinuationResult>	onSuccessTask(Continuation<TResult,Task<TContinuationResult>> continuation, java.util.concurrent.Executor executor) Runs a continuation when a task completes successfully, forwarding along Exceptions or cancellation.
void	waitForCompletion() Blocks until the task is complete.
static Task<java.lang.Void>	whenAll(java.util.Collection<? extends Task<?>> tasks) Creates a task that completes when all of the provided tasks are complete.

Methods inherited from class java.lang.Object

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

Field Detail

BACKGROUND_EXECUTOR

public static final java.util.concurrent.ExecutorService BACKGROUND_EXECUTOR

An Executor that executes tasks in parallel.

UI_THREAD_EXECUTOR

public static final java.util.concurrent.Executor UI_THREAD_EXECUTOR

An Executor that executes tasks on the UI thread.

Method Detail

create

public static <TResult> Task.TaskCompletionSource create()

Creates a TaskCompletionSource that orchestrates a Task. This allows the creator of a task to be solely responsible for its completion.

Returns:

A new TaskCompletionSource.

isCompleted

public boolean isCompleted()

Returns:

true if the task completed (has a result, an error, or was cancelled. false otherwise.

isCancelled

public boolean isCancelled()

Returns:

true if the task was cancelled, false otherwise.

isFaulted

public boolean isFaulted()

Returns:

true if the task has an error, false otherwise.

getResult

public TResult getResult()

Returns:

The result of the task, if set. null otherwise.

getError

public java.lang.Exception getError()

Returns:

The error for the task, if set. null otherwise.

waitForCompletion

public void waitForCompletion()
                       throws java.lang.InterruptedException

Blocks until the task is complete.

Throws:

java.lang.InterruptedException

forResult

public static <TResult> Task<TResult> forResult(TResult value)

Creates a completed task with the given value.

forError

public static <TResult> Task<TResult> forError(java.lang.Exception error)

Creates a faulted task with the given error.

cancelled

public static <TResult> Task<TResult> cancelled()

Creates a cancelled task.

cast

public <TOut> Task<TOut> cast()

Makes a fluent cast of a Task's result possible, avoiding an extra continuation just to cast the type of the result.

makeVoid

public Task<java.lang.Void> makeVoid()

Turns a Task into a Task, dropping any result.

callInBackground

public static <TResult> Task<TResult> callInBackground(java.util.concurrent.Callable<TResult> callable)

Invokes the callable on a background thread, returning a Task to represent the operation.

call

public static <TResult> Task<TResult> call(java.util.concurrent.Callable<TResult> callable,
                           java.util.concurrent.Executor executor)

Invokes the callable using the given executor, returning a Task to represent the operation.

call

public static <TResult> Task<TResult> call(java.util.concurrent.Callable<TResult> callable)

Invokes the callable on the current thread, producing a Task.

whenAll

public static Task<java.lang.Void> whenAll(java.util.Collection<? extends Task<?>> tasks)

Creates a task that completes when all of the provided tasks are complete.

Parameters:

tasks - The tasks that the return value will wait for before completing.

Returns:

A Task that will resolve to Void when all the tasks are resolved. If a single task fails, it will resolve to that Exception. If multiple tasks fail, it will resolve to an AggregateException of all the Exceptions.

continueWhile

public Task<java.lang.Void> continueWhile(java.util.concurrent.Callable<java.lang.Boolean> predicate,
                                 Continuation<java.lang.Void,Task<java.lang.Void>> continuation)

Continues a task with the equivalent of a Task-based while loop, where the body of the loop is a task continuation.

continueWhile

public Task<java.lang.Void> continueWhile(java.util.concurrent.Callable<java.lang.Boolean> predicate,
                                 Continuation<java.lang.Void,Task<java.lang.Void>> continuation,
                                 java.util.concurrent.Executor executor)

Continues a task with the equivalent of a Task-based while loop, where the body of the loop is a task continuation.

continueWith

public <TContinuationResult> Task<TContinuationResult> continueWith(Continuation<TResult,TContinuationResult> continuation,
                                                           java.util.concurrent.Executor executor)

Adds a continuation that will be scheduled using the executor, returning a new task that completes after the continuation has finished running. This allows the continuation to be scheduled on different thread.

continueWith

public <TContinuationResult> Task<TContinuationResult> continueWith(Continuation<TResult,TContinuationResult> continuation)

Adds a synchronous continuation to this task, returning a new task that completes after the continuation has finished running.

continueWithTask

public <TContinuationResult> Task<TContinuationResult> continueWithTask(Continuation<TResult,Task<TContinuationResult>> continuation,
                                                               java.util.concurrent.Executor executor)

Adds an Task-based continuation to this task that will be scheduled using the executor, returning a new task that completes after the task returned by the continuation has completed.

continueWithTask

public <TContinuationResult> Task<TContinuationResult> continueWithTask(Continuation<TResult,Task<TContinuationResult>> continuation)

Adds an asynchronous continuation to this task, returning a new task that completes after the task returned by the continuation has completed.

onSuccess

public <TContinuationResult> Task<TContinuationResult> onSuccess(Continuation<TResult,TContinuationResult> continuation,
                                                        java.util.concurrent.Executor executor)

Runs a continuation when a task completes successfully, forwarding along Exception or cancellation.

onSuccess

public <TContinuationResult> Task<TContinuationResult> onSuccess(Continuation<TResult,TContinuationResult> continuation)

Runs a continuation when a task completes successfully, forwarding along Exceptions or cancellation.

onSuccessTask

public <TContinuationResult> Task<TContinuationResult> onSuccessTask(Continuation<TResult,Task<TContinuationResult>> continuation,
                                                            java.util.concurrent.Executor executor)

Runs a continuation when a task completes successfully, forwarding along Exceptions or cancellation.

onSuccessTask

public <TContinuationResult> Task<TContinuationResult> onSuccessTask(Continuation<TResult,Task<TContinuationResult>> continuation)

Runs a continuation when a task completes successfully, forwarding along Exceptions or cancellation.