Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.trolltech.qt.core
Class QFuture<T>

    java.lang.Object
      com.trolltech.qt.QSignalEmitter
          com.trolltech.qt.QtJambiObject
              com.trolltech.qt.core.QFuture<T>

All Implemented Interfaces:
  QtJambiInterface, java.lang.Cloneable

    public class QFuture<T>

extends QtJambiObject
implements java.lang.Cloneable

The `QFuture` class represents the result of an asynchronous computation. To start a computation, use one of the APIs in the Qt Concurrent framework.

`QFuture` allows threads to be synchronized against one or more results which will be ready at a later point in time. The result can be of any type that has a default constructor and a copy constructor. If a result is not available at the time of calling the `result()`, `resultAt()`, or `results()` functions, `QFuture` will wait until the result becomes available. You can use the `isResultReadyAt()` function to determine if a result is ready or not. For `QFuture` objects that report more than one result, the `resultCount()` function returns the number of continuous results. This means that it is always safe to iterate through the results from 0 to `resultCount()`.

`QFuture` provides a Java-style iterator (`QFutureIterator`) and an STL-style iterator (QFuture::const_iterator). Using these iterators is another way to access results in the future.

`QFuture` also offers ways to interact with a runnning computation. For instance, the computation can be canceled with the `cancel()` function. To pause the computation, use the `setPaused()` function or one of the `pause()`, `resume()`, or `togglePaused()` convenience functions. Be aware that not all asynchronous computations can be canceled or paused. For example, the future returned by QtConcurrent::run() cannot be canceled; but the future returned by QtConcurrent::mappedReduced() can.

Progress information is provided by the `progressValue()`, `progressMinimum()`, `progressMaximum()`, and `progressText()` functions. The `waitForFinished()` function causes the calling thread to block and wait for the computation to finish, ensuring that all results are available.

The state of the computation represented by a `QFuture` can be queried using the `isCanceled()`, `isStarted()`, `isFinished()`, `isRunning()`, or `isPaused()` functions.

`QFuture` is a lightweight reference counted class that can be passed by value.

`QFuture`<void> is specialized to not contain any of the result fetching functions. Any `QFuture`<T> can be assigned or copied into a `QFuture`<void> as well. This is useful if only status or progress information is needed - not the actual result data.

To interact with running tasks using signals and slots, use `QFutureWatcher`.

See also:
  `QFutureWatcher`, and Qt Concurrent.

Nested Class Summary

Nested classes/interfaces inherited from class com.trolltech.qt.QtJambiObject
`QtJambiObject.QPrivateConstructor`

Nested classes/interfaces inherited from class com.trolltech.qt.QSignalEmitter
`QSignalEmitter.AbstractSignal, QSignalEmitter.Signal0, QSignalEmitter.Signal1<A>, QSignalEmitter.Signal2<A,B>, QSignalEmitter.Signal3<A,B,C>, QSignalEmitter.Signal4<A,B,C,D>, QSignalEmitter.Signal5<A,B,C,D,E>, QSignalEmitter.Signal6<A,B,C,D,E,F>, QSignalEmitter.Signal7<A,B,C,D,E,F,G>, QSignalEmitter.Signal8<A,B,C,D,E,F,G,H>, QSignalEmitter.Signal9<A,B,C,D,E,F,G,H,I>`

Constructor Summary
`` | `QFuture()` Constructs an empty future.
`` | `QFuture(QFuture<T> other)` Constructs a copy of `other`.
`protected` | `QFuture(QtJambiObject.QPrivateConstructor p)` This method is internal to Qt Jambi.

Method Summary
`void` | `cancel()` Cancels the asynchronous computation represented by this future.
`QFuture` | `clone()` This method is reimplemented for internal reasons
`boolean` | `equals(java.lang.Object other)` This method is internal to Qt Jambi.
`static QFuture` | `fromNativePointer(QNativePointer nativePointer)` This method returns the QFuture instance pointed to by `nativePointer`.
`boolean` | `isCanceled()` Returns true if the asynchronous computation has been canceled with the `cancel()` function; otherwise returns false.
`boolean` | `isFinished()` Returns true if the asynchronous computation represented by this future has finished; otherwise returns false.
`boolean` | `isPaused()` Returns true if the asynchronous computation has been paused with the `pause()` function; otherwise returns false.
`boolean` | `isResultReadyAt(int index)` Returns true if the result at `index` is immediately available; otherwise returns false.
`boolean` | `isRunning()` Returns true if the asynchronous computation represented by this future is currently running; otherwise returns false.
`boolean` | `isStarted()` Returns true if the asynchronous computation represented by this future has been started; otherwise returns false.
`static QNativePointer` | `nativePointerArray(QFuture[] array)` This function returns a QNativePointer that is pointing to the specified QFuture array.
`void` | `pause()` Pauses the asynchronous computation represented by this future.
`int` | `progressMaximum()` Returns the maximum `progressValue()`.
`int` | `progressMinimum()` Returns the minimum `progressValue()`.
`java.lang.String` | `progressText()` Returns the (optional) textual representation of the progress as reported by the asynchronous computation.
`int` | `progressValue()` Returns the current progress value, which is between the `progressMinimum()` and `progressMaximum()`.
`T` | `result()` Returns the first result in the future.
`T` | `resultAt(int index)` Returns the result at `index` in the future.
`int` | `resultCount()` Returns the number of continuous results available in this future.
`java.util.List<T>` | `results()` Returns all results from the future.
`void` | `resume()` Resumes the asynchronous computation represented by this future.
`void` | `setPaused(boolean paused)` If `paused` is true, this function pauses the asynchronous computation represented by the future.
`void` | `togglePaused()` Toggles the paused state of the asynchronous computation.
`void` | `waitForFinished()` Waits for the asynchronous computation to finish (including `cancel()`ed computations).

Methods inherited from class com.trolltech.qt.QtJambiObject
`disableGarbageCollection, dispose, disposed, finalize, nativeId, nativePointer, reassignNativeResources, reenableGarbageCollection, setJavaOwnership, tr, tr, tr`

Methods inherited from class com.trolltech.qt.QSignalEmitter
`__qt_signalInitialization, blockSignals, disconnect, disconnect, signalsBlocked, signalSender, thread`

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

Constructor Detail

### QFuture

    public QFuture()

  Constructs an empty future.

### QFuture

    public QFuture(QFuture<T> other)

  Constructs a copy of `other`.

See also:
  operator=().

### QFuture

    protected QFuture(QtJambiObject.QPrivateConstructor p)

  This method is internal to Qt Jambi.

Method Detail

### cancel

    public final void cancel()

  Cancels the asynchronous computation represented by this future. Note that the cancelation is asynchronous. Use `waitForFinished()` after calling `cancel()` when you need synchronous cancelation.

  Results currently available may still be accessed on a canceled future, but new results will not become available after calling this function. Any `QFutureWatcher` object that is watching this future will not deliver progress and result ready signals on a canceled future.

  Be aware that not all asynchronous computations can be canceled. For example, the future returned by QtConcurrent::run() cannot be canceled; but the future returned by QtConcurrent::mappedReduced() can.

### isCanceled

    public final boolean isCanceled()

  Returns true if the asynchronous computation has been canceled with the `cancel()` function; otherwise returns false.

  Be aware that the computation may still be running even though this function returns true. See `cancel()` for more details.

### isFinished

    public final boolean isFinished()

  Returns true if the asynchronous computation represented by this future has finished; otherwise returns false.

### isPaused

    public final boolean isPaused()

  Returns true if the asynchronous computation has been paused with the `pause()` function; otherwise returns false.

  Be aware that the computation may still be running even though this function returns true. See `setPaused()` for more details.

See also:
  `setPaused()`, and `togglePaused()`.

### isResultReadyAt

    public final boolean isResultReadyAt(int index)

  Returns true if the result at `index` is immediately available; otherwise returns false.

See also:
  `resultAt()`, and `resultCount()`.

### isRunning

    public final boolean isRunning()

  Returns true if the asynchronous computation represented by this future is currently running; otherwise returns false.

### isStarted

    public final boolean isStarted()

  Returns true if the asynchronous computation represented by this future has been started; otherwise returns false.

### pause

    public final void pause()

  Pauses the asynchronous computation represented by this future. This is a convenience method that simply calls `setPaused`(true).

See also:
  `resume()`.

### progressMaximum

    public final int progressMaximum()

  Returns the maximum `progressValue()`.

See also:
  `progressValue()`, and `progressMinimum()`.

### progressMinimum

    public final int progressMinimum()

  Returns the minimum `progressValue()`.

See also:
  `progressValue()`, and `progressMaximum()`.

### progressText

    public final java.lang.String progressText()

  Returns the (optional) textual representation of the progress as reported by the asynchronous computation.

  Be aware that not all computations provide a textual representation of the progress, and as such, this function may return an empty string.

### progressValue

    public final int progressValue()

  Returns the current progress value, which is between the `progressMinimum()` and `progressMaximum()`.

See also:
  `progressMinimum()`, and `progressMaximum()`.

### result

    public final T result()

  Returns the first result in the future. If the result is not immediately available, this function will block and wait for the result to become available. This is a convenience method for calling `resultAt`(0).

See also:
  `resultAt()`, and `results()`.

### resultAt

    public final T resultAt(int index)

  Returns the result at `index` in the future. If the result is not immediately available, this function will block and wait for the result to become available.

See also:
  `result()`, `results()`, and `resultCount()`.

### resultCount

    public final int resultCount()

  Returns the number of continuous results available in this future. The real number of results stored might be different from this value, due to gaps in the result set. It is always safe to iterate through the results from 0 to `resultCount()`.

See also:
  `result()`, `resultAt()`, and `results()`.

### results

    public final java.util.List<T> results()

  Returns all results from the future. If the results are not immediately available, this function will block and wait for them to become available.

See also:
  `result()`, `resultAt()`, and `resultCount()`.

### resume

    public final void resume()

  Resumes the asynchronous computation represented by this future. This is a convenience method that simply calls `setPaused`(false).

See also:
  `pause()`.

### setPaused

    public final void setPaused(boolean paused)

  If `paused` is true, this function pauses the asynchronous computation represented by the future. If the computation is already paused, this function does nothing. Any `QFutureWatcher` object that is watching this future will stop delivering progress and result ready signals while the future is paused. Signal delivery will continue once the future is resumed.

  If `paused` is false, this function resumes the asynchronous computation. If the computation was not previously paused, this function does nothing.

  Be aware that not all computations can be paused. For example, the future returned by QtConcurrent::run() cannot be paused; but the future returned by QtConcurrent::mappedReduced() can.

See also:
  `isPaused()`, `pause()`, `resume()`, and `togglePaused()`.

### togglePaused

    public final void togglePaused()

  Toggles the paused state of the asynchronous computation. In other words, if the computation is currently paused, calling this function resumes it; if the computation is running, it is paused. This is a convenience method for calling `setPaused`(!`isPaused()`).

See also:
  `setPaused()`, `pause()`, and `resume()`.

### waitForFinished

    public final void waitForFinished()

  Waits for the asynchronous computation to finish (including `cancel()`ed computations).

### fromNativePointer

    public static QFuture fromNativePointer(QNativePointer nativePointer)

  This method returns the QFuture instance pointed to by `nativePointer`.

### nativePointerArray

    public static QNativePointer nativePointerArray(QFuture[] array)

  This function returns a QNativePointer that is pointing to the specified QFuture array.

### equals

    public boolean equals(java.lang.Object other)

  This method is internal to Qt Jambi.

  Overrides:
    `equals` in class `QtJambiObject`
  Parameters:
    `other` - The object with which to compare
  Returns:
    true if the native resources of the two objects are one and the same.

### clone

    public QFuture clone()

  This method is reimplemented for internal reasons

  Overrides:
    `clone` in class `java.lang.Object`

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD