QtConcurrent Namespace

Funktionsdokumentation

template <typename Sequence, typename KeepFunctor> void QtConcurrent::blockingFilter(Sequence &sequence, KeepFunctor &&filterFunction)

Ruft für jedes Element in „ sequence “ einmal „ filterFunction “ auf. Wenn „ filterFunction “ „ true “ zurückgibt, wird das Element in „ sequence “ beibehalten; andernfalls wird das Element aus „ sequence “ entfernt.

Beachten Sie, dass diese Methode keine Überladung für die Verwendung mit Iteratoren besitzt, da sie die Iteratoren der Sequenz, auf der sie angewendet wird, ungültig macht.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template <typename Sequence, typename KeepFunctor> void QtConcurrent::blockingFilter(QThreadPool *pool, Sequence &sequence, KeepFunctor &&filterFunction)

Ruft für jedes Element in ` sequence` einmal ` filterFunction ` auf. Alle Aufrufe von ` filterFunction ` erfolgen aus den Threads, die aus ` QThreadPool ` pool entnommen werden. Wenn ` filterFunction ` ` true` zurückgibt, bleibt das Element in ` sequence` erhalten; andernfalls wird das Element aus ` sequence` entfernt.

Beachten Sie, dass diese Methode keine Überladung für die Verwendung mit Iteratoren besitzt, da sie die Iteratoren der Sequenz, auf der sie angewendet wird, ungültig macht.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template <typename Sequence, typename KeepFunctor> std::decay_t<Sequence> QtConcurrent::blockingFiltered(Sequence &&sequence, KeepFunctor &&filterFunction)

Ruft für jedes Element in „ sequence “ einmal „ filterFunction “ auf und gibt eine neue Sequenz der beibehaltenen Elemente zurück. Wenn „ filterFunction “ „ true “ zurückgibt, wird eine Kopie des Elements in die neue Sequenz aufgenommen. Andernfalls erscheint das Element nicht in der neuen Sequenz.

Siehe auch „ filtered()“ sowie „Concurrent Filter“ und „Filter-Reduce“.

template < typename OutputSequence, typename Iterator, typename KeepFunctor > OutputSequence QtConcurrent::blockingFiltered(Iterator begin, Iterator end, KeepFunctor &&filterFunction)

Ruft für jedes Element aus dem Bereich von begin bis end einmal die Funktion „ filterFunction “ auf und gibt eine neue Sequenz der beibehaltenen Elemente zurück. Wenn „ filterFunction “ den Wert „ true “ zurückgibt, wird eine Kopie des Elements in die neue Sequenz aufgenommen. Andernfalls erscheint das Element nicht in der neuen Sequenz.

Siehe auch „ filtered()“ sowie „Concurrent Filter“ und „Filter-Reduce“.

template <typename Sequence, typename KeepFunctor> std::decay_t<Sequence> QtConcurrent::blockingFiltered(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction)

Ruft für jedes Element in „ sequence “ einmal „ filterFunction “ auf und gibt eine neue Sequenz mit den beibehaltenen Elementen zurück. Alle Aufrufe von „ filterFunction “ erfolgen aus den Threads, die aus „ QThreadPool “ pool entnommen wurden. Wenn „ filterFunction “ „ true “ zurückgibt, wird eine Kopie des Elements in die neue Sequenz aufgenommen. Andernfalls erscheint das Element nicht in der neuen Sequenz.

Siehe auch „ filtered()“ sowie „Concurrent Filter“ und „Filter-Reduce“.

template < typename OutputSequence, typename Iterator, typename KeepFunctor > OutputSequence QtConcurrent::blockingFiltered(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction)

Ruft für jedes Element aus dem Bereich von begin bis end einmal die Funktion „ filterFunction “ auf und gibt eine neue Sequenz der beibehaltenen Elemente zurück. Alle Aufrufe von „ filterFunction “ erfolgen aus den Threads, die aus dem Thread-Pool QThreadPool pool entnommen werden. Wenn „ filterFunction “ den Wert „ true “ zurückgibt, wird eine Kopie des Elements in die neue Sequenz aufgenommen. Andernfalls erscheint das Element nicht in der neuen Sequenz.

Siehe auch „ filtered()“ sowie „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingFilteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft für jedes Element in „ sequence “ einmal „ filterFunction “ auf. Wenn „ filterFunction “ für ein Element „ true “ zurückgibt, wird dieses Element anschließend an „ reduceFunction “ übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von „ reduceFunction “ für jedes Element, bei dem „ filterFunction “ „ true “ zurückgibt.

Beachten Sie, dass zwar filterFunction parallel aufgerufen wird, jedoch jeweils nur ein Thread reduceFunction aufruft. Die Reihenfolge, in der reduceFunction aufgerufen wird, ist undefiniert, wenn reduceOptions gleich QtConcurrent::UnorderedReduce ist. Ist reduceOptions gleich QtConcurrent::OrderedReduce, wird reduceFunction in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „ filteredReduced()“ sowie „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingFilteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ filterFunction “ einmal für jedes Element aus dem Bereich von „ begin “ bis „ end “ auf. Wenn „ filterFunction “ für ein Element „ true “ zurückgibt, wird dieses Element anschließend an „ reduceFunction “ übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von „ reduceFunction “ für jedes Element, bei dem „ filterFunction “ „ true “ zurückgibt.

Beachten Sie, dass zwar „ filterFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, ist undefiniert, wenn „ reduceOptions “ „ QtConcurrent::UnorderedReduce “ ist. Ist „ reduceOptions “ „ QtConcurrent::OrderedReduce “, wird „ reduceFunction “ in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „ filteredReduced()“ sowie „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingFilteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ filterFunction “ einmal für jedes Element in „ sequence “ auf. Alle Aufrufe von „ filterFunction “ werden aus den Threads ausgeführt, die aus „ QThreadPool “ pool entnommen wurden. Wenn „ filterFunction “ für ein Element „ true “ zurückgibt, wird dieses Element anschließend an „ reduceFunction “ übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von „ reduceFunction “ für jedes Element, bei dem „ filterFunction “ „ true “ zurückgibt.

Beachten Sie, dass zwar filterFunction parallel aufgerufen wird, jedoch jeweils nur ein Thread reduceFunction aufruft. Die Reihenfolge, in der reduceFunction aufgerufen wird, ist undefiniert, wenn reduceOptions QtConcurrent::UnorderedReduce ist. Ist reduceOptions QtConcurrent::OrderedReduce , wird reduceFunction in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „ filteredReduced()“ sowie „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingFilteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft für jedes Element in ` sequence` einmal ` filterFunction ` auf. Wenn ` filterFunction ` für ein Element ` true ` zurückgibt, wird dieses Element anschließend an ` reduceFunction` übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von ` reduceFunction ` für jedes Element, bei dem ` filterFunction ` ` true` zurückgibt. Der Ergebniswert wird beim Aufruf der Funktion auf ` initialValue ` initialisiert, und der erste Aufruf von ` reduceFunction ` wird auf diesen Wert angewendet.

Beachten Sie, dass zwar filterFunction parallel aufgerufen wird, jedoch jeweils nur ein Thread reduceFunction aufruft. Die Reihenfolge, in der reduceFunction aufgerufen wird, ist undefiniert, wenn reduceOptions gleich QtConcurrent::UnorderedReduce ist. Ist reduceOptions gleich QtConcurrent::OrderedReduce, wird reduceFunction in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „ filteredReduced()“ sowie „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingFilteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ filterFunction “ einmal für jedes Element aus dem Bereich von „ begin “ bis „ end “ auf. Wenn „ filterFunction “ für ein Element „ true “ zurückgibt, wird dieses Element anschließend an „ reduceFunction “ übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von „ reduceFunction “ für jedes Element, bei dem „ filterFunction “ „ true “ zurückgibt. Der Ergebniswert wird beim Aufruf der Funktion auf „ initialValue “ initialisiert, und der erste Aufruf von „ reduceFunction “ wird auf diesen Wert angewendet.

Beachten Sie, dass zwar filterFunction parallel aufgerufen wird, jedoch jeweils nur ein Thread reduceFunction aufruft. Die Reihenfolge, in der reduceFunction aufgerufen wird, ist undefiniert, wenn reduceOptions QtConcurrent::UnorderedReduce ist. Ist reduceOptions QtConcurrent::OrderedReduce , wird reduceFunction in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „ filteredReduced()“ sowie „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingFilteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ filterFunction “ einmal für jedes Element aus dem Bereich von „ begin “ bis „ end “ auf. Alle Aufrufe von „ filterFunction “ erfolgen aus den Threads, die aus „ QThreadPool “ pool entnommen wurden. Wenn „ filterFunction “ für ein Element „ true “ zurückgibt, wird dieses Element anschließend an „ reduceFunction “ übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von „ reduceFunction “ für jedes Element, bei dem „ filterFunction “ „ true “ zurückgibt.

Beachten Sie, dass zwar „ filterFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, ist undefiniert, wenn „ reduceOptions “ „ QtConcurrent::UnorderedReduce “ ist. Ist „ reduceOptions “ „ QtConcurrent::OrderedReduce “, wird „ reduceFunction “ in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „ filteredReduced()“ sowie „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingFilteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft für jedes Element in ` sequence` einmal ` filterFunction ` auf. Alle Aufrufe von ` filterFunction ` erfolgen aus den Threads, die aus ` QThreadPool ` pool entnommen wurden. Wenn ` filterFunction ` für ein Element ` true ` zurückgibt, wird dieses Element anschließend an ` reduceFunction` übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von ` reduceFunction ` für jedes Element, bei dem ` filterFunction ` ` true` zurückgibt. Der Ergebniswert wird beim Aufruf der Funktion auf ` initialValue ` initialisiert, und der erste Aufruf von ` reduceFunction ` wird auf diesen Wert angewendet.

Beachten Sie, dass zwar filterFunction gleichzeitig aufgerufen wird, jedoch jeweils nur ein Thread reduceFunction aufruft. Die Reihenfolge, in der reduceFunction aufgerufen wird, ist undefiniert, wenn reduceOptions QtConcurrent::UnorderedReduce ist. Ist reduceOptions QtConcurrent::OrderedReduce , wird reduceFunction in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „ filteredReduced()“ sowie „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingFilteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft für jedes Element aus dem Bereich von begin bis end einmal die Funktion „ filterFunction “ auf. Alle Aufrufe von „ filterFunction “ erfolgen aus den Threads, die aus dem Array „ QThreadPool “ ( pool) entnommen werden. Wenn „ filterFunction “ für ein Element den Wert „ true “ zurückgibt, wird dieses Element anschließend an „ reduceFunction “ übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von „ reduceFunction “ für jedes Element, bei dem „ filterFunction “ den Wert „ true “ zurückgibt. Der Ergebniswert wird beim Aufruf der Funktion auf „ initialValue “ initialisiert, und der erste Aufruf von „ reduceFunction “ wird auf diesen Wert angewendet.

Beachten Sie, dass zwar „ filterFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, ist undefiniert, wenn „ reduceOptions “ „ QtConcurrent::UnorderedReduce “ ist. Ist „ reduceOptions “ „ QtConcurrent::OrderedReduce “, wird „ reduceFunction “ in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „ filteredReduced()“ sowie „Concurrent Filter“ und „Filter-Reduce“.

template <typename Sequence, typename MapFunctor> void QtConcurrent::blockingMap(Sequence &&sequence, MapFunctor &&function)

Ruft für jedes Element in „ sequence “ einmal „ function “ auf. „ function “ nimmt eine Referenz auf das Element entgegen, sodass alle am Element vorgenommenen Änderungen in „ sequence “ erscheinen.

Siehe auch „ map()“ sowie „Concurrent Map“ und „Map-Reduce“.

template <typename Iterator, typename MapFunctor> void QtConcurrent::blockingMap(Iterator begin, Iterator end, MapFunctor &&function)

Ruft für jedes Element aus dem Bereich von begin bis end einmal die Funktion „ function “ auf. Die Funktion „ function “ nimmt eine Referenz auf das Element entgegen, sodass alle am Element vorgenommenen Änderungen in der Sequenz sichtbar werden, zu der die Iteratoren gehören.

Siehe auch „ map()“ sowie „Concurrent Map“ und „Map-Reduce“.

template <typename Sequence, typename MapFunctor> void QtConcurrent::blockingMap(QThreadPool *pool, Sequence &&sequence, MapFunctor function)

Ruft für jedes Element in „ sequence “ einmal „ function “ auf. Alle Aufrufe von „ function “ werden aus den Threads ausgeführt, die aus „ QThreadPool “ pool stammen. „ function “ nimmt eine Referenz auf das Element entgegen, sodass alle am Element vorgenommenen Änderungen in „ sequence “ erscheinen.

Siehe auch „ map()“ sowie „Concurrent Map“ und „Map-Reduce“.

template <typename Iterator, typename MapFunctor> void QtConcurrent::blockingMap(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)

Ruft für jedes Element aus dem Bereich von begin bis end einmal die Funktion „ function “ auf. Alle Aufrufe von „ function “ erfolgen aus den Threads, die aus dem Array „ QThreadPool “ ( pool) entnommen wurden. Die Funktion „ function “ übernimmt eine Referenz auf das Element, sodass alle an dem Element vorgenommenen Änderungen in der Sequenz sichtbar werden, zu der die Iteratoren gehören.

Siehe auch „ map()“ sowie „Concurrent Map“ und „Map-Reduce“.

template < typename OutputSequence, typename InputSequence, typename MapFunctor > OutputSequence QtConcurrent::blockingMapped(InputSequence &&sequence, MapFunctor &&function)

Ruft für jedes Element in „ sequence “ einmal „ function “ auf und gibt eine „OutputSequence“ zurück, die die Ergebnisse enthält. Der Typ der Ergebnisse entspricht dem vom „MapFunctor“ zurückgegebenen Typ.

Siehe auch „ mapped()“ sowie „Concurrent Map“ und „Map-Reduce“.

template < typename Sequence, typename Iterator, typename MapFunctor > Sequence QtConcurrent::blockingMapped(Iterator begin, Iterator end, MapFunctor &&function)

Ruft für jedes Element aus dem Bereich von ` begin ` bis ` end ` einmal die Funktion ` function ` auf und gibt einen Container mit den Ergebnissen zurück. Sie können den Typ des Containers als Template-Argument wie folgt angeben:

QList<int> ints = QtConcurrent::blockingMapped<QList<int> >(beginIterator, endIterator, fn);

Siehe auch „ mapped()“ sowie „Concurrent Map“ und „Map-Reduce“.

template < typename OutputSequence, typename InputSequence, typename MapFunctor > OutputSequence QtConcurrent::blockingMapped(QThreadPool *pool, InputSequence &&sequence, MapFunctor &&function)

Ruft für jedes Element in „ sequence “ einmal „ function “ auf und gibt eine „OutputSequence“ zurück, die die Ergebnisse enthält. Alle Aufrufe von „ function “ werden aus den Threads ausgeführt, die aus dem „ QThreadPool “ pool entnommen wurden. Der Typ der Ergebnisse entspricht dem vom „MapFunctor“ zurückgegebenen Typ.

Siehe auch „ mapped()“ sowie „Concurrent Map“ und „Map-Reduce“.

template < typename Sequence, typename Iterator, typename MapFunctor > Sequence QtConcurrent::blockingMapped(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)

Ruft einmal für jedes Element von begin bis end die Funktion „ function “ auf und gibt einen Container mit den Ergebnissen zurück. Alle Aufrufe von „ function “ erfolgen über die Threads, die aus der Liste „ QThreadPool “ pool entnommen werden. Sie können den Typ des Containers als Template-Argument wie folgt angeben:

QList<int> ints = QtConcurrent::blockingMapped<QList<int> >(beginIterator, endIterator, fn);

Siehe auch „ mapped()“ sowie „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingMappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft für jedes Element in „ sequence “ einmal „ mapFunction “ auf. Der Rückgabewert jedes „ mapFunction “ wird an „ reduceFunction “ übergeben.

Beachten Sie, dass „ mapFunction “ zwar parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, wird von „ reduceOptions “ festgelegt.

Siehe auch „ mapped()“ sowie „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingMappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ mapFunction “ einmal für jedes Element aus dem Bereich von „ begin “ bis „ end “ auf. Der Rückgabewert jedes „ mapFunction “ wird an „ reduceFunction “ übergeben.

Beachten Sie, dass zwar mapFunction parallel aufgerufen wird, jedoch jeweils nur ein Thread reduceFunction aufruft. Die Reihenfolge, in der reduceFunction aufgerufen wird, ist nicht definiert.

Siehe auch „ blockingMappedReduced()“ sowie „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingMappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ mapFunction “ einmal für jedes Element in „ sequence “ auf. Alle Aufrufe von „ mapFunction “ werden von den Threads ausgeführt, die aus dem Array „ QThreadPool “ pool entnommen wurden. Der Rückgabewert jedes Aufrufs von „ mapFunction “ wird an „ reduceFunction “ übergeben.

Beachten Sie, dass zwar „ mapFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, wird durch „ reduceOptions “ bestimmt.

Siehe auch „ mapped()“ sowie „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingMappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ mapFunction “ einmal für jedes Element in „ sequence “ auf. Der Rückgabewert jedes „ mapFunction “ wird an „ reduceFunction “ übergeben. Der Ergebniswert wird beim Aufruf der Funktion auf „ initialValue “ initialisiert, und der erste Aufruf von „ reduceFunction “ wird auf diesen Wert angewendet.

Beachten Sie, dass zwar „ mapFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, wird von „ reduceOptions “ bestimmt.

Siehe auch „ mapped()“ sowie „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingMappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ mapFunction “ einmal für jedes Element von „ begin “ bis „ end “ auf. Der Rückgabewert jedes „ mapFunction “ wird an „ reduceFunction “ übergeben. Der Ergebniswert wird beim Aufruf der Funktion auf „ initialValue “ initialisiert, und der erste Aufruf von „ reduceFunction “ wird auf diesen Wert angewendet.

Beachten Sie, dass zwar „ mapFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, ist nicht definiert.

Siehe auch „ blockingMappedReduced()“ sowie „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingMappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ mapFunction “ einmal für jedes Element aus dem Bereich von „ begin “ bis „ end “ auf. Alle Aufrufe von „ mapFunction “ erfolgen aus den Threads, die aus dem Array „ QThreadPool “ pool entnommen wurden. Der Rückgabewert jedes Aufrufs von „ mapFunction “ wird an „ reduceFunction “ übergeben.

Beachten Sie, dass zwar „ mapFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, ist nicht definiert.

Siehe auch ` blockingMappedReduced()` sowie „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingMappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ mapFunction “ einmal für jedes Element in „ sequence “ auf. Alle Aufrufe von „ mapFunction “ werden aus den Threads ausgeführt, die aus dem „ QThreadPool “ pool entnommen wurden. Der Rückgabewert jedes „ mapFunction “ wird an „ reduceFunction “ übergeben. Der Ergebniswert wird beim Aufruf der Funktion auf „ initialValue “ initialisiert, und der erste Aufruf von „ reduceFunction “ wird auf diesen Wert angewendet.

Beachten Sie, dass zwar „ mapFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, wird durch „ reduceOptions “ bestimmt.

Siehe auch „ mapped()“ sowie „Paralleles Map und Map-Reduce“.

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingMappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ mapFunction “ einmal für jedes Element aus dem Bereich von „ begin “ bis „ end “ auf. Alle Aufrufe von „ mapFunction “ erfolgen aus den Threads, die aus dem Array „ QThreadPool “ mit dem Index „ pool “ entnommen werden. Der Rückgabewert jedes Aufrufs von „ mapFunction “ wird an „ reduceFunction “ übergeben. Der Ergebniswert wird beim Aufruf der Funktion auf „ initialValue “ initialisiert, und der erste Aufruf von „ reduceFunction “ wird auf diesen Wert angewendet.

Beachten Sie, dass zwar mapFunction gleichzeitig aufgerufen wird, jedoch jeweils nur ein Thread reduceFunction aufruft. Die Reihenfolge, in der reduceFunction aufgerufen wird, ist undefiniert.

Siehe auch ` blockingMappedReduced()` sowie „Concurrent Map“ und „Map-Reduce“.

template <typename Sequence, typename KeepFunctor> QFuture<void> QtConcurrent::filter(Sequence &sequence, KeepFunctor &&filterFunction)

Ruft für jedes Element in „ sequence “ einmal „ filterFunction “ auf. Wenn „ filterFunction “ „ true “ zurückgibt, wird das Element in „ sequence “ beibehalten; andernfalls wird das Element aus „ sequence “ entfernt.

Beachten Sie, dass diese Methode keine Überladung für die Verwendung mit Iteratoren besitzt, da sie die Iteratoren der Sequenz, auf der sie angewendet wird, ungültig macht.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template <typename Sequence, typename KeepFunctor> QFuture<void> QtConcurrent::filter(QThreadPool *pool, Sequence &sequence, KeepFunctor &&filterFunction)

Ruft für jedes Element in „ sequence “ einmal „ filterFunction “ auf. Alle Aufrufe von „ filterFunction “ erfolgen aus den Threads, die aus „ QThreadPool “ pool entnommen werden. Wenn „ filterFunction “ „ true “ zurückgibt, bleibt das Element in „ sequence “ erhalten; andernfalls wird das Element aus „ sequence “ entfernt.

Beachten Sie, dass diese Methode keine Überladung für die Verwendung mit Iteratoren besitzt, da sie die Iteratoren der Sequenz, auf der sie angewendet wird, ungültig macht.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template <typename Sequence, typename KeepFunctor> QFuture<typename std::decay_t<Sequence>::value_type> QtConcurrent::filtered(Sequence &&sequence, KeepFunctor &&filterFunction)

Ruft für jedes Element in „ sequence “ einmal „ filterFunction “ auf und gibt eine neue Sequenz der beibehaltenen Elemente zurück. Wenn „ filterFunction “ „ true “ zurückgibt, wird eine Kopie des Elements in die neue Sequenz aufgenommen. Andernfalls erscheint das Element nicht in der neuen Sequenz.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template <typename Iterator, typename KeepFunctor> QFuture<typename qValueType<Iterator>::value_type> QtConcurrent::filtered(Iterator begin, Iterator end, KeepFunctor &&filterFunction)

Ruft für jedes Element aus dem Bereich von begin bis end einmal die Funktion „ filterFunction “ auf und gibt eine neue Sequenz der beibehaltenen Elemente zurück. Wenn „ filterFunction “ den Wert „ true “ zurückgibt, wird eine Kopie des Elements in die neue Sequenz aufgenommen. Andernfalls erscheint das Element nicht in der neuen Sequenz.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template <typename Sequence, typename KeepFunctor> QFuture<typename std::decay_t<Sequence>::value_type> QtConcurrent::filtered(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction)

Ruft für jedes Element in „ sequence “ einmal „ filterFunction “ auf und gibt eine neue Sequenz der beibehaltenen Elemente zurück. Alle Aufrufe von „ filterFunction “ werden aus den Threads ausgeführt, die aus „ QThreadPool “ pool entnommen wurden. Wenn „ filterFunction “ „ true “ zurückgibt, wird eine Kopie des Elements in die neue Sequenz aufgenommen. Andernfalls erscheint das Element nicht in der neuen Sequenz.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template <typename Iterator, typename KeepFunctor> QFuture<typename qValueType<Iterator>::value_type> QtConcurrent::filtered(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction)

Ruft für jedes Element aus dem Bereich „ begin “ bis „ end “ einmal die Funktion „ filterFunction “ auf und gibt eine neue Sequenz der beibehaltenen Elemente zurück. Alle Aufrufe von „ filterFunction “ erfolgen aus den Threads, die aus „ QThreadPool “ pool entnommen wurden. Wenn „ filterFunction “ den Wert „ true “ zurückgibt, wird eine Kopie des Elements in die neue Sequenz aufgenommen. Andernfalls erscheint das Element nicht in der neuen Sequenz.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::filteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft für jedes Element in „ sequence “ einmal „ filterFunction “ auf. Wenn „ filterFunction “ für ein Element „ true “ zurückgibt, wird dieses Element anschließend an „ reduceFunction “ übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von „ reduceFunction “ für jedes Element, bei dem „ filterFunction “ „ true “ zurückgibt.

Beachten Sie, dass zwar „ filterFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, ist undefiniert, wenn „ reduceOptions “ gleich „ QtConcurrent::UnorderedReduce “ ist. Ist „ reduceOptions “ gleich „ QtConcurrent::OrderedReduce “, wird „ reduceFunction “ in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::filteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ filterFunction “ einmal für jedes Element aus dem Bereich von „ begin “ bis „ end “ auf. Wenn „ filterFunction “ für ein Element „ true “ zurückgibt, wird dieses Element anschließend an „ reduceFunction “ übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von „ reduceFunction “ für jedes Element, bei dem „ filterFunction “ „ true “ zurückgibt.

Beachten Sie, dass zwar „ filterFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, ist undefiniert, wenn „ reduceOptions “ „ QtConcurrent::UnorderedReduce “ ist. Ist „ reduceOptions “ gleich „ QtConcurrent::OrderedReduce “, wird „ reduceFunction “ in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::filteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ filterFunction “ einmal für jedes Element in „ sequence “ auf. Alle Aufrufe von „ filterFunction “ werden aus den Threads ausgeführt, die aus „ QThreadPool “ pool entnommen wurden. Wenn „ filterFunction “ für ein Element „ true “ zurückgibt, wird dieses Element anschließend an „ reduceFunction “ übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von „ reduceFunction “ für jedes Element, bei dem „ filterFunction “ „ true “ zurückgibt.

Beachten Sie, dass zwar filterFunction parallel aufgerufen wird, jedoch jeweils nur ein Thread reduceFunction aufruft. Die Reihenfolge, in der reduceFunction aufgerufen wird, ist undefiniert, wenn reduceOptions QtConcurrent::UnorderedReduce ist. Ist reduceOptions QtConcurrent::OrderedReduce , wird reduceFunction in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::filteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft für jedes Element in „ sequence “ einmal „ filterFunction “ auf. Wenn „ filterFunction “ für ein Element „ true “ zurückgibt, wird dieses Element anschließend an „ reduceFunction “ übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von „ reduceFunction “ für jedes Element, bei dem „ filterFunction “ „ true “ zurückgibt. Der Ergebniswert wird beim Aufruf der Funktion auf „ initialValue “ initialisiert, und der erste Aufruf von „ reduceFunction “ wird auf diesen Wert angewendet.

Beachten Sie, dass zwar filterFunction parallel aufgerufen wird, jedoch jeweils nur ein Thread reduceFunction aufruft. Die Reihenfolge, in der reduceFunction aufgerufen wird, ist undefiniert, wenn reduceOptions gleich QtConcurrent::UnorderedReduce ist. Ist reduceOptions gleich QtConcurrent::OrderedReduce, wird reduceFunction in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::filteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ filterFunction “ einmal für jedes Element von „ begin “ bis „ end “ auf. Wenn „ filterFunction “ für ein Element „ true “ zurückgibt, wird dieses Element anschließend an „ reduceFunction “ übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von „ reduceFunction “ für jedes Element, bei dem „ filterFunction “ „ true “ zurückgibt. Der Rückgabewert wird beim Aufruf der Funktion auf „ initialValue “ initialisiert, und der erste Aufruf von „ reduceFunction “ wird auf diesen Wert angewendet.

Beachten Sie, dass zwar filterFunction parallel aufgerufen wird, jedoch jeweils nur ein Thread reduceFunction aufruft. Die Reihenfolge, in der reduceFunction aufgerufen wird, ist undefiniert, wenn reduceOptions QtConcurrent::UnorderedReduce ist. Ist reduceOptions QtConcurrent::OrderedReduce , wird reduceFunction in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::filteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ filterFunction “ einmal für jedes Element aus dem Bereich von „ begin “ bis „ end “ auf. Alle Aufrufe von „ filterFunction “ erfolgen aus den Threads, die aus „ QThreadPool “ und „ pool “ stammen. Wenn „ filterFunction “ für ein Element „ true “ zurückgibt, wird dieses Element anschließend an „ reduceFunction “ übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von „ reduceFunction “ für jedes Element, bei dem „ filterFunction “ „ true “ zurückgibt.

Beachten Sie, dass zwar „ filterFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, ist undefiniert, wenn „ reduceOptions “ „ QtConcurrent::UnorderedReduce “ ist. Ist „ reduceOptions “ „ QtConcurrent::OrderedReduce “, wird „ reduceFunction “ in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::filteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft für jedes Element in ` sequence` einmal ` filterFunction ` auf. Alle Aufrufe von ` filterFunction ` erfolgen aus den Threads, die aus ` QThreadPool ` pool entnommen werden. Wenn ` filterFunction ` für ein Element ` true ` zurückgibt, wird dieses Element anschließend an ` reduceFunction` übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von ` reduceFunction ` für jedes Element, bei dem ` filterFunction ` ` true` zurückgibt. Der Ergebniswert wird beim Aufruf der Funktion auf ` initialValue ` initialisiert, und der erste Aufruf von ` reduceFunction ` wird auf diesen Wert angewendet.

Beachten Sie, dass zwar filterFunction parallel aufgerufen wird, jedoch jeweils nur ein Thread reduceFunction aufruft. Die Reihenfolge, in der reduceFunction aufgerufen wird, ist undefiniert, wenn reduceOptions QtConcurrent::UnorderedReduce ist. Ist reduceOptions QtConcurrent::OrderedReduce , wird reduceFunction in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::filteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft einmal für jedes Element von begin bis end die Funktion „ filterFunction “ auf. Alle Aufrufe von filterFunction erfolgen aus den Threads, die aus QThreadPool pool stammen. Wenn filterFunction für ein Element true zurückgibt, wird dieses Element anschließend an reduceFunction übergeben. Mit anderen Worten: Der Rückgabewert ist das Ergebnis von reduceFunction für jedes Element, bei dem filterFunction true zurückgibt. Der Ergebniswert wird beim Aufruf der Funktion auf ` initialValue ` initialisiert, und der erste Aufruf von ` reduceFunction ` wird auf diesen Wert angewendet.

Beachten Sie, dass zwar „ filterFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, ist undefiniert, wenn „ reduceOptions “ „ QtConcurrent::UnorderedReduce “ ist. Ist „ reduceOptions “ „ QtConcurrent::OrderedReduce “, wird „ reduceFunction “ in der Reihenfolge der ursprünglichen Sequenz aufgerufen.

Siehe auch „Concurrent Filter“ und „Filter-Reduce“.

template <typename Sequence, typename MapFunctor> QFuture<void> QtConcurrent::map(Sequence &&sequence, MapFunctor &&function)

Ruft für jedes Element in „ sequence “ einmal „ function “ auf. „ function “ nimmt eine Referenz auf das Element entgegen, sodass alle am Element vorgenommenen Änderungen in „ sequence “ sichtbar werden.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template <typename Iterator, typename MapFunctor> QFuture<void> QtConcurrent::map(Iterator begin, Iterator end, MapFunctor &&function)

Ruft für jedes Element aus dem Bereich von begin bis end einmal „ function “ auf. „ function “ nimmt eine Referenz auf das Element entgegen, sodass alle am Element vorgenommenen Änderungen in der Sequenz erscheinen, zu der die Iteratoren gehören.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template <typename Sequence, typename MapFunctor> QFuture<void> QtConcurrent::map(QThreadPool *pool, Sequence &&sequence, MapFunctor &&function)

Ruft für jedes Element in „ sequence “ einmal „ function “ auf. Alle Aufrufe von „ function “ werden aus den Threads ausgeführt, die aus „ QThreadPool “ pool stammen. „ function “ nimmt eine Referenz auf das Element entgegen, sodass alle am Element vorgenommenen Änderungen in „ sequence “ sichtbar werden.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template <typename Iterator, typename MapFunctor> QFuture<void> QtConcurrent::map(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)

Ruft für jedes Element aus dem Bereich von begin bis end einmal „ function “ auf. Alle Aufrufe von „ function “ erfolgen aus den Threads, die aus dem Bereich QThreadPool pool entnommen wurden. „ function “ nimmt eine Referenz auf das Element entgegen, sodass alle am Element vorgenommenen Änderungen in der Sequenz erscheinen, zu der die Iteratoren gehören.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template <typename Sequence, typename MapFunctor> QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> QtConcurrent::mapped(Sequence &&sequence, MapFunctor &&function)

Ruft für jedes Element in „ sequence “ einmal „ function “ auf und gibt ein Future zurück, dessen Ergebnis jedes zugeordnete Element enthält. Mit „ QFuture::const_iterator “ oder „ QFutureIterator “ können Sie die Ergebnisse durchlaufen.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template <typename Iterator, typename MapFunctor> QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> QtConcurrent::mapped(Iterator begin, Iterator end, MapFunctor &&function)

Ruft für jedes Element einmal „ function “ auf – von „ begin “ bis „ end “ – und gibt ein Future zurück, dessen Ergebnis jedes zugeordnete Element enthält. Sie können „ QFuture::const_iterator “ oder „ QFutureIterator “ verwenden, um die Ergebnisse zu durchlaufen.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template <typename Sequence, typename MapFunctor> QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> QtConcurrent::mapped(QThreadPool *pool, Sequence &&sequence, MapFunctor &&function)

Ruft für jedes Element in „ sequence “ einmal „ function “ auf und gibt ein Future zurück, dessen Ergebnis jedes abgebildete Element enthält. Alle Aufrufe von „ function “ werden aus den Threads ausgeführt, die aus „ QThreadPool “ pool entnommen werden. Sie können „ QFuture::const_iterator “ oder „ QFutureIterator “ verwenden, um die Ergebnisse zu durchlaufen.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template <typename Iterator, typename MapFunctor> QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> QtConcurrent::mapped(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)

Ruft für jedes Element aus dem Bereich von begin bis end einmal die Funktion „ function “ auf und gibt ein Future zurück, dessen Ergebnis jedes zugeordnete Element enthält. Alle Aufrufe von „ function “ werden in Threads ausgeführt, die aus dem Pool „ QThreadPool “ ( pool) entnommen werden. Sie können „ QFuture::const_iterator “ oder „ QFutureIterator “ verwenden, um die Ergebnisse zu durchlaufen.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::mappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft für jedes Element in „ sequence “ einmal „ mapFunction “ auf. Der Rückgabewert von jedem „ mapFunction “ wird an „ reduceFunction “ übergeben.

Beachten Sie, dass zwar „ mapFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, wird von „ reduceOptions “ bestimmt.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::mappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft für jedes Element aus dem Bereich von ` begin ` bis ` end` einmal die Funktion ` mapFunction ` auf. Der Rückgabewert jedes Aufrufs von ` mapFunction ` wird an ` reduceFunction` übergeben.

Beachten Sie, dass zwar „ mapFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Standardmäßig ist die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, nicht definiert.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::mappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ mapFunction “ einmal für jedes Element in „ sequence “ auf. Alle Aufrufe von „ mapFunction “ werden aus den Threads ausgeführt, die aus „ QThreadPool “ pool entnommen wurden. Der Rückgabewert jedes „ mapFunction “ wird an „ reduceFunction “ übergeben.

Beachten Sie, dass zwar „ mapFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, wird durch reduceOptions bestimmt.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::mappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft für jedes Element in ` sequence` einmal ` mapFunction ` auf. Der Rückgabewert jedes ` mapFunction ` wird an ` reduceFunction` übergeben. Der Ergebniswert wird beim Aufruf der Funktion auf ` initialValue ` initialisiert, und der erste Aufruf von ` reduceFunction ` wird auf diesen Wert angewendet.

Beachten Sie, dass zwar „ mapFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, wird durch „ reduceOptions “ bestimmt.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::mappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ mapFunction “ einmal für jedes Element aus dem Bereich von „ begin “ bis „ end “ auf. Der Rückgabewert jedes „ mapFunction “ wird an „ reduceFunction “ übergeben. Der Ergebniswert wird beim Aufruf der Funktion auf „ initialValue “ initialisiert, und der erste Aufruf von „ reduceFunction “ wird auf diesen Wert angewendet.

Beachten Sie, dass zwar mapFunction parallel aufgerufen wird, jedoch jeweils nur ein Thread reduceFunction aufruft. Standardmäßig ist die Reihenfolge, in der reduceFunction aufgerufen wird, nicht definiert.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::mappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ mapFunction “ einmal für jedes Element aus dem Bereich von „ begin “ bis „ end “ auf. Alle Aufrufe von „ mapFunction “ erfolgen aus den Threads, die aus dem Thread-Pool „ QThreadPool “ ( pool) entnommen werden. Der Rückgabewert jedes Aufrufs von „ mapFunction “ wird an „ reduceFunction “ übergeben.

Beachten Sie, dass zwar mapFunction parallel aufgerufen wird, jedoch jeweils nur ein Thread reduceFunction aufruft. Standardmäßig ist die Reihenfolge, in der reduceFunction aufgerufen wird, nicht definiert.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::mappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ mapFunction “ einmal für jedes Element in „ sequence “ auf. Alle Aufrufe von „ mapFunction “ erfolgen aus den Threads, die aus „ QThreadPool “ pool entnommen wurden. Der Rückgabewert jedes „ mapFunction “ wird an „ reduceFunction “ übergeben. Der Ergebniswert wird beim Aufruf der Funktion auf „ initialValue “ initialisiert, und der erste Aufruf von „ reduceFunction “ wird auf diesen Wert angewendet.

Beachten Sie, dass zwar „ mapFunction “ parallel aufgerufen wird, jedoch jeweils nur ein Thread „ reduceFunction “ aufruft. Die Reihenfolge, in der „ reduceFunction “ aufgerufen wird, wird durch „ reduceOptions “ bestimmt.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::mappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Ruft „ mapFunction “ einmal für jedes Element aus dem Bereich von ` begin ` bis ` end` auf. Alle Aufrufe von „ mapFunction “ erfolgen aus den Threads, die aus dem Array ` QThreadPool ` ( pool) entnommen werden. Der Rückgabewert jedes Aufrufs von „ mapFunction “ wird an „ reduceFunction “ übergeben. Der Ergebniswert wird beim Aufruf der Funktion auf ` initialValue ` initialisiert, und der erste Aufruf von „ reduceFunction “ wird auf diesen Wert angewendet.

Beachten Sie, dass zwar mapFunction parallel aufgerufen wird, jedoch jeweils nur ein Thread reduceFunction aufruft. Standardmäßig ist die Reihenfolge, in der reduceFunction aufgerufen wird, nicht definiert.

Siehe auch „Concurrent Map“ und „Map-Reduce“.

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

Entspricht

QtConcurrent::run(QThreadPool::globalInstance(), function, ...);

Führt „ function “ in einem separaten Thread aus. Der Thread wird aus dem globalen „ QThreadPool “ entnommen. Beachten Sie, dass „ function “ möglicherweise nicht sofort ausgeführt wird; „ function “ wird erst ausgeführt, sobald ein Thread verfügbar ist.

Im Basismodus hat T denselben Typ wie der Rückgabewert von ` function`. Auf Rückgabewerte, die nicht vom Typ `void` sind, kann über die Funktion ` QFuture::result()` zugegriffen werden.

Im Basismodus kann das zurückgegebene QFuture nur dazu verwendet werden, den Status „läuft“ oder „abgeschlossen“ sowie den Rückgabewert der Funktion abzufragen. Insbesondere können ein Abbruch oder eine Unterbrechung nur dann veranlasst werden, wenn die Berechnungen hinter dem Future noch nicht gestartet wurden.

Im „Run with Promise“-Modus wird erwartet, dass das „ function “ den Wert „void“ zurückgibt und ein zusätzliches Argument vom Typ „ QPromise<T> & “ entgegennimmt, das als erstes Argument in der Argumentliste der Funktion steht. „T“ ist der Ergebnistyp und entspricht dem des zurückgegebenen „ QFuture<T> “.

Im Modus „Ausführung mit Promise“ kann das zurückgegebene ` QFuture `, ähnlich wie im Basismodus, verwendet werden, um den Status (laufend/beendet) sowie den von der Funktion gemeldeten Wert abzufragen. Darüber hinaus kann es zum Anhalten oder Abbrechen der laufenden Aufgabe, zum Abrufen mehrerer Ergebnisse aus dem aufgerufenen ` function ` oder zur Überwachung des von ` function` gemeldeten Fortschritts verwendet werden.

Siehe auch „Concurrent Run“ (Basis-Modus), „Concurrent Run mit Promise“ und „ QThreadPool::start()“.

template <typename T> QFuture<T> QtConcurrent::run(QThreadPool *pool, Function function, ...)

function wird unter pool eingeplant. Beachten Sie, dass function möglicherweise nicht sofort ausgeführt wird; function wird erst ausgeführt, sobald ein Thread verfügbar ist.

Im Basis-Modus hat T denselben Typ wie der Rückgabewert von ` function`. Auf Rückgabewerte, die nicht vom Typ `void` sind, kann über die Funktion ` QFuture::result()` zugegriffen werden.

Im Basismodus kann das zurückgegebene ` QFuture ` nur verwendet werden, um den Status „läuft“ oder „abgeschlossen“ sowie den Rückgabewert der Funktion abzufragen. Insbesondere können ein Abbruch oder eine Unterbrechung nur dann veranlasst werden, wenn die Berechnungen hinter dem `Future` noch nicht gestartet wurden.

Im „Run with Promise“-Modus wird erwartet, dass das „ function “ den Wert „void“ zurückgibt, und es muss ein zusätzliches Argument vom Typ „ QPromise<T> & “ annehmen, das als erstes Argument in der Argumentliste der Funktion steht. „T“ ist der Ergebnistyp und entspricht dem des zurückgegebenen „ QFuture<T> “.

Im Modus „Ausführung mit Promise“ kann das zurückgegebene ` QFuture `, ähnlich wie im Basismodus, verwendet werden, um den Status („läuft“/„beendet“) und den von der Funktion gemeldeten Wert abzufragen. Darüber hinaus kann es zum Anhalten oder Abbrechen der laufenden Aufgabe, zum Abrufen mehrerer Ergebnisse aus dem aufgerufenen ` function ` oder zur Überwachung des von ` function` gemeldeten Fortschritts verwendet werden.

Siehe auch „Concurrent Run“ (Grundmodus), „Concurrent Run mit Promise“ und „ QThreadPool::start()“.

[since 6.0] template <typename Task> QtConcurrent::QTaskBuilder<Task> QtConcurrent::task(Task &&task)

Erstellt eine Instanz von ` QtConcurrent::QTaskBuilder`. Mit diesem Objekt lassen sich bestimmte Parameter anpassen und ` task ` in einem separaten Thread ausführen.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch „Concurrent Task “ und „ QtConcurrent::QTaskBuilder “.