QtConcurrent Namespace

Documentación de funciones

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

Llama a filterFunction una vez por cada elemento de sequence. Si filterFunction devuelve true, el elemento se mantiene en sequence; en caso contrario, el elemento se elimina de sequence.

Observe que este método no tiene una sobrecarga que trabaje con iteradores, porque invalida los iteradores de la secuencia sobre la que opera.

Vea también Filtro Concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de sequence. Todas las llamadas a filterFunction se invocan desde los hilos tomados de QThreadPool pool . Si filterFunction devuelve true, el elemento se mantiene en sequence; en caso contrario, el elemento se elimina de sequence.

Nótese que este método no tiene una sobrecarga que trabaje con iteradores, porque invalida los iteradores de la secuencia sobre la que opera.

Ver también Filtro Concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de sequence y devuelve una nueva secuencia de elementos conservados. Si filterFunction devuelve true, se pone una copia del elemento en la nueva Secuencia. En caso contrario, el elemento no aparecerá en la nueva secuencia.

Véase también filtered() y Filtro Concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de begin a end y devuelve una nueva Secuencia de elementos conservados. Si filterFunction devuelve true, se pone una copia del elemento en la nueva Secuencia. En caso contrario, el elemento no aparecerá en la nueva secuencia.

Véase también filtered() y Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de sequence y devuelve una nueva secuencia de elementos conservados. Todas las llamadas a filterFunction se invocan desde los hilos tomados de QThreadPool pool . Si filterFunction devuelve true, se coloca una copia del elemento en la nueva Secuencia. En caso contrario, el elemento no aparecerá en la nueva Secuencia.

Véase también filtered() y Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de begin a end y devuelve una nueva secuencia de elementos conservados. Todas las llamadas a filterFunction se invocan desde los hilos tomados de QThreadPool pool . Si filterFunction devuelve true, se coloca una copia del elemento en la nueva Secuencia. En caso contrario, el elemento no aparecerá en la nueva Secuencia.

Véase también filtered() y Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de sequence. Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento en el que filterFunction devuelve true.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction es indefinido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se llama en el orden de la secuencia original.

Véase también filteredReduced() y Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de begin a end. Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento donde filterFunction devuelve true.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction es indefinido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, se llama a reduceFunction en el orden de la secuencia original.

Véase también filteredReduced() y Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de sequence. Todas las llamadas a filterFunction se invocan desde los hilos tomados de QThreadPool pool . Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento donde filterFunction devuelve true.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction es indefinido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se llama en el orden de la secuencia original.

Véase también filteredReduced() y Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de sequence. Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento en el que filterFunction devuelva true. El valor resultante se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction es indefinido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se llama en el orden de la secuencia original.

Véase también filteredReduced() y Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de begin a end. Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento donde filterFunction devuelve true. El valor resultante se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction es indefinido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, se llama a reduceFunction en el orden de la secuencia original.

Véase también filteredReduced() y Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de begin a end. Todas las llamadas a filterFunction se invocan desde los hilos tomados de QThreadPool pool . Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento donde filterFunction devuelve true.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction es indefinido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, se llama a reduceFunction en el orden de la secuencia original.

Véase también filteredReduced() y Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de sequence. Todas las llamadas a filterFunction se invocan desde los hilos tomados de QThreadPool pool . Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento en el que filterFunction devuelve true. El valor resultante se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction es indefinido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se llama en el orden de la secuencia original.

Véase también filteredReduced() y Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de begin a end. Todas las llamadas a filterFunction se invocan desde los hilos tomados de QThreadPool pool . Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento en el que filterFunction devuelve true. El valor resultante se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction es indefinido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, se llama a reduceFunction en el orden de la secuencia original.

Véase también filteredReduced() y Filtro concurrente y Filtro-Reducción.

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

Llama a function una vez por cada elemento de sequence. function toma una referencia al elemento, de modo que cualquier modificación que se realice en el elemento aparecerá en sequence.

Véase también map() y Concurrent Map y Map-Reduce.

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

Llama a function una vez por cada ítem de begin a end. function toma una referencia al ítem, de forma que cualquier modificación que se haga en el ítem aparecerá en la secuencia a la que pertenecen los iteradores.

Véase también map() y Concurrent Map y Map-Reduce.

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

Llama a function una vez por cada elemento de sequence. Todas las llamadas a function se invocan desde los hilos tomados de QThreadPool pool . function toma una referencia al elemento, de modo que cualquier modificación que se realice en el elemento aparecerá en sequence.

Véase también map() y Concurrent Map y Map-Reduce.

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

Llama a function una vez por cada elemento de begin a end. Todas las llamadas a function se invocan desde los iteradores tomados de QThreadPool pool . function toma una referencia al ítem, de forma que cualquier modificación que se realice en el ítem aparecerá en la secuencia a la que pertenecen los iteradores.

Véase también map() y Concurrent Map y Map-Reduce.

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

Llama a function una vez por cada elemento de sequence y devuelve una OutputSequence que contiene los resultados. El tipo de los resultados coincidirá con el tipo devuelto por el MapFunctor.

Véase también mapped() y Concurrent Map y Map-Reduce.

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

Llama a function una vez por cada elemento de begin a end y devuelve un contenedor con los resultados. Puede especificar el tipo de contenedor como argumento de la plantilla a, de esta forma:

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

Véase también mapped() y Concurrent Map y Map-Reduce.

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

Llama a function una vez por cada elemento de sequence y devuelve una OutputSequence que contiene los resultados. Todas las llamadas a function se invocan desde los hilos tomados de QThreadPool pool . El tipo de los resultados coincidirá con el tipo devuelto por el MapFunctor.

Véase también mapped() y Concurrent Map y Map-Reduce.

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

Llama a function una vez por cada elemento de begin a end y devuelve un contenedor con los resultados. Todas las llamadas a function se invocan desde los hilos tomados de QThreadPool pool . Puede especificar el tipo de contenedor como argumento de la plantilla a, de esta forma:

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

Véase también mapped() y Concurrent Map y 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))

Llama a mapFunction una vez por cada elemento de sequence. El valor de retorno de cada mapFunction se pasa a reduceFunction.

Obsérvese que mientras mapFunction es llamado concurrentemente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction viene determinado por reduceOptions.

Véase también mapped() y Concurrent Map y 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))

Llama a mapFunction una vez por cada elemento de begin a end. El valor de retorno de cada mapFunction se pasa a reduceFunction.

Nótese que mientras mapFunction es llamado concurrentemente, sólo un hilo a la vez llamará a reduceFunction. El orden en el que se llama a reduceFunction no está definido.

Véase también blockingMappedReduced() y Concurrent Map y 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))

Llama a mapFunction una vez por cada elemento de sequence. Todas las llamadas a mapFunction se invocan desde los hilos tomados de QThreadPool pool . El valor de retorno de cada mapFunction se pasa a reduceFunction.

Tenga en cuenta que mientras mapFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en el que se llama a reduceFunction viene determinado por reduceOptions.

Véase también mapped() y Concurrent Map y 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))

Llama a mapFunction una vez por cada elemento de sequence. El valor de retorno de cada mapFunction se pasa a reduceFunction. El valor resultante se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras mapFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en el que se llama a reduceFunction viene determinado por reduceOptions.

Véase también mapped() y Concurrent Map y 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))

Llama a mapFunction una vez por cada elemento de begin a end. El valor de retorno de cada mapFunction se pasa a reduceFunction. El valor de resultado se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras mapFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en el que se llama a reduceFunction no está definido.

Véase también blockingMappedReduced() y Concurrent Map y 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))

Llama a mapFunction una vez por cada elemento de begin a end. Todas las llamadas a mapFunction se invocan desde los hilos tomados de QThreadPool pool . El valor de retorno de cada mapFunction se pasa a reduceFunction.

Tenga en cuenta que mientras mapFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en el que se llama a reduceFunction no está definido.

Véase también blockingMappedReduced() y Concurrent Map y 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))

Llama a mapFunction una vez por cada elemento de sequence. Todas las llamadas a mapFunction se invocan desde los hilos tomados de QThreadPool pool . El valor de retorno de cada mapFunction se pasa a reduceFunction. El valor de resultado se inicializa a initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras mapFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en el que se llama a reduceFunction viene determinado por reduceOptions.

Véase también mapped() y Concurrent Map y 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))

Llama a mapFunction una vez por cada elemento de begin a end. Todas las llamadas a mapFunction se invocan desde los hilos tomados de QThreadPool pool . El valor de retorno de cada mapFunction se pasa a reduceFunction. El valor de resultado se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras mapFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden de llamada a reduceFunction no está definido.

Véase también blockingMappedReduced() y Concurrent Map y Map-Reduce.

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

Llama a filterFunction una vez por cada elemento de sequence. Si filterFunction devuelve true, el elemento se mantiene en sequence; en caso contrario, el elemento se elimina de sequence.

Nótese que este método no tiene una sobrecarga que trabaje con iteradores, porque invalida los iteradores de la secuencia sobre la que opera.

Véase también Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de sequence. Todas las llamadas a filterFunction se invocan desde los hilos tomados de QThreadPool pool . Si filterFunction devuelve true, el elemento se mantiene en sequence; en caso contrario, el elemento se elimina de sequence.

Nótese que este método no tiene una sobrecarga que trabaje con iteradores, porque invalida los iteradores de la secuencia sobre la que opera.

Véase también Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de sequence y devuelve una nueva secuencia de elementos conservados. Si filterFunction devuelve true, se pone una copia del elemento en la nueva Secuencia. En caso contrario, el elemento no aparecerá en la nueva secuencia.

Véase también Filtro concurrente y Filtro-reducción.

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

Llama a filterFunction una vez por cada elemento de begin a end y devuelve una nueva Secuencia de elementos conservados. Si filterFunction devuelve true, se pone una copia del elemento en la nueva Secuencia. En caso contrario, el elemento no aparecerá en la nueva secuencia.

Véase también Filtro concurrente y Filtro-reducción.

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

Llama a filterFunction una vez por cada elemento de sequence y devuelve una nueva secuencia de elementos conservados. Todas las llamadas a filterFunction se invocan desde los hilos tomados de QThreadPool pool . Si filterFunction devuelve true, se coloca una copia del elemento en la nueva Secuencia. En caso contrario, el elemento no aparecerá en la nueva Secuencia.

Véase también Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de begin a end y devuelve una nueva secuencia de elementos conservados. Todas las llamadas a filterFunction se invocan desde los hilos tomados de QThreadPool pool . Si filterFunction devuelve true, se coloca una copia del elemento en la nueva Secuencia. En caso contrario, el elemento no aparecerá en la nueva Secuencia.

Véase también Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de sequence. Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento en el que filterFunction devuelve true.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se llama en el orden de la secuencia original.

Véase también Filtro concurrente y Filtro-reducción.

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

Llama a filterFunction una vez por cada elemento de begin a end. Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento donde filterFunction devuelve true.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction es indefinido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, se llama a reduceFunction en el orden de la secuencia original.

Véase también Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de sequence. Todas las llamadas a filterFunction se invocan desde los hilos tomados de QThreadPool pool . Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento donde filterFunction devuelve true.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se llama en el orden de la secuencia original.

Véase también Filtro concurrente y Filtro-reducción.

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

Llama a filterFunction una vez por cada elemento de sequence. Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento en el que filterFunction devuelva true. El valor resultante se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en el que se llama a reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se llama en el orden de la secuencia original.

Véase también Filtro concurrente y Filtro-reducción.

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

Llama a filterFunction una vez por cada elemento de begin a end. Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento donde filterFunction devuelve true. El valor resultante se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction es indefinido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, se llama a reduceFunction en el orden de la secuencia original.

Véase también Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de begin a end. Todas las llamadas a filterFunction se invocan desde los hilos tomados de QThreadPool pool . Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento donde filterFunction devuelve true.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, se llama a reduceFunction en el orden de la secuencia original.

Véase también Filtro concurrente y Filtro-Reducción.

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

Llama a filterFunction una vez por cada elemento de sequence. Todas las llamadas a filterFunction se invocan desde los hilos tomados de QThreadPool pool . Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento en el que filterFunction devuelve true. El valor resultante se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en el que se llama a reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se llama en el orden de la secuencia original.

Véase también Filtro concurrente y Filtro-reducción.

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

Llama a filterFunction una vez por cada elemento de begin a end. Todas las llamadas a filterFunction se invocan desde los hilos tomados de QThreadPool pool . Si filterFunction devuelve true para un elemento, ese elemento se pasa a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento en el que filterFunction devuelve true. El valor resultante se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras filterFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction es indefinido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, se llama a reduceFunction en el orden de la secuencia original.

Véase también Filtro concurrente y Filtro-Reducción.

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

Llama a function una vez por cada elemento de sequence. function toma una referencia al elemento, de modo que cualquier modificación que se realice en él aparecerá en sequence.

Véase también Concurrent Map y Map-Reduce.

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

Llama a function una vez por cada elemento de begin a end. function toma una referencia al elemento, de modo que cualquier modificación que se haga en el elemento aparecerá en la secuencia a la que pertenecen los iteradores.

Véase también Concurrent Map y Map-Reduce.

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

Llama a function una vez por cada elemento de sequence. Todas las llamadas a function se invocan desde los hilos tomados de QThreadPool pool . function toma una referencia al elemento, de modo que cualquier modificación que se realice en el elemento aparecerá en sequence.

Véase también Concurrent Map y Map-Reduce.

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

Llama a function una vez por cada elemento de begin a end. Todas las llamadas a function se invocan desde los iteradores tomados de QThreadPool pool . El function toma una referencia al ítem, de forma que cualquier modificación que se haga al ítem aparecerá en la secuencia a la que pertenecen los iteradores.

Véase también Concurrent Map y Map-Reduce.

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

Llama a function una vez por cada elemento de sequence y devuelve un futuro con cada elemento mapeado como resultado. Puede utilizar QFuture::const_iterator o QFutureIterator para iterar a través de los resultados.

Véase también Concurrent Map y Map-Reduce.

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

Llama a function una vez por cada elemento de begin a end y devuelve un futuro con cada elemento mapeado como resultado. Puede utilizar QFuture::const_iterator o QFutureIterator para iterar a través de los resultados.

Véase también Concurrent Map y Map-Reduce.

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

Llama a function una vez por cada elemento de sequence y devuelve un futuro con cada elemento mapeado como resultado. Todas las llamadas a function se invocan desde los hilos tomados de QThreadPool pool . Se puede utilizar QFuture::const_iterator o QFutureIterator para iterar a través de los resultados.

Véase también Concurrent Map y Map-Reduce.

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

Llama a function una vez por cada elemento de begin a end y devuelve un futuro con cada elemento mapeado como resultado. Todas las llamadas a function se invocan desde los hilos tomados de QThreadPool pool . Puede utilizar QFuture::const_iterator o QFutureIterator para iterar a través de los resultados.

Véase también Concurrent Map y 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))

Llama a mapFunction una vez por cada elemento de sequence. El valor de retorno de cada mapFunction se pasa a reduceFunction.

Obsérvese que mientras mapFunction es llamado concurrentemente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction viene determinado por reduceOptions.

Véase también Map concurrente y 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))

Llama a mapFunction una vez por cada elemento de begin a end. El valor de retorno de cada mapFunction se pasa a reduceFunction.

Nótese que mientras mapFunction es llamado concurrentemente, sólo un hilo a la vez llamará a reduceFunction. Por defecto, el orden en el que se llama a reduceFunction es indefinido.

Véase también Concurrent Map y 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))

Llama a mapFunction una vez por cada elemento de sequence. Todas las llamadas a mapFunction se invocan desde los hilos tomados de QThreadPool pool . El valor de retorno de cada mapFunction se pasa a reduceFunction.

Tenga en cuenta que mientras mapFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en que se llama a reduceFunction viene determinado por reduceOptions.

Véase también Map concurrente y 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))

Llama a mapFunction una vez por cada elemento de sequence. El valor de retorno de cada mapFunction se pasa a reduceFunction. El valor resultante se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras mapFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en el que se llama a reduceFunction viene determinado por reduceOptions.

Véase también Map concurrente y 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))

Llama a mapFunction una vez por cada elemento de begin a end. El valor de retorno de cada mapFunction se pasa a reduceFunction. El valor de resultado se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras mapFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. Por defecto, el orden de llamada a reduceFunction es indefinido.

Véase también Map concurrente y 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))

Llama a mapFunction una vez por cada elemento de begin a end. Todas las llamadas a mapFunction se invocan desde los hilos tomados de QThreadPool pool . El valor de retorno de cada mapFunction se pasa a reduceFunction.

Tenga en cuenta que mientras mapFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. Por defecto, el orden en el que se llama a reduceFunction es indefinido.

Véase también Map concurrente y 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))

Llama a mapFunction una vez por cada elemento de sequence. Todas las llamadas a mapFunction se invocan desde los hilos tomados de QThreadPool pool . El valor de retorno de cada mapFunction se pasa a reduceFunction. El valor de resultado se inicializa a initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras mapFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. El orden en el que se llama a reduceFunction viene determinado por reduceOptions.

Véase también Map concurrente y 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))

Llama a mapFunction una vez por cada elemento de begin a end. Todas las llamadas a mapFunction se invocan desde los hilos tomados de QThreadPool pool . El valor de retorno de cada mapFunction se pasa a reduceFunction. El valor de resultado se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que mientras mapFunction se llama de forma concurrente, sólo un hilo a la vez llamará a reduceFunction. Por defecto, el orden de llamada a reduceFunction es indefinido.

Véase también Map concurrente y Map-Reduce.

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

Equivale a

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

Ejecuta function en un hilo separado. El hilo se toma del global QThreadPool. Tenga en cuenta que function puede no ejecutarse inmediatamente; function sólo se ejecutará una vez que haya un hilo disponible.

En modo básico T es del mismo tipo que el valor de retorno de function. Se puede acceder a los valores de retorno no vacíos mediante la función QFuture::result().

En modo básico, el QFuture devuelto sólo puede utilizarse para consultar el estado de ejecución/finalización y el valor de retorno de la función. En particular, la cancelación o la pausa sólo se pueden emitir si no se han iniciado los cálculos que hay detrás del futuro.

En el modo de ejecución con promesa, se espera que function devuelva void y debe tomar un argumento adicional de tipo QPromise<T> &, colocado como primer argumento en la lista de argumentos de la función. T es el tipo de resultado y es el mismo para el QFuture<T> devuelto.

En el modo de ejecución con promesa, similar al modo básico, el QFuture devuelto puede utilizarse para consultar el estado de ejecución/finalización y el valor notificado por la función. Además, puede utilizarse para suspender o cancelar la tarea en ejecución, obtener múltiples resultados del function llamado o supervisar el progreso notificado por el function.

Véase también Ejecución concurrente (modo básico), Ejecución concurrente con promesa y QThreadPool::start().

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

Programa function en pool. Nótese que function puede no ejecutarse inmediatamente; function sólo se ejecutará una vez que un hilo esté disponible.

En modo básico T es del mismo tipo que el valor de retorno de function. Se puede acceder a los valores de retorno no vacíos mediante la función QFuture::result().

En modo básico, el QFuture devuelto sólo puede utilizarse para consultar el estado de ejecución/finalización y el valor de retorno de la función. En particular, la cancelación o la pausa sólo se pueden emitir si no se han iniciado los cálculos que hay detrás del futuro.

En el modo de ejecución con promesa, se espera que function devuelva void y debe tomar un argumento adicional de tipo QPromise<T> &, colocado como primer argumento en la lista de argumentos de la función. T es el tipo de resultado y es el mismo para el QFuture<T> devuelto.

En el modo de ejecución con promesa, similar al modo básico, el QFuture devuelto puede utilizarse para consultar el estado de ejecución/finalización y el valor notificado por la función. Además, puede utilizarse para suspender o cancelar la tarea en ejecución, obtener múltiples resultados del function llamado o supervisar el progreso notificado por el function.

Véase también Ejecución concurrente (modo básico), Ejecución concurrente con promesa y QThreadPool::start().

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

Crea una instancia de QtConcurrent::QTaskBuilder. Este objeto se puede utilizar para ajustar algunos parámetros y ejecutar task en un hilo separado.

Esta función se introdujo en Qt 6.0.

Véase también Tarea concurrente y QtConcurrent::QTaskBuilder.