QtConcurrent Namespace Reference

Namespaces
	internal

Classes
class	BlockSizeManager
class	ConstMemberFunctionWrapper
class	Exception
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	MemberFunctionWrapper
class	MemberFunctionWrapper1
struct	qValueType
struct	qValueType< const T * >
struct	qValueType< T * >
class	ReduceKernel
class	ResultItem
class	ResultIterator
class	ResultIteratorBase
class	ResultReporter
class	ResultReporter< void >
class	ResultStore
class	ResultStoreBase
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
struct	SequenceHolder1
struct	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	UnhandledException
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

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)
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)
template<typename Sequence , typename KeepFunctor >
ThreadEngineStarter< typename Sequence::value_type >	startFiltered (const Sequence &sequence, KeepFunctor functor)
template<typename ResultType , typename Sequence , typename MapFunctor , typename ReduceFunctor >
ThreadEngineStarter< ResultType >	startFilteredReduced (const Sequence &sequence, MapFunctor mapFunctor, ReduceFunctor reduceFunctor, ReduceOptions options)
template<typename ResultType , typename Iterator , typename MapFunctor , typename ReduceFunctor >
ThreadEngineStarter< ResultType >	startFilteredReduced (Iterator begin, Iterator end, MapFunctor mapFunctor, ReduceFunctor reduceFunctor, ReduceOptions options)
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)
template<typename T , typename Iterator , typename Functor >
ThreadEngineStarter< T >	startMapped (Iterator begin, Iterator end, Functor functor)
template<typename T , typename Sequence , typename Functor >
ThreadEngineStarter< T >	startMapped (const Sequence &sequence, Functor functor)
template<typename IntermediateType , typename ResultType , typename Sequence , typename MapFunctor , typename ReduceFunctor >
ThreadEngineStarter< ResultType >	startMappedReduced (const Sequence &sequence, MapFunctor mapFunctor, ReduceFunctor reduceFunctor, ReduceOptions options)
template<typename IntermediateType , typename ResultType , typename Iterator , typename MapFunctor , typename ReduceFunctor >
ThreadEngineStarter< ResultType >	startMappedReduced (Iterator begin, Iterator end, MapFunctor mapFunctor, ReduceFunctor reduceFunctor, ReduceOptions options)
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 ThreadEngine >
ThreadEngineStarter< typename ThreadEngine::ResultType >	startThreadEngine (ThreadEngine *threadEngine)

Enumeration Type Documentation

anonymous enum

Enumerator
ReduceQueueStartLimit
ReduceQueueThrottleLimit

Definition at line 73 of file qtconcurrentreducekernel.h.

     {
    ReduceQueueStartLimit = 20,
    ReduceQueueThrottleLimit = 30
};

enum ReduceOption

Enumerator
UnorderedReduce
OrderedReduce
SequentialReduce

Definition at line 91 of file qtconcurrentreducekernel.h.

                  {
    UnorderedReduce = 0x1,
    OrderedReduce = 0x2,
    SequentialReduce = 0x4
    // ParallelReduce = 0x8
};

enum ThreadFunctionResult

Enumerator
ThrottleThread
ThreadFinished

Definition at line 91 of file qtconcurrentthreadengine.h.

{ ThrottleThread, ThreadFinished };

Function Documentation

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

Definition at line 106 of file qtconcurrentfilter.h.

{
    typedef FilterKernel<Sequence, KeepFunctor, ReduceFunctor> KernelType;
    return startThreadEngine(new KernelType(sequence, keep, reduce));
}

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

Definition at line 114 of file qtconcurrentfilter.h.

{
    return filterInternal(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::PushBackWrapper());
}

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

Definition at line 121 of file qtconcurrentfilter.h.

{
    return startFilteredReduced<ResultType>(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options);
}

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

Definition at line 130 of file qtconcurrentfilter.h.

{
    return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
            (sequence,
             QtPrivate::createFunctionWrapper(keep),
             QtPrivate::createFunctionWrapper(reduce),
             options);
}

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

Definition at line 144 of file qtconcurrentfilter.h.

{
   return startFilteredReduced<ResultType>(begin, end, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options);
}

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

Definition at line 154 of file qtconcurrentfilter.h.

{
   return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
           (begin, end,
            QtPrivate::createFunctionWrapper(keep),
            QtPrivate::createFunctionWrapper(reduce),
            options);
}

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

Definition at line 169 of file qtconcurrentfilter.h.

{
    return startFiltered(sequence, QtPrivate::createFunctionWrapper(keep));
}

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

Definition at line 176 of file qtconcurrentfilter.h.

{
    return startFiltered(begin, end, QtPrivate::createFunctionWrapper(keep));
}

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

Definition at line 183 of file qtconcurrentfilter.h.

{
    filterInternal(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::PushBackWrapper()).startBlocking();
}

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

Definition at line 190 of file qtconcurrentfilter.h.

{
    return startFilteredReduced<ResultType>(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options)
        .startBlocking();
}

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

Definition at line 200 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
        (sequence,
         QtPrivate::createFunctionWrapper(keep),
         QtPrivate::createFunctionWrapper(reduce),
         options);
}

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

Definition at line 214 of file qtconcurrentfilter.h.

{
    return startFilteredReduced<ResultType>
        (begin, end,
         QtPrivate::createFunctionWrapper(keep),
         QtPrivate::createFunctionWrapper(reduce),
         options)
        .startBlocking();
}

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

Definition at line 229 of file qtconcurrentfilter.h.

{
    return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
        (begin, end,
         QtPrivate::createFunctionWrapper(keep),
         QtPrivate::createFunctionWrapper(reduce),
         options)
        .startBlocking();
}

Sequence QtConcurrent::blockingFiltered	(	const Sequence &	sequence,
		KeepFunctor	keep
	)

Definition at line 245 of file qtconcurrentfilter.h.

{
    return startFilteredReduced<Sequence>(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::PushBackWrapper(), OrderedReduce).startBlocking();
}

OutputSequence QtConcurrent::blockingFiltered	(	Iterator	begin,
		Iterator	end,
		KeepFunctor	keep
	)

Definition at line 252 of file qtconcurrentfilter.h.

{
    return startFilteredReduced<OutputSequence>(begin, end,
        QtPrivate::createFunctionWrapper(keep),
        QtPrivate::PushBackWrapper(),
        OrderedReduce).startBlocking();
}

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

inline

Definition at line 302 of file qtconcurrentfilterkernel.h.

{
    return startThreadEngine(new FilteredEachKernel<Iterator, KeepFunctor>(begin, end, functor));
}

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

inline

Definition at line 309 of file qtconcurrentfilterkernel.h.

{
    typedef SequenceHolder1<Sequence,
                            FilteredEachKernel<typename Sequence::const_iterator, KeepFunctor>,
                            KeepFunctor>
        SequenceHolderType;
        return startThreadEngine(new SequenceHolderType(sequence, functor));
}

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

inline

Definition at line 319 of file qtconcurrentfilterkernel.h.

{
    typedef typename Sequence::const_iterator Iterator;
    typedef ReduceKernel<ReduceFunctor, ResultType, typename qValueType<Iterator>::value_type > Reducer;
    typedef FilteredReducedKernel<ResultType, Iterator, MapFunctor, ReduceFunctor, Reducer> FilteredReduceType;
    typedef SequenceHolder2<Sequence, FilteredReduceType, MapFunctor, ReduceFunctor> SequenceHolderType;
    return startThreadEngine(new SequenceHolderType(sequence, mapFunctor, reduceFunctor, options));
}

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

inline

Definition at line 332 of file qtconcurrentfilterkernel.h.

{
    typedef ReduceKernel<ReduceFunctor, ResultType, typename qValueType<Iterator>::value_type> Reducer;
    typedef FilteredReducedKernel<ResultType, Iterator, MapFunctor, ReduceFunctor, Reducer> FilteredReduceType;
    return startThreadEngine(new FilteredReduceType(begin, end, mapFunctor, reduceFunctor, options));
}

bool QtConcurrent::selectIteration ( std::bidirectional_iterator_tag  )

inline

Definition at line 154 of file qtconcurrentiteratekernel.h.

{
    return false; // while
}

bool QtConcurrent::selectIteration ( std::forward_iterator_tag  )

inline

Definition at line 159 of file qtconcurrentiteratekernel.h.

{
    return false; // while
}

bool QtConcurrent::selectIteration ( std::random_access_iterator_tag  )

inline

Definition at line 164 of file qtconcurrentiteratekernel.h.

{
    return true; // for
}

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

Definition at line 111 of file qtconcurrentmap.h.

{
    return startMap(sequence.begin(), sequence.end(), QtPrivate::createFunctionWrapper(map));
}

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

Definition at line 118 of file qtconcurrentmap.h.

{
    return startMap(begin, end, QtPrivate::createFunctionWrapper(map));
}

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

Definition at line 125 of file qtconcurrentmap.h.

{
    return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
        (sequence,
         QtPrivate::createFunctionWrapper(map),
         QtPrivate::createFunctionWrapper(reduce),
         options);
}

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

Definition at line 138 of file qtconcurrentmap.h.

{
    return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
        (sequence,
         QtPrivate::createFunctionWrapper(map),
         QtPrivate::createFunctionWrapper(reduce),
         options);
}

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

Definition at line 152 of file qtconcurrentmap.h.

{
    return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
        (begin, end,
         QtPrivate::createFunctionWrapper(map),
         QtPrivate::createFunctionWrapper(reduce),
         options);
}

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

Definition at line 166 of file qtconcurrentmap.h.

{
    return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
        (begin, end,
         QtPrivate::createFunctionWrapper(map),
         QtPrivate::createFunctionWrapper(reduce),
         options);
}

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

Definition at line 181 of file qtconcurrentmap.h.

{
    return startMapped<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType>(sequence, QtPrivate::createFunctionWrapper(map));
}

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

Definition at line 188 of file qtconcurrentmap.h.

{
    return startMapped<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType>(begin, end, QtPrivate::createFunctionWrapper(map));
}

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

Definition at line 195 of file qtconcurrentmap.h.

{
    startMap(sequence.begin(), sequence.end(), QtPrivate::createFunctionWrapper(map)).startBlocking();
}

void QtConcurrent::blockingMap	(	Iterator	begin,
		Iterator	end,
		MapFunctor	map
	)

Definition at line 202 of file qtconcurrentmap.h.

{
    startMap(begin, end, QtPrivate::createFunctionWrapper(map)).startBlocking();
}

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

Definition at line 209 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
        (sequence,
         QtPrivate::createFunctionWrapper(map),
         QtPrivate::createFunctionWrapper(reduce),
         options)
        .startBlocking();
}

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

Definition at line 223 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
        (sequence,
         QtPrivate::createFunctionWrapper(map),
         QtPrivate::createFunctionWrapper(reduce),
         options)
        .startBlocking();
}

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

Definition at line 238 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
        (begin, end,
         QtPrivate::createFunctionWrapper(map),
         QtPrivate::createFunctionWrapper(reduce),
         options)
        .startBlocking();
}

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

Definition at line 253 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
        (begin, end,
         QtPrivate::createFunctionWrapper(map),
         QtPrivate::createFunctionWrapper(reduce),
         options)
        .startBlocking();
}

OutputSequence QtConcurrent::blockingMapped	(	const InputSequence &	sequence,
		MapFunctor	map
	)

Definition at line 269 of file qtconcurrentmap.h.

{
    return blockingMappedReduced<OutputSequence>
        (sequence,
         QtPrivate::createFunctionWrapper(map),
         QtPrivate::PushBackWrapper(),
         QtConcurrent::OrderedReduce);
}

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

Definition at line 279 of file qtconcurrentmap.h.

{
    typedef typename QtPrivate::MapResultType<InputSequence, MapFunctor>::ResultType OutputSequence;
    return blockingMappedReduced<OutputSequence>
        (sequence,
         QtPrivate::createFunctionWrapper(map),
         QtPrivate::PushBackWrapper(),
         QtConcurrent::OrderedReduce);
}

Sequence QtConcurrent::blockingMapped	(	Iterator	begin,
		Iterator	end,
		MapFunctor	map
	)

Definition at line 291 of file qtconcurrentmap.h.

{
    return blockingMappedReduced<Sequence>
        (begin, end,
         QtPrivate::createFunctionWrapper(map),
         QtPrivate::PushBackWrapper(),
         QtConcurrent::OrderedReduce);
}

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

Definition at line 301 of file qtconcurrentmap.h.

{
    typedef typename QtPrivate::MapResultType<Iterator, MapFunctor>::ResultType OutputSequence;
    return blockingMappedReduced<OutputSequence>
        (begin, end,
         QtPrivate::createFunctionWrapper(map),
         QtPrivate::PushBackWrapper(),
         QtConcurrent::OrderedReduce);
}

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

inline

Definition at line 199 of file qtconcurrentmapkernel.h.

{
    return startThreadEngine(new MapKernel<Iterator, Functor>(begin, end, functor));
}

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

inline

Definition at line 205 of file qtconcurrentmapkernel.h.

{
    return startThreadEngine(new MappedEachKernel<Iterator, Functor>(begin, end, functor));
}

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

inline

Definition at line 233 of file qtconcurrentmapkernel.h.

{
    typedef SequenceHolder1<Sequence,
                            MappedEachKernel<typename Sequence::const_iterator , Functor>, Functor>
                            SequenceHolderType;

    return startThreadEngine(new SequenceHolderType(sequence, functor));
}

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

inline

Definition at line 243 of file qtconcurrentmapkernel.h.

{
    typedef typename Sequence::const_iterator Iterator;
    typedef ReduceKernel<ReduceFunctor, ResultType, IntermediateType> Reducer;
    typedef MappedReducedKernel<ResultType, Iterator, MapFunctor, ReduceFunctor, Reducer> MappedReduceType;
    typedef SequenceHolder2<Sequence, MappedReduceType, MapFunctor, ReduceFunctor> SequenceHolderType;
    return startThreadEngine(new SequenceHolderType(sequence, mapFunctor, reduceFunctor, options));
}

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

inline

Definition at line 255 of file qtconcurrentmapkernel.h.

{
    typedef ReduceKernel<ReduceFunctor, ResultType, IntermediateType> Reducer;
    typedef MappedReducedKernel<ResultType, Iterator, MapFunctor, ReduceFunctor, Reducer> MappedReduceType;
    return startThreadEngine(new MappedReduceType(begin, end, mapFunctor, reduceFunctor, options));
}

QFuture<T> QtConcurrent::run

(

T(*)()

functionPointer

)

Definition at line 72 of file qtconcurrentrun.h.

{
    return (new StoredFunctorCall0<T, T (*)()>(functionPointer))->start();
}

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

Definition at line 77 of file qtconcurrentrun.h.

{
    return (new StoredFunctorCall1<T, T (*)(Param1), Arg1>(functionPointer, arg1))->start();
}

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

Definition at line 82 of file qtconcurrentrun.h.

{
    return (new StoredFunctorCall2<T, T (*)(Param1, Param2), Arg1, Arg2>(functionPointer, arg1, arg2))->start();
}

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

Definition at line 87 of file qtconcurrentrun.h.

{
    return (new StoredFunctorCall3<T, T (*)(Param1, Param2, Param3), Arg1, Arg2, Arg3>(functionPointer, arg1, arg2, arg3))->start();
}

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

Definition at line 92 of file qtconcurrentrun.h.

{
    return (new StoredFunctorCall4<T, T (*)(Param1, Param2, Param3, Param4), Arg1, Arg2, Arg3, Arg4>(functionPointer, arg1, arg2, arg3, arg4))->start();
}

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
	)

Definition at line 97 of file qtconcurrentrun.h.

{
    return (new StoredFunctorCall5<T, T (*)(Param1, Param2, Param3, Param4, Param5), Arg1, Arg2, Arg3, Arg4, Arg5>(functionPointer, arg1, arg2, arg3, arg4, arg5))->start();
}

QFuture<typename FunctionObject::result_type> QtConcurrent::run

(

FunctionObject

functionObject

)

Definition at line 154 of file qtconcurrentrun.h.

{
    return (new StoredFunctorCall0<QT_TYPENAME FunctionObject::result_type, FunctionObject>(functionObject))->start();
}

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

Definition at line 159 of file qtconcurrentrun.h.

{
    return (new StoredFunctorCall1<QT_TYPENAME FunctionObject::result_type, FunctionObject, Arg1>(functionObject, arg1))->start();
}

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

Definition at line 164 of file qtconcurrentrun.h.

{
    return (new StoredFunctorCall2<QT_TYPENAME FunctionObject::result_type, FunctionObject, Arg1, Arg2>(functionObject, arg1, arg2))->start();
}

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

Definition at line 169 of file qtconcurrentrun.h.

{
    return (new StoredFunctorCall3<QT_TYPENAME FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3>(functionObject, arg1, arg2, arg3))->start();
}

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

Definition at line 174 of file qtconcurrentrun.h.

{
    return (new StoredFunctorCall4<QT_TYPENAME FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4>(functionObject, arg1, arg2, arg3, arg4))->start();
}

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

Definition at line 179 of file qtconcurrentrun.h.

{
    return (new StoredFunctorCall5<QT_TYPENAME FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4, Arg5>(functionObject, arg1, arg2, arg3, arg4, arg5))->start();
}

QFuture<typename FunctionObject::result_type> QtConcurrent::run

(

FunctionObject *

functionObject

)

Definition at line 185 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredFunctorPointerCall0<QT_TYPENAME FunctionObject::result_type, FunctionObject>::type(functionObject))->start();
}

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

Definition at line 190 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredFunctorPointerCall1<QT_TYPENAME FunctionObject::result_type, FunctionObject, Arg1>::type(functionObject, arg1))->start();
}

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

Definition at line 195 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredFunctorPointerCall2<QT_TYPENAME FunctionObject::result_type, FunctionObject, Arg1, Arg2>::type(functionObject, arg1, arg2))->start();
}

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

Definition at line 200 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredFunctorPointerCall3<QT_TYPENAME FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3>::type(functionObject, arg1, arg2, arg3))->start();
}

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

Definition at line 205 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredFunctorPointerCall4<QT_TYPENAME FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4>::type(functionObject, arg1, arg2, arg3, arg4))->start();
}

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

Definition at line 210 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredFunctorPointerCall5<QT_TYPENAME FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4, Arg5>::type(functionObject, arg1, arg2, arg3, arg4, arg5))->start();
}

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

Definition at line 216 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredMemberFunctionCall0<T, Class>::type(fn, object))->start();
}

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

Definition at line 221 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredMemberFunctionCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
}

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

Definition at line 226 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
}

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

Definition at line 231 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
}

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

Definition at line 236 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
}

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

Definition at line 241 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
}

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

Definition at line 278 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredMemberFunctionPointerCall0<T, Class>::type(fn, object))->start();
}

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

Definition at line 283 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredMemberFunctionPointerCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
}

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

Definition at line 288 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
}

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

Definition at line 293 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
}

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
	)

Definition at line 298 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
}

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
	)

Definition at line 303 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
}

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

Definition at line 309 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredConstMemberFunctionPointerCall0<T, Class>::type(fn, object))->start();
}

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

Definition at line 314 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredConstMemberFunctionPointerCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
}

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

Definition at line 319 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredConstMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
}

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

Definition at line 324 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredConstMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
}

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
	)

Definition at line 329 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredConstMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
}

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
	)

Definition at line 334 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredConstMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
}

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

inline

Definition at line 271 of file qtconcurrentthreadengine.h.

{
    return ThreadEngineStarter<typename ThreadEngine::ResultType>(threadEngine);
}