|  | Home · All Classes · Main Classes · Grouped Classes · Modules · Functions |

# QtConcurrent Namespace Reference
[QtCore module]

The QtConcurrent namespace provides high-level APIs that make it possible to write multi-threaded programs without using low-level threading primitives. More...

     #include <QtConcurrent>

This namespace was introduced in Qt 4.4.

### Classes

- class Exception
- class UnhandledException

### Types

- enum ReduceOption { UnorderedReduce, OrderedReduce, SequentialReduce }
- flags ReduceOptions

### Functions

- void blockingFilter ( Sequence & sequence, FilterFunction filterFunction )
- Sequence blockingFiltered ( const Sequence & sequence, FilterFunction filterFunction )
- Sequence blockingFiltered ( ConstIterator begin, ConstIterator end, FilterFunction filterFunction )
- T blockingFilteredReduced ( const Sequence & sequence, FilterFunction filterFunction, ReduceFunction reduceFunction, QtConcurrent::ReduceOptions reduceOptions = UnorderedReduce | SequentialReduce )
- T blockingFilteredReduced ( ConstIterator begin, ConstIterator end, FilterFunction filterFunction, ReduceFunction reduceFunction, QtConcurrent::ReduceOptions reduceOptions = UnorderedReduce | SequentialReduce )
- void blockingMap ( Sequence & sequence, MapFunction function )
- void blockingMap ( Iterator begin, Iterator end, MapFunction function )
- T blockingMapped ( const Sequence & sequence, MapFunction function )
- T blockingMapped ( ConstIterator begin, ConstIterator end, MapFunction function )
- T blockingMappedReduced ( const Sequence & sequence, MapFunction function, ReduceFunction function, QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce )
- T blockingMappedReduced ( ConstIterator begin, ConstIterator end, MapFunction function, ReduceFunction function, QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce )
- QFuture<void> filter ( Sequence & sequence, FilterFunction filterFunction )
- QFuture<T> filtered ( const Sequence & sequence, FilterFunction filterFunction )
- QFuture<T> filtered ( ConstIterator begin, ConstIterator end, FilterFunction filterFunction )
- QFuture<T> filteredReduced ( const Sequence & sequence, FilterFunction filterFunction, ReduceFunction reduceFunction, QtConcurrent::ReduceOptions reduceOptions = UnorderedReduce | SequentialReduce )
- QFuture<T> filteredReduced ( ConstIterator begin, ConstIterator end, FilterFunction filterFunction, ReduceFunction reduceFunction, QtConcurrent::ReduceOptions reduceOptions = UnorderedReduce | SequentialReduce )
- QFuture<void> map ( Sequence & sequence, MapFunction function )
- QFuture<void> map ( Iterator begin, Iterator end, MapFunction function )
- QFuture<T> mapped ( const Sequence & sequence, MapFunction function )
- QFuture<T> mapped ( ConstIterator begin, ConstIterator end, MapFunction function )
- QFuture<T> mappedReduced ( const Sequence & sequence, MapFunction mapFunction, ReduceFunction reduceFunction, QtConcurrent::ReduceOptions reduceOptions = UnorderedReduce | SequentialReduce )
- QFuture<T> mappedReduced ( ConstIterator begin, ConstIterator end, MapFunction mapFunction, ReduceFunction reduceFunction, QtConcurrent::ReduceOptions reduceOptions = UnorderedReduce | SequentialReduce )
- QFuture<T> run ( Function function, ... )

## Detailed Description

The QtConcurrent namespace provides high-level APIs that make it possible to write multi-threaded programs without using low-level threading primitives.

See the Qt Concurrent section in the threading documentation.

## Classes

### class Exception

The Exception class provides a base class for exceptions that can transferred across threads. More...

### class UnhandledException

The UnhandledException class represents an unhandled exception in a worker thread. More...

## Type Documentation

### enum QtConcurrent::ReduceOption
flags QtConcurrent::ReduceOptions

This enum specifies the order of which results from the map or filter function are passed to the reduce function.

Constant | Value | Description
--- | --- | ---
`QtConcurrent::UnorderedReduce` | `0x1` | Reduction is done in an arbitrary order.
`QtConcurrent::OrderedReduce` | `0x2` | Reduction is done in the order of the original sequence.
`QtConcurrent::SequentialReduce` | `0x4` | Reduction is done sequentally: only one thread will enter the reduce function at a time (parallel reduction might be supported in a future version of Qt Concurrent.)

The ReduceOptions type is a typedef for QFlags<ReduceOption>. It stores an OR combination of ReduceOption values.

## Function Documentation

### void QtConcurrent::blockingFilter ( Sequence & sequence, FilterFunction filterFunction )

### Sequence QtConcurrent::blockingFiltered ( const Sequence & sequence, FilterFunction filterFunction )

### Sequence QtConcurrent::blockingFiltered ( ConstIterator begin, ConstIterator end, FilterFunction filterFunction )

This is an overloaded member function, provided for convenience.

### T QtConcurrent::blockingFilteredReduced ( const Sequence & sequence, FilterFunction filterFunction, ReduceFunction reduceFunction, QtConcurrent::ReduceOptions reduceOptions = UnorderedReduce | SequentialReduce )

### T QtConcurrent::blockingFilteredReduced ( ConstIterator begin, ConstIterator end, FilterFunction filterFunction, ReduceFunction reduceFunction, QtConcurrent::ReduceOptions reduceOptions = UnorderedReduce | SequentialReduce )

This is an overloaded member function, provided for convenience.

### void QtConcurrent::blockingMap ( Sequence & sequence, MapFunction function )

### void QtConcurrent::blockingMap ( Iterator begin, Iterator end, MapFunction function )

This is an overloaded member function, provided for convenience.

### T QtConcurrent::blockingMapped ( const Sequence & sequence, MapFunction function )

### T QtConcurrent::blockingMapped ( ConstIterator begin, ConstIterator end, MapFunction function )

This is an overloaded member function, provided for convenience.

### T QtConcurrent::blockingMappedReduced ( const Sequence & sequence, MapFunction function, ReduceFunction function, QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce )

### T QtConcurrent::blockingMappedReduced ( ConstIterator begin, ConstIterator end, MapFunction function, ReduceFunction function, QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce )

This is an overloaded member function, provided for convenience.

### QFuture<void> QtConcurrent::filter ( Sequence & sequence, FilterFunction filterFunction )

Calls filterFunction once for each item in sequence. If filterFunction returns true, the item is kept in sequence; otherwise, the item is removed from sequence.

### QFuture<T> QtConcurrent::filtered ( const Sequence & sequence, FilterFunction filterFunction )

Calls filterFunction once for each item in sequence and returns a new Sequence of kept items. If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.

### QFuture<T> QtConcurrent::filtered ( ConstIterator begin, ConstIterator end, FilterFunction filterFunction )

This is an overloaded member function, provided for convenience.

Calls filterFunction once for each item from begin to end and returns a new Sequence of kept items. If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.

### QFuture<T> QtConcurrent::filteredReduced ( const Sequence & sequence, FilterFunction filterFunction, ReduceFunction reduceFunction, QtConcurrent::ReduceOptions reduceOptions = UnorderedReduce | SequentialReduce )

Calls filterFunction once for each item in sequence. If filterFunction returns true for an item, that item is then passed to reduceFunction. In other words, the return value is the result of reduceFunction for each item where filterFunction returns true.

Note that while filterFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is undefined if reduceOptions is QtConcurrent::UnorderedReduce. If reduceOptions is QtConcurrent::OrderedReduce, reduceFunction is called in the order of the original sequence.

### QFuture<T> QtConcurrent::filteredReduced ( ConstIterator begin, ConstIterator end, FilterFunction filterFunction, ReduceFunction reduceFunction, QtConcurrent::ReduceOptions reduceOptions = UnorderedReduce | SequentialReduce )

This is an overloaded member function, provided for convenience.

Calls filterFunction once for each item from begin to end. If filterFunction returns true for an item, that item is then passed to reduceFunction. In other words, the return value is the result of reduceFunction for each item where filterFunction returns true.

Note that while filterFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is undefined if reduceOptions is QtConcurrent::UnorderedReduce. If reduceOptions is QtConcurrent::OrderedReduce, the reduceFunction is called in the order of the original sequence.

### QFuture<void> QtConcurrent::map ( Sequence & sequence, MapFunction function )

Calls function once for each item in sequence. The function is passed a reference to the item, so that any modifications done to the item will appear in sequence.

### QFuture<void> QtConcurrent::map ( Iterator begin, Iterator end, MapFunction function )

This is an overloaded member function, provided for convenience.

Calls function once for each item from begin to end. The function is passed a reference to the item, so that any modifications done to the item will appear in the sequence which the iterators belong to.

### QFuture<T> QtConcurrent::mapped ( const Sequence & sequence, MapFunction function )

Calls function once for each item in sequence and returns a future with each mapped item as a result. You can use QFuture::const_iterator or QFutureIterator to iterate through the results.

### QFuture<T> QtConcurrent::mapped ( ConstIterator begin, ConstIterator end, MapFunction function )

This is an overloaded member function, provided for convenience.

Calls function once for each item from begin to end and returns a future with each mapped item as a result. You can use QFuture::const_iterator or QFutureIterator to iterate through the results.

### QFuture<T> QtConcurrent::mappedReduced ( const Sequence & sequence, MapFunction mapFunction, ReduceFunction reduceFunction, QtConcurrent::ReduceOptions reduceOptions = UnorderedReduce | SequentialReduce )

Calls mapFunction once for each item in sequence. The return value of each mapFunction is passed to reduceFunction.

Note that while mapFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is determined by reduceOptions.

### QFuture<T> QtConcurrent::mappedReduced ( ConstIterator begin, ConstIterator end, MapFunction mapFunction, ReduceFunction reduceFunction, QtConcurrent::ReduceOptions reduceOptions = UnorderedReduce | SequentialReduce )

This is an overloaded member function, provided for convenience.

Calls mapFunction once for each item from begin to end. The return value of each mapFunction is passed to reduceFunction.

Note that while mapFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is undefined.

### QFuture<T> QtConcurrent::run ( Function function, ... )

Runs function in a separate thread. The thread is taken from the global QThreadPool. Note that the function may not run immediately; the function will only be run when a thread is available.

T is the same type as the return value of function. Non-void return values can be accessed via the QFuture::result() function.

Note that the QFuture returned by QtConcurrent::run() does not support canceling, pausing, or progress reporting. The QFuture returned can only be used to query for the running/finished status and the return value of the function.