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

Classes
class	BlockSizeManager

class	BlockSizeManagerV2

class	ConstMemberFunctionWrapper

class	FilteredEachKernel

class	FilteredReducedKernel

class	FilterKernel

class	FunctionWrapper0

class	FunctionWrapper1

class	FunctionWrapper2

class	IntermediateResults

class	IterateKernel

class	MapKernel

class	MappedEachKernel

class	MappedReducedKernel

class	Median

class	MedianDouble

class	MemberFunctionWrapper

class	MemberFunctionWrapper1

class	qValueType

struct	qValueType< const T * >

class	qValueType< const T *>

struct	qValueType< T * >

class	qValueType< T *>

class	ReduceKernel

class	ResultReporter

class	ResultReporter< void >

class	RunFunctionTask

class	RunFunctionTask< void >

class	RunFunctionTaskBase

struct	SelectSpecialization

struct	SelectSpecialization< void >

struct	SelectStoredConstMemberFunctionCall0

struct	SelectStoredConstMemberFunctionCall1

struct	SelectStoredConstMemberFunctionCall2

struct	SelectStoredConstMemberFunctionCall3

struct	SelectStoredConstMemberFunctionCall4

struct	SelectStoredConstMemberFunctionCall5

struct	SelectStoredConstMemberFunctionPointerCall0

struct	SelectStoredConstMemberFunctionPointerCall1

struct	SelectStoredConstMemberFunctionPointerCall2

struct	SelectStoredConstMemberFunctionPointerCall3

struct	SelectStoredConstMemberFunctionPointerCall4

struct	SelectStoredConstMemberFunctionPointerCall5

struct	SelectStoredFunctorPointerCall0

struct	SelectStoredFunctorPointerCall1

struct	SelectStoredFunctorPointerCall2

struct	SelectStoredFunctorPointerCall3

struct	SelectStoredFunctorPointerCall4

struct	SelectStoredFunctorPointerCall5

struct	SelectStoredMemberFunctionCall0

struct	SelectStoredMemberFunctionCall1

struct	SelectStoredMemberFunctionCall2

struct	SelectStoredMemberFunctionCall3

struct	SelectStoredMemberFunctionCall4

struct	SelectStoredMemberFunctionCall5

struct	SelectStoredMemberFunctionPointerCall0

struct	SelectStoredMemberFunctionPointerCall1

struct	SelectStoredMemberFunctionPointerCall2

struct	SelectStoredMemberFunctionPointerCall3

struct	SelectStoredMemberFunctionPointerCall4

struct	SelectStoredMemberFunctionPointerCall5

class	SequenceHolder1

class	SequenceHolder2

class	StoredConstMemberFunctionCall0

class	StoredConstMemberFunctionCall1

class	StoredConstMemberFunctionCall2

class	StoredConstMemberFunctionCall3

class	StoredConstMemberFunctionCall4

class	StoredConstMemberFunctionCall5

class	StoredConstMemberFunctionPointerCall0

class	StoredConstMemberFunctionPointerCall1

class	StoredConstMemberFunctionPointerCall2

class	StoredConstMemberFunctionPointerCall3

class	StoredConstMemberFunctionPointerCall4

class	StoredConstMemberFunctionPointerCall5

class	StoredFunctorCall

struct	StoredFunctorCall0

struct	StoredFunctorCall0< void, FunctionPointer >

struct	StoredFunctorCall1

struct	StoredFunctorCall1< void, FunctionPointer, Arg1 >

struct	StoredFunctorCall2

struct	StoredFunctorCall2< void, FunctionPointer, Arg1, Arg2 >

struct	StoredFunctorCall3

struct	StoredFunctorCall3< void, FunctionPointer, Arg1, Arg2, Arg3 >

struct	StoredFunctorCall4

struct	StoredFunctorCall4< void, FunctionPointer, Arg1, Arg2, Arg3, Arg4 >

struct	StoredFunctorCall5

struct	StoredFunctorCall5< void, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5 >

class	StoredFunctorCall< void, Functor >

struct	StoredFunctorPointerCall0

struct	StoredFunctorPointerCall1

struct	StoredFunctorPointerCall2

struct	StoredFunctorPointerCall3

struct	StoredFunctorPointerCall4

struct	StoredFunctorPointerCall5

class	StoredMemberFunctionCall0

class	StoredMemberFunctionCall1

class	StoredMemberFunctionCall2

class	StoredMemberFunctionCall3

class	StoredMemberFunctionCall4

class	StoredMemberFunctionCall5

class	StoredMemberFunctionPointerCall0

class	StoredMemberFunctionPointerCall1

class	StoredMemberFunctionPointerCall2

class	StoredMemberFunctionPointerCall3

class	StoredMemberFunctionPointerCall4

class	StoredMemberFunctionPointerCall5

class	ThreadEngine

class	ThreadEngineBarrier

class	ThreadEngineBase

class	ThreadEngineStarter

class	ThreadEngineStarter< void >

class	ThreadEngineStarterBase

class	VoidStoredConstMemberFunctionCall0

class	VoidStoredConstMemberFunctionCall1

class	VoidStoredConstMemberFunctionCall2

class	VoidStoredConstMemberFunctionCall3

class	VoidStoredConstMemberFunctionCall4

class	VoidStoredConstMemberFunctionCall5

class	VoidStoredConstMemberFunctionPointerCall0

class	VoidStoredConstMemberFunctionPointerCall1

class	VoidStoredConstMemberFunctionPointerCall2

class	VoidStoredConstMemberFunctionPointerCall3

class	VoidStoredConstMemberFunctionPointerCall4

class	VoidStoredConstMemberFunctionPointerCall5

struct	VoidStoredFunctorPointerCall0

struct	VoidStoredFunctorPointerCall1

struct	VoidStoredFunctorPointerCall2

struct	VoidStoredFunctorPointerCall3

struct	VoidStoredFunctorPointerCall4

struct	VoidStoredFunctorPointerCall5

class	VoidStoredMemberFunctionCall0

class	VoidStoredMemberFunctionCall1

class	VoidStoredMemberFunctionCall2

class	VoidStoredMemberFunctionCall3

class	VoidStoredMemberFunctionCall4

class	VoidStoredMemberFunctionCall5

class	VoidStoredMemberFunctionPointerCall0

class	VoidStoredMemberFunctionPointerCall1

class	VoidStoredMemberFunctionPointerCall2

class	VoidStoredMemberFunctionPointerCall3

class	VoidStoredMemberFunctionPointerCall4

class	VoidStoredMemberFunctionPointerCall5

Typedefs
typedef Q_DECL_DEPRECATED QException	Exception

typedef Q_DECL_DEPRECATED QUnhandledException	UnhandledException

Enumerations
enum	{ ReduceQueueStartLimit = 20, ReduceQueueThrottleLimit = 30 }

enum	ReduceOption { UnorderedReduce = 0x1, OrderedReduce = 0x2, SequentialReduce = 0x4 }

enum	ThreadFunctionResult { ThrottleThread, ThreadFinished }

Functions
template<typename Sequence , typename KeepFunctor , typename ReduceFunctor >
ThreadEngineStarter< void >	filterInternal (Sequence &sequence, KeepFunctor keep, ReduceFunctor reduce)
	[QtConcurrent-1] More...

template<typename Sequence , typename KeepFunctor >
QFuture< void >	filter (Sequence &sequence, KeepFunctor keep)

template<typename ResultType , typename Sequence , typename KeepFunctor , typename ReduceFunctor >
QFuture< ResultType >	filteredReduced (const Sequence &sequence, KeepFunctor keep, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce\|SequentialReduce))

template<typename Sequence , typename KeepFunctor , typename ReduceFunctor >
QFuture< typename QtPrivate::ReduceResultType< ReduceFunctor >::ResultType >	filteredReduced (const Sequence &sequence, 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 Iterator , typename KeepFunctor , typename ReduceFunctor >
QFuture< typename QtPrivate::ReduceResultType< ReduceFunctor >::ResultType >	filteredReduced (Iterator begin, Iterator end, KeepFunctor keep, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce\|SequentialReduce))

template<typename Sequence , typename KeepFunctor >
QFuture< typename Sequence::value_type >	filtered (const Sequence &sequence, KeepFunctor keep)

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

template<typename Sequence , typename KeepFunctor >
void	blockingFilter (Sequence &sequence, KeepFunctor keep)

template<typename ResultType , typename Sequence , typename KeepFunctor , typename ReduceFunctor >
ResultType	blockingFilteredReduced (const Sequence &sequence, KeepFunctor keep, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce\|SequentialReduce))

template<typename Sequence , typename KeepFunctor , typename ReduceFunctor >
QtPrivate::ReduceResultType< ReduceFunctor >::ResultType	blockingFilteredReduced (const Sequence &sequence, 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 Iterator , typename KeepFunctor , typename ReduceFunctor >
QtPrivate::ReduceResultType< ReduceFunctor >::ResultType	blockingFilteredReduced (Iterator begin, Iterator end, KeepFunctor keep, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce\|SequentialReduce))

template<typename Sequence , typename KeepFunctor >
Sequence	blockingFiltered (const Sequence &sequence, KeepFunctor keep)

template<typename OutputSequence , typename Iterator , typename KeepFunctor >
OutputSequence	blockingFiltered (Iterator begin, Iterator end, KeepFunctor keep)

template<typename Iterator , typename KeepFunctor >
ThreadEngineStarter< typename qValueType< Iterator >::value_type >	startFiltered (Iterator begin, Iterator end, KeepFunctor functor)
	[QtConcurrent-2] More...

template<typename Sequence , typename KeepFunctor >
ThreadEngineStarter< typename Sequence::value_type >	startFiltered (const Sequence &sequence, KeepFunctor functor)
	[QtConcurrent-3] More...

template<typename ResultType , typename Sequence , typename MapFunctor , typename ReduceFunctor >
ThreadEngineStarter< ResultType >	startFilteredReduced (const Sequence &sequence, MapFunctor mapFunctor, ReduceFunctor reduceFunctor, ReduceOptions options)
	[QtConcurrent-4] More...

template<typename ResultType , typename Iterator , typename MapFunctor , typename ReduceFunctor >
ThreadEngineStarter< ResultType >	startFilteredReduced (Iterator begin, Iterator end, MapFunctor mapFunctor, ReduceFunctor reduceFunctor, ReduceOptions options)
	[QtConcurrent-5] More...

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 (Sequence &sequence, MapFunctor map)

template<typename Iterator , typename MapFunctor >
QFuture< void >	map (Iterator begin, Iterator end, MapFunctor map)

template<typename ResultType , typename Sequence , typename MapFunctor , typename ReduceFunctor >
QFuture< ResultType >	mappedReduced (const Sequence &sequence, MapFunctor map, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce\|SequentialReduce))

template<typename Sequence , typename MapFunctor , typename ReduceFunctor >
QFuture< typename QtPrivate::ReduceResultType< ReduceFunctor >::ResultType >	mappedReduced (const Sequence &sequence, 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 Iterator , typename MapFunctor , typename ReduceFunctor >
QFuture< typename QtPrivate::ReduceResultType< ReduceFunctor >::ResultType >	mappedReduced (Iterator begin, Iterator end, MapFunctor map, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce\|SequentialReduce))

template<typename Sequence , typename MapFunctor >
QFuture< typename QtPrivate::MapResultType< void, MapFunctor >::ResultType >	mapped (const Sequence &sequence, MapFunctor map)

template<typename Iterator , typename MapFunctor >
QFuture< typename QtPrivate::MapResultType< void, MapFunctor >::ResultType >	mapped (Iterator begin, Iterator end, MapFunctor map)

template<typename Sequence , typename MapFunctor >
void	blockingMap (Sequence &sequence, MapFunctor map)

template<typename Iterator , typename MapFunctor >
void	blockingMap (Iterator begin, Iterator end, MapFunctor map)

template<typename ResultType , typename Sequence , typename MapFunctor , typename ReduceFunctor >
ResultType	blockingMappedReduced (const Sequence &sequence, MapFunctor map, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce\|SequentialReduce))

template<typename MapFunctor , typename ReduceFunctor , typename Sequence >
QtPrivate::ReduceResultType< ReduceFunctor >::ResultType	blockingMappedReduced (const Sequence &sequence, 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, QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce\|QtConcurrent::SequentialReduce))

template<typename Iterator , typename MapFunctor , typename ReduceFunctor >
QtPrivate::ReduceResultType< ReduceFunctor >::ResultType	blockingMappedReduced (Iterator begin, Iterator end, MapFunctor map, ReduceFunctor reduce, QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce\|QtConcurrent::SequentialReduce))

template<typename OutputSequence , typename InputSequence , typename MapFunctor >
OutputSequence	blockingMapped (const InputSequence &sequence, MapFunctor map)

template<typename MapFunctor , typename InputSequence >
QtPrivate::MapResultType< InputSequence, MapFunctor >::ResultType	blockingMapped (const InputSequence &sequence, MapFunctor map)

template<typename Sequence , typename Iterator , typename MapFunctor >
Sequence	blockingMapped (Iterator begin, Iterator end, MapFunctor map)

template<typename Iterator , typename MapFunctor >
QtPrivate::MapResultType< Iterator, MapFunctor >::ResultType	blockingMapped (Iterator begin, Iterator end, MapFunctor map)

template<typename Iterator , typename Functor >
ThreadEngineStarter< void >	startMap (Iterator begin, Iterator end, Functor functor)
	[qtconcurrentmapkernel-1] More...

template<typename T , typename Iterator , typename Functor >
ThreadEngineStarter< T >	startMapped (Iterator begin, Iterator end, Functor functor)
	[qtconcurrentmapkernel-2] More...

template<typename T , typename Sequence , typename Functor >
ThreadEngineStarter< T >	startMapped (const Sequence &sequence, Functor functor)
	[qtconcurrentmapkernel-3] More...

template<typename IntermediateType , typename ResultType , typename Sequence , typename MapFunctor , typename ReduceFunctor >
ThreadEngineStarter< ResultType >	startMappedReduced (const Sequence &sequence, MapFunctor mapFunctor, ReduceFunctor reduceFunctor, ReduceOptions options)
	[qtconcurrentmapkernel-4] More...

template<typename IntermediateType , typename ResultType , typename Iterator , typename MapFunctor , typename ReduceFunctor >
ThreadEngineStarter< ResultType >	startMappedReduced (Iterator begin, Iterator end, MapFunctor mapFunctor, ReduceFunctor reduceFunctor, ReduceOptions options)
	[qtconcurrentmapkernel-5] More...

template<typename T >
QFuture< T >	run (T(*functionPointer)())

template<typename T , typename Param1 , typename Arg1 >
QFuture< T >	run (T(*functionPointer)(Param1), const Arg1 &arg1)

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >
QFuture< T >	run (T(*functionPointer)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >
QFuture< T >	run (T(*functionPointer)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >
QFuture< T >	run (T(*functionPointer)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >
QFuture< T >	run (T(*functionPointer)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)

template<typename FunctionObject >
QFuture< typename FunctionObject::result_type >	run (FunctionObject functionObject)

template<typename FunctionObject , typename Arg1 >
QFuture< typename FunctionObject::result_type >	run (FunctionObject functionObject, const Arg1 &arg1)

template<typename FunctionObject , typename Arg1 , typename Arg2 >
QFuture< typename FunctionObject::result_type >	run (FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2)

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 >
QFuture< typename FunctionObject::result_type >	run (FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
QFuture< typename FunctionObject::result_type >	run (FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
QFuture< typename FunctionObject::result_type >	run (FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)

template<typename FunctionObject >
QFuture< typename FunctionObject::result_type >	run (FunctionObject *functionObject)

template<typename FunctionObject , typename Arg1 >
QFuture< typename FunctionObject::result_type >	run (FunctionObject *functionObject, const Arg1 &arg1)

template<typename FunctionObject , typename Arg1 , typename Arg2 >
QFuture< typename FunctionObject::result_type >	run (FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2)

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 >
QFuture< typename FunctionObject::result_type >	run (FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
QFuture< typename FunctionObject::result_type >	run (FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
QFuture< typename FunctionObject::result_type >	run (FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)

template<typename T , typename Class >
QFuture< T >	run (const Class &object, T(Class::*fn)())

template<typename T , typename Class , typename Param1 , typename Arg1 >
QFuture< T >	run (const Class &object, T(Class::*fn)(Param1), const Arg1 &arg1)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >
QFuture< T >	run (const Class &object, T(Class::*fn)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >
QFuture< T >	run (const Class &object, T(Class::*fn)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >
QFuture< T >	run (const Class &object, T(Class::*fn)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >
QFuture< T >	run (const Class &object, T(Class::*fn)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)

template<typename T , typename Class >
QFuture< T >	run (Class object, T(Class::fn)())

template<typename T , typename Class , typename Param1 , typename Arg1 >
QFuture< T >	run (Class object, T(Class::fn)(Param1), const Arg1 &arg1)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >
QFuture< T >	run (Class object, T(Class::fn)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >
QFuture< T >	run (Class object, T(Class::fn)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >
QFuture< T >	run (Class object, T(Class::fn)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >
QFuture< T >	run (Class object, T(Class::fn)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)

template<typename T , typename Class >
QFuture< T >	run (const Class object, T(Class::fn)() const)

template<typename T , typename Class , typename Param1 , typename Arg1 >
QFuture< T >	run (const Class object, T(Class::fn)(Param1) const, const Arg1 &arg1)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >
QFuture< T >	run (const Class object, T(Class::fn)(Param1, Param2) const, const Arg1 &arg1, const Arg2 &arg2)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >
QFuture< T >	run (const Class object, T(Class::fn)(Param1, Param2, Param3) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >
QFuture< T >	run (const Class object, T(Class::fn)(Param1, Param2, Param3, Param4) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >
QFuture< T >	run (const Class object, T(Class::fn)(Param1, Param2, Param3, Param4, Param5) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)

template<typename T >
QFuture< T >	run (QThreadPool pool, T(functionPointer)())

template<typename T , typename Param1 , typename Arg1 >
QFuture< T >	run (QThreadPool pool, T(functionPointer)(Param1), const Arg1 &arg1)

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >
QFuture< T >	run (QThreadPool pool, T(functionPointer)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >
QFuture< T >	run (QThreadPool pool, T(functionPointer)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >
QFuture< T >	run (QThreadPool pool, T(functionPointer)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >
QFuture< T >	run (QThreadPool pool, T(functionPointer)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)

template<typename FunctionObject >
QFuture< typename FunctionObject::result_type >	run (QThreadPool *pool, FunctionObject functionObject)

template<typename FunctionObject , typename Arg1 >
QFuture< typename FunctionObject::result_type >	run (QThreadPool *pool, FunctionObject functionObject, const Arg1 &arg1)

template<typename FunctionObject , typename Arg1 , typename Arg2 >
QFuture< typename FunctionObject::result_type >	run (QThreadPool *pool, FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2)

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 >
QFuture< typename FunctionObject::result_type >	run (QThreadPool *pool, FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
QFuture< typename FunctionObject::result_type >	run (QThreadPool *pool, FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
QFuture< typename FunctionObject::result_type >	run (QThreadPool *pool, FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)

template<typename FunctionObject >
QFuture< typename FunctionObject::result_type >	run (QThreadPool pool, FunctionObject functionObject)

template<typename FunctionObject , typename Arg1 >
QFuture< typename FunctionObject::result_type >	run (QThreadPool pool, FunctionObject functionObject, const Arg1 &arg1)

template<typename FunctionObject , typename Arg1 , typename Arg2 >
QFuture< typename FunctionObject::result_type >	run (QThreadPool pool, FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2)

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 >
QFuture< typename FunctionObject::result_type >	run (QThreadPool pool, FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
QFuture< typename FunctionObject::result_type >	run (QThreadPool pool, FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
QFuture< typename FunctionObject::result_type >	run (QThreadPool pool, FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)

template<typename T , typename Class >
QFuture< T >	run (QThreadPool pool, const Class &object, T(Class::fn)())

template<typename T , typename Class , typename Param1 , typename Arg1 >
QFuture< T >	run (QThreadPool pool, const Class &object, T(Class::fn)(Param1), const Arg1 &arg1)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >
QFuture< T >	run (QThreadPool pool, const Class &object, T(Class::fn)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >
QFuture< T >	run (QThreadPool pool, const Class &object, T(Class::fn)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >
QFuture< T >	run (QThreadPool pool, const Class &object, T(Class::fn)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >
QFuture< T >	run (QThreadPool pool, const Class &object, T(Class::fn)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)

template<typename T , typename Class >
QFuture< T >	run (QThreadPool pool, Class object, T(Class::*fn)())

template<typename T , typename Class , typename Param1 , typename Arg1 >
QFuture< T >	run (QThreadPool pool, Class object, T(Class::*fn)(Param1), const Arg1 &arg1)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >
QFuture< T >	run (QThreadPool pool, Class object, T(Class::*fn)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >
QFuture< T >	run (QThreadPool pool, Class object, T(Class::*fn)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >
QFuture< T >	run (QThreadPool pool, Class object, T(Class::*fn)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >
QFuture< T >	run (QThreadPool pool, Class object, T(Class::*fn)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)

template<typename T , typename Class >
QFuture< T >	run (QThreadPool pool, const Class object, T(Class::*fn)() const)

template<typename T , typename Class , typename Param1 , typename Arg1 >
QFuture< T >	run (QThreadPool pool, const Class object, T(Class::*fn)(Param1) const, const Arg1 &arg1)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >
QFuture< T >	run (QThreadPool pool, const Class object, T(Class::*fn)(Param1, Param2) const, const Arg1 &arg1, const Arg2 &arg2)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >
QFuture< T >	run (QThreadPool pool, const Class object, T(Class::*fn)(Param1, Param2, Param3) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >
QFuture< T >	run (QThreadPool pool, const Class object, T(Class::*fn)(Param1, Param2, Param3, Param4) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >
QFuture< T >	run (QThreadPool pool, const Class object, T(Class::*fn)(Param1, Param2, Param3, Param4, Param5) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)

template<typename ThreadEngine >
ThreadEngineStarter< typename ThreadEngine::ResultType >	startThreadEngine (ThreadEngine *threadEngine)
	[qtconcurrentthreadengine-1] More...

Detailed Description

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

QtConcurrent

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

QtConcurrent

Typedef Documentation

◆ Exception

typedef Q_DECL_DEPRECATED QException QtConcurrent::Exception

◆ UnhandledException

typedef Q_DECL_DEPRECATED QUnhandledException QtConcurrent::UnhandledException

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
ReduceQueueStartLimit
ReduceQueueThrottleLimit

◆ ReduceOption

enum QtConcurrent::ReduceOption

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

UnorderedReduce Reduction is done in an arbitrary order. OrderedReduce Reduction is done in the order of the original sequence. 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

◆ ThreadFunctionResult

enum QtConcurrent::ThreadFunctionResult

Enumerator
ThrottleThread
ThreadFinished

Function Documentation

◆ blockingFilter()

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: This function will block until all items in the sequence have been processed.

See also: {Concurrent Filter and Filter-Reduce}

◆ blockingFiltered() [1/2]

template<typename Sequence , typename KeepFunctor >

template< typename Sequence, typename KeepFunctor > Sequence QtConcurrent::blockingFiltered	(	const 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}

◆ blockingFiltered() [2/2]

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}

◆ blockingFilteredReduced() [1/4]

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

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

◆ blockingFilteredReduced() [2/4]

template<typename Sequence , typename KeepFunctor , typename ReduceFunctor >

QtPrivate::ReduceResultType<ReduceFunctor>::ResultType QtConcurrent::blockingFilteredReduced	(	const Sequence &	sequence,
		KeepFunctor	keep,
		ReduceFunctor	reduce,
		ReduceOptions	options = `ReduceOptions(UnorderedReduce \| SequentialReduce)`
	)

◆ blockingFilteredReduced() [3/4]

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

◆ blockingFilteredReduced() [4/4]

template<typename Iterator , typename KeepFunctor , typename ReduceFunctor >

QtPrivate::ReduceResultType<ReduceFunctor>::ResultType QtConcurrent::blockingFilteredReduced	(	Iterator	begin,
		Iterator	end,
		KeepFunctor	keep,
		ReduceFunctor	reduce,
		ReduceOptions	options = `ReduceOptions(UnorderedReduce \| SequentialReduce)`
	)

◆ blockingMap() [1/2]

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 is passed 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}

◆ blockingMap() [2/2]

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 is passed 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}

◆ blockingMapped() [1/4]

template<typename OutputSequence , typename InputSequence , typename MapFunctor >

template< typename OutputSequence, typename InputSequence, typename MapFunctor > OutputSequence QtConcurrent::blockingMapped	(	const 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 my the MapFunctor.

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

See also: mapped(), {Concurrent Map and Map-Reduce}

◆ blockingMapped() [2/4]

template<typename MapFunctor , typename InputSequence >

QtPrivate::MapResultType<InputSequence, MapFunctor>::ResultType QtConcurrent::blockingMapped	(	const InputSequence &	sequence,
		MapFunctor	map
	)

◆ blockingMapped() [3/4]

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. 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}

◆ blockingMapped() [4/4]

template<typename Iterator , typename MapFunctor >

QtPrivate::MapResultType<Iterator, MapFunctor>::ResultType QtConcurrent::blockingMapped	(	Iterator	begin,
		Iterator	end,
		MapFunctor	map
	)

◆ blockingMappedReduced() [1/4]

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

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

◆ blockingMappedReduced() [2/4]

template<typename MapFunctor , typename ReduceFunctor , typename Sequence >

QtPrivate::ReduceResultType<ReduceFunctor>::ResultType QtConcurrent::blockingMappedReduced	(	const Sequence &	sequence,
		MapFunctor	map,
		ReduceFunctor	reduce,
		ReduceOptions	options = `ReduceOptions(UnorderedReduce \| SequentialReduce)`
	)

◆ blockingMappedReduced() [3/4]

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

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

Calls mapFunction once for each item from begin to end. The return value of each mapFunction is passed to reduceFunction.

Note that while mapFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is undefined.

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

See also: blockingMappedReduced(), {Concurrent Map and Map-Reduce}

◆ blockingMappedReduced() [4/4]

template<typename Iterator , typename MapFunctor , typename ReduceFunctor >

QtPrivate::ReduceResultType<ReduceFunctor>::ResultType QtConcurrent::blockingMappedReduced	(	Iterator	begin,
		Iterator	end,
		MapFunctor	map,
		ReduceFunctor	reduce,
		QtConcurrent::ReduceOptions	options = `QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce \| QtConcurrent::SequentialReduce)`
	)

◆ filter()

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.

See also: {Concurrent Filter and Filter-Reduce}

◆ filtered() [1/2]

template<typename Sequence , typename KeepFunctor >

template< typename Sequence, typename KeepFunctor > QFuture< Sequence::value_type > QtConcurrent::filtered	(	const 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}

◆ filtered() [2/2]

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}

◆ filteredReduced() [1/4]

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

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

◆ filteredReduced() [2/4]

template<typename Sequence , typename KeepFunctor , typename ReduceFunctor >

QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> QtConcurrent::filteredReduced	(	const Sequence &	sequence,
		KeepFunctor	keep,
		ReduceFunctor	reduce,
		ReduceOptions	options = `ReduceOptions(UnorderedReduce \| SequentialReduce)`
	)

◆ filteredReduced() [3/4]

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

◆ filteredReduced() [4/4]

template<typename Iterator , typename KeepFunctor , typename ReduceFunctor >

QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> QtConcurrent::filteredReduced	(	Iterator	begin,
		Iterator	end,
		KeepFunctor	keep,
		ReduceFunctor	reduce,
		ReduceOptions	options = `ReduceOptions(UnorderedReduce \| SequentialReduce)`
	)

◆ filterInternal()

template<typename Sequence , typename KeepFunctor , typename ReduceFunctor >

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

[QtConcurrent-1]

◆ map() [1/2]

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 is passed a reference to the item, so that any modifications done to the item will appear in sequence.

See also: {Concurrent Map and Map-Reduce}

◆ map() [2/2]

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 is passed 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}

◆ mapped() [1/2]

template<typename Sequence , typename MapFunctor >

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

Calls function once for each item in sequence and returns a future with each mapped item as a result. You can use QFuture::const_iterator or QFutureIterator to iterate through the results.

See also: {Concurrent Map and Map-Reduce}

◆ mapped() [2/2]

template<typename Iterator , typename MapFunctor >

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

Calls function once for each item from begin to end and returns a future with each mapped item as a result. You can use QFuture::const_iterator or QFutureIterator to iterate through the results.

See also: {Concurrent Map and Map-Reduce}

◆ mappedReduced() [1/4]

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

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

◆ mappedReduced() [2/4]

template<typename Sequence , typename MapFunctor , typename ReduceFunctor >

QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> QtConcurrent::mappedReduced	(	const Sequence &	sequence,
		MapFunctor	map,
		ReduceFunctor	reduce,
		ReduceOptions	options = `ReduceOptions(UnorderedReduce \| SequentialReduce)`
	)

◆ mappedReduced() [3/4]

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

◆ mappedReduced() [4/4]

template<typename Iterator , typename MapFunctor , typename ReduceFunctor >

QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> QtConcurrent::mappedReduced	(	Iterator	begin,
		Iterator	end,
		MapFunctor	map,
		ReduceFunctor	reduce,
		ReduceOptions	options = `ReduceOptions(UnorderedReduce \| SequentialReduce)`
	)

◆ run() [1/72]

template<typename T >

QFuture<T> QtConcurrent::run ( T(*)() functionPointer )

◆ run() [2/72]

template<typename T , typename Param1 , typename Arg1 >

QFuture<T> QtConcurrent::run	(	T(*)(Param1)	functionPointer,
		const Arg1 &	arg1
	)

◆ run() [3/72]

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >

QFuture<T> QtConcurrent::run	(	T(*)(Param1, Param2)	functionPointer,
		const Arg1 &	arg1,
		const Arg2 &	arg2
	)

◆ run() [4/72]

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >

QFuture<T> QtConcurrent::run	(	T(*)(Param1, Param2, Param3)	functionPointer,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3
	)

◆ run() [5/72]

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >

QFuture<T> QtConcurrent::run	(	T(*)(Param1, Param2, Param3, Param4)	functionPointer,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4
	)

◆ run() [6/72]

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >

QFuture<T> QtConcurrent::run	(	T(*)(Param1, Param2, Param3, Param4, Param5)	functionPointer,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4,
		const Arg5 &	arg5
	)

◆ run() [7/72]

template<typename FunctionObject >

QFuture<typename FunctionObject::result_type> QtConcurrent::run ( FunctionObject functionObject )

◆ run() [8/72]

template<typename FunctionObject , typename Arg1 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	FunctionObject	functionObject,
		const Arg1 &	arg1
	)

◆ run() [9/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	FunctionObject	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2
	)

◆ run() [10/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	FunctionObject	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3
	)

◆ run() [11/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	FunctionObject	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4
	)

◆ run() [12/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	FunctionObject	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4,
		const Arg5 &	arg5
	)

◆ run() [13/72]

template<typename FunctionObject >

QFuture<typename FunctionObject::result_type> QtConcurrent::run ( FunctionObject * functionObject )

◆ run() [14/72]

template<typename FunctionObject , typename Arg1 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	FunctionObject *	functionObject,
		const Arg1 &	arg1
	)

◆ run() [15/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	FunctionObject *	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2
	)

◆ run() [16/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	FunctionObject *	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3
	)

◆ run() [17/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	FunctionObject *	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4
	)

◆ run() [18/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	FunctionObject *	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4,
		const Arg5 &	arg5
	)

◆ run() [19/72]

template<typename T , typename Class >

QFuture< T > QtConcurrent::run	(	const Class &	object,
		T(Class::*)()	fn
	)

◆ run() [20/72]

template<typename T , typename Class , typename Param1 , typename Arg1 >

QFuture< T > QtConcurrent::run	(	const Class &	object,
		T(Class::*)(Param1)	fn,
		const Arg1 &	arg1
	)

◆ run() [21/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >

QFuture< T > QtConcurrent::run	(	const Class &	object,
		T(Class::*)(Param1, Param2)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2
	)

◆ run() [22/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >

QFuture< T > QtConcurrent::run	(	const Class &	object,
		T(Class::*)(Param1, Param2, Param3)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3
	)

◆ run() [23/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >

QFuture< T > QtConcurrent::run	(	const Class &	object,
		T(Class::*)(Param1, Param2, Param3, Param4)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4
	)

◆ run() [24/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >

QFuture< T > QtConcurrent::run	(	const Class &	object,
		T(Class::*)(Param1, Param2, Param3, Param4, Param5)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4,
		const Arg5 &	arg5
	)

◆ run() [25/72]

template<typename T , typename Class >

QFuture<T> QtConcurrent::run	(	Class *	object,
		T(Class::*)()	fn
	)

◆ run() [26/72]

template<typename T , typename Class , typename Param1 , typename Arg1 >

QFuture<T> QtConcurrent::run	(	Class *	object,
		T(Class::*)(Param1)	fn,
		const Arg1 &	arg1
	)

◆ run() [27/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >

QFuture<T> QtConcurrent::run	(	Class *	object,
		T(Class::*)(Param1, Param2)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2
	)

◆ run() [28/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >

QFuture<T> QtConcurrent::run	(	Class *	object,
		T(Class::*)(Param1, Param2, Param3)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3
	)

◆ run() [29/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >

QFuture<T> QtConcurrent::run	(	Class *	object,
		T(Class::*)(Param1, Param2, Param3, Param4)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4
	)

◆ run() [30/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >

QFuture<T> QtConcurrent::run	(	Class *	object,
		T(Class::*)(Param1, Param2, Param3, Param4, Param5)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4,
		const Arg5 &	arg5
	)

◆ run() [31/72]

template<typename T , typename Class >

QFuture<T> QtConcurrent::run	(	const Class *	object,
		T(Class::*)() const	fn
	)

◆ run() [32/72]

template<typename T , typename Class , typename Param1 , typename Arg1 >

QFuture<T> QtConcurrent::run	(	const Class *	object,
		T(Class::*)(Param1) const	fn,
		const Arg1 &	arg1
	)

◆ run() [33/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >

QFuture<T> QtConcurrent::run	(	const Class *	object,
		T(Class::*)(Param1, Param2) const	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2
	)

◆ run() [34/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >

QFuture<T> QtConcurrent::run	(	const Class *	object,
		T(Class::*)(Param1, Param2, Param3) const	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3
	)

◆ run() [35/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >

QFuture<T> QtConcurrent::run	(	const Class *	object,
		T(Class::*)(Param1, Param2, Param3, Param4) const	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4
	)

◆ run() [36/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >

QFuture<T> QtConcurrent::run	(	const Class *	object,
		T(Class::*)(Param1, Param2, Param3, Param4, Param5) const	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4,
		const Arg5 &	arg5
	)

◆ run() [37/72]

template<typename T >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		T(*)()	functionPointer
	)

◆ run() [38/72]

template<typename T , typename Param1 , typename Arg1 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		T(*)(Param1)	functionPointer,
		const Arg1 &	arg1
	)

◆ run() [39/72]

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		T(*)(Param1, Param2)	functionPointer,
		const Arg1 &	arg1,
		const Arg2 &	arg2
	)

◆ run() [40/72]

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		T(*)(Param1, Param2, Param3)	functionPointer,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3
	)

◆ run() [41/72]

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		T(*)(Param1, Param2, Param3, Param4)	functionPointer,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4
	)

◆ run() [42/72]

template<typename T , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		T(*)(Param1, Param2, Param3, Param4, Param5)	functionPointer,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4,
		const Arg5 &	arg5
	)

◆ run() [43/72]

template<typename FunctionObject >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	QThreadPool *	pool,
		FunctionObject	functionObject
	)

◆ run() [44/72]

template<typename FunctionObject , typename Arg1 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	QThreadPool *	pool,
		FunctionObject	functionObject,
		const Arg1 &	arg1
	)

◆ run() [45/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	QThreadPool *	pool,
		FunctionObject	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2
	)

◆ run() [46/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	QThreadPool *	pool,
		FunctionObject	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3
	)

◆ run() [47/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	QThreadPool *	pool,
		FunctionObject	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4
	)

◆ run() [48/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	QThreadPool *	pool,
		FunctionObject	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4,
		const Arg5 &	arg5
	)

◆ run() [49/72]

template<typename FunctionObject >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	QThreadPool *	pool,
		FunctionObject *	functionObject
	)

◆ run() [50/72]

template<typename FunctionObject , typename Arg1 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	QThreadPool *	pool,
		FunctionObject *	functionObject,
		const Arg1 &	arg1
	)

◆ run() [51/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	QThreadPool *	pool,
		FunctionObject *	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2
	)

◆ run() [52/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	QThreadPool *	pool,
		FunctionObject *	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3
	)

◆ run() [53/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	QThreadPool *	pool,
		FunctionObject *	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4
	)

◆ run() [54/72]

template<typename FunctionObject , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >

QFuture<typename FunctionObject::result_type> QtConcurrent::run	(	QThreadPool *	pool,
		FunctionObject *	functionObject,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4,
		const Arg5 &	arg5
	)

◆ run() [55/72]

template<typename T , typename Class >

QFuture< T > QtConcurrent::run	(	QThreadPool *	pool,
		const Class &	object,
		T(Class::*)()	fn
	)

◆ run() [56/72]

template<typename T , typename Class , typename Param1 , typename Arg1 >

QFuture< T > QtConcurrent::run	(	QThreadPool *	pool,
		const Class &	object,
		T(Class::*)(Param1)	fn,
		const Arg1 &	arg1
	)

◆ run() [57/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >

QFuture< T > QtConcurrent::run	(	QThreadPool *	pool,
		const Class &	object,
		T(Class::*)(Param1, Param2)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2
	)

◆ run() [58/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >

QFuture< T > QtConcurrent::run	(	QThreadPool *	pool,
		const Class &	object,
		T(Class::*)(Param1, Param2, Param3)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3
	)

◆ run() [59/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >

QFuture< T > QtConcurrent::run	(	QThreadPool *	pool,
		const Class &	object,
		T(Class::*)(Param1, Param2, Param3, Param4)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4
	)

◆ run() [60/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >

QFuture< T > QtConcurrent::run	(	QThreadPool *	pool,
		const Class &	object,
		T(Class::*)(Param1, Param2, Param3, Param4, Param5)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4,
		const Arg5 &	arg5
	)

◆ run() [61/72]

template<typename T , typename Class >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		Class *	object,
		T(Class::*)()	fn
	)

◆ run() [62/72]

template<typename T , typename Class , typename Param1 , typename Arg1 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		Class *	object,
		T(Class::*)(Param1)	fn,
		const Arg1 &	arg1
	)

◆ run() [63/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		Class *	object,
		T(Class::*)(Param1, Param2)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2
	)

◆ run() [64/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		Class *	object,
		T(Class::*)(Param1, Param2, Param3)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3
	)

◆ run() [65/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		Class *	object,
		T(Class::*)(Param1, Param2, Param3, Param4)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4
	)

◆ run() [66/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		Class *	object,
		T(Class::*)(Param1, Param2, Param3, Param4, Param5)	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4,
		const Arg5 &	arg5
	)

◆ run() [67/72]

template<typename T , typename Class >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		const Class *	object,
		T(Class::*)() const	fn
	)

◆ run() [68/72]

template<typename T , typename Class , typename Param1 , typename Arg1 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		const Class *	object,
		T(Class::*)(Param1) const	fn,
		const Arg1 &	arg1
	)

◆ run() [69/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		const Class *	object,
		T(Class::*)(Param1, Param2) const	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2
	)

◆ run() [70/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		const Class *	object,
		T(Class::*)(Param1, Param2, Param3) const	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3
	)

◆ run() [71/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		const Class *	object,
		T(Class::*)(Param1, Param2, Param3, Param4) const	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4
	)

◆ run() [72/72]

template<typename T , typename Class , typename Param1 , typename Arg1 , typename Param2 , typename Arg2 , typename Param3 , typename Arg3 , typename Param4 , typename Arg4 , typename Param5 , typename Arg5 >

QFuture<T> QtConcurrent::run	(	QThreadPool *	pool,
		const Class *	object,
		T(Class::*)(Param1, Param2, Param3, Param4, Param5) const	fn,
		const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4,
		const Arg5 &	arg5
	)

◆ selectIteration() [1/3]

bool QtConcurrent::selectIteration ( std::bidirectional_iterator_tag )

inline

◆ selectIteration() [2/3]

bool QtConcurrent::selectIteration ( std::forward_iterator_tag )

inline

◆ selectIteration() [3/3]

bool QtConcurrent::selectIteration ( std::random_access_iterator_tag )

inline

◆ startFiltered() [1/2]

template<typename Iterator , typename KeepFunctor >

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

inline

[QtConcurrent-2]

◆ startFiltered() [2/2]

template<typename Sequence , typename KeepFunctor >

ThreadEngineStarter<typename Sequence::value_type> QtConcurrent::startFiltered	(	const Sequence &	sequence,
		KeepFunctor	functor
	)

inline

[QtConcurrent-3]

◆ startFilteredReduced() [1/2]

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

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

inline

[QtConcurrent-4]

◆ startFilteredReduced() [2/2]

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

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

inline

[QtConcurrent-5]

◆ startMap()

template<typename Iterator , typename Functor >

ThreadEngineStarter<void> QtConcurrent::startMap	(	Iterator	begin,
		Iterator	end,
		Functor	functor
	)

inline

[qtconcurrentmapkernel-1]

◆ startMapped() [1/2]

template<typename T , typename Iterator , typename Functor >

ThreadEngineStarter<T> QtConcurrent::startMapped	(	Iterator	begin,
		Iterator	end,
		Functor	functor
	)

inline

[qtconcurrentmapkernel-2]

◆ startMapped() [2/2]

template<typename T , typename Sequence , typename Functor >

ThreadEngineStarter<T> QtConcurrent::startMapped	(	const Sequence &	sequence,
		Functor	functor
	)

inline

[qtconcurrentmapkernel-3]

◆ startMappedReduced() [1/2]

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

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

inline

[qtconcurrentmapkernel-4]

◆ startMappedReduced() [2/2]

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

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

inline

[qtconcurrentmapkernel-5]

◆ startThreadEngine()

template<typename ThreadEngine >

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

inline

[qtconcurrentthreadengine-1]

Classes

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

◆ Exception

◆ UnhandledException

Enumeration Type Documentation

◆ anonymous enum

◆ ReduceOption

◆ ThreadFunctionResult

Function Documentation

◆ blockingFilter()

◆ blockingFiltered() [1/2]

◆ blockingFiltered() [2/2]

◆ blockingFilteredReduced() [1/4]

◆ blockingFilteredReduced() [2/4]

◆ blockingFilteredReduced() [3/4]

◆ blockingFilteredReduced() [4/4]

◆ blockingMap() [1/2]

◆ blockingMap() [2/2]

◆ blockingMapped() [1/4]

◆ blockingMapped() [2/4]

◆ blockingMapped() [3/4]

◆ blockingMapped() [4/4]

◆ blockingMappedReduced() [1/4]

◆ blockingMappedReduced() [2/4]

◆ blockingMappedReduced() [3/4]

◆ blockingMappedReduced() [4/4]

◆ filter()

◆ filtered() [1/2]

◆ filtered() [2/2]

◆ filteredReduced() [1/4]

◆ filteredReduced() [2/4]

◆ filteredReduced() [3/4]

◆ filteredReduced() [4/4]

◆ filterInternal()

◆ map() [1/2]

◆ map() [2/2]

◆ mapped() [1/2]

◆ mapped() [2/2]

◆ mappedReduced() [1/4]

◆ mappedReduced() [2/4]

◆ mappedReduced() [3/4]

◆ mappedReduced() [4/4]

◆ run() [1/72]

◆ run() [2/72]

◆ run() [3/72]

◆ run() [4/72]

◆ run() [5/72]

◆ run() [6/72]

◆ run() [7/72]

◆ run() [8/72]

◆ run() [9/72]

◆ run() [10/72]

◆ run() [11/72]

◆ run() [12/72]

◆ run() [13/72]

◆ run() [14/72]

◆ run() [15/72]

◆ run() [16/72]

◆ run() [17/72]

◆ run() [18/72]

◆ run() [19/72]

◆ run() [20/72]

◆ run() [21/72]

◆ run() [22/72]

◆ run() [23/72]

◆ run() [24/72]

◆ run() [25/72]

◆ run() [26/72]

◆ run() [27/72]

◆ run() [28/72]

◆ run() [29/72]

◆ run() [30/72]

◆ run() [31/72]

◆ run() [32/72]

◆ run() [33/72]

◆ run() [34/72]