QtConcurrent Namespace Reference

\inmodule QtConcurrent More...

Classes
class	BlockSizeManager
	\inmodule QtConcurrent More...
struct	DefaultValueContainer
struct	DefaultValueContainer< void >
class	FilteredEachKernel
	\inmodule QtConcurrent More...
class	FilteredReducedKernel
	\inmodule QtConcurrent More...
class	FilterKernel
	\inmodule QtConcurrent More...
struct	FunctionResolver
struct	FunctionResolverHelper
struct	FunctionResolverHelper< std::false_type, Function, PromiseType, Args... >
struct	FunctionResolverHelper< std::true_type, Function, PromiseType, Args... >
class	IntermediateResults
struct	InvokeResult
class	IterateKernel
	\inmodule QtConcurrent More...
class	MapKernel
	\inmodule QtConcurrent More...
class	MappedEachKernel
	\inmodule QtConcurrent More...
class	MappedReducedKernel
	\inmodule QtConcurrent More...
class	Median
	\inmodule QtConcurrent More...
struct	MemberFunctionResolver
struct	MemberFunctionResolver< Function, PromiseType, Arg, Args... >
struct	NonMemberFunctionResolver
struct	NonMemberFunctionResolver< Function, PromiseType, Args... >
struct	NonPromiseTaskResolver
struct	NonPromiseTaskResolver< Function, Args... >
struct	PromiseTaskResolver
struct	PromiseTaskResolver< Function, Args... >
class	QTaskBuilder
class	qValueType
	\inmodule QtConcurrent More...
class	qValueType< const T * >
	\inmodule QtConcurrent More...
class	qValueType< T * >
	\inmodule QtConcurrent More...
class	ReduceKernel
	\inmodule QtConcurrent More...
class	ResultReporter
	\inmodule QtConcurrent More...
class	ResultReporter< void >
class	RunFunctionTaskBase
struct	SelectSpecialization
struct	SelectSpecialization< void >
class	SequenceHolder1
	\inmodule QtConcurrent More...
class	SequenceHolder2
	\inmodule QtConcurrent More...
struct	StoredFunctionCall
struct	StoredFunctionCallWithPromise
struct	TaskResolver
struct	TaskResolverHelper
struct	TaskResolverHelper< std::false_type, Function, Args... >
struct	TaskResolverHelper< std::true_type, Function, Args... >
struct	TaskStartParameters
class	ThreadEngine
	\inmodule QtConcurrent More...
class	ThreadEngineBarrier
	\inmodule QtConcurrent More...
class	ThreadEngineBase
	\inmodule QtConcurrent More...
class	ThreadEngineStarter
	\inmodule QtConcurrent More...
class	ThreadEngineStarter< void >
class	ThreadEngineStarterBase
	\inmodule QtConcurrent More...

Typedefs
template<class Function, class ... Args>
using	InvokeResultType = typename InvokeResult<Function, Args...>::Type
template<class ... Types>
using	DecayedTuple = std::tuple<std::decay_t<Types>...>

Enumerations
enum	ThreadFunctionResult { ThrottleThread , ThreadFinished }
enum class	FutureResult { Ignore }
enum	{ ReduceQueueStartLimit = 20 , ReduceQueueThrottleLimit = 30 }
enum	ReduceOption { UnorderedReduce = 0x1 , OrderedReduce = 0x2 , SequentialReduce = 0x4 }
	This enum specifies the order of which results from the map or filter function are passed to the reduce function. More...

Functions
bool	selectIteration (std::bidirectional_iterator_tag)
bool	selectIteration (std::forward_iterator_tag)
bool	selectIteration (std::random_access_iterator_tag)
template<typename ThreadEngine>
ThreadEngineStarter< typename ThreadEngine::ResultType >	startThreadEngine (ThreadEngine *threadEngine)
	[qtconcurrentthreadengine-1]
template<typename Sequence, typename KeepFunctor, typename ReduceFunctor>
ThreadEngineStarter< void >	filterInternal (QThreadPool *pool, Sequence &sequence, KeepFunctor &&keep, ReduceFunctor &&reduce)
	[QtConcurrent-1]
template<typename Sequence, typename KeepFunctor>
QFuture< void >	filter (QThreadPool *pool, Sequence &sequence, KeepFunctor &&keep)
	Calls filterFunction once for each item in sequence.
template<typename Sequence, typename KeepFunctor>
QFuture< void >	filter (Sequence &sequence, KeepFunctor &&keep)
	Calls filterFunction once for each item in sequence.
template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor>
QFuture< ResultType >	filteredReduced (QThreadPool *pool, Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor>
QFuture< ResultType >	filteredReduced (Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
QFuture< ResultType >	filteredReduced (QThreadPool *pool, Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
QFuture< ResultType >	filteredReduced (Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
QFuture< ResultType >	filteredReduced (QThreadPool *pool, Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
QFuture< ResultType >	filteredReduced (Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
QFuture< ResultType >	filteredReduced (QThreadPool *pool, Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
QFuture< ResultType >	filteredReduced (Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor>
QFuture< ResultType >	filteredReduced (QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&keep, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor>
QFuture< ResultType >	filteredReduced (Iterator begin, Iterator end, KeepFunctor &&keep, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
QFuture< ResultType >	filteredReduced (QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&keep, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
QFuture< ResultType >	filteredReduced (Iterator begin, Iterator end, KeepFunctor &&keep, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator, typename KeepFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isIterator_v< Iterator >, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
QFuture< ResultType >	filteredReduced (Iterator begin, Iterator end, KeepFunctor &&keep, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename KeepFunctor>
QFuture< typename std::decay_t< Sequence >::value_type >	filtered (QThreadPool *pool, Sequence &&sequence, KeepFunctor &&keep)
	Calls filterFunction once for each item in sequence and returns a new Sequence of kept items.
template<typename Sequence, typename KeepFunctor>
QFuture< typename std::decay_t< Sequence >::value_type >	filtered (Sequence &&sequence, KeepFunctor &&keep)
	Calls filterFunction once for each item in sequence and returns a new Sequence of kept items.
template<typename Iterator, typename KeepFunctor>
QFuture< typename qValueType< Iterator >::value_type >	filtered (QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&keep)
	Calls filterFunction once for each item from begin to end and returns a new Sequence of kept items.
template<typename Iterator, typename KeepFunctor>
QFuture< typename qValueType< Iterator >::value_type >	filtered (Iterator begin, Iterator end, KeepFunctor &&keep)
	Calls filterFunction once for each item from begin to end and returns a new Sequence of kept items.
template<typename Sequence, typename KeepFunctor>
void	blockingFilter (QThreadPool *pool, Sequence &sequence, KeepFunctor &&keep)
	Calls filterFunction once for each item in sequence.
template<typename Sequence, typename KeepFunctor>
void	blockingFilter (Sequence &sequence, KeepFunctor &&keep)
	Calls filterFunction once for each item in sequence.
template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor>
ResultType	blockingFilteredReduced (QThreadPool *pool, Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor>
ResultType	blockingFilteredReduced (Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
ResultType	blockingFilteredReduced (QThreadPool *pool, Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
ResultType	blockingFilteredReduced (Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
ResultType	blockingFilteredReduced (QThreadPool *pool, Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
ResultType	blockingFilteredReduced (Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
ResultType	blockingFilteredReduced (QThreadPool *pool, Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
ResultType	blockingFilteredReduced (Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor>
ResultType	blockingFilteredReduced (QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&keep, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor>
ResultType	blockingFilteredReduced (Iterator begin, Iterator end, KeepFunctor &&keep, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
ResultType	blockingFilteredReduced (QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&keep, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
ResultType	blockingFilteredReduced (Iterator begin, Iterator end, KeepFunctor &&keep, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator, typename KeepFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isIterator_v< Iterator >, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
ResultType	blockingFilteredReduced (Iterator begin, Iterator end, KeepFunctor &&keep, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename KeepFunctor>
std::decay_t< Sequence >	blockingFiltered (QThreadPool *pool, Sequence &&sequence, KeepFunctor &&keep)
	Calls filterFunction once for each item in sequence and returns a new Sequence of kept items.
template<typename Sequence, typename KeepFunctor>
std::decay_t< Sequence >	blockingFiltered (Sequence &&sequence, KeepFunctor &&keep)
	Calls filterFunction once for each item in sequence and returns a new Sequence of kept items.
template<typename OutputSequence, typename Iterator, typename KeepFunctor>
OutputSequence	blockingFiltered (QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&keep)
	Calls filterFunction once for each item from begin to end and returns a new Sequence of kept items.
template<typename OutputSequence, typename Iterator, typename KeepFunctor>
OutputSequence	blockingFiltered (Iterator begin, Iterator end, KeepFunctor &&keep)
	Calls filterFunction once for each item from begin to end and returns a new Sequence of kept items.
template<typename Iterator, typename KeepFunctor>
ThreadEngineStarter< typename qValueType< Iterator >::value_type >	startFiltered (QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&functor)
	[QtConcurrent-2]
template<typename Sequence, typename KeepFunctor>
decltype(auto)	startFiltered (QThreadPool *pool, Sequence &&sequence, KeepFunctor &&functor)
	[QtConcurrent-3]
template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
ThreadEngineStarter< ResultType >	startFilteredReduced (QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunctor, ReduceFunctor &&reduceFunctor, ReduceOptions options)
	[QtConcurrent-4]
template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
ThreadEngineStarter< ResultType >	startFilteredReduced (QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunctor, ReduceFunctor &&reduceFunctor, ReduceOptions options)
	[QtConcurrent-5]
template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
ThreadEngineStarter< ResultType >	startFilteredReduced (QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunctor, ReduceFunctor &&reduceFunctor, ResultType &&initialValue, ReduceOptions options)
	[QtConcurrent-6]
template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
ThreadEngineStarter< ResultType >	startFilteredReduced (QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunctor, ReduceFunctor &&reduceFunctor, ResultType &&initialValue, ReduceOptions options)
	[QtConcurrent-7]
template<typename Sequence, typename MapFunctor>
QFuture< void >	map (QThreadPool *pool, Sequence &&sequence, MapFunctor &&map)
	Calls function once for each item in sequence.
template<typename Sequence, typename MapFunctor>
QFuture< void >	map (Sequence &&sequence, MapFunctor &&map)
	Calls function once for each item in sequence.
template<typename Iterator, typename MapFunctor>
QFuture< void >	map (QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&map)
	Calls function once for each item from begin to end.
template<typename Iterator, typename MapFunctor>
QFuture< void >	map (Iterator begin, Iterator end, MapFunctor &&map)
	Calls function once for each item from begin to end.
template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
QFuture< ResultType >	mappedReduced (QThreadPool *pool, Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
QFuture< ResultType >	mappedReduced (Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
QFuture< ResultType >	mappedReduced (QThreadPool *pool, Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
QFuture< ResultType >	mappedReduced (Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename MapFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
QFuture< ResultType >	mappedReduced (QThreadPool *pool, Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename MapFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
QFuture< ResultType >	mappedReduced (Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
QFuture< ResultType >	mappedReduced (QThreadPool *pool, Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
QFuture< ResultType >	mappedReduced (Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
QFuture< ResultType >	mappedReduced (QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&map, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
QFuture< ResultType >	mappedReduced (Iterator begin, Iterator end, MapFunctor &&map, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
QFuture< ResultType >	mappedReduced (QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&map, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
QFuture< ResultType >	mappedReduced (Iterator begin, Iterator end, MapFunctor &&map, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator, typename MapFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isIterator_v< Iterator >, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
QFuture< ResultType >	mappedReduced (Iterator begin, Iterator end, MapFunctor &&map, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename MapFunctor>
QFuture< QtPrivate::MapResultType< Sequence, MapFunctor > >	mapped (QThreadPool *pool, Sequence &&sequence, MapFunctor &&map)
template<typename Sequence, typename MapFunctor>
QFuture< QtPrivate::MapResultType< Sequence, MapFunctor > >	mapped (Sequence &&sequence, MapFunctor &&map)
template<typename Iterator, typename MapFunctor>
QFuture< QtPrivate::MapResultType< Iterator, MapFunctor > >	mapped (QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&map)
template<typename Iterator, typename MapFunctor>
QFuture< QtPrivate::MapResultType< Iterator, MapFunctor > >	mapped (Iterator begin, Iterator end, MapFunctor &&map)
template<typename Sequence, typename MapFunctor>
void	blockingMap (QThreadPool *pool, Sequence &&sequence, MapFunctor map)
	Calls function once for each item in sequence.
template<typename Sequence, typename MapFunctor>
void	blockingMap (Sequence &&sequence, MapFunctor &&map)
	Calls function once for each item in sequence.
template<typename Iterator, typename MapFunctor>
void	blockingMap (QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&map)
	Calls function once for each item from begin to end.
template<typename Iterator, typename MapFunctor>
void	blockingMap (Iterator begin, Iterator end, MapFunctor &&map)
	Calls function once for each item from begin to end.
template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
ResultType	blockingMappedReduced (QThreadPool *pool, Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
ResultType	blockingMappedReduced (Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
ResultType	blockingMappedReduced (QThreadPool *pool, Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
ResultType	blockingMappedReduced (Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename MapFunctor, typename ReduceFunctor, typename Sequence, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
ResultType	blockingMappedReduced (QThreadPool *pool, Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename MapFunctor, typename ReduceFunctor, typename Sequence, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
ResultType	blockingMappedReduced (Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename MapFunctor, typename ReduceFunctor, typename Sequence, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
ResultType	blockingMappedReduced (QThreadPool *pool, Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename MapFunctor, typename ReduceFunctor, typename Sequence, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
ResultType	blockingMappedReduced (Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
ResultType	blockingMappedReduced (QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&map, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
ResultType	blockingMappedReduced (Iterator begin, Iterator end, MapFunctor &&map, ReduceFunctor &&reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
ResultType	blockingMappedReduced (QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&map, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
ResultType	blockingMappedReduced (Iterator begin, Iterator end, MapFunctor &&map, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator, typename MapFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isIterator_v< Iterator >, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>
ResultType	blockingMappedReduced (Iterator begin, Iterator end, MapFunctor &&map, ReduceFunctor &&reduce, InitialValueType &&initialValue, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename OutputSequence, typename InputSequence, typename MapFunctor>
OutputSequence	blockingMapped (QThreadPool *pool, InputSequence &&sequence, MapFunctor &&map)
	Calls function once for each item in sequence and returns an OutputSequence containing the results.
template<typename OutputSequence, typename InputSequence, typename MapFunctor>
OutputSequence	blockingMapped (InputSequence &&sequence, MapFunctor &&map)
	Calls function once for each item in sequence and returns an OutputSequence containing the results.
template<typename MapFunctor, typename InputSequence>
auto	blockingMapped (QThreadPool *pool, InputSequence &&sequence, MapFunctor &&map)
template<typename MapFunctor, typename InputSequence>
auto	blockingMapped (InputSequence &&sequence, MapFunctor &&map)
template<typename Sequence, typename Iterator, typename MapFunctor>
Sequence	blockingMapped (QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&map)
	Calls function once for each item from begin to end and returns a container with the results.
template<typename Sequence, typename Iterator, typename MapFunctor>
Sequence	blockingMapped (Iterator begin, Iterator end, MapFunctor &&map)
	Calls function once for each item from begin to end and returns a container with the results.
template<typename Iterator, typename MapFunctor>
auto	blockingMapped (QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&map)
template<typename Iterator, typename MapFunctor>
auto	blockingMapped (Iterator begin, Iterator end, MapFunctor &&map)
template<typename Iterator, typename Functor>
ThreadEngineStarter< void >	startMap (QThreadPool *pool, Iterator begin, Iterator end, Functor &&functor)
	[qtconcurrentmapkernel-1]
template<typename T, typename Iterator, typename Functor>
ThreadEngineStarter< T >	startMapped (QThreadPool *pool, Iterator begin, Iterator end, Functor &&functor)
	[qtconcurrentmapkernel-2]
template<typename T, typename Sequence, typename Functor>
ThreadEngineStarter< T >	startMapped (QThreadPool *pool, Sequence &&sequence, Functor &&functor)
	[qtconcurrentmapkernel-3]
template<typename IntermediateType, typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
ThreadEngineStarter< ResultType >	startMappedReduced (QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunctor, ReduceFunctor &&reduceFunctor, ReduceOptions options)
	[qtconcurrentmapkernel-4]
template<typename IntermediateType, typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
ThreadEngineStarter< ResultType >	startMappedReduced (QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunctor, ReduceFunctor &&reduceFunctor, ReduceOptions options)
	[qtconcurrentmapkernel-5]
template<typename IntermediateType, typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
ThreadEngineStarter< ResultType >	startMappedReduced (QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunctor, ReduceFunctor &&reduceFunctor, ResultType &&initialValue, ReduceOptions options)
	[qtconcurrentmapkernel-6]
template<typename IntermediateType, typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
ThreadEngineStarter< ResultType >	startMappedReduced (QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunctor, ReduceFunctor &&reduceFunctor, ResultType &&initialValue, ReduceOptions options)
	[qtconcurrentmapkernel-7]
template<class Function, class ... Args>
QTCONCURRENT_RUN_NODISCARD auto	run (QThreadPool *pool, Function &&f, Args &&...args)
template<class Function, class ... Args>
QTCONCURRENT_RUN_NODISCARD auto	run (QThreadPool *pool, std::reference_wrapper< const Function > &&functionWrapper, Args &&...args)
template<class Function, class ... Args>
QTCONCURRENT_RUN_NODISCARD auto	run (Function &&f, Args &&...args)
template<class PromiseType, class Function, class ... Args>
QTCONCURRENT_RUN_NODISCARD auto	run (QThreadPool *pool, Function &&f, Args &&...args)
template<class PromiseType, class Function, class ... Args>
QTCONCURRENT_RUN_NODISCARD auto	run (Function &&f, Args &&...args)
template<class Task>
constexpr auto	task (Task &&t)

Detailed Description

\inmodule QtConcurrent

Since

4.4

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

See the \l {Qt Concurrent} module documentation for an overview of available functions, or see below for detailed information on each function.

Typedef Documentation

DecayedTuple

template<class ... Types>

using QtConcurrent::DecayedTuple = std::tuple<std::decay_t<Types>...>

Definition at line 103 of file qtconcurrentstoredfunctioncall.h.

InvokeResultType

template<class Function, class ... Args>

using QtConcurrent::InvokeResultType = typename InvokeResult<Function, Args...>::Type

Definition at line 100 of file qtconcurrentstoredfunctioncall.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
ReduceQueueStartLimit
ReduceQueueThrottleLimit

Definition at line 50 of file qtconcurrentreducekernel.h.

FutureResult

enum class QtConcurrent::FutureResult

strong

Enumerator
Ignore

Definition at line 48 of file qtaskbuilder.h.

ReduceOption

enum QtConcurrent::ReduceOption

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

\value UnorderedReduce Reduction is done in an arbitrary order. \value OrderedReduce Reduction is done in the order of the original sequence. \value SequentialReduce Reduction is done sequentially: only one thread will enter the reduce function at a time. (Parallel reduction might be supported in a future version of Qt Concurrent.)

Enumerator
UnorderedReduce
OrderedReduce
SequentialReduce

Definition at line 67 of file qtconcurrentreducekernel.h.

ThreadFunctionResult

enum QtConcurrent::ThreadFunctionResult

Enumerator
ThrottleThread
ThreadFinished

Definition at line 45 of file qtconcurrentthreadengine.h.

Function Documentation

blockingFilter() [1/2]

template<typename Sequence, typename KeepFunctor>

void QtConcurrent::blockingFilter	(	QThreadPool *	pool,
		Sequence &	sequence,
		KeepFunctor &&	filterFunction )

Calls filterFunction once for each item in sequence.

All calls to filterFunction are invoked from the threads taken from the QThreadPool pool. If filterFunction returns true, the item is kept in sequence; otherwise, the item is removed from sequence.

Note that this method doesn't have an overload working with iterators, because it invalidates the iterators of the sequence it operates on.

Note

This function will block until all items in the sequence have been processed.

See also

{Concurrent Filter and Filter-Reduce}

Definition at line 369 of file qtconcurrentfilter.h.

blockingFilter() [2/2]

template<typename Sequence, typename KeepFunctor>

void QtConcurrent::blockingFilter	(	Sequence &	sequence,
		KeepFunctor &&	filterFunction )

Calls filterFunction once for each item in sequence.

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

Note that this method doesn't have an overload working with iterators, because it invalidates the iterators of the sequence it operates on.

Note

This function will block until all items in the sequence have been processed.

See also

{Concurrent Filter and Filter-Reduce}

Definition at line 376 of file qtconcurrentfilter.h.

blockingFiltered() [1/4]

template<typename OutputSequence, typename Iterator, typename KeepFunctor>

OutputSequence QtConcurrent::blockingFiltered	(	Iterator	begin,
		Iterator	end,
		KeepFunctor &&	filterFunction )

Calls filterFunction once for each item from begin to end and returns a new Sequence of kept items.

If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.

Note

This function will block until the iterator reaches the end of the sequence being processed.

See also

filtered(), {Concurrent Filter and Filter-Reduce}

Definition at line 707 of file qtconcurrentfilter.h.

blockingFiltered() [2/4]

template<typename OutputSequence, typename Iterator, typename KeepFunctor>

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

Calls filterFunction once for each item from begin to end and returns a new Sequence of kept items.

All calls to filterFunction are invoked from the threads taken from the QThreadPool pool. If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.

Note

This function will block until the iterator reaches the end of the sequence being processed.

See also

filtered(), {Concurrent Filter and Filter-Reduce}

Definition at line 699 of file qtconcurrentfilter.h.

blockingFiltered() [3/4]

template<typename Sequence, typename KeepFunctor>

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

Calls filterFunction once for each item in sequence and returns a new Sequence of kept items.

All calls to filterFunction are invoked from the threads taken from the QThreadPool pool. If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.

Note

This function will block until all items in the sequence have been processed.

See also

filtered(), {Concurrent Filter and Filter-Reduce}

Definition at line 682 of file qtconcurrentfilter.h.

blockingFiltered() [4/4]

template<typename Sequence, typename KeepFunctor>

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

Calls filterFunction once for each item in sequence and returns a new Sequence of kept items.

If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.

Note

This function will block until all items in the sequence have been processed.

See also

filtered(), {Concurrent Filter and Filter-Reduce}

Definition at line 690 of file qtconcurrentfilter.h.

blockingFilteredReduced() [1/13]

template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

ResultType QtConcurrent::blockingFilteredReduced	(	Iterator	begin,
		Iterator	end,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                         | SequentialReduce) )

Definition at line 594 of file qtconcurrentfilter.h.

blockingFilteredReduced() [2/13]

template<typename Iterator, typename KeepFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isIterator_v< Iterator >, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

ResultType QtConcurrent::blockingFilteredReduced	(	Iterator	begin,
		Iterator	end,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                         | SequentialReduce) )

Definition at line 665 of file qtconcurrentfilter.h.

blockingFilteredReduced() [3/13]

template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor>

ResultType QtConcurrent::blockingFilteredReduced	(	Iterator	begin,
		Iterator	end,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                         | SequentialReduce) )

Definition at line 548 of file qtconcurrentfilter.h.

blockingFilteredReduced() [4/13]

template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

ResultType QtConcurrent::blockingFilteredReduced	(	QThreadPool *	pool,
		Iterator	begin,
		Iterator	end,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                         | SequentialReduce) )

Definition at line 570 of file qtconcurrentfilter.h.

blockingFilteredReduced() [5/13]

template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor>

ResultType QtConcurrent::blockingFilteredReduced	(	QThreadPool *	pool,
		Iterator	begin,
		Iterator	end,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                         | SequentialReduce) )

Definition at line 533 of file qtconcurrentfilter.h.

blockingFilteredReduced() [6/13]

template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

ResultType QtConcurrent::blockingFilteredReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                         | SequentialReduce) )

Definition at line 419 of file qtconcurrentfilter.h.

blockingFilteredReduced() [7/13]

template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

ResultType QtConcurrent::blockingFilteredReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                         | SequentialReduce) )

Definition at line 495 of file qtconcurrentfilter.h.

blockingFilteredReduced() [8/13]

template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor>

ResultType QtConcurrent::blockingFilteredReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                         | SequentialReduce) )

Definition at line 384 of file qtconcurrentfilter.h.

blockingFilteredReduced() [9/13]

template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>

ResultType QtConcurrent::blockingFilteredReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                         | SequentialReduce) )

Definition at line 461 of file qtconcurrentfilter.h.

blockingFilteredReduced() [10/13]

template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

ResultType QtConcurrent::blockingFilteredReduced	(	Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                         | SequentialReduce) )

Definition at line 443 of file qtconcurrentfilter.h.

blockingFilteredReduced() [11/13]

template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

ResultType QtConcurrent::blockingFilteredReduced	(	Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                         | SequentialReduce) )

Definition at line 516 of file qtconcurrentfilter.h.

blockingFilteredReduced() [12/13]

template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor>

ResultType QtConcurrent::blockingFilteredReduced	(	Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                         | SequentialReduce) )

Definition at line 398 of file qtconcurrentfilter.h.

blockingFilteredReduced() [13/13]

template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>

ResultType QtConcurrent::blockingFilteredReduced	(	Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                         | SequentialReduce) )

Definition at line 477 of file qtconcurrentfilter.h.

blockingMap() [1/4]

template<typename Iterator, typename MapFunctor>

void QtConcurrent::blockingMap	(	Iterator	begin,
		Iterator	end,
		MapFunctor &&	function )

Calls function once for each item from begin to end.

The function takes a reference to the item, so that any modifications done to the item will appear in the sequence which the iterators belong to.

Note

This function will block until the iterator reaches the end of the sequence being processed.

See also

map(), {Concurrent Map and Map-Reduce}

Definition at line 420 of file qtconcurrentmap.h.

blockingMap() [2/4]

template<typename Iterator, typename MapFunctor>

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

Calls function once for each item from begin to end.

All calls to function are invoked from the threads taken from the QThreadPool pool. The function takes a reference to the item, so that any modifications done to the item will appear in the sequence which the iterators belong to.

Note

This function will block until the iterator reaches the end of the sequence being processed.

See also

map(), {Concurrent Map and Map-Reduce}

Definition at line 413 of file qtconcurrentmap.h.

blockingMap() [3/4]

template<typename Sequence, typename MapFunctor>

void QtConcurrent::blockingMap	(	QThreadPool *	pool,
		Sequence &&	sequence,
		MapFunctor	function )

Calls function once for each item in sequence.

All calls to function are invoked from the threads taken from the QThreadPool pool. The function takes a reference to the item, so that any modifications done to the item will appear in sequence.

Note

This function will block until all items in the sequence have been processed.

See also

map(), {Concurrent Map and Map-Reduce}

Definition at line 396 of file qtconcurrentmap.h.

blockingMap() [4/4]

template<typename Sequence, typename MapFunctor>

void QtConcurrent::blockingMap	(	Sequence &&	sequence,
		MapFunctor &&	function )

Calls function once for each item in sequence.

The function takes a reference to the item, so that any modifications done to the item will appear in sequence.

Note

This function will block until all items in the sequence have been processed.

See also

map(), {Concurrent Map and Map-Reduce}

Definition at line 404 of file qtconcurrentmap.h.

blockingMapped() [1/8]

template<typename OutputSequence, typename InputSequence, typename MapFunctor>

OutputSequence QtConcurrent::blockingMapped	(	InputSequence &&	sequence,
		MapFunctor &&	function )

Calls function once for each item in sequence and returns an OutputSequence containing the results.

The type of the results will match the type returned by the MapFunctor.

Note

This function will block until all items in the sequence have been processed.

See also

mapped(), {Concurrent Map and Map-Reduce}

Definition at line 756 of file qtconcurrentmap.h.

blockingMapped() [2/8]

template<typename MapFunctor, typename InputSequence>

auto QtConcurrent::blockingMapped	(	InputSequence &&	sequence,
		MapFunctor &&	map )

Definition at line 774 of file qtconcurrentmap.h.

blockingMapped() [3/8]

template<typename Sequence, typename Iterator, typename MapFunctor>

Sequence QtConcurrent::blockingMapped	(	Iterator	begin,
		Iterator	end,
		MapFunctor &&	function )

Calls function once for each item from begin to end and returns a container with the results.

You can specify the type of container as the a template argument, like this:

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

Note

This function will block until the iterator reaches the end of the sequence being processed.

See also

mapped(), {Concurrent Map and Map-Reduce}

Definition at line 793 of file qtconcurrentmap.h.

blockingMapped() [4/8]

template<typename Iterator, typename MapFunctor>

auto QtConcurrent::blockingMapped	(	Iterator	begin,
		Iterator	end,
		MapFunctor &&	map )

Definition at line 809 of file qtconcurrentmap.h.

blockingMapped() [5/8]

template<typename OutputSequence, typename InputSequence, typename MapFunctor>

OutputSequence QtConcurrent::blockingMapped	(	QThreadPool *	pool,
		InputSequence &&	sequence,
		MapFunctor &&	function )

Calls function once for each item in sequence and returns an OutputSequence containing the results.

All calls to function are invoked from the threads taken from the QThreadPool pool. The type of the results will match the type returned by the MapFunctor.

Note

This function will block until all items in the sequence have been processed.

See also

mapped(), {Concurrent Map and Map-Reduce}

Definition at line 748 of file qtconcurrentmap.h.

blockingMapped() [6/8]

template<typename MapFunctor, typename InputSequence>

auto QtConcurrent::blockingMapped	(	QThreadPool *	pool,
		InputSequence &&	sequence,
		MapFunctor &&	map )

Definition at line 764 of file qtconcurrentmap.h.

blockingMapped() [7/8]

template<typename Sequence, typename Iterator, typename MapFunctor>

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

Calls function once for each item from begin to end and returns a container with the results.

All calls to function are invoked from the threads taken from the QThreadPool pool. You can specify the type of container as the a template argument, like this:

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

Note

This function will block until the iterator reaches the end of the sequence being processed.

See also

mapped(), {Concurrent Map and Map-Reduce}

Definition at line 786 of file qtconcurrentmap.h.

blockingMapped() [8/8]

template<typename Iterator, typename MapFunctor>

auto QtConcurrent::blockingMapped	(	QThreadPool *	pool,
		Iterator	begin,
		Iterator	end,
		MapFunctor &&	map )

Definition at line 801 of file qtconcurrentmap.h.

blockingMappedReduced() [1/13]

template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

ResultType QtConcurrent::blockingMappedReduced	(	Iterator	begin,
		Iterator	end,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                       | SequentialReduce) )

Definition at line 650 of file qtconcurrentmap.h.

blockingMappedReduced() [2/13]

template<typename Iterator, typename MapFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isIterator_v< Iterator >, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

ResultType QtConcurrent::blockingMappedReduced	(	Iterator	begin,
		Iterator	end,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                       | SequentialReduce) )

Definition at line 732 of file qtconcurrentmap.h.

blockingMappedReduced() [3/13]

template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>

ResultType QtConcurrent::blockingMappedReduced	(	Iterator	begin,
		Iterator	end,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                       | SequentialReduce) )

Definition at line 603 of file qtconcurrentmap.h.

blockingMappedReduced() [4/13]

template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

ResultType QtConcurrent::blockingMappedReduced	(	QThreadPool *	pool,
		Iterator	begin,
		Iterator	end,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                       | SequentialReduce) )

Definition at line 625 of file qtconcurrentmap.h.

blockingMappedReduced() [5/13]

template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>

ResultType QtConcurrent::blockingMappedReduced	(	QThreadPool *	pool,
		Iterator	begin,
		Iterator	end,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                       | SequentialReduce) )

Definition at line 588 of file qtconcurrentmap.h.

blockingMappedReduced() [6/13]

template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

ResultType QtConcurrent::blockingMappedReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                       | SequentialReduce) )

Definition at line 466 of file qtconcurrentmap.h.

blockingMappedReduced() [7/13]

template<typename MapFunctor, typename ReduceFunctor, typename Sequence, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

ResultType QtConcurrent::blockingMappedReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                       | SequentialReduce) )

Definition at line 547 of file qtconcurrentmap.h.

blockingMappedReduced() [8/13]

template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>

ResultType QtConcurrent::blockingMappedReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                       | SequentialReduce) )

Definition at line 429 of file qtconcurrentmap.h.

blockingMappedReduced() [9/13]

template<typename MapFunctor, typename ReduceFunctor, typename Sequence, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>

ResultType QtConcurrent::blockingMappedReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                       | SequentialReduce) )

Definition at line 507 of file qtconcurrentmap.h.

blockingMappedReduced() [10/13]

template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

ResultType QtConcurrent::blockingMappedReduced	(	Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                       | SequentialReduce) )

Definition at line 490 of file qtconcurrentmap.h.

blockingMappedReduced() [11/13]

template<typename MapFunctor, typename ReduceFunctor, typename Sequence, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

ResultType QtConcurrent::blockingMappedReduced	(	Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                       | SequentialReduce) )

Definition at line 572 of file qtconcurrentmap.h.

blockingMappedReduced() [12/13]

template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>

ResultType QtConcurrent::blockingMappedReduced	(	Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                       | SequentialReduce) )

Definition at line 444 of file qtconcurrentmap.h.

blockingMappedReduced() [13/13]

template<typename MapFunctor, typename ReduceFunctor, typename Sequence, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>

ResultType QtConcurrent::blockingMappedReduced	(	Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                       | SequentialReduce) )

Definition at line 524 of file qtconcurrentmap.h.

filter() [1/2]

template<typename Sequence, typename KeepFunctor>

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

Calls filterFunction once for each item in sequence.

All calls to filterFunction are invoked from the threads taken from the QThreadPool pool. If filterFunction returns true, the item is kept in sequence; otherwise, the item is removed from sequence.

Note that this method doesn't have an overload working with iterators, because it invalidates the iterators of the sequence it operates on.

See also

{Concurrent Filter and Filter-Reduce}

Definition at line 36 of file qtconcurrentfilter.h.

filter() [2/2]

template<typename Sequence, typename KeepFunctor>

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

Calls filterFunction once for each item in sequence.

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

Note that this method doesn't have an overload working with iterators, because it invalidates the iterators of the sequence it operates on.

See also

{Concurrent Filter and Filter-Reduce}

Definition at line 43 of file qtconcurrentfilter.h.

filtered() [1/4]

template<typename Iterator, typename KeepFunctor>

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

Calls filterFunction once for each item from begin to end and returns a new Sequence of kept items.

If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.

See also

{Concurrent Filter and Filter-Reduce}

Definition at line 359 of file qtconcurrentfilter.h.

filtered() [2/4]

template<typename Iterator, typename KeepFunctor>

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

Calls filterFunction once for each item from begin to end and returns a new Sequence of kept items.

All calls to filterFunction are invoked from the threads taken from the QThreadPool pool. If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.

See also

{Concurrent Filter and Filter-Reduce}

Definition at line 350 of file qtconcurrentfilter.h.

filtered() [3/4]

template<typename Sequence, typename KeepFunctor>

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

Calls filterFunction once for each item in sequence and returns a new Sequence of kept items.

All calls to filterFunction are invoked from the threads taken from the QThreadPool pool. If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.

See also

{Concurrent Filter and Filter-Reduce}

Definition at line 334 of file qtconcurrentfilter.h.

filtered() [4/4]

template<typename Sequence, typename KeepFunctor>

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

Calls filterFunction once for each item in sequence and returns a new Sequence of kept items.

If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.

See also

{Concurrent Filter and Filter-Reduce}

Definition at line 341 of file qtconcurrentfilter.h.

filteredReduced() [1/13]

template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

QFuture< ResultType > QtConcurrent::filteredReduced	(	Iterator	begin,
		Iterator	end,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                          | SequentialReduce) )

Definition at line 249 of file qtconcurrentfilter.h.

filteredReduced() [2/13]

template<typename Iterator, typename KeepFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isIterator_v< Iterator >, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

QFuture< ResultType > QtConcurrent::filteredReduced	(	Iterator	begin,
		Iterator	end,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                          | SequentialReduce) )

Definition at line 317 of file qtconcurrentfilter.h.

filteredReduced() [3/13]

template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor>

QFuture< ResultType > QtConcurrent::filteredReduced	(	Iterator	begin,
		Iterator	end,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                          | SequentialReduce) )

Definition at line 205 of file qtconcurrentfilter.h.

filteredReduced() [4/13]

template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

QFuture< ResultType > QtConcurrent::filteredReduced	(	QThreadPool *	pool,
		Iterator	begin,
		Iterator	end,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                          | SequentialReduce) )

Definition at line 226 of file qtconcurrentfilter.h.

filteredReduced() [5/13]

template<typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor>

QFuture< ResultType > QtConcurrent::filteredReduced	(	QThreadPool *	pool,
		Iterator	begin,
		Iterator	end,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                          | SequentialReduce) )

Definition at line 192 of file qtconcurrentfilter.h.

filteredReduced() [6/13]

template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

QFuture< ResultType > QtConcurrent::filteredReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                          | SequentialReduce) )

Definition at line 84 of file qtconcurrentfilter.h.

filteredReduced() [7/13]

template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

QFuture< ResultType > QtConcurrent::filteredReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                          | SequentialReduce) )

Definition at line 156 of file qtconcurrentfilter.h.

filteredReduced() [8/13]

template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor>

QFuture< ResultType > QtConcurrent::filteredReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                          | SequentialReduce) )

Definition at line 51 of file qtconcurrentfilter.h.

filteredReduced() [9/13]

template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>

QFuture< ResultType > QtConcurrent::filteredReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                          | SequentialReduce) )

Definition at line 124 of file qtconcurrentfilter.h.

filteredReduced() [10/13]

template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

QFuture< ResultType > QtConcurrent::filteredReduced	(	Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                          | SequentialReduce) )

Definition at line 107 of file qtconcurrentfilter.h.

filteredReduced() [11/13]

template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

QFuture< ResultType > QtConcurrent::filteredReduced	(	Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                          | SequentialReduce) )

Definition at line 176 of file qtconcurrentfilter.h.

filteredReduced() [12/13]

template<typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor>

QFuture< ResultType > QtConcurrent::filteredReduced	(	Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                          | SequentialReduce) )

Definition at line 64 of file qtconcurrentfilter.h.

filteredReduced() [13/13]

template<typename Sequence, typename KeepFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isInvocable< KeepFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>

QFuture< ResultType > QtConcurrent::filteredReduced	(	Sequence &&	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                          | SequentialReduce) )

Definition at line 139 of file qtconcurrentfilter.h.

filterInternal()

template<typename Sequence, typename KeepFunctor, typename ReduceFunctor>

ThreadEngineStarter< void > QtConcurrent::filterInternal	(	QThreadPool *	pool,
		Sequence &	sequence,
		KeepFunctor &&	keep,
		ReduceFunctor &&	reduce )

[QtConcurrent-1]

Definition at line 25 of file qtconcurrentfilter.h.

map() [1/4]

template<typename Iterator, typename MapFunctor>

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

Calls function once for each item from begin to end.

The function takes a reference to the item, so that any modifications done to the item will appear in the sequence which the iterators belong to.

See also

{Concurrent Map and Map-Reduce}

Definition at line 48 of file qtconcurrentmap.h.

map() [2/4]

template<typename Iterator, typename MapFunctor>

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

Calls function once for each item from begin to end.

All calls to function are invoked from the threads taken from the QThreadPool pool. The function takes a reference to the item, so that any modifications done to the item will appear in the sequence which the iterators belong to.

See also

{Concurrent Map and Map-Reduce}

Definition at line 42 of file qtconcurrentmap.h.

map() [3/4]

template<typename Sequence, typename MapFunctor>

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

Calls function once for each item in sequence.

All calls to function are invoked from the threads taken from the QThreadPool pool. The function takes a reference to the item, so that any modifications done to the item will appear in sequence.

See also

{Concurrent Map and Map-Reduce}

Definition at line 28 of file qtconcurrentmap.h.

map() [4/4]

template<typename Sequence, typename MapFunctor>

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

Calls function once for each item in sequence.

The function takes a reference to the item, so that any modifications done to the item will appear in sequence.

See also

{Concurrent Map and Map-Reduce}

Definition at line 34 of file qtconcurrentmap.h.

mapped() [1/4]

template<typename Iterator, typename MapFunctor>

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

Definition at line 385 of file qtconcurrentmap.h.

mapped() [2/4]

template<typename Iterator, typename MapFunctor>

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

Definition at line 374 of file qtconcurrentmap.h.

mapped() [3/4]

template<typename Sequence, typename MapFunctor>

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

Definition at line 353 of file qtconcurrentmap.h.

mapped() [4/4]

template<typename Sequence, typename MapFunctor>

QFuture< QtPrivate::MapResultType< Sequence, MapFunctor > > QtConcurrent::mapped	(	Sequence &&	sequence,
		MapFunctor &&	map )

Definition at line 363 of file qtconcurrentmap.h.

mappedReduced() [1/13]

template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

QFuture< ResultType > QtConcurrent::mappedReduced	(	Iterator	begin,
		Iterator	end,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                        | SequentialReduce) )

Definition at line 259 of file qtconcurrentmap.h.

mappedReduced() [2/13]

template<typename Iterator, typename MapFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isIterator_v< Iterator >, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

QFuture< ResultType > QtConcurrent::mappedReduced	(	Iterator	begin,
		Iterator	end,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                        | SequentialReduce) )

Definition at line 337 of file qtconcurrentmap.h.

mappedReduced() [3/13]

template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>

QFuture< ResultType > QtConcurrent::mappedReduced	(	Iterator	begin,
		Iterator	end,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                        | SequentialReduce) )

Definition at line 215 of file qtconcurrentmap.h.

mappedReduced() [4/13]

template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

QFuture< ResultType > QtConcurrent::mappedReduced	(	QThreadPool *	pool,
		Iterator	begin,
		Iterator	end,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                        | SequentialReduce) )

Definition at line 236 of file qtconcurrentmap.h.

mappedReduced() [5/13]

template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>

QFuture< ResultType > QtConcurrent::mappedReduced	(	QThreadPool *	pool,
		Iterator	begin,
		Iterator	end,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                        | SequentialReduce) )

Definition at line 201 of file qtconcurrentmap.h.

mappedReduced() [6/13]

template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

QFuture< ResultType > QtConcurrent::mappedReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                        | SequentialReduce) )

Definition at line 88 of file qtconcurrentmap.h.

mappedReduced() [7/13]

template<typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

QFuture< ResultType > QtConcurrent::mappedReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                        | SequentialReduce) )

Definition at line 162 of file qtconcurrentmap.h.

mappedReduced() [8/13]

template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>

QFuture< ResultType > QtConcurrent::mappedReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                        | SequentialReduce) )

Definition at line 55 of file qtconcurrentmap.h.

mappedReduced() [9/13]

template<typename Sequence, typename MapFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>

QFuture< ResultType > QtConcurrent::mappedReduced	(	QThreadPool *	pool,
		Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                        | SequentialReduce) )

Definition at line 126 of file qtconcurrentmap.h.

mappedReduced() [10/13]

template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

QFuture< ResultType > QtConcurrent::mappedReduced	(	Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                        | SequentialReduce) )

Definition at line 110 of file qtconcurrentmap.h.

mappedReduced() [11/13]

template<typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type, std::enable_if_t< QtPrivate::isInitialValueCompatible_v< InitialValueType, ResultType >, int > = 0>

QFuture< ResultType > QtConcurrent::mappedReduced	(	Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		InitialValueType &&	initialValue,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                        | SequentialReduce) )

Definition at line 186 of file qtconcurrentmap.h.

mappedReduced() [12/13]

template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>

QFuture< ResultType > QtConcurrent::mappedReduced	(	Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                        | SequentialReduce) )

Definition at line 68 of file qtconcurrentmap.h.

mappedReduced() [13/13]

template<typename Sequence, typename MapFunctor, typename ReduceFunctor, std::enable_if_t< QtPrivate::isInvocable< MapFunctor, Sequence >::value, int > = 0, typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>

QFuture< ResultType > QtConcurrent::mappedReduced	(	Sequence &&	sequence,
		MapFunctor &&	map,
		ReduceFunctor &&	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce                                                                        | SequentialReduce) )

Definition at line 141 of file qtconcurrentmap.h.

run() [1/5]

template<class Function, class ... Args>

QTCONCURRENT_RUN_NODISCARD auto QtConcurrent::run	(	Function &&	f,
		Args &&...	args )

Definition at line 63 of file qtconcurrentrun.h.

run() [2/5]

template<class PromiseType, class Function, class ... Args>

QTCONCURRENT_RUN_NODISCARD auto QtConcurrent::run	(	Function &&	f,
		Args &&...	args )

Definition at line 81 of file qtconcurrentrun.h.

run() [3/5]

template<class Function, class ... Args>

QTCONCURRENT_RUN_NODISCARD auto QtConcurrent::run	(	QThreadPool *	pool,
		Function &&	f,
		Args &&...	args )

Definition at line 44 of file qtconcurrentrun.h.

run() [4/5]

template<class PromiseType, class Function, class ... Args>

QTCONCURRENT_RUN_NODISCARD auto QtConcurrent::run	(	QThreadPool *	pool,
		Function &&	f,
		Args &&...	args )

Definition at line 72 of file qtconcurrentrun.h.

run() [5/5]

template<class Function, class ... Args>

QTCONCURRENT_RUN_NODISCARD auto QtConcurrent::run	(	QThreadPool *	pool,
		std::reference_wrapper< const Function > &&	functionWrapper,
		Args &&...	args )

Definition at line 54 of file qtconcurrentrun.h.

selectIteration() [1/3]

bool QtConcurrent::selectIteration ( std::bidirectional_iterator_tag )

inline

Definition at line 131 of file qtconcurrentiteratekernel.h.

selectIteration() [2/3]

bool QtConcurrent::selectIteration ( std::forward_iterator_tag )

inline

Definition at line 136 of file qtconcurrentiteratekernel.h.

selectIteration() [3/3]

bool QtConcurrent::selectIteration ( std::random_access_iterator_tag )

inline

Definition at line 141 of file qtconcurrentiteratekernel.h.

startFiltered() [1/2]

template<typename Iterator, typename KeepFunctor>

ThreadEngineStarter< typename qValueType< Iterator >::value_type > QtConcurrent::startFiltered ( QThreadPool * pool, Iterator begin, Iterator end, KeepFunctor && functor )

inline

[QtConcurrent-2]

Definition at line 271 of file qtconcurrentfilterkernel.h.

startFiltered() [2/2]

template<typename Sequence, typename KeepFunctor>

decltype(auto) QtConcurrent::startFiltered ( QThreadPool * pool, Sequence && sequence, KeepFunctor && functor )

inline

[QtConcurrent-3]

Definition at line 279 of file qtconcurrentfilterkernel.h.

startFilteredReduced() [1/4]

template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>

ThreadEngineStarter< ResultType > QtConcurrent::startFilteredReduced ( QThreadPool * pool, Iterator begin, Iterator end, MapFunctor && mapFunctor, ReduceFunctor && reduceFunctor, ReduceOptions options )

inline

[QtConcurrent-5]

Definition at line 317 of file qtconcurrentfilterkernel.h.

startFilteredReduced() [2/4]

template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>

ThreadEngineStarter< ResultType > QtConcurrent::startFilteredReduced ( QThreadPool * pool, Iterator begin, Iterator end, MapFunctor && mapFunctor, ReduceFunctor && reduceFunctor, ResultType && initialValue, ReduceOptions options )

inline

[QtConcurrent-7]

Definition at line 361 of file qtconcurrentfilterkernel.h.

startFilteredReduced() [3/4]

template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>

ThreadEngineStarter< ResultType > QtConcurrent::startFilteredReduced ( QThreadPool * pool, Sequence && sequence, MapFunctor && mapFunctor, ReduceFunctor && reduceFunctor, ReduceOptions options )

inline

[QtConcurrent-4]

Definition at line 292 of file qtconcurrentfilterkernel.h.

startFilteredReduced() [4/4]

template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>

ThreadEngineStarter< ResultType > QtConcurrent::startFilteredReduced ( QThreadPool * pool, Sequence && sequence, MapFunctor && mapFunctor, ReduceFunctor && reduceFunctor, ResultType && initialValue, ReduceOptions options )

inline

[QtConcurrent-6]

Definition at line 336 of file qtconcurrentfilterkernel.h.

startMap()

template<typename Iterator, typename Functor>

ThreadEngineStarter< void > QtConcurrent::startMap ( QThreadPool * pool, Iterator begin, Iterator end, Functor && functor )

inline

[qtconcurrentmapkernel-1]

Definition at line 177 of file qtconcurrentmapkernel.h.

startMapped() [1/2]

template<typename T, typename Iterator, typename Functor>

ThreadEngineStarter< T > QtConcurrent::startMapped ( QThreadPool * pool, Iterator begin, Iterator end, Functor && functor )

inline

[qtconcurrentmapkernel-2]

Definition at line 186 of file qtconcurrentmapkernel.h.

startMapped() [2/2]

template<typename T, typename Sequence, typename Functor>

ThreadEngineStarter< T > QtConcurrent::startMapped ( QThreadPool * pool, Sequence && sequence, Functor && functor )

inline

[qtconcurrentmapkernel-3]

Definition at line 217 of file qtconcurrentmapkernel.h.

startMappedReduced() [1/4]

template<typename IntermediateType, typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>

ThreadEngineStarter< ResultType > QtConcurrent::startMappedReduced ( QThreadPool * pool, Iterator begin, Iterator end, MapFunctor && mapFunctor, ReduceFunctor && reduceFunctor, ReduceOptions options )

inline

[qtconcurrentmapkernel-5]

Definition at line 258 of file qtconcurrentmapkernel.h.

startMappedReduced() [2/4]

template<typename IntermediateType, typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>

ThreadEngineStarter< ResultType > QtConcurrent::startMappedReduced ( QThreadPool * pool, Iterator begin, Iterator end, MapFunctor && mapFunctor, ReduceFunctor && reduceFunctor, ResultType && initialValue, ReduceOptions options )

inline

[qtconcurrentmapkernel-7]

Definition at line 304 of file qtconcurrentmapkernel.h.

startMappedReduced() [3/4]

template<typename IntermediateType, typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>

ThreadEngineStarter< ResultType > QtConcurrent::startMappedReduced ( QThreadPool * pool, Sequence && sequence, MapFunctor && mapFunctor, ReduceFunctor && reduceFunctor, ReduceOptions options )

inline

[qtconcurrentmapkernel-4]

Definition at line 234 of file qtconcurrentmapkernel.h.

startMappedReduced() [4/4]

template<typename IntermediateType, typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>

ThreadEngineStarter< ResultType > QtConcurrent::startMappedReduced ( QThreadPool * pool, Sequence && sequence, MapFunctor && mapFunctor, ReduceFunctor && reduceFunctor, ResultType && initialValue, ReduceOptions options )

inline

[qtconcurrentmapkernel-6]

Definition at line 278 of file qtconcurrentmapkernel.h.

startThreadEngine()

template<typename ThreadEngine>

ThreadEngineStarter< typename ThreadEngine::ResultType > QtConcurrent::startThreadEngine ( ThreadEngine * threadEngine )

inline

[qtconcurrentthreadengine-1]

Definition at line 212 of file qtconcurrentthreadengine.h.

task()

template<class Task>

auto QtConcurrent::task ( Task && t )

nodiscardconstexpr

Definition at line 34 of file qtconcurrenttask.h.