TaskChain (TaskChain (Core) 3.7.2 API)

java.lang.Object
- co.aikar.taskchain.TaskChain<T>

```
public class TaskChain<T>
extends Object
```
The Main API class of TaskChain. TaskChain's are created by a TaskChainFactory

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`abort()` Call to abort execution of the chain.
`TaskChain<?>`	`abortChain()` Aborts the chain once this step is reached.
`TaskChain<T>`	`abortIf(Predicate<T> predicate)` Checks if the previous task return matches the supplied predicate, and aborts if it was.
`TaskChain<T>`	`abortIf(Predicate<T> predicate, TaskChainAbortAction<?,?,?> action)` `abortIf(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1> TaskChain<T>`	`abortIf(Predicate<T> predicate, TaskChainAbortAction<A1,?,?> action, A1 arg1)` `abortIf(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1,A2> TaskChain<T>`	`abortIf(Predicate<T> predicate, TaskChainAbortAction<A1,A2,?> action, A1 arg1, A2 arg2)` `abortIf(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1,A2,A3> TaskChain<T>`	`abortIf(Predicate<T> predicate, TaskChainAbortAction<A1,A2,A3> action, A1 arg1, A2 arg2, A3 arg3)` Checks if the previous task return matches the supplied predicate, and aborts if it was.
`TaskChain<T>`	`abortIf(T ifObj)` Checks if the previous task return is the supplied value.
`TaskChain<T>`	`abortIf(T ifObj, TaskChainAbortAction<?,?,?> action)` `abortIf(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1> TaskChain<T>`	`abortIf(T ifObj, TaskChainAbortAction<A1,?,?> action, A1 arg1)` `abortIf(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1,A2> TaskChain<T>`	`abortIf(T ifObj, TaskChainAbortAction<A1,A2,?> action, A1 arg1, A2 arg2)` `abortIf(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1,A2,A3> TaskChain<T>`	`abortIf(T ifObj, TaskChainAbortAction<A1,A2,A3> action, A1 arg1, A2 arg2, A3 arg3)` `abortIf(Predicate, TaskChainAbortAction, Object, Object, Object)`
`TaskChain<T>`	`abortIfNot(Predicate<T> ifNotPredicate)` Checks if the previous task return does NOT match the supplied predicate, and aborts if it does not match.
`TaskChain<T>`	`abortIfNot(Predicate<T> ifNotPredicate, TaskChainAbortAction<?,?,?> action)` `abortIfNot(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1> TaskChain<T>`	`abortIfNot(Predicate<T> ifNotPredicate, TaskChainAbortAction<A1,?,?> action, A1 arg1)` `abortIfNot(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1,A2> TaskChain<T>`	`abortIfNot(Predicate<T> ifNotPredicate, TaskChainAbortAction<A1,A2,?> action, A1 arg1, A2 arg2)` `abortIfNot(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1,A2,A3> TaskChain<T>`	`abortIfNot(Predicate<T> ifNotPredicate, TaskChainAbortAction<A1,A2,A3> action, A1 arg1, A2 arg2, A3 arg3)` Checks if the previous task return does NOT match the supplied predicate, and aborts if it does not match.
`TaskChain<T>`	`abortIfNot(T ifNotObj)` `abortIfNot(Object, TaskChainAbortAction, Object, Object, Object)`
`TaskChain<T>`	`abortIfNot(T ifNotObj, TaskChainAbortAction<?,?,?> action)` `abortIfNot(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1> TaskChain<T>`	`abortIfNot(T ifNotObj, TaskChainAbortAction<A1,?,?> action, A1 arg1)` `abortIfNot(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1,A2> TaskChain<T>`	`abortIfNot(T ifNotObj, TaskChainAbortAction<A1,A2,?> action, A1 arg1, A2 arg2)` `abortIfNot(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1,A2,A3> TaskChain<T>`	`abortIfNot(T ifNotObj, TaskChainAbortAction<A1,A2,A3> action, A1 arg1, A2 arg2, A3 arg3)` `abortIfNot(Predicate, TaskChainAbortAction, Object, Object, Object)`
`TaskChain<T>`	`abortIfNull()` Checks if the previous task return was null.
`TaskChain<T>`	`abortIfNull(TaskChainAbortAction<?,?,?> action)` `abortIf(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1> TaskChain<T>`	`abortIfNull(TaskChainAbortAction<A1,?,?> action, A1 arg1)` `abortIf(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1,A2> TaskChain<T>`	`abortIfNull(TaskChainAbortAction<A1,A2,?> action, A1 arg1, A2 arg2)` `abortIf(Object, TaskChainAbortAction, Object, Object, Object)`
`<A1,A2,A3> TaskChain<T>`	`abortIfNull(TaskChainAbortAction<A1,A2,A3> action, A1 arg1, A2 arg2, A3 arg3)` Checks if the previous task return was null, and aborts if it was Then executes supplied action handler If not null, the previous task return will forward to the next task.
`protected TaskChain`	`add0(co.aikar.taskchain.TaskChain.TaskHolder<?,?> task)`
`TaskChain<?>`	`async(TaskChainTasks.GenericTask task)` `TaskChain#sync(GenericTask)` but ran off main thread
`<R> TaskChain<R>`	`async(TaskChainTasks.Task<R,T> task)` `TaskChain#sync(Task)` but ran off main thread
`TaskChain<?>`	`asyncCallback(TaskChainTasks.AsyncExecutingGenericTask task)` `TaskChain#syncCallback(AsyncExecutingTask)` but ran off main thread
`<R> TaskChain<R>`	`asyncCallback(TaskChainTasks.AsyncExecutingTask<R,T> task)` `TaskChain#syncCallback(AsyncExecutingTask)` but ran off main thread
`<R> TaskChain<R>`	`asyncFirst(TaskChainTasks.FirstTask<R> task)` `TaskChain#syncFirst(FirstTask)` but ran off main thread
`<R> TaskChain<R>`	`asyncFirstCallback(TaskChainTasks.AsyncExecutingFirstTask<R> task)` `TaskChain#syncFirstCallback(AsyncExecutingFirstTask)` but ran off main thread
`<R> TaskChain<R>`	`asyncFirstFuture(TaskChainTasks.FutureFirstTask<R> task)` `TaskChain#syncFirstFuture(FutureFirstTask)` but ran off main thread
`<R> TaskChain<List<R>>`	`asyncFirstFutures(TaskChainTasks.FirstTask<List<CompletableFuture<R>>> task)` Executes a Task off the Main thread that provides a list of Futures, and holds processing of the chain until all of the futures completes.
`TaskChain<?>`	`asyncFuture(TaskChainTasks.FutureGenericTask task)` `TaskChain#syncFuture(FutureTask)` but the future provider is ran off main thread
`<R> TaskChain<R>`	`asyncFuture(TaskChainTasks.FutureTask<R,T> task)` `TaskChain#syncFuture(FutureTask)` but the future provider is ran off main thread
`<R> TaskChain<List<R>>`	`asyncFutures(TaskChainTasks.Task<List<CompletableFuture<R>>,T> task)` Executes a Task off the Main thread that provides a list of Futures, and holds processing of the chain until all of the futures completes.
`TaskChain<?>`	`asyncLast(TaskChainTasks.LastTask<T> task)` `TaskChain#syncLast(LastTask)` but ran off main thread
`TaskChain<T>`	`configure(Consumer<TaskChain<T>> configure)` Allows you to call a callback to insert tasks into the chain without having to break the fluent interface Example: Plugin.newChain().sync(some::task).configure(chain -> { chain.async(some::foo); chain.sync(other::bar); }).async(other::task).execute();
`TaskChain<?>`	`current(TaskChainTasks.GenericTask task)` `TaskChain#sync(GenericTask)` but ran on current thread the Chain was created on
`<R> TaskChain<R>`	`current(TaskChainTasks.Task<R,T> task)` `TaskChain#sync(Task)` but ran on current thread the Chain was created on
`TaskChain<?>`	`currentCallback(TaskChainTasks.AsyncExecutingGenericTask task)` `TaskChain#syncCallback(AsyncExecutingTask)` but ran on current thread the Chain was created on
`<R> TaskChain<R>`	`currentCallback(TaskChainTasks.AsyncExecutingTask<R,T> task)` `TaskChain#syncCallback(AsyncExecutingTask)` but ran on current thread the Chain was created on
`<R> TaskChain<R>`	`currentFirst(TaskChainTasks.FirstTask<R> task)` `TaskChain#syncFirst(FirstTask)` but ran on current thread the Chain was created on
`<R> TaskChain<R>`	`currentFirstCallback(TaskChainTasks.AsyncExecutingFirstTask<R> task)` `TaskChain#syncFirstCallback(AsyncExecutingFirstTask)` but ran on current thread the Chain was created on
`<R> TaskChain<R>`	`currentFirstFuture(TaskChainTasks.FutureFirstTask<R> task)` `TaskChain#syncFirstFuture(FutureFirstTask)` but ran on current thread the Chain was created on
`<R> TaskChain<List<R>>`	`currentFirstFutures(TaskChainTasks.FirstTask<List<CompletableFuture<R>>> task)` Executes a Task on the current thread that provides a list of Futures, and holds processing of the chain until all of the futures completes.
`TaskChain<?>`	`currentFuture(TaskChainTasks.FutureGenericTask task)` `TaskChain#syncFuture(FutureTask)` but the future provider is ran on current thread the Chain was created on
`<R> TaskChain<R>`	`currentFuture(TaskChainTasks.FutureTask<R,T> task)` `TaskChain#syncFuture(FutureTask)` but the future provider is ran on current thread the Chain was created on
`<R> TaskChain<List<R>>`	`currentFutures(TaskChainTasks.Task<List<CompletableFuture<R>>,T> task)` Executes a Task on the current thread that provides a list of Futures, and holds processing of the chain until all of the futures completes.
`TaskChain<?>`	`currentLast(TaskChainTasks.LastTask<T> task)` `TaskChain#syncLast(LastTask)` but ran on current thread the Chain was created on
`TaskChain<T>`	`delay(int gameUnits)` IMPLEMENTATION SPECIFIC!! Consult your application implementation to understand how long 1 unit is.
`TaskChain<T>`	`delay(int duration, TimeUnit unit)` Adds a real time delay to the chain execution.
`void`	`execute()` Finished adding tasks, begins executing them.
`void`	`execute(BiConsumer<Exception,TaskChainTasks.Task<?,?>> errorHandler)` Finished adding tasks, begins executing them, with an error handler
`void`	`execute(Consumer<Boolean> done)` Finished adding tasks, with a done notifier
`void`	`execute(Consumer<Boolean> done, BiConsumer<Exception,TaskChainTasks.Task<?,?>> errorHandler)` Finished adding tasks, begins executing them with a done notifier and error handler
`void`	`execute(Runnable done)` Finished adding tasks, begins executing them with a done notifier
`void`	`execute(Runnable done, BiConsumer<Exception,TaskChainTasks.Task<?,?>> errorHandler)` Finished adding tasks, begins executing them with a done notifier and error handler
`<R> TaskChain<R>`	`future(CompletableFuture<R> future)` Takes a supplied Future, and holds processing of the chain until the future completes.
`<R> TaskChain<List<R>>`	`futures(CompletableFuture<R>... futures)` Takes multiple supplied Futures, and holds processing of the chain until the futures completes.
`<R> TaskChain<List<R>>`	`futures(List<CompletableFuture<R>> futures)` Takes multiple supplied Futures, and holds processing of the chain until the futures completes.
`int`	`getCurrentActionIndex()` Called in an executing task, get the current action index.
`static TaskChain<?>`	`getCurrentChain()` Usable only inside of an executing Task or Chain Error/Done handlers Gets the current chain that is executing this Task or Error/Done handler This method should only be called on the same thread that is executing the method.
`BiConsumer<Exception,TaskChainTasks.Task<?,?>>`	`getErrorHandler()`
`<R> R`	`getTaskData(String key)` Retrieves a value relating to a specific key, saved by a previous task.
`boolean`	`hasTaskData(String key)` Checks if the chain has a value saved for the specified key.
`static <D1,D2> TaskChainDataWrappers.Data2<D1,D2>`	`multi(D1 var1, D2 var2)` Creates a data wrapper to return multiple objects from a task
`static <D1,D2,D3> TaskChainDataWrappers.Data3<D1,D2,D3>`	`multi(D1 var1, D2 var2, D3 var3)` Creates a data wrapper to return multiple objects from a task
`static <D1,D2,D3,D4> TaskChainDataWrappers.Data4<D1,D2,D3,D4>`	`multi(D1 var1, D2 var2, D3 var3, D4 var4)` Creates a data wrapper to return multiple objects from a task
`static <D1,D2,D3,D4,D5> TaskChainDataWrappers.Data5<D1,D2,D3,D4,D5>`	`multi(D1 var1, D2 var2, D3 var3, D4 var4, D5 var5)` Creates a data wrapper to return multiple objects from a task
`static <D1,D2,D3,D4,D5,D6> TaskChainDataWrappers.Data6<D1,D2,D3,D4,D5,D6>`	`multi(D1 var1, D2 var2, D3 var3, D4 var4, D5 var5, D6 var6)` Creates a data wrapper to return multiple objects from a task
`<R> R`	`removeTaskData(String key)` Removes a saved value on the chain.
`TaskChain<TaskChain<?>>`	`returnChain()` Returns the chain itself to the next task.
`<R> TaskChain<R>`	`returnData(String key)` Reads the specified key from Task Data, and passes it to the next task.
`void`	`setDoneCallback(Consumer<Boolean> doneCallback)` Changes the done callback handler for this chain
`void`	`setErrorHandler(BiConsumer<Exception,TaskChainTasks.Task<?,?>> errorHandler)` Changes the error handler for this chain
`<R> R`	`setTaskData(String key, Object val)` Saves a value for this chain so that a task furthur up the chain can access it.
`TaskChain<T>`	`storeAsData(String key)` Takes the previous tasks return value, stores it to the specified key as Task Data, and then forwards that value to the next task.
`TaskChain<?>`	`sync(TaskChainTasks.GenericTask task)` Execute task on main thread, with no input or output
`<R> TaskChain<R>`	`sync(TaskChainTasks.Task<R,T> task)` Execute task on main thread, with the last returned input, returning an output
`TaskChain<?>`	`syncCallback(TaskChainTasks.AsyncExecutingGenericTask task)` `TaskChain#syncCallback(AsyncExecutingTask)`, ran on main thread but no input or output
`<R> TaskChain<R>`	`syncCallback(TaskChainTasks.AsyncExecutingTask<R,T> task)` Execute a task on the main thread, with the last output, and a callback to return the response to.
`<R> TaskChain<R>`	`syncFirst(TaskChainTasks.FirstTask<R> task)` Execute task on main thread, with no input, returning an output
`<R> TaskChain<R>`	`syncFirstCallback(TaskChainTasks.AsyncExecutingFirstTask<R> task)` Execute a task on the main thread, with no previous input, and a callback to return the response to.
`<R> TaskChain<R>`	`syncFirstFuture(TaskChainTasks.FutureFirstTask<R> task)` Execute a task on the main thread, with no previous input, that will return a Future to signal completion It's important you don't perform blocking operations in this method.
`<R> TaskChain<List<R>>`	`syncFirstFutures(TaskChainTasks.FirstTask<List<CompletableFuture<R>>> task)` Executes a Task on the Main thread that provides a list of Futures, and holds processing of the chain until all of the futures completes.
`TaskChain<?>`	`syncFuture(TaskChainTasks.FutureGenericTask task)` `TaskChain#syncFuture(FutureTask)`, ran on main thread but no input or output
`<R> TaskChain<R>`	`syncFuture(TaskChainTasks.FutureTask<R,T> task)` Execute a task on the main thread, with the last output as the input to the future provider, that will return a Future to signal completion.
`<R> TaskChain<List<R>>`	`syncFutures(TaskChainTasks.Task<List<CompletableFuture<R>>,T> task)` Executes a Task on the Main thread that provides a list of Futures, and holds processing of the chain until all of the futures completes.
`TaskChain<?>`	`syncLast(TaskChainTasks.LastTask<T> task)` Execute task on main thread, with the last output, and no furthur output

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

- Method Detail
  - getCurrentActionIndex
```
public int getCurrentActionIndex()
```
    Called in an executing task, get the current action index. For every action that adds a task to the chain, the action index is increased. Useful in error or done handlers to know where you are in the chain when it aborted or threw exception.
    
    Returns:
    
    The current index
  - setDoneCallback
```
public void setDoneCallback(Consumer<Boolean> doneCallback)
```
    Changes the done callback handler for this chain
    
    Parameters:
    
    doneCallback - The handler
  - getErrorHandler
```
public BiConsumer<Exception,TaskChainTasks.Task<?,?>> getErrorHandler()
```
    Returns:
    
    The current error handler or null
  - setErrorHandler
```
public void setErrorHandler(BiConsumer<Exception,TaskChainTasks.Task<?,?>> errorHandler)
```
    Changes the error handler for this chain
    
    Parameters:
    
    errorHandler - The error handler
  - multi
```
public static <D1,D2> TaskChainDataWrappers.Data2<D1,D2> multi(D1 var1,
                                                               D2 var2)
```
    Creates a data wrapper to return multiple objects from a task
  - multi
```
public static <D1,D2,D3> TaskChainDataWrappers.Data3<D1,D2,D3> multi(D1 var1,
                                                                     D2 var2,
                                                                     D3 var3)
```
    Creates a data wrapper to return multiple objects from a task
  - multi
```
public static <D1,D2,D3,D4> TaskChainDataWrappers.Data4<D1,D2,D3,D4> multi(D1 var1,
                                                                           D2 var2,
                                                                           D3 var3,
                                                                           D4 var4)
```
    Creates a data wrapper to return multiple objects from a task
  - multi
```
public static <D1,D2,D3,D4,D5> TaskChainDataWrappers.Data5<D1,D2,D3,D4,D5> multi(D1 var1,
                                                                                 D2 var2,
                                                                                 D3 var3,
                                                                                 D4 var4,
                                                                                 D5 var5)
```
    Creates a data wrapper to return multiple objects from a task
  - multi
```
public static <D1,D2,D3,D4,D5,D6> TaskChainDataWrappers.Data6<D1,D2,D3,D4,D5,D6> multi(D1 var1,
                                                                                       D2 var2,
                                                                                       D3 var3,
                                                                                       D4 var4,
                                                                                       D5 var5,
                                                                                       D6 var6)
```
    Creates a data wrapper to return multiple objects from a task
  - abort
```
public static void abort()
```
    Call to abort execution of the chain. Should be called inside of an executing task.
  - getCurrentChain
```
public static TaskChain<?> getCurrentChain()
```
    Usable only inside of an executing Task or Chain Error/Done handlers Gets the current chain that is executing this Task or Error/Done handler This method should only be called on the same thread that is executing the method. In an AsyncExecutingTask or a FutureTask, You must call this method BEFORE passing control to another thread.
  - configure
```
public TaskChain<T> configure(Consumer<TaskChain<T>> configure)
```
    Allows you to call a callback to insert tasks into the chain without having to break the fluent interface Example: Plugin.newChain().sync(some::task).configure(chain -> { chain.async(some::foo); chain.sync(other::bar); }).async(other::task).execute();
    
    Parameters:
    
    configure - Instance of the current chain.
    
    Returns:
    
    The same chain
  - hasTaskData
```
public boolean hasTaskData(String key)
```
    Checks if the chain has a value saved for the specified key.
    
    Parameters:
    
    key - Key to check if Task Data has a value for
  - getTaskData
```
public <R> R getTaskData(String key)
```
    Retrieves a value relating to a specific key, saved by a previous task.
    
    Type Parameters:
    
    R - Type the Task Data value is expected to be
    
    Parameters:
    
    key - Key to look up Task Data for
  - setTaskData
```
public <R> R setTaskData(String key,
                         Object val)
```
    Saves a value for this chain so that a task furthur up the chain can access it. Useful for passing multiple values to the next (or furthur) tasks.
    
    Type Parameters:
    
    R - Type the Task Data value is expected to be
    
    Parameters:
    
    key - Key to store in Task Data
    
    val - Value to store in Task Data
  - removeTaskData
```
public <R> R removeTaskData(String key)
```
    Removes a saved value on the chain.
    
    Type Parameters:
    
    R - Type the Task Data value is expected to be
    
    Parameters:
    
    key - Key to remove from Task Data
  - storeAsData
```
public TaskChain<T> storeAsData(String key)
```
    Takes the previous tasks return value, stores it to the specified key as Task Data, and then forwards that value to the next task.
    
    Parameters:
    
    key - Key to store the previous return value into Task Data
  - returnData
```
public <R> TaskChain<R> returnData(String key)
```
    Reads the specified key from Task Data, and passes it to the next task. Will need to pass expected type such as chain.<Foo>returnData("key")
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    key - Key to retrieve from Task Data and pass to next task
  - returnChain
```
public TaskChain<TaskChain<?>> returnChain()
```
    Returns the chain itself to the next task.
  - delay
```
public TaskChain<T> delay(int gameUnits)
```
    IMPLEMENTATION SPECIFIC!! Consult your application implementation to understand how long 1 unit is. For example, in Minecraft it is a tick, which is roughly 50 milliseconds, but not guaranteed. Adds a delay to the chain execution.
    
    Parameters:
    
    gameUnits - # of game units to delay before next task
  - delay
```
public TaskChain<T> delay(int duration,
                          TimeUnit unit)
```
    Adds a real time delay to the chain execution. Chain will abort if the delay is interrupted.
    
    Parameters:
    
    duration - duration of the delay before next task
  - abortChain
```
public TaskChain<?> abortChain()
```
    Aborts the chain once this step is reached. This is primarily useful when you are dynamically building the chains steps (such as .configure()) and want to conditionally stop the chain from proceeding.
    
    Returns:
    
    Chain
  - abortIfNull
```
public TaskChain<T> abortIfNull()
```
    Checks if the previous task return was null. If not null, the previous task return will forward to the next task.
  - abortIfNull
```
public TaskChain<T> abortIfNull(TaskChainAbortAction<?,?,?> action)
```
    abortIf(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIfNull
```
public <A1> TaskChain<T> abortIfNull(TaskChainAbortAction<A1,?,?> action,
                                     A1 arg1)
```
    abortIf(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIfNull
```
public <A1,A2> TaskChain<T> abortIfNull(TaskChainAbortAction<A1,A2,?> action,
                                        A1 arg1,
                                        A2 arg2)
```
    abortIf(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIfNull
```
public <A1,A2,A3> TaskChain<T> abortIfNull(TaskChainAbortAction<A1,A2,A3> action,
                                           A1 arg1,
                                           A2 arg2,
                                           A3 arg3)
```
    Checks if the previous task return was null, and aborts if it was Then executes supplied action handler If not null, the previous task return will forward to the next task.
  - abortIf
```
public TaskChain<T> abortIf(T ifObj)
```
    Checks if the previous task return is the supplied value. If not, the previous task return will forward to the next task.
  - abortIf
```
public TaskChain<T> abortIf(T ifObj,
                            TaskChainAbortAction<?,?,?> action)
```
    abortIf(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIf
```
public <A1> TaskChain<T> abortIf(T ifObj,
                                 TaskChainAbortAction<A1,?,?> action,
                                 A1 arg1)
```
    abortIf(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIf
```
public <A1,A2> TaskChain<T> abortIf(T ifObj,
                                    TaskChainAbortAction<A1,A2,?> action,
                                    A1 arg1,
                                    A2 arg2)
```
    abortIf(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIf
```
public <A1,A2,A3> TaskChain<T> abortIf(T ifObj,
                                       TaskChainAbortAction<A1,A2,A3> action,
                                       A1 arg1,
                                       A2 arg2,
                                       A3 arg3)
```
    abortIf(Predicate, TaskChainAbortAction, Object, Object, Object)
  - abortIf
```
public TaskChain<T> abortIf(Predicate<T> predicate)
```
    Checks if the previous task return matches the supplied predicate, and aborts if it was. If predicate does not match, the previous task return will forward to the next task.
  - abortIf
```
public TaskChain<T> abortIf(Predicate<T> predicate,
                            TaskChainAbortAction<?,?,?> action)
```
    abortIf(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIf
```
public <A1> TaskChain<T> abortIf(Predicate<T> predicate,
                                 TaskChainAbortAction<A1,?,?> action,
                                 A1 arg1)
```
    abortIf(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIf
```
public <A1,A2> TaskChain<T> abortIf(Predicate<T> predicate,
                                    TaskChainAbortAction<A1,A2,?> action,
                                    A1 arg1,
                                    A2 arg2)
```
    abortIf(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIf
```
public <A1,A2,A3> TaskChain<T> abortIf(Predicate<T> predicate,
                                       TaskChainAbortAction<A1,A2,A3> action,
                                       A1 arg1,
                                       A2 arg2,
                                       A3 arg3)
```
    Checks if the previous task return matches the supplied predicate, and aborts if it was. Then executes supplied action handler If predicate does not match, the previous task return will forward to the next task.
  - abortIfNot
```
public TaskChain<T> abortIfNot(T ifNotObj)
```
    abortIfNot(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIfNot
```
public TaskChain<T> abortIfNot(T ifNotObj,
                               TaskChainAbortAction<?,?,?> action)
```
    abortIfNot(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIfNot
```
public <A1> TaskChain<T> abortIfNot(T ifNotObj,
                                    TaskChainAbortAction<A1,?,?> action,
                                    A1 arg1)
```
    abortIfNot(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIfNot
```
public <A1,A2> TaskChain<T> abortIfNot(T ifNotObj,
                                       TaskChainAbortAction<A1,A2,?> action,
                                       A1 arg1,
                                       A2 arg2)
```
    abortIfNot(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIfNot
```
public <A1,A2,A3> TaskChain<T> abortIfNot(T ifNotObj,
                                          TaskChainAbortAction<A1,A2,A3> action,
                                          A1 arg1,
                                          A2 arg2,
                                          A3 arg3)
```
    abortIfNot(Predicate, TaskChainAbortAction, Object, Object, Object)
  - abortIfNot
```
public TaskChain<T> abortIfNot(Predicate<T> ifNotPredicate)
```
    Checks if the previous task return does NOT match the supplied predicate, and aborts if it does not match. If predicate matches, the previous task return will forward to the next task.
  - abortIfNot
```
public TaskChain<T> abortIfNot(Predicate<T> ifNotPredicate,
                               TaskChainAbortAction<?,?,?> action)
```
    abortIfNot(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIfNot
```
public <A1> TaskChain<T> abortIfNot(Predicate<T> ifNotPredicate,
                                    TaskChainAbortAction<A1,?,?> action,
                                    A1 arg1)
```
    abortIfNot(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIfNot
```
public <A1,A2> TaskChain<T> abortIfNot(Predicate<T> ifNotPredicate,
                                       TaskChainAbortAction<A1,A2,?> action,
                                       A1 arg1,
                                       A2 arg2)
```
    abortIfNot(Object, TaskChainAbortAction, Object, Object, Object)
  - abortIfNot
```
public <A1,A2,A3> TaskChain<T> abortIfNot(Predicate<T> ifNotPredicate,
                                          TaskChainAbortAction<A1,A2,A3> action,
                                          A1 arg1,
                                          A2 arg2,
                                          A3 arg3)
```
    Checks if the previous task return does NOT match the supplied predicate, and aborts if it does not match. Then executes supplied action handler If predicate matches, the previous task return will forward to the next task.
  - syncFirstCallback
```
public <R> TaskChain<R> syncFirstCallback(TaskChainTasks.AsyncExecutingFirstTask<R> task)
```
    Execute a task on the main thread, with no previous input, and a callback to return the response to. It's important you don't perform blocking operations in this method. Only use this if the task will be scheduling a different sync operation outside of the TaskChains scope. Usually you could achieve the same design with a blocking API by switching to an async task for the next task and running it there. This method would primarily be for cases where you need to use an API that ONLY provides a callback style API.
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - asyncFirstCallback
```
public <R> TaskChain<R> asyncFirstCallback(TaskChainTasks.AsyncExecutingFirstTask<R> task)
```
    TaskChain#syncFirstCallback(AsyncExecutingFirstTask) but ran off main thread
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - currentFirstCallback
```
public <R> TaskChain<R> currentFirstCallback(TaskChainTasks.AsyncExecutingFirstTask<R> task)
```
    TaskChain#syncFirstCallback(AsyncExecutingFirstTask) but ran on current thread the Chain was created on
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - syncCallback
```
public <R> TaskChain<R> syncCallback(TaskChainTasks.AsyncExecutingTask<R,T> task)
```
    Execute a task on the main thread, with the last output, and a callback to return the response to. It's important you don't perform blocking operations in this method. Only use this if the task will be scheduling a different sync operation outside of the TaskChains scope. Usually you could achieve the same design with a blocking API by switching to an async task for the next task and running it there. This method would primarily be for cases where you need to use an API that ONLY provides a callback style API.
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - syncCallback
```
public TaskChain<?> syncCallback(TaskChainTasks.AsyncExecutingGenericTask task)
```
    TaskChain#syncCallback(AsyncExecutingTask), ran on main thread but no input or output
    
    Parameters:
    
    task - The task to execute
  - asyncCallback
```
public <R> TaskChain<R> asyncCallback(TaskChainTasks.AsyncExecutingTask<R,T> task)
```
    TaskChain#syncCallback(AsyncExecutingTask) but ran off main thread
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - asyncCallback
```
public TaskChain<?> asyncCallback(TaskChainTasks.AsyncExecutingGenericTask task)
```
    TaskChain#syncCallback(AsyncExecutingTask) but ran off main thread
    
    Parameters:
    
    task - The task to execute
  - currentCallback
```
public <R> TaskChain<R> currentCallback(TaskChainTasks.AsyncExecutingTask<R,T> task)
```
    TaskChain#syncCallback(AsyncExecutingTask) but ran on current thread the Chain was created on
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - currentCallback
```
public TaskChain<?> currentCallback(TaskChainTasks.AsyncExecutingGenericTask task)
```
    TaskChain#syncCallback(AsyncExecutingTask) but ran on current thread the Chain was created on
    
    Parameters:
    
    task - The task to execute
  - future
```
public <R> TaskChain<R> future(CompletableFuture<R> future)
```
    Takes a supplied Future, and holds processing of the chain until the future completes. The value of the Future will be passed until the next task.
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    future - The Future to wait until it is complete on
  - futures
```
@SafeVarargs
public final <R> TaskChain<List<R>> futures(CompletableFuture<R>... futures)
```
    Takes multiple supplied Futures, and holds processing of the chain until the futures completes. The results of the Futures will be passed until the next task.
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    futures - The Futures to wait until it is complete on
  - futures
```
public <R> TaskChain<List<R>> futures(List<CompletableFuture<R>> futures)
```
    Takes multiple supplied Futures, and holds processing of the chain until the futures completes. The results of the Futures will be passed until the next task.
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    futures - The Futures to wait until it is complete on
  - syncFutures
```
public <R> TaskChain<List<R>> syncFutures(TaskChainTasks.Task<List<CompletableFuture<R>>,T> task)
```
    Executes a Task on the Main thread that provides a list of Futures, and holds processing of the chain until all of the futures completes. The response of every future will be passed to the next task as a List, in the order the futures were supplied.
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The Futures Provider Task
  - asyncFutures
```
public <R> TaskChain<List<R>> asyncFutures(TaskChainTasks.Task<List<CompletableFuture<R>>,T> task)
```
    Executes a Task off the Main thread that provides a list of Futures, and holds processing of the chain until all of the futures completes. The response of every future will be passed to the next task as a List, in the order the futures were supplied.
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The Futures Provider Task
  - currentFutures
```
public <R> TaskChain<List<R>> currentFutures(TaskChainTasks.Task<List<CompletableFuture<R>>,T> task)
```
    Executes a Task on the current thread that provides a list of Futures, and holds processing of the chain until all of the futures completes. The response of every future will be passed to the next task as a List, in the order the futures were supplied.
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The Futures Provider Task
  - syncFirstFutures
```
public <R> TaskChain<List<R>> syncFirstFutures(TaskChainTasks.FirstTask<List<CompletableFuture<R>>> task)
```
    Executes a Task on the Main thread that provides a list of Futures, and holds processing of the chain until all of the futures completes. The response of every future will be passed to the next task as a List, in the order the futures were supplied.
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The Futures Provider Task
  - asyncFirstFutures
```
public <R> TaskChain<List<R>> asyncFirstFutures(TaskChainTasks.FirstTask<List<CompletableFuture<R>>> task)
```
    Executes a Task off the Main thread that provides a list of Futures, and holds processing of the chain until all of the futures completes. The response of every future will be passed to the next task as a List, in the order the futures were supplied.
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The Futures Provider Task
  - currentFirstFutures
```
public <R> TaskChain<List<R>> currentFirstFutures(TaskChainTasks.FirstTask<List<CompletableFuture<R>>> task)
```
    Executes a Task on the current thread that provides a list of Futures, and holds processing of the chain until all of the futures completes. The response of every future will be passed to the next task as a List, in the order the futures were supplied.
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The Futures Provider Task
  - syncFirstFuture
```
public <R> TaskChain<R> syncFirstFuture(TaskChainTasks.FutureFirstTask<R> task)
```
    Execute a task on the main thread, with no previous input, that will return a Future to signal completion It's important you don't perform blocking operations in this method. Only use this if the task will be scheduling a different async operation outside of the TaskChains scope.
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - asyncFirstFuture
```
public <R> TaskChain<R> asyncFirstFuture(TaskChainTasks.FutureFirstTask<R> task)
```
    TaskChain#syncFirstFuture(FutureFirstTask) but ran off main thread
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - currentFirstFuture
```
public <R> TaskChain<R> currentFirstFuture(TaskChainTasks.FutureFirstTask<R> task)
```
    TaskChain#syncFirstFuture(FutureFirstTask) but ran on current thread the Chain was created on
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - syncFuture
```
public <R> TaskChain<R> syncFuture(TaskChainTasks.FutureTask<R,T> task)
```
    Execute a task on the main thread, with the last output as the input to the future provider, that will return a Future to signal completion. It's important you don't perform blocking operations in this method. Only use this if the task will be scheduling a different async operation outside of the TaskChains scope.
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - syncFuture
```
public TaskChain<?> syncFuture(TaskChainTasks.FutureGenericTask task)
```
    TaskChain#syncFuture(FutureTask), ran on main thread but no input or output
    
    Parameters:
    
    task - The task to execute
  - asyncFuture
```
public <R> TaskChain<R> asyncFuture(TaskChainTasks.FutureTask<R,T> task)
```
    TaskChain#syncFuture(FutureTask) but the future provider is ran off main thread
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - asyncFuture
```
public TaskChain<?> asyncFuture(TaskChainTasks.FutureGenericTask task)
```
    TaskChain#syncFuture(FutureTask) but the future provider is ran off main thread
    
    Parameters:
    
    task - The task to execute
  - currentFuture
```
public <R> TaskChain<R> currentFuture(TaskChainTasks.FutureTask<R,T> task)
```
    TaskChain#syncFuture(FutureTask) but the future provider is ran on current thread the Chain was created on
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - currentFuture
```
public TaskChain<?> currentFuture(TaskChainTasks.FutureGenericTask task)
```
    TaskChain#syncFuture(FutureTask) but the future provider is ran on current thread the Chain was created on
    
    Parameters:
    
    task - The task to execute
  - syncFirst
```
public <R> TaskChain<R> syncFirst(TaskChainTasks.FirstTask<R> task)
```
    Execute task on main thread, with no input, returning an output
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - asyncFirst
```
public <R> TaskChain<R> asyncFirst(TaskChainTasks.FirstTask<R> task)
```
    TaskChain#syncFirst(FirstTask) but ran off main thread
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - currentFirst
```
public <R> TaskChain<R> currentFirst(TaskChainTasks.FirstTask<R> task)
```
    TaskChain#syncFirst(FirstTask) but ran on current thread the Chain was created on
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - sync
```
public <R> TaskChain<R> sync(TaskChainTasks.Task<R,T> task)
```
    Execute task on main thread, with the last returned input, returning an output
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - sync
```
public TaskChain<?> sync(TaskChainTasks.GenericTask task)
```
    Execute task on main thread, with no input or output
    
    Parameters:
    
    task - The task to execute
  - async
```
public <R> TaskChain<R> async(TaskChainTasks.Task<R,T> task)
```
    TaskChain#sync(Task) but ran off main thread
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - async
```
public TaskChain<?> async(TaskChainTasks.GenericTask task)
```
    TaskChain#sync(GenericTask) but ran off main thread
    
    Parameters:
    
    task - The task to execute
  - current
```
public <R> TaskChain<R> current(TaskChainTasks.Task<R,T> task)
```
    TaskChain#sync(Task) but ran on current thread the Chain was created on
    
    Type Parameters:
    
    R - Return type that the next parameter can expect as argument type
    
    Parameters:
    
    task - The task to execute
  - current
```
public TaskChain<?> current(TaskChainTasks.GenericTask task)
```
    TaskChain#sync(GenericTask) but ran on current thread the Chain was created on
    
    Parameters:
    
    task - The task to execute
  - syncLast
```
public TaskChain<?> syncLast(TaskChainTasks.LastTask<T> task)
```
    Execute task on main thread, with the last output, and no furthur output
    
    Parameters:
    
    task - The task to execute
  - asyncLast
```
public TaskChain<?> asyncLast(TaskChainTasks.LastTask<T> task)
```
    TaskChain#syncLast(LastTask) but ran off main thread
    
    Parameters:
    
    task - The task to execute
  - currentLast
```
public TaskChain<?> currentLast(TaskChainTasks.LastTask<T> task)
```
    TaskChain#syncLast(LastTask) but ran on current thread the Chain was created on
    
    Parameters:
    
    task - The task to execute
  - execute
```
public void execute()
```
    Finished adding tasks, begins executing them.
  - execute
```
public void execute(Runnable done)
```
    Finished adding tasks, begins executing them with a done notifier
    
    Parameters:
    
    done - The Callback to handle when the chain has finished completion. Argument to consumer contains finish state
  - execute
```
public void execute(Runnable done,
                    BiConsumer<Exception,TaskChainTasks.Task<?,?>> errorHandler)
```
    Finished adding tasks, begins executing them with a done notifier and error handler
    
    Parameters:
    
    done - The Callback to handle when the chain has finished completion. Argument to consumer contains finish state
    
    errorHandler - The Error handler to handle exceptions
  - execute
```
public void execute(Consumer<Boolean> done)
```
    Finished adding tasks, with a done notifier
    
    Parameters:
    
    done - The Callback to handle when the chain has finished completion. Argument to consumer contains finish state
  - execute
```
public void execute(BiConsumer<Exception,TaskChainTasks.Task<?,?>> errorHandler)
```
    Finished adding tasks, begins executing them, with an error handler
    
    Parameters:
    
    errorHandler - The Error handler to handle exceptions
  - execute
```
public void execute(Consumer<Boolean> done,
                    BiConsumer<Exception,TaskChainTasks.Task<?,?>> errorHandler)
```
    Finished adding tasks, begins executing them with a done notifier and error handler
    
    Parameters:
    
    done - The Callback to handle when the chain has finished completion. Argument to consumer contains finish state
    
    errorHandler - The Error handler to handle exceptions
  - add0
```
protected TaskChain add0(co.aikar.taskchain.TaskChain.TaskHolder<?,?> task)
```

Class TaskChain<T>

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getCurrentActionIndex

setDoneCallback

getErrorHandler

setErrorHandler

multi

multi

multi

multi

multi

abort

getCurrentChain

configure

hasTaskData

getTaskData

setTaskData

removeTaskData

storeAsData

returnData

returnChain

delay

delay

abortChain

abortIfNull

abortIfNull

abortIfNull

abortIfNull

abortIfNull

abortIf

abortIf

abortIf

abortIf

abortIf

abortIf

abortIf

abortIf

abortIf

abortIf

abortIfNot

abortIfNot

abortIfNot

abortIfNot

abortIfNot

abortIfNot

abortIfNot

abortIfNot

abortIfNot

abortIfNot

syncFirstCallback

asyncFirstCallback

currentFirstCallback

syncCallback

syncCallback

asyncCallback

asyncCallback

currentCallback

currentCallback

future

futures

futures

syncFutures

asyncFutures

currentFutures

syncFirstFutures

asyncFirstFutures

currentFirstFutures

syncFirstFuture

asyncFirstFuture

currentFirstFuture

syncFuture

syncFuture

asyncFuture

asyncFuture

currentFuture

currentFuture

syncFirst

asyncFirst