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 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...
enum	ThreadFunctionResult { ThrottleThread , ThreadFinished }

Functions
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]
bool	selectIteration (std::bidirectional_iterator_tag)
bool	selectIteration (std::forward_iterator_tag)
bool	selectIteration (std::random_access_iterator_tag)
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)
template<typename ThreadEngine >
ThreadEngineStarter< typename ThreadEngine::ResultType >	startThreadEngine (ThreadEngine *threadEngine)
	[qtconcurrentthreadengine-1]

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.

\inheaderfile QtConcurrent

Typedef Documentation

DecayedTuple

template<class ... Types>

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

Definition at line 102 of file qtconcurrentstoredfunctioncall.h.

InvokeResultType

template<class Function , class ... Args>

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

Definition at line 99 of file qtconcurrentstoredfunctioncall.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
ReduceQueueStartLimit
ReduceQueueThrottleLimit

Definition at line 49 of file qtconcurrentreducekernel.h.

FutureResult

enum class QtConcurrent::FutureResult

strong

Enumerator
Ignore

Definition at line 47 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 66 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 >

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 368 of file qtconcurrentfilter.h.

References future, pool, and QFuture< T >::waitForFinished().

Here is the call graph for this function:

blockingFilter() [2/2]

template<typename Sequence , typename KeepFunctor >

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 375 of file qtconcurrentfilter.h.

References future, and QFuture< T >::waitForFinished().

Here is the call graph for this function:

blockingFiltered() [1/4]

template<typename OutputSequence , typename Iterator , typename KeepFunctor >

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 706 of file qtconcurrentfilter.h.

References begin(), QThreadPool::globalInstance(), and OrderedReduce.

Here is the call graph for this function:

blockingFiltered() [2/4]

template<typename OutputSequence , typename Iterator , typename KeepFunctor >

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 698 of file qtconcurrentfilter.h.

References begin(), OrderedReduce, and pool.

Here is the call graph for this function:

blockingFiltered() [3/4]

template<typename Sequence , typename KeepFunctor >

template< typename Sequence, typename KeepFunctor > 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 681 of file qtconcurrentfilter.h.

References OrderedReduce, and pool.

blockingFiltered() [4/4]

template<typename Sequence , typename KeepFunctor >

template< typename Sequence, typename KeepFunctor > 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 689 of file qtconcurrentfilter.h.

References QThreadPool::globalInstance(), and OrderedReduce.

Here is the call graph for this function:

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 593 of file qtconcurrentfilter.h.

References begin(), future, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 664 of file qtconcurrentfilter.h.

References begin(), future, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 547 of file qtconcurrentfilter.h.

References begin(), future, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 569 of file qtconcurrentfilter.h.

References begin(), future, pool, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 532 of file qtconcurrentfilter.h.

References begin(), future, pool, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 418 of file qtconcurrentfilter.h.

References future, pool, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 494 of file qtconcurrentfilter.h.

References future, pool, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 383 of file qtconcurrentfilter.h.

References future, pool, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 460 of file qtconcurrentfilter.h.

References future, pool, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 442 of file qtconcurrentfilter.h.

References future, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 515 of file qtconcurrentfilter.h.

References future, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 397 of file qtconcurrentfilter.h.

References future, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 476 of file qtconcurrentfilter.h.

References future, and QFuture< T >::takeResult().

Here is the call graph for this function:

blockingMap() [1/4]

template<typename Iterator , typename MapFunctor >

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 419 of file qtconcurrentmap.h.

References begin(), future, QThreadPool::globalInstance(), map, startMap(), and QFuture< T >::waitForFinished().

Here is the call graph for this function:

blockingMap() [2/4]

template<typename Iterator , typename MapFunctor >

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 412 of file qtconcurrentmap.h.

References begin(), future, map, pool, startMap(), and QFuture< T >::waitForFinished().

Here is the call graph for this function:

blockingMap() [3/4]

template<typename Sequence , typename MapFunctor >

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 395 of file qtconcurrentmap.h.

References future, map, pool, startMap(), and QFuture< T >::waitForFinished().

Here is the call graph for this function:

blockingMap() [4/4]

template<typename Sequence , typename MapFunctor >

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 403 of file qtconcurrentmap.h.

References future, QThreadPool::globalInstance(), map, startMap(), and QFuture< T >::waitForFinished().

Here is the call graph for this function:

blockingMapped() [1/8]

template<typename OutputSequence , typename InputSequence , typename MapFunctor >

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 755 of file qtconcurrentmap.h.

References QThreadPool::globalInstance(), map, and OrderedReduce.

Here is the call graph for this function:

blockingMapped() [2/8]

template<typename MapFunctor , typename InputSequence >

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

Definition at line 773 of file qtconcurrentmap.h.

References QThreadPool::globalInstance(), map, and OrderedReduce.

Here is the call graph for this function:

blockingMapped() [3/8]

template<typename Sequence , typename Iterator , typename MapFunctor >

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 792 of file qtconcurrentmap.h.

References begin(), QThreadPool::globalInstance(), map, and OrderedReduce.

Here is the call graph for this function:

blockingMapped() [4/8]

template<typename Iterator , typename MapFunctor >

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

Definition at line 808 of file qtconcurrentmap.h.

References begin(), QThreadPool::globalInstance(), map, and OrderedReduce.

Here is the call graph for this function:

blockingMapped() [5/8]

template<typename OutputSequence , typename InputSequence , typename MapFunctor >

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 747 of file qtconcurrentmap.h.

References map, OrderedReduce, and pool.

blockingMapped() [6/8]

template<typename MapFunctor , typename InputSequence >

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

Definition at line 763 of file qtconcurrentmap.h.

References map, OrderedReduce, and pool.

blockingMapped() [7/8]

template<typename Sequence , typename Iterator , typename MapFunctor >

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 785 of file qtconcurrentmap.h.

References begin(), map, OrderedReduce, and pool.

Here is the call graph for this function:

blockingMapped() [8/8]

template<typename Iterator , typename MapFunctor >

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

Definition at line 800 of file qtconcurrentmap.h.

References begin(), map, OrderedReduce, and pool.

Here is the call graph for this function:

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 649 of file qtconcurrentmap.h.

References begin(), future, map, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 731 of file qtconcurrentmap.h.

References begin(), future, map, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 602 of file qtconcurrentmap.h.

References begin(), future, map, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 624 of file qtconcurrentmap.h.

References begin(), future, map, pool, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 587 of file qtconcurrentmap.h.

References begin(), future, map, pool, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 465 of file qtconcurrentmap.h.

References future, map, pool, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 546 of file qtconcurrentmap.h.

References future, map, pool, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 428 of file qtconcurrentmap.h.

References future, map, pool, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 506 of file qtconcurrentmap.h.

References future, map, pool, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 489 of file qtconcurrentmap.h.

References future, map, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 571 of file qtconcurrentmap.h.

References future, map, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 443 of file qtconcurrentmap.h.

References future, map, and QFuture< T >::takeResult().

Here is the call graph for this function:

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 523 of file qtconcurrentmap.h.

References future, map, and QFuture< T >::takeResult().

Here is the call graph for this function:

filter() [1/2]

template<typename Sequence , typename KeepFunctor >

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 35 of file qtconcurrentfilter.h.

References filterInternal(), and pool.

Here is the call graph for this function:

filter() [2/2]

template<typename Sequence , typename KeepFunctor >

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 42 of file qtconcurrentfilter.h.

References filterInternal(), and QThreadPool::globalInstance().

Here is the call graph for this function:

filtered() [1/4]

template<typename Iterator , typename KeepFunctor >

template< typename Iterator, typename KeepFunctor > QFuture< typename QtConcurrent::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 358 of file qtconcurrentfilter.h.

References begin(), QThreadPool::globalInstance(), and startFiltered().

Here is the call graph for this function:

filtered() [2/4]

template<typename Iterator , typename KeepFunctor >

template< typename Iterator, typename KeepFunctor > QFuture< typename QtConcurrent::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 349 of file qtconcurrentfilter.h.

References begin(), pool, and startFiltered().

Here is the call graph for this function:

filtered() [3/4]

template<typename Sequence , typename KeepFunctor >

template< typename Sequence, typename KeepFunctor > QFuture< 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 333 of file qtconcurrentfilter.h.

References pool, and startFiltered().

Here is the call graph for this function:

filtered() [4/4]

template<typename Sequence , typename KeepFunctor >

template< typename Sequence, typename KeepFunctor > QFuture< 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 340 of file qtconcurrentfilter.h.

References QThreadPool::globalInstance(), and startFiltered().

Here is the call graph for this function:

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 248 of file qtconcurrentfilter.h.

References begin(), and QThreadPool::globalInstance().

Here is the call graph for this function:

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 316 of file qtconcurrentfilter.h.

References begin(), and QThreadPool::globalInstance().

Here is the call graph for this function:

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 204 of file qtconcurrentfilter.h.

References begin(), and QThreadPool::globalInstance().

Here is the call graph for this function:

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 225 of file qtconcurrentfilter.h.

References begin(), and pool.

Here is the call graph for this function:

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 191 of file qtconcurrentfilter.h.

References begin(), and pool.

Here is the call graph for this function:

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 83 of file qtconcurrentfilter.h.

References pool.

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 155 of file qtconcurrentfilter.h.

References pool.

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 50 of file qtconcurrentfilter.h.

References pool.

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 123 of file qtconcurrentfilter.h.

References pool.

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 106 of file qtconcurrentfilter.h.

References QThreadPool::globalInstance().

Here is the call graph for this function:

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 175 of file qtconcurrentfilter.h.

References QThreadPool::globalInstance().

Here is the call graph for this function:

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 63 of file qtconcurrentfilter.h.

References QThreadPool::globalInstance().

Here is the call graph for this function:

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 138 of file qtconcurrentfilter.h.

References QThreadPool::globalInstance().

Here is the call graph for this function:

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 24 of file qtconcurrentfilter.h.

References pool, and startThreadEngine().

Referenced by filter(), and filter().

Here is the call graph for this function:

Here is the caller graph for this function:

map() [1/4]

template<typename Iterator , typename MapFunctor >

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 47 of file qtconcurrentmap.h.

References begin(), QThreadPool::globalInstance(), map, and startMap().

Here is the call graph for this function:

map() [2/4]

template<typename Iterator , typename MapFunctor >

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 41 of file qtconcurrentmap.h.

References begin(), map, pool, and startMap().

Here is the call graph for this function:

map() [3/4]

template<typename Sequence , typename MapFunctor >

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 27 of file qtconcurrentmap.h.

References map, pool, and startMap().

Referenced by someFunction().

Here is the call graph for this function:

Here is the caller graph for this function:

map() [4/4]

template<typename Sequence , typename MapFunctor >

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 33 of file qtconcurrentmap.h.

References QThreadPool::globalInstance(), map, and startMap().

Here is the call graph for this function:

mapped() [1/4]

template<typename Iterator , typename MapFunctor >

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

Definition at line 384 of file qtconcurrentmap.h.

References begin(), QThreadPool::globalInstance(), and map.

Here is the call graph for this function:

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 373 of file qtconcurrentmap.h.

References begin(), map, and pool.

Here is the call graph for this function:

mapped() [3/4]

template<typename Sequence , typename MapFunctor >

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

Definition at line 352 of file qtconcurrentmap.h.

References map, and pool.

mapped() [4/4]

template<typename Sequence , typename MapFunctor >

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

Definition at line 362 of file qtconcurrentmap.h.

References QThreadPool::globalInstance(), and map.

Here is the call graph for this function:

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 258 of file qtconcurrentmap.h.

References begin(), QThreadPool::globalInstance(), and map.

Here is the call graph for this function:

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 336 of file qtconcurrentmap.h.

References begin(), QThreadPool::globalInstance(), and map.

Here is the call graph for this function:

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 214 of file qtconcurrentmap.h.

References begin(), QThreadPool::globalInstance(), and map.

Here is the call graph for this function:

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 235 of file qtconcurrentmap.h.

References begin(), map, and pool.

Here is the call graph for this function:

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 200 of file qtconcurrentmap.h.

References begin(), map, and pool.

Here is the call graph for this function:

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 87 of file qtconcurrentmap.h.

References map, and pool.

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 161 of file qtconcurrentmap.h.

References map, and pool.

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 54 of file qtconcurrentmap.h.

References map, and pool.

Referenced by if().

Here is the caller graph for this function:

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 125 of file qtconcurrentmap.h.

References map, and pool.

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 109 of file qtconcurrentmap.h.

References QThreadPool::globalInstance(), and map.

Here is the call graph for this function:

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 185 of file qtconcurrentmap.h.

References QThreadPool::globalInstance(), and map.

Here is the call graph for this function:

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 67 of file qtconcurrentmap.h.

References QThreadPool::globalInstance(), and map.

Here is the call graph for this function:

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 140 of file qtconcurrentmap.h.

References QThreadPool::globalInstance(), and map.

Here is the call graph for this function:

run() [1/5]

template<class Function , class ... Args>

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

Definition at line 62 of file qtconcurrentrun.h.

References args, QThreadPool::globalInstance(), and run().

Here is the call graph for this function:

run() [2/5]

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

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

Definition at line 80 of file qtconcurrentrun.h.

References args, and QThreadPool::globalInstance().

Here is the call graph for this function:

run() [3/5]

template<class Function , class ... Args>

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

Definition at line 43 of file qtconcurrentrun.h.

References args, pool, and run().

Referenced by if(), run(), run(), run(), QFFmpegMediaPlayer::setMedia(), someFunction(), and QtConcurrent::QTaskBuilder< Task, Args >::spawn().

Here is the call graph for this function:

Here is the caller graph for this function:

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 71 of file qtconcurrentrun.h.

References args, and pool.

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 53 of file qtconcurrentrun.h.

References args, pool, and run().

Here is the call graph for this function:

selectIteration() [1/3]

bool QtConcurrent::selectIteration ( std::bidirectional_iterator_tag )

inline

Definition at line 130 of file qtconcurrentiteratekernel.h.

selectIteration() [2/3]

bool QtConcurrent::selectIteration ( std::forward_iterator_tag )

inline

Definition at line 135 of file qtconcurrentiteratekernel.h.

selectIteration() [3/3]

bool QtConcurrent::selectIteration ( std::random_access_iterator_tag )

inline

Definition at line 140 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 270 of file qtconcurrentfilterkernel.h.

References begin(), pool, and startThreadEngine().

Referenced by filtered(), filtered(), filtered(), and filtered().

Here is the call graph for this function:

Here is the caller graph for this function:

startFiltered() [2/2]

template<typename Sequence , typename KeepFunctor >

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

inline

[QtConcurrent-3]

Definition at line 278 of file qtconcurrentfilterkernel.h.

References pool, and startThreadEngine().

Here is the call graph for this function:

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 316 of file qtconcurrentfilterkernel.h.

References begin(), pool, and startThreadEngine().

Here is the call graph for this function:

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 360 of file qtconcurrentfilterkernel.h.

References begin(), pool, and startThreadEngine().

Here is the call graph for this function:

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 291 of file qtconcurrentfilterkernel.h.

References pool, and startThreadEngine().

Here is the call graph for this function:

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 335 of file qtconcurrentfilterkernel.h.

References pool, and startThreadEngine().

Here is the call graph for this function:

startMap()

template<typename Iterator , typename Functor >

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

inline

[qtconcurrentmapkernel-1]

Definition at line 176 of file qtconcurrentmapkernel.h.

References begin(), pool, and startThreadEngine().

Referenced by blockingMap(), blockingMap(), blockingMap(), blockingMap(), map(), map(), map(), and map().

Here is the call graph for this function:

Here is the caller graph for this function:

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 185 of file qtconcurrentmapkernel.h.

References begin(), pool, and startThreadEngine().

Here is the call graph for this function:

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 216 of file qtconcurrentmapkernel.h.

References pool, and startThreadEngine().

Here is the call graph for this function:

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 257 of file qtconcurrentmapkernel.h.

References begin(), pool, and startThreadEngine().

Here is the call graph for this function:

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 303 of file qtconcurrentmapkernel.h.

References begin(), pool, and startThreadEngine().

Here is the call graph for this function:

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 233 of file qtconcurrentmapkernel.h.

References pool, and startThreadEngine().

Here is the call graph for this function:

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 277 of file qtconcurrentmapkernel.h.

References pool, and startThreadEngine().

Here is the call graph for this function:

startThreadEngine()

template<typename ThreadEngine >

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

inline

[qtconcurrentthreadengine-1]

Definition at line 212 of file qtconcurrentthreadengine.h.

Referenced by filterInternal(), startFiltered(), startFiltered(), startFilteredReduced(), startFilteredReduced(), startFilteredReduced(), startFilteredReduced(), startMap(), startMapped(), startMapped(), startMappedReduced(), startMappedReduced(), startMappedReduced(), and startMappedReduced().

Here is the caller graph for this function:

task()

template<class Task >

constexpr auto QtConcurrent::task ( Task && t )

constexpr

Definition at line 29 of file qtconcurrenttask.h.