com.mattunderscore.executors

Class UnboundedFuture

java.lang.Object

com.mattunderscore.executors.UnboundedFuture

All Implemented Interfaces:

ISettableFuture<Void>, Future<Void>

public final class UnboundedFuture
extends Object

A base implementation for a Future of a task that is executed an unlimited number of times.

Since there is no limit to the executions Callable tasks should not be provided to this. This prevent storage issues. It is possible to implement an unbounded repeating future that allows access to the last result or a finite result window. This implementation is only intended for Runnable tasks.

Since:

0.1.0

Author:

Matt Champion

Constructor Summary

Constructors

Constructor and Description
UnboundedFuture(ITaskCanceller canceller)

Method Summary

Modifier and Type	Method and Description
protected void	await() Blocks the thread until the result is set or the task is cancelled.
protected boolean	await(long timeout, TimeUnit unit) Blocks the thread until the result is set or the task is cancelled.
boolean	cancel(boolean mayInterruptIfRunning)
protected void	checkCancellationException() Checks if the CancellationException needs to be thrown.
protected void	checkExecutionException(TaskExecutionResult<V> result) Checks if a ExecutionException needs to be thrown.
V	get()
V	get(long timeout, TimeUnit unit)
protected TaskExecutionResult<Void>	getResult() Return the result of the task execution.
boolean	isCancelled()
boolean	isDone()
protected boolean	processCancellation(boolean mayInterruptIfRunning) Process cancellation of the task.
protected void	processResult(TaskExecutionResult<Void> result) Process the result being set.
void	setException(Throwable result) Set the result of the task execution.
void	setResult(V result) Set the result of the task execution.
void	setTask(ITaskWrapper wrapper) Set the task
protected boolean	taskDone() Indicate if the task has been executed.

Methods inherited from class java.lang.Object

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

Constructor Detail

UnboundedFuture

public UnboundedFuture(ITaskCanceller canceller)

Method Detail

processResult

protected void processResult(TaskExecutionResult<Void> result)

Process the result being set.

Parameters:

result - The result

processCancellation

protected boolean processCancellation(boolean mayInterruptIfRunning)

Process cancellation of the task.

Parameters:

mayInterruptIfRunning - If the thread should be interrupted if it is running

Returns:

Was the cancellation successful

taskDone

protected boolean taskDone()

Indicate if the task has been executed.

Returns:

True if the task has executed

await

protected void await()
              throws InterruptedException

Blocks the thread until the result is set or the task is cancelled.

Throws:

InterruptedException - The thread was Interrupted while waiting

await

protected boolean await(long timeout,
                        TimeUnit unit)
                 throws InterruptedException

Blocks the thread until the result is set or the task is cancelled. Takes a timeout as the maximum amount of time it will block.

Parameters:

timeout - Duration of the timeout

unit - Unit of the timeout

Returns:

True if the timeout was not reached

Throws:

InterruptedException - The thread was Interrupted while waiting

getResult

protected TaskExecutionResult<Void> getResult()

Return the result of the task execution. Assumes that it is set.

Returns:

The result

setTask

public void setTask(ITaskWrapper wrapper)

Description copied from interface: ISettableFuture

Set the task

Parameters:

wrapper - TaskWrapper for task of the future

cancel

public boolean cancel(boolean mayInterruptIfRunning)

Specified by:

cancel in interface Future<V>

isCancelled

public boolean isCancelled()

Specified by:

isCancelled in interface Future<V>

isDone

public boolean isDone()

Specified by:

isDone in interface Future<V>

get

public V get()
      throws InterruptedException,
             ExecutionException,
             CancellationException

Specified by:

get in interface Future<V>

Throws:

InterruptedException

ExecutionException

CancellationException

get

public V get(long timeout,
             TimeUnit unit)
      throws InterruptedException,
             ExecutionException,
             TimeoutException,
             CancellationException

Specified by:

get in interface Future<V>

Throws:

InterruptedException

ExecutionException

TimeoutException

CancellationException

checkCancellationException

protected void checkCancellationException()
                                   throws CancellationException

Checks if the CancellationException needs to be thrown.

Throws:

CancellationException - If it needs to be thrown

checkExecutionException

protected void checkExecutionException(TaskExecutionResult<V> result)
                                throws ExecutionException

Checks if a ExecutionException needs to be thrown.

Parameters:

result - The result of the task

Throws:

ExecutionException - If it needs to be thrown

setResult

public void setResult(V result)

Description copied from interface: ISettableFuture

Set the result of the task execution.

Specified by:

setResult in interface ISettableFuture<V>

Parameters:

result - The result of the execution

setException

public void setException(Throwable result)

Description copied from interface: ISettableFuture

Set the result of the task execution.

Specified by:

setException in interface ISettableFuture<V>

Parameters:

result - The execution thrown by the execution