Module 
Package org.xnio

Class 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 java.lang.Object
implements IoFuture<T>
    An abstract base class for IoFuture objects. Used to easily produce implementations.

    • Constructor Detail

      • AbstractIoFuture

        protected AbstractIoFuture()
        Construct a new instance.

    • Method Detail

      • await

        public IoFuture.Status await​(long time,
                             java.util.concurrent.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 java.lang.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:
        java.lang.InterruptedException - if the operation is interrupted

      • awaitInterruptibly

        public IoFuture.Status awaitInterruptibly​(long time,
                                          java.util.concurrent.TimeUnit timeUnit)
                                   throws java.lang.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:
        java.lang.InterruptedException - if the operation is interrupted

      • get

        public T get()
      throws java.io.IOException,
             java.util.concurrent.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:
        java.io.IOException - if the operation failed
        java.util.concurrent.CancellationException - if the operation was cancelled

      • getInterruptibly

        public T getInterruptibly()
                   throws java.io.IOException,
                          java.lang.InterruptedException,
                          java.util.concurrent.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:
        java.io.IOException - if the operation failed
        java.lang.InterruptedException - if the operation is interrupted
        java.util.concurrent.CancellationException - if the operation was cancelled

      • getException

        public java.io.IOException getException()
                                 throws java.lang.IllegalStateException
        Get the failure reason.
        Specified by:
        getException in interface IoFuture<T>
        Returns:
        the failure reason
        Throws:
        java.lang.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​(java.io.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​(java.lang.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 java.util.concurrent.Executor getNotifierExecutor()
        Get the executor used to run asynchronous notifiers. By default, this implementation simply returns the direct executor.
        Returns:
        the executor to use