FutureOperation (Riak Client for Java 2.1.1 API)

java.lang.Object
- com.basho.riak.client.core.FutureOperation<T,U,S>

Type Parameters:

T - The type the operation returns

U - The protocol type returned

S - Query info type

All Implemented Interfaces:

RiakFuture<T,S>, Future<T>

Direct Known Subclasses:

CoveragePlanOperation, DeleteOperation, DtFetchOperation, DtUpdateOperation, FetchBucketPropsOperation, FetchOperation, PBFutureOperation, PingOperation, ResetBucketPropsOperation, SearchOperation, StoreBucketPropsOperation, StoreOperation, TTBFutureOperation, YzDeleteIndexOperation, YzFetchIndexOperation, YzGetSchemaOperation, YzPutIndexOperation, YzPutSchemaOperation
```
public abstract class FutureOperation<T,U,S>
extends Object
implements RiakFuture<T,S>
```
Since:

2.0 State Transition Diagram New Operation | | | | +-------------------------|---------Cancel-------------+ | | | | +-----v-----+ | | | | | +------Cancel-------+ CREATED +----Exception------+ | | | | | | | +-----------+ | | | | +---v-----+ | +<---Retries Left-----+ +---+ | | | RETRY | | | Write Data | | | | | +---^-----+ | +------v--- --+ +-----v-----+ | | | | | +----Exception------+ | | CANCELLED <----Cancel--+ WRITTEN | | | | | | | +-------------+ +-----------+ | | | Read OK | Response Done | | | +-------v--------+ | | | | | CLEANUP_WAIT <------No Retries Left-----+ | | +----------------+ | **Caller Returns Connection** setComplete() | +-----v------+ | | | COMPLETE | | | +------------+

Author:

Brian Roach

Constructor Summary

Constructors
Constructor and Description

FutureOperation()

Constructors
Constructor and Description
`FutureOperation()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addListener(RiakFutureListener<T,S> listener)` Add a listener to this RiakFuture.
`void`	`await()` Waits for this RiakFuture to be completed.
`boolean`	`await(long timeout, TimeUnit unit)` Waits for this RiakFuture to be completed for a set amount of time.
`boolean`	`cancel(boolean mayInterruptIfRunning)` Not supported due to limitations of the Riak API.
`Throwable`	`cause()` Return information about the operation and why it failed.
`Object`	`channelMessage()`
`protected U`	`checkAndGetSingleResponse(List<U> responses)`
`protected abstract T`	`convert(List<U> rawResponse)`
`protected abstract RiakMessage`	`createChannelMessage()`
`protected abstract U`	`decode(RiakMessage rawMessage)`
`protected boolean`	`done(U message)` Detect when the streaming operation is finished
`T`	`get()` Waits for this RiakFuture to be completed if necessary and returns the response if available.
`T`	`get(long timeout, TimeUnit unit)` Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.
`T`	`getNow()` Return the result without blocking or throwing an exception.
`abstract S`	`getQueryInfo()` Returns information related to the operation performed.
`boolean`	`isCancelled()`
`boolean`	`isDone()`
`boolean`	`isSuccess()` Determine if the operation completed successfully.
`protected void`	`processBatchMessage(U decodedMessage)`
`protected void`	`processMessage(U decodedMessage)`
`void`	`removeListener(RiakFutureListener<T,S> listener)` Remove a listener from this RiakFuture.
`void`	`setComplete()`
`void`	`setResponse(RiakMessage rawResponse)`

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

- Constructor Detail
  - FutureOperation
```
public FutureOperation()
```
- Method Detail
  - addListener
```
public void addListener(RiakFutureListener<T,S> listener)
```
    Description copied from interface: RiakFuture
    
    Add a listener to this RiakFuture.
    
    Specified by:
    
    addListener in interface RiakFuture<T,S>
    
    Parameters:
    
    listener - a RiakFutureListener that will be notified when this RiakFuture completes.
  - removeListener
```
public void removeListener(RiakFutureListener<T,S> listener)
```
    Description copied from interface: RiakFuture
    
    Remove a listener from this RiakFuture.
    
    Specified by:
    
    removeListener in interface RiakFuture<T,S>
    
    Parameters:
    
    listener - The listener to remove.
  - setResponse
```
public final void setResponse(RiakMessage rawResponse)
```
  - processMessage
```
protected void processMessage(U decodedMessage)
```
  - processBatchMessage
```
protected void processBatchMessage(U decodedMessage)
```
  - setComplete
```
public final void setComplete()
```
  - done
```
protected boolean done(U message)
```
    Detect when the streaming operation is finished
    
    Parameters:
    
    message - raw message
    
    Returns:
    
    returns true if this is the last message in the streaming operation
  - channelMessage
```
public final Object channelMessage()
```
  - cancel
```
public final boolean cancel(boolean mayInterruptIfRunning)
```
    Description copied from interface: RiakFuture
    
    Not supported due to limitations of the Riak API.
    At present time there is no way to cancel an operation sent to Riak. This method will never succeed and always return false.
    
    Specified by:
    
    cancel in interface RiakFuture<T,S>
    
    Specified by:
    
    cancel in interface Future<T>
    
    Returns:
    
    always false.
  - isCancelled
```
public final boolean isCancelled()
```
    Specified by:
    
    isCancelled in interface RiakFuture<T,S>
    
    Specified by:
    
    isCancelled in interface Future<T>
  - isDone
```
public final boolean isDone()
```
    Specified by:
    
    isDone in interface RiakFuture<T,S>
    
    Specified by:
    
    isDone in interface Future<T>
  - isSuccess
```
public final boolean isSuccess()
```
    Description copied from interface: RiakFuture
    
    Determine if the operation completed successfully.
    
    Specified by:
    
    isSuccess in interface RiakFuture<T,S>
    
    Returns:
    
    true if the operation succeeded, false if not yet completed or failed.
  - cause
```
public final Throwable cause()
```
    Description copied from interface: RiakFuture
    
    Return information about the operation and why it failed.
    Note this will return null if the operation completed successfully.
    
    Specified by:
    
    cause in interface RiakFuture<T,S>
    
    Returns:
    
    The exception thrown during the operation, or null if not set.
    
    See Also:
    
    RiakFuture.isSuccess()
  - get
```
public final T get()
            throws InterruptedException,
                   ExecutionException
```
    Description copied from interface: RiakFuture
    
    Waits for this RiakFuture to be completed if necessary and returns the response if available.
    
    Specified by:
    
    get in interface RiakFuture<T,S>
    
    Specified by:
    
    get in interface Future<T>
    
    Returns:
    
    The response from the operation.
    
    Throws:
    
    InterruptedException - if the current thread was interrupted while waiting
    
    ExecutionException - if the computation threw an exception
  - get
```
public final T get(long timeout,
                   TimeUnit unit)
            throws InterruptedException,
                   ExecutionException,
                   TimeoutException
```
    Description copied from interface: RiakFuture
    
    Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.
    Note that the timeout value here is how long you are willing to wait for this RiakFuture to complete. If you wish to set a timeout on the command itself, use the timeout() method provided in the command's associated builder.
    
    Specified by:
    
    get in interface RiakFuture<T,S>
    
    Specified by:
    
    get in interface Future<T>
    
    Parameters:
    
    timeout - the amount of time to wait before returning.
    
    unit - the unit of time.
    
    Returns:
    
    the response, or null if not completed or failed.
    
    Throws:
    
    InterruptedException - if the current thread was interrupted while waiting.
    
    ExecutionException - if the computation threw an exception.
    
    TimeoutException - if the wait timed out.
  - getNow
```
public final T getNow()
```
    Description copied from interface: RiakFuture
    
    Return the result without blocking or throwing an exception. If the future is not yet done or has failed this will return null. As it is possible that a null value is used to mark the future as successful you also need to check if the future is really done with RiakFuture.isDone() and not rely on the returned null value.
    
    Specified by:
    
    getNow in interface RiakFuture<T,S>
    
    Returns:
    
    The response, or null if the future is not yet completed or failed.
    
    See Also:
    
    RiakFuture.isDone(), RiakFuture.isSuccess()
  - await
```
public final void await()
                 throws InterruptedException
```
    Description copied from interface: RiakFuture
    
    Waits for this RiakFuture to be completed.
    Upon returning, the operation has completed. Checking isSuccess() tells you if it did so successfully.
    
    Specified by:
    
    await in interface RiakFuture<T,S>
    
    Throws:
    
    InterruptedException - if the current thread was interrupted while waiting
    
    See Also:
    
    RiakFuture.isSuccess()
  - await
```
public final boolean await(long timeout,
                           TimeUnit unit)
                    throws InterruptedException
```
    Description copied from interface: RiakFuture
    
    Waits for this RiakFuture to be completed for a set amount of time.
    Note that the timeout value here is how long you are willing to wait for this RiakFuture to complete. Upon return you can check isDone() to see if the future has completed yet or not. The operation is still in progress if that returns false.
    
    If you wish to set a timeout on the command itself, use the timeout() method provided in the command's associated builder.
    
    Specified by:
    
    await in interface RiakFuture<T,S>
    
    Parameters:
    
    timeout - the amount of time to wait before returning.
    
    unit - the unit of time.
    
    Returns:
    
    true if the future completed and false if the waiting time elapsed before it completed
    
    Throws:
    
    InterruptedException - if the current thread was interrupted while waiting
    
    See Also:
    
    RiakFuture.isDone(), RiakFuture.isSuccess()
  - checkAndGetSingleResponse
```
protected U checkAndGetSingleResponse(List<U> responses)
```
  - convert
```
protected abstract T convert(List<U> rawResponse)
```
  - createChannelMessage
```
protected abstract RiakMessage createChannelMessage()
```
  - decode
```
protected abstract U decode(RiakMessage rawMessage)
```
  - getQueryInfo
```
public abstract S getQueryInfo()
```
    Description copied from interface: RiakFuture
    
    Returns information related to the operation performed.
    Useful in async operations when you want to know what operation this future refers to.
    
    Specified by:
    
    getQueryInfo in interface RiakFuture<T,S>
    
    Returns:
    
    Information pertaining to the operation attached to this future.

Class FutureOperation<T,U,S>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FutureOperation

Method Detail

addListener

removeListener

setResponse

processMessage

processBatchMessage

setComplete

done

channelMessage

cancel

isCancelled

isDone

isSuccess

cause

get

get

getNow

await

await

checkAndGetSingleResponse

convert

createChannelMessage

decode

getQueryInfo