ForwardingTask (Apache Brooklyn)

java.lang.Object
- com.google.common.collect.ForwardingObject
- - brooklyn.util.task.ForwardingTask<T>

All Implemented Interfaces:

Task<T>, TaskAdaptable<T>, TaskInternal<T>, com.google.common.util.concurrent.ListenableFuture<T>, java.util.concurrent.Future<T>
```
public abstract class ForwardingTask<T>
extends com.google.common.collect.ForwardingObject
implements TaskInternal<T>
```

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addListener(java.lang.Runnable listener, java.util.concurrent.Executor executor)`
`void`	`applyTagModifier(com.google.common.base.Function<java.util.Set<java.lang.Object>,java.lang.Void> modifier)`
`Task<T>`	`asTask()`
`void`	`blockUntilEnded()` Causes calling thread to block until the task is ended.
`boolean`	`blockUntilEnded(Duration timeout)` As `Task.blockUntilEnded()`, but returning after the given timeout; true if the task has ended and false otherwise
`void`	`blockUntilStarted()` Causes calling thread to block until the task is started.
`boolean`	`blockUntilStarted(Duration timeout)`
`boolean`	`cancel()`
`boolean`	`cancel(boolean arg0)` As `Future.cancel(boolean)`.
`T`	`get()`
`T`	`get(Duration duration)` As `Future.get(long, java.util.concurrent.TimeUnit)`
`T`	`get(long arg0, java.util.concurrent.TimeUnit arg1)`
`java.lang.String`	`getBlockingDetails()` returns a textual message giving details while the task is blocked
`Task<?>`	`getBlockingTask()` returns a task that this task is blocked on
`java.lang.String`	`getDescription()`
`java.lang.String`	`getDisplayName()`
`long`	`getEndTimeUtc()` if `Future.isDone()` (for any reason) returns the time when the task ended; guaranteed to be >= `Task.getStartTimeUtc()` > 0 if ended, or -1 otherwise
`java.lang.Object`	`getExtraStatusText()`
`java.lang.String`	`getId()`
`java.util.concurrent.Future<T>`	`getInternalFuture()` returns the underlying future where this task's results will come in; see `TaskInternal.initInternalFuture(ListenableFuture)`
`java.util.concurrent.Callable<T>`	`getJob()`
`com.google.common.util.concurrent.ExecutionList`	`getListeners()`
`java.util.Set<java.lang.Object>`	`getMutableTags()`
`Task<?>`	`getProxyTarget()` if a task is a proxy for another one (used mainly for internal tasks), this returns the "real" task represented by this one
`long`	`getQueuedTimeUtc()` if the job is queued for submission (e.g.
`long`	`getStartTimeUtc()` if `Task.isBegun()` returns the time when the task was starts; guaranteed to be >= `Task.getSubmitTimeUtc()` > 0 if started, or -1 otherwise
`java.lang.String`	`getStatusDetail(boolean multiline)` Returns detailed status, suitable for a hover.
`java.lang.String`	`getStatusSummary()`
`Task<?>`	`getSubmittedByTask()` task which submitted this task, if was submitted by a task
`long`	`getSubmitTimeUtc()` if `Task.isSubmitted()` returns the time when the task was submitted; or -1 otherwise
`java.util.Set<java.lang.Object>`	`getTags()`
`java.lang.Thread`	`getThread()` The thread where the task is running, if it is running.
`T`	`getUnchecked()` As `Future.get()`, but propagating checked exceptions as unchecked for convenience.
`T`	`getUnchecked(Duration duration)` As `Future.get()`, but propagating checked exceptions as unchecked for convenience (including a `TimeoutException` if the duration expires)
`void`	`initInternalFuture(com.google.common.util.concurrent.ListenableFuture<T> result)` sets the internal future object used to record the association to a job submitted to an `ExecutorService`
`boolean`	`isBegun()` Whether task has started running.
`boolean`	`isCancelled()`
`boolean`	`isDone()`
`boolean`	`isError()` Whether the task threw an error, including cancellation (implies `Future.isDone()`)
`boolean`	`isQueued()`
`boolean`	`isQueuedAndNotSubmitted()`
`boolean`	`isQueuedOrSubmitted()`
`boolean`	`isSubmitted()` Whether task has been submitted Submitted tasks are normally expected to start running then complete, but unsubmitted tasks are sometimes passed around for someone else to submit them.
`void`	`markQueued()` marks the task as queued for execution
`void`	`resetBlockingDetails()`
`void`	`resetBlockingTask()`
`void`	`runListeners()`
`java.lang.String`	`setBlockingDetails(java.lang.String blockingDetails)` allows a task user to specify why a task is blocked; for use immediately before a blocking/wait, and typically cleared immediately afterwards; referenced by management api to inspect a task which is blocking
`Task<?>`	`setBlockingTask(Task<?> blockingTask)` as `TaskInternal.setBlockingDetails(String)` but records a task which is blocking, for use e.g.
`void`	`setEndTimeUtc(long val)`
`void`	`setExtraStatusText(java.lang.Object extraStatus)`
`void`	`setJob(java.util.concurrent.Callable<T> job)`
`void`	`setStartTimeUtc(long currentTimeMillis)`
`void`	`setSubmittedByTask(Task<?> task)`
`void`	`setSubmitTimeUtc(long currentTimeMillis)`
`void`	`setThread(java.lang.Thread thread)`

Methods inherited from class com.google.common.collect.ForwardingObject
toString

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

- Method Detail
  - addListener
```
public void addListener(java.lang.Runnable listener,
               java.util.concurrent.Executor executor)
```
    Specified by:
    
    addListener in interface com.google.common.util.concurrent.ListenableFuture<T>
  - cancel
```
public boolean cancel(boolean arg0)
```
    Description copied from interface: Task
    
    As Future.cancel(boolean). Note that Future.isDone() and Task.blockUntilEnded(Duration) return immediately once a task is cancelled, consistent with the underlying FutureTask behaviour. TODO Fine-grained control over underlying jobs, e.g. to ensure anything represented by this task is actually completed, is not (yet) publicly exposed. See the convenience method blockUntilInternalTasksEnded in the Tasks set of helpers for more discussion.
    
    Specified by:
    
    cancel in interface Task<T>
    
    Specified by:
    
    cancel in interface java.util.concurrent.Future<T>
  - get
```
public T get()
      throws java.lang.InterruptedException,
             java.util.concurrent.ExecutionException
```
    Specified by:
    
    get in interface java.util.concurrent.Future<T>
    
    Throws:
    
    java.lang.InterruptedException
    
    java.util.concurrent.ExecutionException
  - get
```
public T get(long arg0,
    java.util.concurrent.TimeUnit arg1)
      throws java.lang.InterruptedException,
             java.util.concurrent.ExecutionException,
             java.util.concurrent.TimeoutException
```
    Specified by:
    
    get in interface java.util.concurrent.Future<T>
    
    Throws:
    
    java.lang.InterruptedException
    
    java.util.concurrent.ExecutionException
    
    java.util.concurrent.TimeoutException
  - isCancelled
```
public boolean isCancelled()
```
    Specified by:
    
    isCancelled in interface java.util.concurrent.Future<T>
  - isDone
```
public boolean isDone()
```
    Specified by:
    
    isDone in interface java.util.concurrent.Future<T>
  - asTask
```
public Task<T> asTask()
```
    Specified by:
    
    asTask in interface TaskAdaptable<T>
  - getId
```
public java.lang.String getId()
```
    Specified by:
    
    getId in interface Task<T>
  - getTags
```
public java.util.Set<java.lang.Object> getTags()
```
    Specified by:
    
    getTags in interface Task<T>
  - getSubmitTimeUtc
```
public long getSubmitTimeUtc()
```
    Description copied from interface: Task
    
    if Task.isSubmitted() returns the time when the task was submitted; or -1 otherwise
    
    Specified by:
    
    getSubmitTimeUtc in interface Task<T>
  - getStartTimeUtc
```
public long getStartTimeUtc()
```
    Description copied from interface: Task
    
    if Task.isBegun() returns the time when the task was starts; guaranteed to be >= Task.getSubmitTimeUtc() > 0 if started, or -1 otherwise
    
    Specified by:
    
    getStartTimeUtc in interface Task<T>
  - getEndTimeUtc
```
public long getEndTimeUtc()
```
    Description copied from interface: Task
    
    if Future.isDone() (for any reason) returns the time when the task ended; guaranteed to be >= Task.getStartTimeUtc() > 0 if ended, or -1 otherwise
    
    Specified by:
    
    getEndTimeUtc in interface Task<T>
  - getDisplayName
```
public java.lang.String getDisplayName()
```
    Specified by:
    
    getDisplayName in interface Task<T>
  - getDescription
```
public java.lang.String getDescription()
```
    Specified by:
    
    getDescription in interface Task<T>
  - getSubmittedByTask
```
public Task<?> getSubmittedByTask()
```
    Description copied from interface: Task
    
    task which submitted this task, if was submitted by a task
    
    Specified by:
    
    getSubmittedByTask in interface Task<T>
  - getThread
```
public java.lang.Thread getThread()
```
    Description copied from interface: Task
    
    The thread where the task is running, if it is running.
    
    Specified by:
    
    getThread in interface Task<T>
  - isSubmitted
```
public boolean isSubmitted()
```
    Description copied from interface: Task
    
    Whether task has been submitted Submitted tasks are normally expected to start running then complete, but unsubmitted tasks are sometimes passed around for someone else to submit them.
    
    Specified by:
    
    isSubmitted in interface Task<T>
  - isBegun
```
public boolean isBegun()
```
    Description copied from interface: Task
    
    Whether task has started running. Will remain true after normal completion or non-cancellation error. will be true on cancel iff the thread did actually start.
    
    Specified by:
    
    isBegun in interface Task<T>
  - isError
```
public boolean isError()
```
    Description copied from interface: Task
    
    Whether the task threw an error, including cancellation (implies Future.isDone())
    
    Specified by:
    
    isError in interface Task<T>
  - blockUntilStarted
```
public void blockUntilStarted()
```
    Description copied from interface: Task
    
    Causes calling thread to block until the task is started.
    
    Specified by:
    
    blockUntilStarted in interface Task<T>
  - blockUntilEnded
```
public void blockUntilEnded()
```
    Description copied from interface: Task
    
    Causes calling thread to block until the task is ended.
    Either normally or by cancellation or error, but without throwing error on cancellation or error. (Errors are logged at debug.)
    
    Specified by:
    
    blockUntilEnded in interface Task<T>
  - blockUntilEnded
```
public boolean blockUntilEnded(Duration timeout)
```
    Description copied from interface: Task
    
    As Task.blockUntilEnded(), but returning after the given timeout; true if the task has ended and false otherwise
    
    Specified by:
    
    blockUntilEnded in interface Task<T>
  - getStatusSummary
```
public java.lang.String getStatusSummary()
```
    Specified by:
    
    getStatusSummary in interface Task<T>
  - getStatusDetail
```
public java.lang.String getStatusDetail(boolean multiline)
```
    Description copied from interface: Task
    
    Returns detailed status, suitable for a hover. Plain-text format, with new-lines (and sometimes extra info) if multiline enabled.
    
    Specified by:
    
    getStatusDetail in interface Task<T>
  - get
```
public T get(Duration duration)
      throws java.lang.InterruptedException,
             java.util.concurrent.ExecutionException,
             java.util.concurrent.TimeoutException
```
    Description copied from interface: Task
    
    As Future.get(long, java.util.concurrent.TimeUnit)
    
    Specified by:
    
    get in interface Task<T>
    
    Throws:
    
    java.lang.InterruptedException
    
    java.util.concurrent.ExecutionException
    
    java.util.concurrent.TimeoutException
  - getUnchecked
```
public T getUnchecked()
```
    Description copied from interface: Task
    
    As Future.get(), but propagating checked exceptions as unchecked for convenience.
    
    Specified by:
    
    getUnchecked in interface Task<T>
  - getUnchecked
```
public T getUnchecked(Duration duration)
```
    Description copied from interface: Task
    
    As Future.get(), but propagating checked exceptions as unchecked for convenience (including a TimeoutException if the duration expires)
    
    Specified by:
    
    getUnchecked in interface Task<T>
  - initInternalFuture
```
public void initInternalFuture(com.google.common.util.concurrent.ListenableFuture<T> result)
```
    Description copied from interface: TaskInternal
    
    sets the internal future object used to record the association to a job submitted to an ExecutorService
    
    Specified by:
    
    initInternalFuture in interface TaskInternal<T>
  - getQueuedTimeUtc
```
public long getQueuedTimeUtc()
```
    Description copied from interface: TaskInternal
    
    if the job is queued for submission (e.g. by another task) it can indicate that fact (and time) here; note tasks can (and often are) submitted without any queueing, in which case this value may be -1
    
    Specified by:
    
    getQueuedTimeUtc in interface TaskInternal<T>
  - getInternalFuture
```
public java.util.concurrent.Future<T> getInternalFuture()
```
    Description copied from interface: TaskInternal
    
    returns the underlying future where this task's results will come in; see TaskInternal.initInternalFuture(ListenableFuture)
    
    Specified by:
    
    getInternalFuture in interface TaskInternal<T>
  - isQueued
```
public boolean isQueued()
```
    Specified by:
    
    isQueued in interface TaskInternal<T>
  - isQueuedOrSubmitted
```
public boolean isQueuedOrSubmitted()
```
    Specified by:
    
    isQueuedOrSubmitted in interface TaskInternal<T>
  - isQueuedAndNotSubmitted
```
public boolean isQueuedAndNotSubmitted()
```
    Specified by:
    
    isQueuedAndNotSubmitted in interface TaskInternal<T>
  - markQueued
```
public void markQueued()
```
    Description copied from interface: TaskInternal
    
    marks the task as queued for execution
    
    Specified by:
    
    markQueued in interface TaskInternal<T>
  - cancel
```
public boolean cancel()
```
    Specified by:
    
    cancel in interface TaskInternal<T>
  - blockUntilStarted
```
public boolean blockUntilStarted(Duration timeout)
```
    Specified by:
    
    blockUntilStarted in interface TaskInternal<T>
  - setBlockingDetails
```
public java.lang.String setBlockingDetails(java.lang.String blockingDetails)
```
    Description copied from interface: TaskInternal
    
    allows a task user to specify why a task is blocked; for use immediately before a blocking/wait, and typically cleared immediately afterwards; referenced by management api to inspect a task which is blocking
    returns previous details, in case caller wishes to recall and restore it (e.g. if it is doing a sub-blocking)
    
    Specified by:
    
    setBlockingDetails in interface TaskInternal<T>
  - setBlockingTask
```
public Task<?> setBlockingTask(Task<?> blockingTask)
```
    Description copied from interface: TaskInternal
    
    as TaskInternal.setBlockingDetails(String) but records a task which is blocking, for use e.g. in a gui to navigate to the current active subtask
    returns previous blocking task, in case caller wishes to recall and restore it
    
    Specified by:
    
    setBlockingTask in interface TaskInternal<T>
  - resetBlockingDetails
```
public void resetBlockingDetails()
```
    Specified by:
    
    resetBlockingDetails in interface TaskInternal<T>
  - resetBlockingTask
```
public void resetBlockingTask()
```
    Specified by:
    
    resetBlockingTask in interface TaskInternal<T>
  - getBlockingDetails
```
public java.lang.String getBlockingDetails()
```
    Description copied from interface: TaskInternal
    
    returns a textual message giving details while the task is blocked
    
    Specified by:
    
    getBlockingDetails in interface TaskInternal<T>
  - getBlockingTask
```
public Task<?> getBlockingTask()
```
    Description copied from interface: TaskInternal
    
    returns a task that this task is blocked on
    
    Specified by:
    
    getBlockingTask in interface TaskInternal<T>
  - setExtraStatusText
```
public void setExtraStatusText(java.lang.Object extraStatus)
```
    Specified by:
    
    setExtraStatusText in interface TaskInternal<T>
  - getExtraStatusText
```
public java.lang.Object getExtraStatusText()
```
    Specified by:
    
    getExtraStatusText in interface TaskInternal<T>
  - runListeners
```
public void runListeners()
```
    Specified by:
    
    runListeners in interface TaskInternal<T>
  - setEndTimeUtc
```
public void setEndTimeUtc(long val)
```
    Specified by:
    
    setEndTimeUtc in interface TaskInternal<T>
  - setThread
```
public void setThread(java.lang.Thread thread)
```
    Specified by:
    
    setThread in interface TaskInternal<T>
  - getJob
```
public java.util.concurrent.Callable<T> getJob()
```
    Specified by:
    
    getJob in interface TaskInternal<T>
  - setJob
```
public void setJob(java.util.concurrent.Callable<T> job)
```
    Specified by:
    
    setJob in interface TaskInternal<T>
  - getListeners
```
public com.google.common.util.concurrent.ExecutionList getListeners()
```
    Specified by:
    
    getListeners in interface TaskInternal<T>
  - setSubmitTimeUtc
```
public void setSubmitTimeUtc(long currentTimeMillis)
```
    Specified by:
    
    setSubmitTimeUtc in interface TaskInternal<T>
  - setSubmittedByTask
```
public void setSubmittedByTask(Task<?> task)
```
    Specified by:
    
    setSubmittedByTask in interface TaskInternal<T>
  - getMutableTags
```
public java.util.Set<java.lang.Object> getMutableTags()
```
    Specified by:
    
    getMutableTags in interface TaskInternal<T>
  - setStartTimeUtc
```
public void setStartTimeUtc(long currentTimeMillis)
```
    Specified by:
    
    setStartTimeUtc in interface TaskInternal<T>
  - applyTagModifier
```
public void applyTagModifier(com.google.common.base.Function<java.util.Set<java.lang.Object>,java.lang.Void> modifier)
```
    Specified by:
    
    applyTagModifier in interface TaskInternal<T>
  - getProxyTarget
```
public Task<?> getProxyTarget()
```
    Description copied from interface: TaskInternal
    
    if a task is a proxy for another one (used mainly for internal tasks), this returns the "real" task represented by this one
    
    Specified by:
    
    getProxyTarget in interface TaskInternal<T>

Class ForwardingTask<T>

Method Summary

Methods inherited from class com.google.common.collect.ForwardingObject

Methods inherited from class java.lang.Object

Method Detail

addListener

cancel

get

get

isCancelled

isDone

asTask

getId

getTags

getSubmitTimeUtc

getStartTimeUtc

getEndTimeUtc

getDisplayName

getDescription

getSubmittedByTask

getThread

isSubmitted

isBegun

isError

blockUntilStarted

blockUntilEnded

blockUntilEnded

getStatusSummary

getStatusDetail

get

getUnchecked

getUnchecked

initInternalFuture

getQueuedTimeUtc

getInternalFuture

isQueued

isQueuedOrSubmitted

isQueuedAndNotSubmitted

markQueued

cancel

blockUntilStarted

setBlockingDetails

setBlockingTask

resetBlockingDetails

resetBlockingTask

getBlockingDetails

getBlockingTask

setExtraStatusText

getExtraStatusText

runListeners

setEndTimeUtc

setThread

getJob

setJob

getListeners

setSubmitTimeUtc

setSubmittedByTask

getMutableTags

setStartTimeUtc

applyTagModifier

getProxyTarget