com.jogamp.common.util

## Class TaskBase

- java.lang.Object
- - com.jogamp.common.util.TaskBase

- All Implemented Interfaces:
    Runnable
  Direct Known Subclasses:
    FunctionTask, RunnableTask

      public abstract class TaskBase
      extends Object
      implements Runnable

  Helper class to provide a Runnable queue implementation with a Runnable wrapper which notifies after execution for the `invokeAndWait()` semantics.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Object` | `attachment`
    `protected boolean` | `catchExceptions`
    `protected PrintStream` | `exceptionOut`
    `protected boolean` | `isFlushed`
    `protected Throwable` | `runnableException`
    `protected Throwable` | `sourceStack`
    `protected Object` | `syncObject`
    `protected long` | `tCreated`
    `protected long` | `tExecuted`
    `protected long` | `tStarted`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `TaskBase(Object syncObject, boolean catchExceptions, PrintStream exceptionOut)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `flush(Throwable t)` Simply flush this task and notify a waiting executor.
    `Object` | `getAttachment()` Return the attachment object if any.
    `long` | `getDurationInExec()`
    `long` | `getDurationInQueue()`
    `long` | `getDurationTotal()`
    `protected String` | `getExceptionOutIntro()`
    `Object` | `getSyncObject()` Return the synchronization object if any.
    `Throwable` | `getThrowable()`
    `long` | `getTimestampAfterExec()`
    `long` | `getTimestampBeforeExec()`
    `long` | `getTimestampCreate()`
    `boolean` | `hasWaiter()`
    `boolean` | `isExecuted()`
    `boolean` | `isFlushed()`
    `boolean` | `isInQueue()`
    `protected void` | `printSourceTrace()`
    `abstract void` | `run()`
    `void` | `setAttachment(Object o)` Attach a custom object to this task.
    `String` | `toString()`

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

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

- - ### Field Detail

    - #### syncObject

          protected final Object syncObject

    - #### catchExceptions

          protected final boolean catchExceptions

    - #### exceptionOut

          protected final PrintStream exceptionOut

    - #### sourceStack

          protected final Throwable sourceStack

    - #### attachment

          protected Object attachment

    - #### runnableException

          protected Throwable runnableException

    - #### tCreated

          protected long tCreated

    - #### tStarted

          protected long tStarted

    - #### tExecuted

          protected volatile long tExecuted

    - #### isFlushed

          protected volatile boolean isFlushed

  - ### Constructor Detail

    - #### TaskBase

          protected TaskBase(Object syncObject,
                  boolean catchExceptions,
                  PrintStream exceptionOut)

  - ### Method Detail

    - #### getExceptionOutIntro

          protected final String getExceptionOutIntro()

    - #### printSourceTrace

          protected final void printSourceTrace()

    - #### getSyncObject

          public final Object getSyncObject()

      Return the synchronization object if any.
      See Also:
        `#RunnableTask(Runnable, Object, boolean)`

    - #### setAttachment

          public final void setAttachment(Object o)

      Attach a custom object to this task. Useful to piggybag further information, ie tag a task final.

    - #### getAttachment

          public final Object getAttachment()

      Return the attachment object if any.
      See Also:
        `setAttachment(Object)`

    - #### run

          public abstract void run()

      Specified by:
        `run` in interface `Runnable`

    - #### flush

          public final void flush(Throwable t)

      Simply flush this task and notify a waiting executor. The executor which might have been blocked until notified will be unblocked and the task removed from the queue.
      Parameters:
        `t` - optional Throwable to be assigned for later `getThrowable()` query in case of an error.
      See Also:
        `isFlushed()`, `isInQueue()`

    - #### isInQueue

          public final boolean isInQueue()

      Returns:
        !`isExecuted()` && !`isFlushed()`

    - #### isExecuted

          public final boolean isExecuted()

      Returns:
        True if executed, otherwise false;

    - #### isFlushed

          public final boolean isFlushed()

      Returns:
        True if flushed, otherwise false;

    - #### hasWaiter

          public final boolean hasWaiter()

      Returns:
        True if invoking thread waits until done, ie a `notifyObject` was passed, otherwise false;

    - #### getThrowable

          public final Throwable getThrowable()

      Returns:
        A thrown exception while execution of the user action, if any and if caught
      See Also:
        `#RunnableTask(Runnable, Object, boolean)`

    - #### getTimestampCreate

          public final long getTimestampCreate()

    - #### getTimestampBeforeExec

          public final long getTimestampBeforeExec()

    - #### getTimestampAfterExec

          public final long getTimestampAfterExec()

    - #### getDurationInQueue

          public final long getDurationInQueue()

    - #### getDurationInExec

          public final long getDurationInExec()

    - #### getDurationTotal

          public final long getDurationTotal()

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`