Contents

• Public Types
• Public Functions
• Detailed Description

Detailed Description

TheQFuture class represents the result of an asynchronous computation.

To start a computation, use one of the APIs in theQt 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 theresult(),resultAt(), orresults() functions,QFuture will wait until the result becomes available. You can use theisResultReadyAt() function to determine if a result is ready or not. ForQFuture objects that report more than one result, theresultCount() function returns the number of continuous results. This means that it is always safe to iterate through the results from 0 toresultCount().

QFuture provides aJava-style iterator (QFutureIterator) and anSTL-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 thecancel() function. To pause the computation, use thesetPaused() function or one of thepause(),resume(), ortogglePaused() convenience functions. Be aware that not all asynchronous computations can be canceled or paused. For example, the future returned byQtConcurrent::run() cannot be canceled; but the future returned byQtConcurrent::mappedReduced() can.

Progress information is provided by theprogressValue(),progressMinimum(),progressMaximum(), andprogressText() functions. ThewaitForFinished() 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 aQFuture can be queried using theisCanceled(),isStarted(),isFinished(),isRunning(), orisPaused() 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. AnyQFuture<T> can be assigned or copied into aQFuture<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, useQFutureWatcher.

Member Type Documentation

typedef QFuture::ConstIterator

Qt-style synonym forQFuture::const_iterator.

Member Function Documentation

QFuture::QFuture()

Constructs an empty future.

QFuture::QFuture(constQFuture & other)

Constructs a copy ofother.

See alsooperator=().

QFuture::~QFuture()

Destroys the future.

Note that this neither waits nor cancels the asynchronous computation. UsewaitForFinished() orQFutureSynchronizer when you need to ensure that the computation is completed before the future is destroyed.

const_iterator QFuture::begin() const

Returns a const STL-style iterator pointing to the first result in the future.

See alsoconstBegin() andend().

void QFuture::cancel()

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

Results currently available may still be accessed on a canceled future, but new results willnot become available after calling this function. AnyQFutureWatcher 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 byQtConcurrent::run() cannot be canceled; but the future returned byQtConcurrent::mappedReduced() can.

const_iterator QFuture::constBegin() const

Returns a const STL-style iterator pointing to the first result in the future.

See alsobegin() andconstEnd().

const_iterator QFuture::constEnd() const

Returns a const STL-style iterator pointing to the imaginary result after the last result in the future.

See alsoconstBegin() andend().

const_iterator QFuture::end() const

Returns a const STL-style iterator pointing to the imaginary result after the last result in the future.

See alsobegin() andconstEnd().

bool QFuture::isCanceled() const

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

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

bool QFuture::isFinished() const

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

bool QFuture::isPaused() const

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

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

See alsosetPaused() andtogglePaused().

bool QFuture::isResultReadyAt(int index) const

Returns true if the result atindex is immediately available; otherwise returns false.

See alsoresultAt() andresultCount().

bool QFuture::isRunning() const

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

bool QFuture::isStarted() const

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

void QFuture::pause()

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

See alsoresume().

int QFuture::progressMaximum() const

Returns the maximumprogressValue().

See alsoprogressValue() andprogressMinimum().

int QFuture::progressMinimum() const

Returns the minimumprogressValue().

See alsoprogressValue() andprogressMaximum().

QString QFuture::progressText() const

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.

int QFuture::progressValue() const

Returns the current progress value, which is between theprogressMinimum() andprogressMaximum().

See alsoprogressMinimum() andprogressMaximum().

T QFuture::result() const

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 callingresultAt(0).

See alsoresultAt() andresults().

T QFuture::resultAt(int index) const

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

See alsoresult(),results(), andresultCount().

int QFuture::resultCount() const

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 alsoresult(),resultAt(), andresults().

QList<T> QFuture::results() const

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 alsoresult(),resultAt(), andresultCount().

void QFuture::resume()

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

See alsopause().

void QFuture::setPaused(bool paused)

Ifpaused is true, this function pauses the asynchronous computation represented by the future. If the computation is already paused, this function does nothing. AnyQFutureWatcher 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.

Ifpaused 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 byQtConcurrent::run() cannot be paused; but the future returned byQtConcurrent::mappedReduced() can.

See alsoisPaused(),pause(),resume(), andtogglePaused().

void QFuture::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 callingsetPaused(!isPaused()).

See alsosetPaused(),pause(), andresume().

void QFuture::waitForFinished()

Waits for the asynchronous computation to finish (includingcancel()ed computations).

QFuture::operator T() const

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 callingresult() orresultAt(0).

See alsoresult(),resultAt(), andresults().

bool QFuture::operator!=(constQFuture & other) const

Returns true ifother isnot a copy of this future; otherwise returns false.

QFuture & QFuture::operator=(constQFuture & other)

Assignsother to this future and returns a reference to this future.

bool QFuture::operator==(constQFuture & other) const

Returns true ifother is a copy of this future; otherwise returns false.