Package org.xnio

# Class AbstractIoFuture<T>

java.lang.Object
org.xnio.AbstractIoFuture<T>

Type Parameters:
  `T` - the type of result that this operation produces

All Implemented Interfaces:
  `Cancellable`, `IoFuture<T>`

Direct Known Subclasses:
  `FailedIoFuture`

public abstract class AbstractIoFuture<T> extends Object implements IoFuture<T>
An abstract base class for `IoFuture` objects. Used to easily produce implementations.

## Nested Class Summary

## Nested classes/interfaces inherited from interface org.xnio.IoFuture

`IoFuture.HandlingNotifier<T,A>, IoFuture.Notifier<T,A>, IoFuture.Status`

## Constructor Summary

Constructors
Modifier
Constructor
Description
`protected`
`AbstractIoFuture()`
Construct a new instance.

## Method Summary

Modifier and Type
Method
Description
`protected void`
`addCancelHandler(Cancellable cancellable)`
Add a cancellation handler.
`<A> IoFuture<T>`
`addNotifier(IoFuture.Notifier<? super T,A> notifier, A attachment)`
Add a notifier to be called when this operation is complete.
`IoFuture.Status`
`await()`
Wait for the operation to complete.
`IoFuture.Status`
`await(long time, TimeUnit timeUnit)`
Wait for the operation to complete, with a timeout.
`IoFuture.Status`
`awaitInterruptibly()`
Wait for the operation to complete.
`IoFuture.Status`
`awaitInterruptibly(long time, TimeUnit timeUnit)`
Wait for the operation to complete, with a timeout.
`IoFuture<T>`
`cancel()`
Cancel an operation.
`T`
`get()`
Get the result of the operation.
`IOException`
`getException()`
Get the failure reason.
`T`
`getInterruptibly()`
Get the result of the operation.
`protected Executor`
`getNotifierExecutor()`
Get the executor used to run asynchronous notifiers.
`IoFuture.Status`
`getStatus()`
Get the current status.
`protected void`
`runNotifier(Runnable runnable)`
Run a notifier.
`protected boolean`
`setCancelled()`
Acknowledge the cancellation of this operation.
`protected boolean`
`setException(IOException exception)`
Set the exception for this operation.
`protected boolean`
`setResult(T result)`
Set the result for this operation.

### Methods inherited from class java.lang.Object

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

## Constructor Details

### AbstractIoFuture

protected AbstractIoFuture()
Construct a new instance.

## Method Details

### getStatus

public IoFuture.Status getStatus()
Get the current status.

Specified by:
  `getStatus` in interface `IoFuture<T>`
Returns:
  the current status

### await

public IoFuture.Status await()
Wait for the operation to complete. This method will block until the status changes from `IoFuture.Status.WAITING`.

Specified by:
  `await` in interface `IoFuture<T>`
Returns:
  the new status

### await

public IoFuture.Status await(long time, TimeUnit timeUnit)
Wait for the operation to complete, with a timeout. This method will block until the status changes from `IoFuture.Status.WAITING`, or the given time elapses. If the time elapses before the operation is complete, `IoFuture.Status.WAITING` is returned.

Specified by:
  `await` in interface `IoFuture<T>`
Parameters:
  `time` - the amount of time to wait
  `timeUnit` - the time unit
Returns:
  the new status, or `IoFuture.Status.WAITING` if the timeout expired

### awaitInterruptibly

public IoFuture.Status awaitInterruptibly() throws InterruptedException
Wait for the operation to complete. This method will block until the status changes from `IoFuture.Status.WAITING`, or the current thread is interrupted.

Specified by:
  `awaitInterruptibly` in interface `IoFuture<T>`
Returns:
  the new status
Throws:
  `InterruptedException` - if the operation is interrupted

### awaitInterruptibly

public IoFuture.Status awaitInterruptibly(long time, TimeUnit timeUnit) throws InterruptedException
Wait for the operation to complete, with a timeout. This method will block until the status changes from `IoFuture.Status.WAITING`, the given time elapses, or the current thread is interrupted. If the time elapses before the operation is complete, `IoFuture.Status.WAITING` is returned.

Specified by:
  `awaitInterruptibly` in interface `IoFuture<T>`
Parameters:
  `time` - the amount of time to wait
  `timeUnit` - the time unit
Returns:
  the new status, or `IoFuture.Status.WAITING` if the timeout expired
Throws:
  `InterruptedException` - if the operation is interrupted

### get

public T get() throws IOException, CancellationException
Get the result of the operation. If the operation is not complete, blocks until the operation completes. If the operation fails, or has already failed at the time this method is called, the failure reason is thrown.

Specified by:
  `get` in interface `IoFuture<T>`
Returns:
  the result of the operation
Throws:
  `IOException` - if the operation failed
  `CancellationException` - if the operation was cancelled

### getInterruptibly

public T getInterruptibly() throws IOException, InterruptedException, CancellationException
Get the result of the operation. If the operation is not complete, blocks until the operation completes. If the operation fails, or has already failed at the time this method is called, the failure reason is thrown. If the current thread is interrupted while waiting, an exception is thrown.

Specified by:
  `getInterruptibly` in interface `IoFuture<T>`
Returns:
  the result of the operation
Throws:
  `IOException` - if the operation failed
  `InterruptedException` - if the operation is interrupted
  `CancellationException` - if the operation was cancelled

### getException

public IOException getException() throws IllegalStateException
Get the failure reason.

Specified by:
  `getException` in interface `IoFuture<T>`
Returns:
  the failure reason
Throws:
  `IllegalStateException` - if the operation did not fail

### addNotifier

public <A> IoFuture<T> addNotifier(IoFuture.Notifier<? super T,A> notifier, A attachment)
Add a notifier to be called when this operation is complete. If the operation is already complete, the notifier is called immediately, possibly in the caller's thread. The given attachment is provided to the notifier.

Specified by:
  `addNotifier` in interface `IoFuture<T>`
Type Parameters:
  `A` - the attachment type
Parameters:
  `notifier` - the notifier to be called
  `attachment` - the attachment to pass in to the notifier
Returns:
  this instance

### setException

protected boolean setException(IOException exception)
Set the exception for this operation. Any threads blocking on this instance will be unblocked.

Parameters:
  `exception` - the exception to set
Returns:
  `false` if the operation was already completed, `true` otherwise

### setResult

protected boolean setResult(T result)
Set the result for this operation. Any threads blocking on this instance will be unblocked.

Parameters:
  `result` - the result to set
Returns:
  `false` if the operation was already completed, `true` otherwise

### setCancelled

protected boolean setCancelled()
Acknowledge the cancellation of this operation.

Returns:
  `false` if the operation was already completed, `true` otherwise

### cancel

public IoFuture<T> cancel()
Cancel an operation. The actual cancel may be synchronous or asynchronous. Implementers will use this method to initiate the cancel; use the `setCancelled()` method to indicate that the cancel was successful. The default implementation calls any registered cancel handlers.

Specified by:
  `cancel` in interface `Cancellable`
Specified by:
  `cancel` in interface `IoFuture<T>`
Returns:
  this `IoFuture` instance

### addCancelHandler

protected void addCancelHandler(Cancellable cancellable)
Add a cancellation handler. The argument will be cancelled whenever this `IoFuture` is cancelled. If the `IoFuture` is already cancelled when this method is called, the handler will be called directly.

Parameters:
  `cancellable` - the cancel handler

### runNotifier

protected void runNotifier(Runnable runnable)
Run a notifier. Implementors will run the notifier, preferably in another thread. The default implementation runs the notifier using the `Executor` retrieved via `getNotifierExecutor()`.

Parameters:
  `runnable` - the runnable task

### getNotifierExecutor

protected Executor getNotifierExecutor()
Get the executor used to run asynchronous notifiers. By default, this implementation simply returns the direct executor.

Returns:
  the executor to use