SwingTask (swing-tasks 0.0.3 API)

java.lang.Object
- de.javagl.swing.tasks.SwingTask<T,V>

Type Parameters:

T - The result type

V - The intermediate results type

All Implemented Interfaces:

Runnable, Future<T>, RunnableFuture<T>
```
public abstract class SwingTask<T,V>
extends Object
implements RunnableFuture<T>
```
A background task for Swing. A SwingTask is very similar to a SwingWorker: It offers a method doInBackground() that may be overridden and will be executed in a background thread, and implements the RunnableFuture interface.
Additionally, it maintains a ProgressHandler that may be obtained by calling the getProgressHandler() method, and may be used by implementors to inform observers of this task about the progress of the computation. These observers are ProgressListeners that have been added to this task, and they will be informed about the progress on the Event Dispatch Thread.
It also maintains lists of callbacks that may be informed on the Event Dispatch Thread. These callbacks serve as a runtime-alternative for overriding the process(List) and the done() method respectively: The process callbacks are informed about intermediate results that are produced by this task and published via the publish(Object...) method. The done callbacks are informed when this task is done(). When any of the callbacks throws an exception, the subsequent behavior of this task is undefined.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`SwingTask()` Creates a new swing task with a default status message
`protected`	`SwingTask(String message)` Creates a new swing task with the given status message

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addDoneCallback(Consumer<SwingTask<T,V>> doneCallback)` Add the given callback to be called on the Event Dispatch Thread, when this task is `done()`
`void`	`addProcessCallback(Consumer<List<V>> processCallback)` Add the given callback to be called on the Event Dispatch Thread, receiving a list of intermediate results that have been passed to the `publish(Object...)` method.
`boolean`	`cancel(boolean mayInterruptIfRunning)`
`protected abstract T`	`doInBackground()` The method that may be overridden by implementors in order to perform the work in the background thread
`protected void`	`done()` This method is executed on the Event Dispatch Thread after the `doInBackground()` method is finished.
`void`	`execute()` Executes this task.
`T`	`get()`
`T`	`get(long timeout, TimeUnit unit)`
`protected ProgressHandler`	`getProgressHandler()` Returns the `ProgressHandler` that may be used to inform this task about the current progress during the execution of the `doInBackground()` method.
`boolean`	`isCancelled()`
`boolean`	`isDone()`
`protected void`	`process(List<V> chunks)` Receives data chunks from the `publish` method on the Event Dispatch Thread.
`protected void`	`publish(V... chunks)` Publishes the given data chunks.
`void`	`removeDoneCallback(Consumer<SwingTask<T,V>> doneCallback)` Remove the given callback
`void`	`removeProcessCallback(Consumer<List<V>> processCallback)` Remove the given callback
`void`	`run()`
`protected void`	`setMessage(String message)` Set the current status message.
`protected void`	`setProgress(double progress)` Set the current progress.

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

- Constructor Detail
  - SwingTask
```
protected SwingTask()
```
    Creates a new swing task with a default status message
  - SwingTask
```
protected SwingTask(String message)
```
    Creates a new swing task with the given status message
    
    Parameters:
    
    message - The status message
- Method Detail
  - addProcessCallback
```
public final void addProcessCallback(Consumer<List<V>> processCallback)
```
    Add the given callback to be called on the Event Dispatch Thread, receiving a list of intermediate results that have been passed to the publish(Object...) method.
    
    Parameters:
    
    processCallback - The callback to add
  - removeProcessCallback
```
public final void removeProcessCallback(Consumer<List<V>> processCallback)
```
    Remove the given callback
    
    Parameters:
    
    processCallback - The callback to remove
    
    See Also:
    
    addProcessCallback(Consumer)
  - addDoneCallback
```
public final void addDoneCallback(Consumer<SwingTask<T,V>> doneCallback)
```
    Add the given callback to be called on the Event Dispatch Thread, when this task is done()
    
    Parameters:
    
    doneCallback - The callback to add
  - removeDoneCallback
```
public final void removeDoneCallback(Consumer<SwingTask<T,V>> doneCallback)
```
    Remove the given callback
    
    Parameters:
    
    doneCallback - The callback to remove
    
    See Also:
    
    addDoneCallback(Consumer)
  - doInBackground
```
protected abstract T doInBackground()
                             throws Exception
```
    The method that may be overridden by implementors in order to perform the work in the background thread
    
    Returns:
    
    The result of the computation
    
    Throws:
    
    Exception - If an exception happens during the computation
  - publish
```
@SafeVarargs
protected final void publish(V... chunks)
```
    Publishes the given data chunks. This method may be called in the doInBackground() method to publish intermediate results. These will be accumulated and may be processed in the process(List) method, which is called on the Event Dispatch Thread
    
    Parameters:
    
    chunks - The chunks to publish
  - process
```
protected void process(List<V> chunks)
```
    Receives data chunks from the publish method on the Event Dispatch Thread. The default implementation is empty and may be overridden.
    Note that instead of overriding this method, it is also possible to register a process callback to be informed about intermediate results.
    
    Parameters:
    
    chunks - The intermediate results
  - execute
```
public final void execute()
```
    Executes this task. Similarly to a SwingWorker, this method may only be called once.
  - run
```
public final void run()
```
    Specified by:
    
    run in interface Runnable
    
    Specified by:
    
    run in interface RunnableFuture<T>
  - get
```
public final T get()
            throws InterruptedException,
                   ExecutionException
```
    Specified by:
    
    get in interface Future<T>
    
    Throws:
    
    InterruptedException
    
    ExecutionException
  - get
```
public final T get(long timeout,
                   TimeUnit unit)
            throws InterruptedException,
                   ExecutionException,
                   TimeoutException
```
    Specified by:
    
    get in interface Future<T>
    
    Throws:
    
    InterruptedException
    
    ExecutionException
    
    TimeoutException
  - cancel
```
public final boolean cancel(boolean mayInterruptIfRunning)
```
    Specified by:
    
    cancel in interface Future<T>
  - isDone
```
public final boolean isDone()
```
    Specified by:
    
    isDone in interface Future<T>
  - isCancelled
```
public final boolean isCancelled()
```
    Specified by:
    
    isCancelled in interface Future<T>
  - done
```
protected void done()
```
    This method is executed on the Event Dispatch Thread after the doInBackground() method is finished. The default implementation is empty and may be overridden.
    Note that instead of overriding this method, it is also possible to register a done callback to be informed when the work is done.
  - getProgressHandler
```
protected final ProgressHandler getProgressHandler()
```
    Returns the ProgressHandler that may be used to inform this task about the current progress during the execution of the doInBackground() method.
    
    Returns:
    
    The ProgressHandler
  - setMessage
```
protected final void setMessage(String message)
```
    Set the current status message. If the message changed, all ProgressListeners will be notified on the Event Dispatch Thread
    
    Parameters:
    
    message - The current status message
  - setProgress
```
protected final void setProgress(double progress)
```
    Set the current progress. This usually is a value between 0 and 1, or a value <0 if the progress is not known. If the progress changed, all ProgressListeners will be notified on the Event Dispatch Thread
    
    Parameters:
    
    progress - The current progress

Class SwingTask<T,V>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SwingTask

SwingTask

Method Detail

addProcessCallback

removeProcessCallback

addDoneCallback

removeDoneCallback

doInBackground

publish

process

execute

run

get

get

cancel

isDone

isCancelled

done

getProgressHandler

setMessage

setProgress