QtConcurrent Namespace

Documentation de la fonction

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

Appelle ` filterFunction ` une fois pour chaque élément de ` sequence`. Si ` filterFunction ` renvoie ` true`, l'élément est conservé dans ` sequence` ; sinon, l'élément est supprimé de ` sequence`.

Notez que cette méthode ne dispose pas de surcharge fonctionnant avec des itérateurs, car elle invalide les itérateurs de la séquence sur laquelle elle opère.

Voir également Filtre concurrent et Filtre-Réduction.

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

Appelle ` filterFunction ` une fois pour chaque élément de ` sequence`. Tous les appels à ` filterFunction ` sont effectués à partir des threads provenant de ` QThreadPool ` pool. Si ` filterFunction ` renvoie ` true`, l'élément est conservé dans ` sequence` ; sinon, l'élément est supprimé de ` sequence`.

Notez que cette méthode ne dispose pas de surcharge fonctionnant avec des itérateurs, car elle invalide les itérateurs de la séquence sur laquelle elle opère.

Voir également Filtre concurrent et Filtre-Réduction.

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

Appelle filterFunction une fois pour chaque élément de sequence et renvoie une nouvelle séquence contenant les éléments conservés. Si filterFunction renvoie true, une copie de l'élément est ajoutée à la nouvelle séquence. Sinon, l'élément n' apparaîtra pas dans la nouvelle séquence.

Voir également filtered() ainsi que Concurrent Filter et Filter-Reduce.

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

Appelle une fois la fonction ` filterFunction ` pour chaque élément compris entre ` begin ` et ` end `, puis renvoie une nouvelle séquence contenant les éléments conservés. Si la fonction ` filterFunction ` renvoie ` true`, une copie de l'élément est ajoutée à la nouvelle séquence. Dans le cas contraire, l'élément n' apparaîtra pas dans la nouvelle séquence.

Voir également filtered() ainsi que Filtre concurrent et Filtre-Réduction.

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

Appelle ` filterFunction ` une fois pour chaque élément de ` sequence ` et renvoie une nouvelle séquence contenant les éléments conservés. Tous les appels à ` filterFunction ` sont effectués à partir des threads extraits de ` QThreadPool ` pool. Si ` filterFunction ` renvoie ` true`, une copie de l'élément est placée dans la nouvelle séquence. Sinon, l'élément n' apparaîtra pas dans la nouvelle séquence.

Voir également filtered() ainsi que « Concurrent Filter » et « Filter-Reduce ».

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

Appelle une fois la fonction ` filterFunction ` pour chaque élément de la séquence ` begin ` à ` end ` et renvoie une nouvelle séquence contenant les éléments conservés. Tous les appels à ` filterFunction ` sont effectués à partir des threads récupérés via ` QThreadPool ` pool. Si ` filterFunction ` renvoie ` true`, une copie de l'élément est ajoutée à la nouvelle séquence. Dans le cas contraire, l'élément n' apparaîtra pas dans la nouvelle séquence.

Voir également filtered() ainsi que « Filtre concurrent » et « Filtre-réduction ».

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

Appelle filterFunction une fois pour chaque élément de sequence. Si filterFunction renvoie true pour un élément, cet élément est alors transmis à reduceFunction. En d’autres termes, la valeur renvoyée correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true.

Notez que bien que filterFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée n’est pas défini si reduceOptions est QtConcurrent::UnorderedReduce. Si reduceOptions est QtConcurrent::OrderedReduce, reduceFunction est appelée dans l’ordre de la séquence d’origine.

Voir également ` filteredReduced()` ainsi que « Filtre concurrent » et « Filtre-Réduction ».

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))

Appelle filterFunction une fois pour chaque élément de la plage allant de begin à end. Si filterFunction renvoie true pour un élément, celui-ci est alors transmis à reduceFunction. En d’autres termes, la valeur renvoyée correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true.

Notez que bien que filterFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée n’est pas défini si reduceOptions est QtConcurrent::UnorderedReduce. Si reduceOptions est QtConcurrent::OrderedReduce, la fonction reduceFunction est appelée dans l’ordre de la séquence d’origine.

Voir également filteredReduced() ainsi que Filtre concurrent et Filtre-Réduction.

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))

Appelle la fonction ` filterFunction ` une fois pour chaque élément de ` sequence`. Tous les appels à ` filterFunction ` sont effectués à partir des threads extraits de ` QThreadPool ` pool. Si ` filterFunction ` renvoie ` true ` pour un élément, celui-ci est alors transmis à ` reduceFunction`. En d’autres termes, la valeur renvoyée correspond au résultat de ` reduceFunction ` pour chaque élément pour lequel ` filterFunction ` renvoie ` true`.

Notez que bien que ` filterFunction ` soit appelée de manière concurrente, un seul thread à la fois appellera ` reduceFunction`. L'ordre dans lequel ` reduceFunction ` est appelée est indéfini si ` reduceOptions ` est ` QtConcurrent::UnorderedReduce`. Si ` reduceOptions ` est ` QtConcurrent::OrderedReduce`, ` reduceFunction ` est appelée dans l'ordre de la séquence d'origine.

Voir également filteredReduced() ainsi que « Concurrent Filter » et « 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))

Appelle filterFunction une fois pour chaque élément de sequence. Si filterFunction renvoie true pour un élément, cet élément est alors transmis à reduceFunction. En d’autres termes, la valeur de retour correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true. La valeur de résultat est initialisée à initialValue lors de l’appel de la fonction, et le premier appel à reduceFunction s’appliquera à cette valeur.

Notez que bien que filterFunction soit appelé de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelé est indéfini si reduceOptions est QtConcurrent::UnorderedReduce. Si reduceOptions est QtConcurrent::OrderedReduce, reduceFunction est appelé dans l’ordre de la séquence d’origine.

Voir également filteredReduced() ainsi que « Concurrent Filter » et « 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))

Appelle filterFunction une fois pour chaque élément de la liste allant de begin à end. Si filterFunction renvoie true pour un élément, cet élément est alors transmis à reduceFunction. En d’autres termes, la valeur renvoyée correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true. La valeur de résultat est initialisée à initialValue lors de l’appel de la fonction, et le premier appel à reduceFunction portera sur cette valeur.

Notez que bien que filterFunction soit appelé de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelé n’est pas défini si reduceOptions est QtConcurrent::UnorderedReduce. Si reduceOptions est QtConcurrent::OrderedReduce, la fonction reduceFunction est appelée dans l’ordre de la séquence d’origine.

Voir également filteredReduced() ainsi que Filtre concurrent et Filtre-Réduction.

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))

Appelle filterFunction une fois pour chaque élément de la liste allant de begin à end. Tous les appels à filterFunction sont effectués à partir des threads extraits de la liste QThreadPool pool . Si filterFunction renvoie true pour un élément, cet élément est alors transmis à reduceFunction. En d’autres termes, la valeur de retour correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true.

Notez que bien que filterFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée n’est pas défini si reduceOptions est QtConcurrent::UnorderedReduce. Si reduceOptions est QtConcurrent::OrderedReduce, la reduceFunction est appelée dans l’ordre de la séquence d’origine.

Voir également filteredReduced() ainsi que Filtre concurrent et Filtre-Réduction.

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))

Appelle filterFunction une fois pour chaque élément de sequence. Tous les appels à filterFunction sont effectués à partir des threads extraits de la liste QThreadPool pool . Si filterFunction renvoie true pour un élément, cet élément est alors transmis à reduceFunction. En d’autres termes, la valeur de retour correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true. La valeur de résultat est initialisée à initialValue lors de l’appel de la fonction, et le premier appel à reduceFunction portera sur cette valeur.

Notez que bien que filterFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée n’est pas défini si reduceOptions est QtConcurrent::UnorderedReduce. Si reduceOptions est QtConcurrent::OrderedReduce, reduceFunction est appelée dans l’ordre de la séquence d’origine.

Voir également filteredReduced() ainsi que Concurrent Filter et 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))

Appelle filterFunction une fois pour chaque élément de la liste allant de begin à end. Tous les appels à filterFunction sont effectués à partir des threads provenant de QThreadPool pool . Si filterFunction renvoie true pour un élément, cet élément est alors transmis à reduceFunction. En d’autres termes, la valeur de retour correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true. La valeur de résultat est initialisée à initialValue lors de l’appel de la fonction, et le premier appel à reduceFunction portera sur cette valeur.

Notez que bien que filterFunction soit appelé de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelé n’est pas défini si reduceOptions est QtConcurrent::UnorderedReduce. Si reduceOptions est QtConcurrent::OrderedReduce, reduceFunction est appelé dans l’ordre de la séquence d’origine.

Voir également filteredReduced() ainsi que Filtre concurrent et Filtre-Réduction.

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

Appelle la fonction ` function ` une fois pour chaque élément de ` sequence`. La fonction ` function ` prend une référence à l'élément, de sorte que toute modification apportée à celui-ci apparaîtra dans ` sequence`.

Voir également map() ainsi que Map et Map-Reduce concurrents.

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

Appelle la fonction ` function ` une fois pour chaque élément de la séquence allant de ` begin ` à ` end`. La fonction ` function ` prend une référence à l'élément, de sorte que toute modification apportée à celui-ci apparaisse dans la séquence à laquelle appartiennent les itérateurs.

Voir également map() ainsi que « Concurrent Map » et « Map-Reduce ».

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

Appelle ` function ` une fois pour chaque élément de ` sequence`. Tous les appels à ` function ` sont effectués à partir des threads extraits de ` QThreadPool ` pool. La fonction ` function ` prend une référence à l'élément, de sorte que toute modification apportée à celui-ci apparaîtra dans ` sequence`.

Voir également map() ainsi que Map et Map-Reduce concurrents.

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

Appelle la fonction ` function ` une fois pour chaque élément de la séquence allant de ` begin ` à ` end`. Tous les appels à ` function ` sont effectués à partir des threads récupérés via ` QThreadPool ` et ` pool`. La fonction ` function ` prend une référence à l'élément, de sorte que toute modification apportée à celui-ci apparaisse dans la séquence à laquelle appartiennent les itérateurs.

Voir également map() ainsi que « Concurrent Map » et « Map-Reduce ».

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

Appelle ` function ` une fois pour chaque élément de ` sequence ` et renvoie une `OutputSequence` contenant les résultats. Le type des résultats correspondra au type renvoyé par le `MapFunctor`.

Voir également mapped() ainsi que Map et Map-Reduce concurrents.

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

Appelle la fonction ` function ` une fois pour chaque élément de la séquence allant de ` begin ` à ` end ` et renvoie un conteneur contenant les résultats. Vous pouvez spécifier le type du conteneur en tant qu’argument de modèle, comme suit :

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

Voir également mapped() ainsi que « Concurrent Map » et « Map-Reduce ».

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

Appelle ` function ` une fois pour chaque élément de ` sequence ` et renvoie une `OutputSequence` contenant les résultats. Tous les appels à ` function ` sont effectués à partir des threads provenant de ` QThreadPool ` pool. Le type des résultats correspondra au type renvoyé par le `MapFunctor`.

Voir également mapped() ainsi que « Concurrent Map » et « Map-Reduce ».

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

Appelle une fois la fonction ` function ` pour chaque élément de la séquence allant de ` begin ` à ` end ` et renvoie un conteneur contenant les résultats. Tous les appels à ` function ` sont effectués à partir des threads provenant de la liste ` QThreadPool ` pool. Vous pouvez spécifier le type du conteneur en tant qu’argument de modèle, comme suit :

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

Voir également mapped() ainsi que « Concurrent Map » et « 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))

Appelle ` mapFunction ` une fois pour chaque élément de ` sequence`. La valeur renvoyée par chaque ` mapFunction ` est transmise à ` reduceFunction`.

Notez que bien que mapFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée est déterminé par reduceOptions.

Voir également ` mapped()` et « Map et Map-Reduce simultanés ».

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))

Appelle la fonction ` mapFunction ` une fois pour chaque élément de la plage allant de ` begin ` à ` end`. La valeur renvoyée par chaque appel à ` mapFunction ` est transmise à ` reduceFunction`.

Notez que bien que mapFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée n’est pas défini.

Voir également blockingMappedReduced() et « Map et Map-Reduce simultanés ».

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))

Appelle ` mapFunction ` une fois pour chaque élément de ` sequence`. Tous les appels à ` mapFunction ` sont effectués à partir des threads extraits de ` QThreadPool ` pool. La valeur de retour de chaque ` mapFunction ` est transmise à ` reduceFunction`.

Notez que bien que mapFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée est déterminé par reduceOptions.

Voir également ` mapped()` et « Map et Map-Reduce simultanés ».

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))

Appelle mapFunction une fois pour chaque élément de sequence. La valeur renvoyée par chaque appel à mapFunction est transmise à reduceFunction. La valeur de résultat est initialisée à initialValue lors de l'appel de la fonction, et le premier appel à reduceFunction portera sur cette valeur.

Notez que bien que ` mapFunction ` soit appelée de manière concurrente, un seul thread à la fois appellera ` reduceFunction`. L’ordre dans lequel ` reduceFunction ` est appelée est déterminé par ` reduceOptions`.

Voir également ` mapped()` et « Map et Map-Reduce simultanés ».

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))

Appelle ` mapFunction ` une fois pour chaque élément de la plage allant de ` begin ` à ` end`. La valeur renvoyée par chaque appel à ` mapFunction ` est transmise à ` reduceFunction`. La valeur de résultat est initialisée à ` initialValue ` lors de l'appel de la fonction, et le premier appel à ` reduceFunction ` portera sur cette valeur.

Notez que bien que mapFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée n’est pas défini.

Voir également blockingMappedReduced() et « Map et Map-Reduce concurrents ».

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))

Appelle ` mapFunction ` une fois pour chaque élément de la liste allant de ` begin ` à ` end`. Tous les appels à ` mapFunction ` sont lancés à partir des threads extraits de la liste ` QThreadPool ` pool. La valeur de retour de chaque appel à ` mapFunction ` est transmise à ` reduceFunction`.

Notez que bien que mapFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée n’est pas défini.

Voir également blockingMappedReduced() et Map et Map-Reduce simultanés.

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))

Appelle ` mapFunction ` une fois pour chaque élément de ` sequence`. Tous les appels à ` mapFunction ` sont effectués à partir des threads extraits de ` QThreadPool ` pool. La valeur de retour de chaque ` mapFunction ` est transmise à ` reduceFunction`. La valeur de résultat est initialisée à ` initialValue ` lors de l'appel de la fonction, et le premier appel à ` reduceFunction ` portera sur cette valeur.

Notez que bien que mapFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée est déterminé par reduceOptions.

Voir également ` mapped()` et « Map et Map-Reduce simultanés ».

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))

Appelle ` mapFunction ` une fois pour chaque élément de la liste allant de ` begin ` à ` end`. Tous les appels à ` mapFunction ` sont effectués à partir des threads extraits de ` QThreadPool ` et ` pool`. La valeur de retour de chaque appel à ` mapFunction ` est transmise à ` reduceFunction`. La valeur de résultat est initialisée à ` initialValue ` lors de l'appel de la fonction, et le premier appel à ` reduceFunction ` portera sur cette valeur.

Notez que bien que mapFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée n’est pas défini.

Voir également blockingMappedReduced() et « Map et Map-Reduce simultanés ».

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

Appelle ` filterFunction ` une fois pour chaque élément de ` sequence`. Si ` filterFunction ` renvoie ` true`, l'élément est conservé dans ` sequence` ; sinon, l'élément est supprimé de ` sequence`.

Notez que cette méthode ne dispose pas de surcharge fonctionnant avec des itérateurs, car elle invalide les itérateurs de la séquence sur laquelle elle opère.

Voir également «Concurrent Filter » et « Filter-Reduce ».

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

Appelle ` filterFunction ` une fois pour chaque élément de ` sequence`. Tous les appels à ` filterFunction ` sont effectués à partir des threads provenant de ` QThreadPool ` pool. Si ` filterFunction ` renvoie ` true`, l'élément est conservé dans ` sequence` ; sinon, l'élément est supprimé de ` sequence`.

Notez que cette méthode ne dispose pas de surcharge fonctionnant avec des itérateurs, car elle invalide les itérateurs de la séquence sur laquelle elle opère.

Voir également «Concurrent Filter » et « Filter-Reduce ».

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

Appelle ` filterFunction ` une fois pour chaque élément de ` sequence ` et renvoie une nouvelle séquence contenant les éléments conservés. Si ` filterFunction ` renvoie ` true`, une copie de l'élément est ajoutée à la nouvelle séquence. Sinon, l'élément n' apparaîtra pas dans la nouvelle séquence.

Voir également Concurrent Filter et Filter-Reduce.

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

Appelle une fois la fonction « filterFunction » pour chaque élément de la séquence « begin » à « end » et renvoie une nouvelle séquence contenant les éléments conservés. Si la fonction « filterFunction » renvoie « true », une copie de l’élément est ajoutée à la nouvelle séquence. Sinon, l’élément n’ apparaîtra pas dans la nouvelle séquence.

Voir également «Concurrent Filter » et « Filter-Reduce ».

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

Appelle ` filterFunction ` une fois pour chaque élément de ` sequence ` et renvoie une nouvelle séquence contenant les éléments conservés. Tous les appels à ` filterFunction ` sont effectués à partir des threads provenant de ` QThreadPool ` pool. Si ` filterFunction ` renvoie ` true`, une copie de l'élément est placée dans la nouvelle séquence. Sinon, l'élément n' apparaîtra pas dans la nouvelle séquence.

Voir également «Concurrent Filter » et « Filter-Reduce ».

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

Appelle une fois la fonction ` filterFunction ` pour chaque élément de la collection ` begin ` à ` end ` et renvoie une nouvelle séquence contenant les éléments conservés. Tous les appels à ` filterFunction ` sont effectués à partir des threads extraits de la collection ` QThreadPool ` pool. Si ` filterFunction ` renvoie ` true`, une copie de l’élément est placée dans la nouvelle séquence. Dans le cas contraire, l’élément n’ apparaîtra pas dans la nouvelle séquence.

Voir également «Concurrent Filter » et « 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))

Appelle filterFunction une fois pour chaque élément de sequence. Si filterFunction renvoie true pour un élément, cet élément est alors transmis à reduceFunction. En d’autres termes, la valeur renvoyée correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true.

Notez que bien que filterFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée est indéfini si reduceOptions est QtConcurrent::UnorderedReduce. Si reduceOptions est QtConcurrent::OrderedReduce, reduceFunction est appelée dans l’ordre de la séquence d’origine.

Voir également «Concurrent Filter » et « 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))

Appelle filterFunction une fois pour chaque élément de la plage allant de begin à end. Si filterFunction renvoie true pour un élément, celui-ci est alors transmis à reduceFunction. En d’autres termes, la valeur renvoyée correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true.

Notez que bien que ` filterFunction ` soit appelée de manière concurrente, un seul thread à la fois appellera ` reduceFunction`. L’ordre dans lequel ` reduceFunction ` est appelée n’est pas défini si ` reduceOptions ` est ` QtConcurrent::UnorderedReduce`. Si ` reduceOptions ` est ` QtConcurrent::OrderedReduce`, ` reduceFunction ` est appelée dans l’ordre de la séquence d’origine.

Voir également «Concurrent Filter » et « 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))

Appelle filterFunction une fois pour chaque élément de sequence. Tous les appels à filterFunction sont lancés à partir des threads extraits de QThreadPool pool . Si filterFunction renvoie true pour un élément, cet élément est alors transmis à reduceFunction. En d’autres termes, la valeur de retour correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true.

Notez que, bien que filterFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée n’est pas défini si reduceOptions est QtConcurrent::UnorderedReduce. Si reduceOptions est QtConcurrent::OrderedReduce, reduceFunction est appelée dans l’ordre de la séquence d’origine.

Voir également «Concurrent Filter » et « 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))

Appelle filterFunction une fois pour chaque élément de sequence. Si filterFunction renvoie true pour un élément, cet élément est alors transmis à reduceFunction. En d’autres termes, la valeur de retour correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true. La valeur de résultat est initialisée à initialValue lors de l’appel de la fonction, et le premier appel à reduceFunction portera sur cette valeur.

Notez que bien que filterFunction soit appelé de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelé n’est pas défini si reduceOptions est QtConcurrent::UnorderedReduce. Si reduceOptions est QtConcurrent::OrderedReduce, reduceFunction est appelé dans l’ordre de la séquence d’origine.

Voir également «Concurrent Filter » et « 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))

Appelle filterFunction une fois pour chaque élément de la plage allant de begin à end. Si filterFunction renvoie true pour un élément, cet élément est alors transmis à reduceFunction. En d’autres termes, la valeur de retour correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true. La valeur de résultat est initialisée à initialValue lors de l’appel de la fonction, et le premier appel à reduceFunction portera sur cette valeur.

Notez que bien que filterFunction soit appelé de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelé n’est pas défini si reduceOptions est QtConcurrent::UnorderedReduce. Si reduceOptions est QtConcurrent::OrderedReduce, les reduceFunction sont appelés dans l’ordre de la séquence d’origine.

Voir également «Concurrent Filter » et « 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))

Appelle filterFunction une fois pour chaque élément de la liste allant de begin à end. Tous les appels à filterFunction sont lancés à partir des threads extraits de la liste QThreadPool pool . Si filterFunction renvoie true pour un élément, cet élément est alors transmis à reduceFunction. En d’autres termes, la valeur de retour correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true.

Notez que bien que filterFunction soit appelé de manière concurrente, un seul thread à la fois appellera reduceFunction. L'ordre dans lequel reduceFunction est appelé n'est pas défini si reduceOptions est QtConcurrent::UnorderedReduce. Si reduceOptions est QtConcurrent::OrderedReduce, la fonction reduceFunction est appelée dans l'ordre de la séquence d'origine.

Voir également «Concurrent Filter » et « 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))

Appelle filterFunction une fois pour chaque élément de sequence. Tous les appels à filterFunction sont effectués à partir des threads extraits de QThreadPool pool . Si filterFunction renvoie true pour un élément, cet élément est alors transmis à reduceFunction. En d’autres termes, la valeur de retour correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true. La valeur de résultat est initialisée à initialValue lors de l’appel de la fonction, et le premier appel à reduceFunction portera sur cette valeur.

Notez que bien que filterFunction soit appelé de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelé n’est pas défini si reduceOptions est QtConcurrent::UnorderedReduce. Si reduceOptions est QtConcurrent::OrderedReduce, reduceFunction est appelé dans l’ordre de la séquence d’origine.

Voir également «Concurrent Filter » et « 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))

Appelle filterFunction une fois pour chaque élément de la liste begin à end. Tous les appels à filterFunction sont effectués à partir des threads provenant de QThreadPool pool . Si filterFunction renvoie true pour un élément, cet élément est alors transmis à reduceFunction. En d’autres termes, la valeur de retour correspond au résultat de reduceFunction pour chaque élément pour lequel filterFunction renvoie true. La valeur de résultat est initialisée à initialValue lors de l’appel de la fonction, et le premier appel à reduceFunction portera sur cette valeur.

Notez que bien que filterFunction soit appelé de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelé n’est pas défini si reduceOptions est QtConcurrent::UnorderedReduce. Si reduceOptions est QtConcurrent::OrderedReduce, les reduceFunction sont appelés dans l’ordre de la séquence d’origine.

Voir également «Concurrent Filter » et « Filter-Reduce ».

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

Appelle ` function ` une fois pour chaque élément de ` sequence`. La fonction ` function ` prend une référence à l'élément, de sorte que toute modification apportée à celui-ci apparaîtra dans ` sequence`.

Voir également «Concurrent Map » et « Map-Reduce ».

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

Appelle ` function ` une fois pour chaque élément de ` begin ` à ` end`. La fonction ` function ` prend une référence à l'élément, de sorte que toute modification apportée à celui-ci apparaîtra dans la séquence à laquelle appartiennent les itérateurs.

Voir également «Concurrent Map » et « Map-Reduce ».

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

Appelle function une fois pour chaque élément de sequence. Tous les appels à function sont effectués à partir des threads provenant de QThreadPool pool . La fonction function prend une référence à l'élément, de sorte que toute modification apportée à celui-ci apparaîtra dans sequence.

Voir également «Concurrent Map » et « Map-Reduce ».

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

Appelle ` function ` une fois pour chaque élément de la collection ` begin ` à ` end`. Tous les appels à ` function ` sont effectués à partir des threads extraits de la collection ` QThreadPool ` pool. La méthode ` function ` prend une référence à l'élément, de sorte que toute modification apportée à celui-ci apparaisse dans la séquence à laquelle appartiennent les itérateurs.

Voir également «Concurrent Map » et « Map-Reduce ».

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

Appelle ` function ` une fois pour chaque élément de ` sequence ` et renvoie un `Future` dont chaque résultat correspond à un élément mappé. Vous pouvez utiliser ` QFuture::const_iterator ` ou ` QFutureIterator ` pour parcourir les résultats.

Voir également «Concurrent Map » et « Map-Reduce ».

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

Appelle une fois la fonction ` function ` pour chaque élément de la liste ` begin ` à ` end ` et renvoie un `Future` dont chaque résultat correspond à un élément mappé. Vous pouvez utiliser ` QFuture::const_iterator ` ou ` QFutureIterator ` pour parcourir les résultats.

Voir également «Concurrent Map » et « Map-Reduce ».

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

Appelle « function » une fois pour chaque élément de « sequence » et renvoie un « future » dont chaque résultat correspond à un élément mappé. Tous les appels à « function » sont effectués à partir des threads provenant de « QThreadPool » pool. Vous pouvez utiliser « QFuture::const_iterator » ou « QFutureIterator » pour parcourir les résultats.

Voir également «Concurrent Map » et « Map-Reduce ».

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

Appelle une fois la fonction ` function ` pour chaque élément de la liste ` begin ` à ` end ` et renvoie un `Future` dont chaque résultat correspond à un élément mappé. Tous les appels à ` function ` sont effectués à partir des threads provenant de ` QThreadPool ` pool. Vous pouvez utiliser ` QFuture::const_iterator ` ou ` QFutureIterator ` pour parcourir les résultats.

Voir également «Concurrent Map » et « 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))

Appelle la fonction ` mapFunction ` une fois pour chaque élément de ` sequence`. La valeur renvoyée par chaque appel à ` mapFunction ` est transmise à ` reduceFunction`.

Notez que bien que mapFunction soit appelé de manière concurrente, un seul thread à la fois appellera reduceFunction. L'ordre dans lequel reduceFunction est appelé est déterminé par reduceOptions.

Voir également «Concurrent Map » et « 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))

Appelle la fonction ` mapFunction ` une fois pour chaque élément de la plage allant de ` begin ` à ` end`. La valeur renvoyée par chaque appel à ` mapFunction ` est transmise à ` reduceFunction`.

Notez que bien que la fonction mapFunction soit appelée en parallèle, un seul thread à la fois appellera la fonction reduceFunction. Par défaut, l’ordre dans lequel la fonction reduceFunction est appelée n’est pas défini.

Voir également Map simultané et 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))

Appelle ` mapFunction ` une fois pour chaque élément de ` sequence`. Tous les appels à ` mapFunction ` sont effectués à partir des threads extraits de ` QThreadPool ` pool. La valeur de retour de chaque ` mapFunction ` est transmise à ` reduceFunction`.

Notez que bien que mapFunction soit appelé de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelé est déterminé par reduceOptions.

Voir également «Concurrent Map » et « 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))

Appelle mapFunction une fois pour chaque élément de sequence. La valeur renvoyée par chaque appel à mapFunction est transmise à reduceFunction. La valeur de résultat est initialisée à initialValue lors de l'appel de la fonction, et le premier appel à reduceFunction portera sur cette valeur.

Notez que bien que mapFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée est déterminé par reduceOptions.

Voir également «Concurrent Map » et « 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))

Appelle ` mapFunction ` une fois pour chaque élément de la plage allant de ` begin ` à ` end`. La valeur renvoyée par chaque appel à ` mapFunction ` est transmise à ` reduceFunction`. La valeur de résultat est initialisée à ` initialValue ` lors de l'appel de la fonction, et le premier appel à ` reduceFunction ` portera sur cette valeur.

Notez que bien que mapFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. Par défaut, l’ordre dans lequel reduceFunction est appelée n’est pas défini.

Voir également Map concurrent et 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))

Appelle ` mapFunction ` une fois pour chaque élément de la liste allant de ` begin ` à ` end`. Tous les appels à ` mapFunction ` sont lancés à partir des threads extraits de la liste ` QThreadPool ` pool. La valeur de retour de chaque appel à ` mapFunction ` est transmise à ` reduceFunction`.

Notez que bien que mapFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. Par défaut, l'ordre dans lequel reduceFunction est appelée n'est pas défini.

Voir également Map concurrent et 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))

Appelle mapFunction une fois pour chaque élément de sequence. Tous les appels à mapFunction sont effectués à partir des threads extraits de QThreadPool pool . La valeur de retour de chaque mapFunction est transmise à reduceFunction. La valeur de résultat est initialisée à initialValue lors de l'appel de la fonction, et le premier appel à reduceFunction portera sur cette valeur.

Notez que bien que mapFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. L’ordre dans lequel reduceFunction est appelée est déterminé par reduceOptions.

Voir également «Concurrent Map » et « 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))

Appelle ` mapFunction ` une fois pour chaque élément de la liste allant de ` begin ` à ` end`. Tous les appels à ` mapFunction ` sont effectués à partir des threads extraits de la liste ` QThreadPool ` pool. La valeur de retour de chaque appel à ` mapFunction ` est transmise à ` reduceFunction`. La valeur de résultat est initialisée à ` initialValue ` lors de l'appel de la fonction, et le premier appel à ` reduceFunction ` portera sur cette valeur.

Notez que bien que mapFunction soit appelée de manière concurrente, un seul thread à la fois appellera reduceFunction. Par défaut, l'ordre dans lequel reduceFunction est appelée n'est pas défini.

Voir également Map concurrent et Map-Reduce.

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

Équivalent à

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

Exécute function dans un thread distinct. Le thread est prélevé dans la variable globale QThreadPool. Notez que function peut ne pas s’exécuter immédiatement ; function ne sera exécuté qu’une fois qu’un thread sera disponible.

En mode basique, T est du même type que la valeur de retour de function. Les valeurs de retour non de type void sont accessibles via la fonction QFuture::result().

En mode de base, le ` QFuture ` renvoyé ne peut être utilisé que pour interroger l’état d’exécution (en cours ou terminé) et la valeur de retour de la fonction. En particulier, l’annulation ou la mise en pause ne peuvent être déclenchées que si les calculs sous-jacents au `future` n’ont pas encore commencé.

En mode « run with promise », l’ function doit renvoyer de type void et prendre un argument supplémentaire de type QPromise<T> &, placé en premier dans la liste des arguments de la fonction. T correspond au type du résultat et est identique à celui de l’ QFuture<T> renvoyée.

En mode « exécution avec promesse », comme en mode de base, l'objet ` QFuture ` renvoyé peut être utilisé pour interroger l'état d'exécution (en cours ou terminé) et la valeur renvoyée par la fonction. De plus, il peut servir à suspendre ou annuler la tâche en cours d'exécution, à récupérer plusieurs résultats de l'function appelée ou à surveiller la progression signalée par l'function.

Voir également Exécution simultanée (mode de base), Exécution simultanée avec Promise et QThreadPool::start().

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

Les planifications sont définies via ` function ` sur pool. Notez que ` function ` ne s'exécute pas nécessairement immédiatement ; ` function ` ne sera exécuté qu'une fois qu'un thread sera disponible.

En mode basique, T est du même type que la valeur de retour de function. Les valeurs de retour non nulles sont accessibles via la fonction QFuture::result().

En mode de base, le ` QFuture ` renvoyé ne peut être utilisé que pour interroger l’état d’exécution (en cours ou terminé) et la valeur de retour de la fonction. En particulier, l’annulation ou la mise en pause ne peuvent être déclenchées que si les calculs sous-jacents au `future` n’ont pas encore commencé.

En mode « run with promise », l’ function doit renvoyer de type void et prendre un argument supplémentaire de type QPromise<T> &, placé en premier dans la liste des arguments de la fonction. T correspond au type du résultat et est identique à celui de l’ QFuture<T> renvoyée.

En mode « run with promise », comme en mode de base, l’ QFuture renvoyée peut être utilisée pour interroger l’état d’exécution (en cours ou terminée) et la valeur rapportée par la fonction. De plus, elle peut servir à suspendre ou annuler la tâche en cours d’exécution, à récupérer plusieurs résultats de l’ function appelée ou à surveiller la progression rapportée par l’ function.

Voir également Exécution simultanée (mode de base), Exécution simultanée avec Promise et QThreadPool::start().

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

Crée une instance de ` QtConcurrent::QTaskBuilder`. Cet objet permet de régler certains paramètres et d'exécuter ` task ` dans un thread distinct.

Cette fonction a été introduite dans Qt 6.0.

Voir également «Tâche concurrente » et « QtConcurrent::QTaskBuilder ».