QtConcurrent Namespace Reference

Namespaces
namespace	internal
Classes
class	Exception
class	UnhandledException
struct	qValueType
struct	qValueType< const T * >
struct	qValueType< T * >
class	FilterKernel
class	FilteredReducedKernel
class	FilteredEachKernel
class	FunctionWrapper0
class	FunctionWrapper1
class	FunctionWrapper2
class	MemberFunctionWrapper
class	MemberFunctionWrapper1
class	ConstMemberFunctionWrapper
class	BlockSizeManager
class	ResultReporter
class	ResultReporter< void >
class	IterateKernel
class	MapKernel
class	MappedReducedKernel
class	MappedEachKernel
struct	SequenceHolder1
class	Median
class	IntermediateResults
class	ReduceKernel
struct	SequenceHolder2
class	ResultItem
class	ResultIteratorBase
class	ResultIterator
class	ResultStoreBase
class	ResultStore
struct	SelectSpecialization
struct	SelectSpecialization< void >
class	RunFunctionTaskBase
class	RunFunctionTask
class	RunFunctionTask< void >
struct	StoredFunctorCall0
struct	VoidStoredFunctorCall0
struct	SelectStoredFunctorCall0
struct	StoredFunctorPointerCall0
struct	VoidStoredFunctorPointerCall0
struct	SelectStoredFunctorPointerCall0
class	StoredMemberFunctionCall0
class	VoidStoredMemberFunctionCall0
struct	SelectStoredMemberFunctionCall0
class	StoredConstMemberFunctionCall0
class	VoidStoredConstMemberFunctionCall0
struct	SelectStoredConstMemberFunctionCall0
class	StoredMemberFunctionPointerCall0
class	VoidStoredMemberFunctionPointerCall0
struct	SelectStoredMemberFunctionPointerCall0
class	StoredConstMemberFunctionPointerCall0
class	VoidStoredConstMemberFunctionPointerCall0
struct	SelectStoredConstMemberFunctionPointerCall0
struct	StoredFunctorCall1
struct	VoidStoredFunctorCall1
struct	SelectStoredFunctorCall1
struct	StoredFunctorPointerCall1
struct	VoidStoredFunctorPointerCall1
struct	SelectStoredFunctorPointerCall1
class	StoredMemberFunctionCall1
class	VoidStoredMemberFunctionCall1
struct	SelectStoredMemberFunctionCall1
class	StoredConstMemberFunctionCall1
class	VoidStoredConstMemberFunctionCall1
struct	SelectStoredConstMemberFunctionCall1
class	StoredMemberFunctionPointerCall1
class	VoidStoredMemberFunctionPointerCall1
struct	SelectStoredMemberFunctionPointerCall1
class	StoredConstMemberFunctionPointerCall1
class	VoidStoredConstMemberFunctionPointerCall1
struct	SelectStoredConstMemberFunctionPointerCall1
struct	StoredFunctorCall2
struct	VoidStoredFunctorCall2
struct	SelectStoredFunctorCall2
struct	StoredFunctorPointerCall2
struct	VoidStoredFunctorPointerCall2
struct	SelectStoredFunctorPointerCall2
class	StoredMemberFunctionCall2
class	VoidStoredMemberFunctionCall2
struct	SelectStoredMemberFunctionCall2
class	StoredConstMemberFunctionCall2
class	VoidStoredConstMemberFunctionCall2
struct	SelectStoredConstMemberFunctionCall2
class	StoredMemberFunctionPointerCall2
class	VoidStoredMemberFunctionPointerCall2
struct	SelectStoredMemberFunctionPointerCall2
class	StoredConstMemberFunctionPointerCall2
class	VoidStoredConstMemberFunctionPointerCall2
struct	SelectStoredConstMemberFunctionPointerCall2
struct	StoredFunctorCall3
struct	VoidStoredFunctorCall3
struct	SelectStoredFunctorCall3
struct	StoredFunctorPointerCall3
struct	VoidStoredFunctorPointerCall3
struct	SelectStoredFunctorPointerCall3
class	StoredMemberFunctionCall3
class	VoidStoredMemberFunctionCall3
struct	SelectStoredMemberFunctionCall3
class	StoredConstMemberFunctionCall3
class	VoidStoredConstMemberFunctionCall3
struct	SelectStoredConstMemberFunctionCall3
class	StoredMemberFunctionPointerCall3
class	VoidStoredMemberFunctionPointerCall3
struct	SelectStoredMemberFunctionPointerCall3
class	StoredConstMemberFunctionPointerCall3
class	VoidStoredConstMemberFunctionPointerCall3
struct	SelectStoredConstMemberFunctionPointerCall3
struct	StoredFunctorCall4
struct	VoidStoredFunctorCall4
struct	SelectStoredFunctorCall4
struct	StoredFunctorPointerCall4
struct	VoidStoredFunctorPointerCall4
struct	SelectStoredFunctorPointerCall4
class	StoredMemberFunctionCall4
class	VoidStoredMemberFunctionCall4
struct	SelectStoredMemberFunctionCall4
class	StoredConstMemberFunctionCall4
class	VoidStoredConstMemberFunctionCall4
struct	SelectStoredConstMemberFunctionCall4
class	StoredMemberFunctionPointerCall4
class	VoidStoredMemberFunctionPointerCall4
struct	SelectStoredMemberFunctionPointerCall4
class	StoredConstMemberFunctionPointerCall4
class	VoidStoredConstMemberFunctionPointerCall4
struct	SelectStoredConstMemberFunctionPointerCall4
struct	StoredFunctorCall5
struct	VoidStoredFunctorCall5
struct	SelectStoredFunctorCall5
struct	StoredFunctorPointerCall5
struct	VoidStoredFunctorPointerCall5
struct	SelectStoredFunctorPointerCall5
class	StoredMemberFunctionCall5
class	VoidStoredMemberFunctionCall5
struct	SelectStoredMemberFunctionCall5
class	StoredConstMemberFunctionCall5
class	VoidStoredConstMemberFunctionCall5
struct	SelectStoredConstMemberFunctionCall5
class	StoredMemberFunctionPointerCall5
class	VoidStoredMemberFunctionPointerCall5
struct	SelectStoredMemberFunctionPointerCall5
class	StoredConstMemberFunctionPointerCall5
class	VoidStoredConstMemberFunctionPointerCall5
struct	SelectStoredConstMemberFunctionPointerCall5
class	ThreadEngineBarrier
class	ThreadEngineBase
class	ThreadEngine
class	ThreadEngineStarterBase
class	ThreadEngineStarter
class	ThreadEngineStarter< void >
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 T , typename C , typename U >
ThreadEngineStarter< void >	filterInternal (Sequence &sequence, KeepFunctor keep, T(C::*reduce)(U))
template<typename Sequence , typename KeepFunctor >
QFuture< void >	filter (Sequence &sequence, KeepFunctor keep)
template<typename Sequence , typename T >
QFuture< void >	filter (Sequence &sequence, bool(keep)(T))
template<typename Sequence , typename C >
QFuture< void >	filter (Sequence &sequence, bool(C::*keep)() const)
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 ResultType , typename Sequence , typename T , typename ReduceFunctor >
QFuture< ResultType >	filteredReduced (const Sequence &sequence, bool(filter)(T), ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType , typename Sequence , typename C , typename ReduceFunctor >
QFuture< ResultType >	filteredReduced (const Sequence &sequence, bool(C::*filter)() const, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename KeepFunctor , typename T , typename U , typename V >
QFuture< U >	filteredReduced (const Sequence &sequence, KeepFunctor keep, T(reduce)(U &, V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename KeepFunctor , typename T , typename C , typename U >
QFuture< C >	filteredReduced (const Sequence &sequence, KeepFunctor keep, T(C::*reduce)(U), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename T , typename U , typename V , typename W >
QFuture< V >	filteredReduced (const Sequence &sequence, bool(keep)(T), U(reduce)(V &, W), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename C , typename T , typename U , typename V >
QFuture< U >	filteredReduced (const Sequence &sequence, bool(C::*keep)() const, T(reduce)(U &, V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename T , typename U , typename C , typename V >
QFuture< C >	filteredReduced (const Sequence &sequence, bool(keep)(T), U(C::*reduce)(V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename C , typename T , typename D , typename U >
QFuture< D >	filteredReduced (const Sequence &sequence, bool(C::*keep)() const, T(D::*reduce)(U), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType , typename Iterator , typename KeepFunctor , typename ReduceFunctor >
QFuture< ResultType >	filteredReduced (Iterator begin, Iterator end, KeepFunctor keep, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType , typename Iterator , typename T , typename ReduceFunctor >
QFuture< ResultType >	filteredReduced (Iterator begin, Iterator end, bool(filter)(T), ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType , typename Iterator , typename C , typename ReduceFunctor >
QFuture< ResultType >	filteredReduced (Iterator begin, Iterator end, bool(C::*filter)() const, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename KeepFunctor , typename T , typename U , typename V >
QFuture< U >	filteredReduced (Iterator begin, Iterator end, KeepFunctor keep, T(reduce)(U &, V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename KeepFunctor , typename T , typename C , typename U >
QFuture< C >	filteredReduced (Iterator begin, Iterator end, KeepFunctor keep, T(C::*reduce)(U), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename T , typename U , typename V , typename W >
QFuture< V >	filteredReduced (Iterator begin, Iterator end, bool(keep)(T), U(reduce)(V &, W), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename C , typename T , typename U , typename V >
QFuture< U >	filteredReduced (Iterator begin, Iterator end, bool(C::*keep)() const, T(reduce)(U &, V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename T , typename U , typename C , typename V >
QFuture< C >	filteredReduced (Iterator begin, Iterator end, bool(keep)(T), U(C::*reduce)(V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename C , typename T , typename D , typename U >
QFuture< D >	filteredReduced (Iterator begin, Iterator end, bool(C::*keep)() const, T(D::*reduce)(U), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename KeepFunctor >
QFuture< typename Sequence::value_type >	filtered (const Sequence &sequence, KeepFunctor keep)
template<typename Sequence , typename T >
QFuture< typename Sequence::value_type >	filtered (const Sequence &sequence, bool(keep)(T))
template<typename Sequence , typename C >
QFuture< typename Sequence::value_type >	filtered (const Sequence &sequence, bool(C::*keep)() const)
template<typename Iterator , typename KeepFunctor >
QFuture< typename qValueType < Iterator >::value_type >	filtered (Iterator begin, Iterator end, KeepFunctor keep)
template<typename Iterator , typename T >
QFuture< typename qValueType < Iterator >::value_type >	filtered (Iterator begin, Iterator end, bool(keep)(T))
template<typename Iterator , typename C >
QFuture< typename qValueType < Iterator >::value_type >	filtered (Iterator begin, Iterator end, bool(C::*keep)() const)
template<typename Sequence , typename KeepFunctor >
void	blockingFilter (Sequence &sequence, KeepFunctor keep)
template<typename Sequence , typename T >
void	blockingFilter (Sequence &sequence, bool(keep)(T))
template<typename Sequence , typename C >
void	blockingFilter (Sequence &sequence, bool(C::*keep)() const)
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 ResultType , typename Sequence , typename T , typename ReduceFunctor >
ResultType	blockingFilteredReduced (const Sequence &sequence, bool(filter)(T), ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType , typename Sequence , typename C , typename ReduceFunctor >
ResultType	blockingFilteredReduced (const Sequence &sequence, bool(C::*filter)() const, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename KeepFunctor , typename T , typename U , typename V >
U	blockingFilteredReduced (const Sequence &sequence, KeepFunctor keep, T(reduce)(U &, V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename KeepFunctor , typename T , typename C , typename U >
C	blockingFilteredReduced (const Sequence &sequence, KeepFunctor keep, T(C::*reduce)(U), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename T , typename U , typename V , typename W >
V	blockingFilteredReduced (const Sequence &sequence, bool(keep)(T), U(reduce)(V &, W), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename C , typename T , typename U , typename V >
U	blockingFilteredReduced (const Sequence &sequence, bool(C::*keep)() const, T(reduce)(U &, V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename T , typename U , typename C , typename V >
C	blockingFilteredReduced (const Sequence &sequence, bool(keep)(T), U(C::*reduce)(V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename C , typename T , typename D , typename U >
D	blockingFilteredReduced (const Sequence &sequence, bool(C::*keep)() const, T(D::*reduce)(U), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType , typename Iterator , typename KeepFunctor , typename ReduceFunctor >
ResultType	blockingFilteredReduced (Iterator begin, Iterator end, KeepFunctor keep, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType , typename Iterator , typename T , typename ReduceFunctor >
ResultType	blockingFilteredReduced (Iterator begin, Iterator end, bool(filter)(T), ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType , typename Iterator , typename C , typename ReduceFunctor >
ResultType	blockingFilteredReduced (Iterator begin, Iterator end, bool(C::*filter)() const, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename KeepFunctor , typename T , typename U , typename V >
U	blockingFilteredReduced (Iterator begin, Iterator end, KeepFunctor keep, T(reduce)(U &, V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename KeepFunctor , typename T , typename C , typename U >
C	blockingFilteredReduced (Iterator begin, Iterator end, KeepFunctor keep, T(C::*reduce)(U), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename T , typename U , typename V , typename W >
V	blockingFilteredReduced (Iterator begin, Iterator end, bool(keep)(T), U(reduce)(V &, W), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename C , typename T , typename U , typename V >
U	blockingFilteredReduced (Iterator begin, Iterator end, bool(C::*keep)() const, T(reduce)(U &, V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename T , typename U , typename C , typename V >
C	blockingFilteredReduced (Iterator begin, Iterator end, bool(keep)(T), U(C::*reduce)(V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename C , typename T , typename D , typename U >
D	blockingFilteredReduced (Iterator begin, Iterator end, bool(C::*keep)() const, T(D::*reduce)(U), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename KeepFunctor >
Sequence	blockingFiltered (const Sequence &sequence, KeepFunctor keep)
template<typename Sequence , typename T >
Sequence	blockingFiltered (const Sequence &sequence, bool(keep)(T))
template<typename Sequence , typename C >
Sequence	blockingFiltered (const Sequence &sequence, bool(C::*filter)() const)
template<typename OutputSequence , typename Iterator , typename KeepFunctor >
OutputSequence	blockingFiltered (Iterator begin, Iterator end, KeepFunctor keep)
template<typename OutputSequence , typename Iterator , typename T >
OutputSequence	blockingFiltered (Iterator begin, Iterator end, bool(keep)(T))
template<typename OutputSequence , typename Iterator , typename C >
OutputSequence	blockingFiltered (Iterator begin, Iterator end, bool(C::*filter)() const)
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 Sequence , typename T , typename U >
QFuture< void >	map (Sequence &sequence, T(map)(U))
template<typename Sequence , typename T , typename C >
QFuture< void >	map (Sequence &sequence, T(C::*map)())
template<typename Iterator , typename MapFunctor >
QFuture< void >	map (Iterator begin, Iterator end, MapFunctor map)
template<typename Iterator , typename T , typename U >
QFuture< void >	map (Iterator begin, Iterator end, T(map)(U))
template<typename Iterator , typename T , typename C >
QFuture< void >	map (Iterator begin, Iterator end, T(C::*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 T , typename U , typename V >
QFuture< U >	mappedReduced (const Sequence &sequence, MapFunctor map, T(reduce)(U &, V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename MapFunctor , typename T , typename C , typename U >
QFuture< C >	mappedReduced (const Sequence &sequence, MapFunctor map, T(C::*reduce)(U), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType , typename Sequence , typename T , typename U , typename ReduceFunctor >
QFuture< ResultType >	mappedReduced (const Sequence &sequence, T(map)(U), ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType , typename Sequence , typename T , typename C , typename ReduceFunctor >
QFuture< ResultType >	mappedReduced (const Sequence &sequence, T(C::*map)() const, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename T , typename U , typename V , typename W , typename X >
QFuture< W >	mappedReduced (const Sequence &sequence, T(map)(U), V(reduce)(W &, X), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename T , typename C , typename U , typename V , typename W >
QFuture< V >	mappedReduced (const Sequence &sequence, T(C::*map)() const, U(reduce)(V &, W), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename T , typename U , typename V , typename C , typename W >
QFuture< C >	mappedReduced (const Sequence &sequence, T(map)(U), V(C::*reduce)(W), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename T , typename C , typename U , typename D , typename V >
QFuture< D >	mappedReduced (const Sequence &sequence, T(C::*map)() const, U(D::*reduce)(V), 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 T , typename U , typename V >
QFuture< U >	mappedReduced (Iterator begin, Iterator end, MapFunctor map, T(reduce)(U &, V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename MapFunctor , typename T , typename C , typename U >
QFuture< C >	mappedReduced (Iterator begin, Iterator end, MapFunctor map, T(C::*reduce)(U), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType , typename Iterator , typename T , typename U , typename ReduceFunctor >
QFuture< ResultType >	mappedReduced (Iterator begin, Iterator end, T(map)(U), ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename ResultType , typename Iterator , typename T , typename C , typename ReduceFunctor >
QFuture< ResultType >	mappedReduced (Iterator begin, Iterator end, T(C::*map)() const, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename T , typename U , typename V , typename W , typename X >
QFuture< W >	mappedReduced (Iterator begin, Iterator end, T(map)(U), V(reduce)(W &, X), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename T , typename C , typename U , typename V , typename W >
QFuture< V >	mappedReduced (Iterator begin, Iterator end, T(C::*map)() const, U(reduce)(V &, W), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename T , typename U , typename V , typename C , typename W >
QFuture< C >	mappedReduced (Iterator begin, Iterator end, T(map)(U), V(C::*reduce)(W), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator , typename T , typename C , typename U , typename D , typename V >
QFuture< D >	mappedReduced (Iterator begin, Iterator end, T(C::*map)() const, U(D::*reduce)(V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence , typename MapFunctor >
QFuture< typename MapFunctor::result_type >	mapped (const Sequence &sequence, MapFunctor map)
template<typename Sequence , typename T , typename U >
QFuture< T >	mapped (const Sequence &sequence, T(map)(U))
template<typename Sequence , typename T , typename C >
QFuture< T >	mapped (const Sequence &sequence, T(C::*map)() const)
template<typename Iterator , typename MapFunctor >
QFuture< typename MapFunctor::result_type >	mapped (Iterator begin, Iterator end, MapFunctor map)
template<typename Iterator , typename T , typename U >
QFuture< T >	mapped (Iterator begin, Iterator end, T(map)(U))
template<typename Iterator , typename T , typename C >
QFuture< T >	mapped (Iterator begin, Iterator end, T(C::*map)() const)
template<typename Sequence , typename MapFunctor >
void	blockingMap (Sequence &sequence, MapFunctor map)
template<typename Sequence , typename T , typename U >
void	blockingMap (Sequence &sequence, T(map)(U))
template<typename Sequence , typename T , typename C >
void	blockingMap (Sequence &sequence, T(C::*map)())
template<typename Iterator , typename MapFunctor >
void	blockingMap (Iterator begin, Iterator end, MapFunctor map)
template<typename Iterator , typename T , typename U >
void	blockingMap (Iterator begin, Iterator end, T(map)(U))
template<typename Iterator , typename T , typename C >
void	blockingMap (Iterator begin, Iterator end, T(C::*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 Sequence , typename MapFunctor , typename T , typename U , typename V >
U	blockingMappedReduced (const Sequence &sequence, MapFunctor map, T(reduce)(U &, V), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename Sequence , typename MapFunctor , typename T , typename C , typename U >
C	blockingMappedReduced (const Sequence &sequence, MapFunctor map, T(C::*reduce)(U), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename ResultType , typename Sequence , typename T , typename U , typename ReduceFunctor >
ResultType	blockingMappedReduced (const Sequence &sequence, T(map)(U), ReduceFunctor reduce, QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename ResultType , typename Sequence , typename T , typename C , typename ReduceFunctor >
ResultType	blockingMappedReduced (const Sequence &sequence, T(C::*map)() const, ReduceFunctor reduce, QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename Sequence , typename T , typename U , typename V , typename W , typename X >
W	blockingMappedReduced (const Sequence &sequence, T(map)(U), V(reduce)(W &, X), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename Sequence , typename T , typename C , typename U , typename V , typename W >
V	blockingMappedReduced (const Sequence &sequence, T(C::*map)() const, U(reduce)(V &, W), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename Sequence , typename T , typename U , typename V , typename C , typename W >
C	blockingMappedReduced (const Sequence &sequence, T(map)(U), V(C::*reduce)(W), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename Sequence , typename T , typename C , typename U , typename D , typename V >
D	blockingMappedReduced (const Sequence &sequence, T(C::*map)() const, U(D::*reduce)(V), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::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 T , typename U , typename V >
U	blockingMappedReduced (Iterator begin, Iterator end, MapFunctor map, T(reduce)(U &, V), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename Iterator , typename MapFunctor , typename T , typename C , typename U >
C	blockingMappedReduced (Iterator begin, Iterator end, MapFunctor map, T(C::*reduce)(U), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename ResultType , typename Iterator , typename T , typename U , typename ReduceFunctor >
ResultType	blockingMappedReduced (Iterator begin, Iterator end, T(map)(U), ReduceFunctor reduce, QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename ResultType , typename Iterator , typename T , typename C , typename ReduceFunctor >
ResultType	blockingMappedReduced (Iterator begin, Iterator end, T(C::*map)() const, ReduceFunctor reduce, QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename Iterator , typename T , typename U , typename V , typename W , typename X >
W	blockingMappedReduced (Iterator begin, Iterator end, T(map)(U), V(reduce)(W &, X), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename Iterator , typename T , typename C , typename U , typename V , typename W >
V	blockingMappedReduced (Iterator begin, Iterator end, T(C::*map)() const, U(reduce)(V &, W), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename Iterator , typename T , typename U , typename V , typename C , typename W >
C	blockingMappedReduced (Iterator begin, Iterator end, T(map)(U), V(C::*reduce)(W), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename Iterator , typename T , typename C , typename U , typename D , typename V >
D	blockingMappedReduced (Iterator begin, Iterator end, T(C::*map)() const, U(D::*reduce)(V), 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 OutputSequence , typename InputSequence , typename T , typename U >
OutputSequence	blockingMapped (const InputSequence &sequence, T(map)(U))
template<typename OutputSequence , typename InputSequence , typename T , typename C >
OutputSequence	blockingMapped (const InputSequence &sequence, T(C::*map)() const)
template<template< typename > class Sequence, typename MapFunctor , typename T >
Sequence< typename MapFunctor::result_type >	blockingMapped (const Sequence< T > &sequence, MapFunctor map)
template<template< typename > class Sequence, typename T , typename U , typename V >
Sequence< U >	blockingMapped (const Sequence< T > &sequence, U(map)(V))
template<template< typename > class Sequence, typename T , typename U , typename C >
Sequence< U >	blockingMapped (const Sequence< T > &sequence, U(C::*map)() const)
template<typename MapFunctor >
QList< typename MapFunctor::result_type >	blockingMapped (const QStringList &sequence, MapFunctor map)
template<typename U , typename V >
QList< U >	blockingMapped (const QStringList &sequence, U(map)(V))
template<typename U , typename C >
QList< U >	blockingMapped (const QStringList &sequence, U(C::*map)() const)
template<typename Sequence , typename Iterator , typename MapFunctor >
Sequence	blockingMapped (Iterator begin, Iterator end, MapFunctor map)
template<typename Sequence , typename Iterator , typename T , typename U >
Sequence	blockingMapped (Iterator begin, Iterator end, T(map)(U))
template<typename Sequence , typename Iterator , typename T , typename C >
Sequence	blockingMapped (Iterator begin, Iterator end, T(C::*map)() const)
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

Search for all occurrences

Enumerator:

ReduceQueueStartLimit	Search for all occurrences
ReduceQueueThrottleLimit	Search for all occurrences

Definition at line 73 of file qtconcurrentreducekernel.h.

     {
    ReduceQueueStartLimit = 20,
    ReduceQueueThrottleLimit = 30
};

enum ReduceOption

Search for all occurrences

Enumerator:

UnorderedReduce	Search for all occurrences
OrderedReduce	Search for all occurrences
SequentialReduce	Search for all occurrences

Definition at line 91 of file qtconcurrentreducekernel.h.

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

enum ThreadFunctionResult

Search for all occurrences

Enumerator:

ThrottleThread	Search for all occurrences
ThreadFinished	Search for all occurrences

Definition at line 91 of file qtconcurrentthreadengine.h.

{ ThrottleThread, ThreadFinished };

---

Function Documentation

ThreadEngineStarter<void> QtConcurrent::filterInternal	(	Sequence &	sequence,
		KeepFunctor	keep,
		T(C::*)(U)	reduce
	)

Search for all occurrences

Definition at line 106 of file qtconcurrentfilter.h.

{
    typedef MemberFunctionWrapper1<T, C, U> ReduceFunctor;
    typedef typename Sequence::const_iterator Iterator;
    typedef FilterKernel<Sequence, KeepFunctor, ReduceFunctor> KernelType;
    return startThreadEngine(new KernelType(sequence, keep, reduce));
}

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

Search for all occurrences

Examples:

PtexExtractor/ptex/Ptexture.h, and PtexImporter/ptex/Ptexture.h.

Definition at line 116 of file qtconcurrentfilter.h.

{
    return filterInternal(sequence, keep, &Sequence::push_back);
}

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

Search for all occurrences

Definition at line 122 of file qtconcurrentfilter.h.

{
    return filterInternal(sequence, FunctionWrapper1<bool, T>(keep), &Sequence::push_back);
}

QFuture<void> QtConcurrent::filter	(	Sequence &	sequence,
		bool(C::*)() const	keep
	)

Search for all occurrences

Definition at line 128 of file qtconcurrentfilter.h.

{
    return filterInternal(sequence, ConstMemberFunctionWrapper<bool, C>(keep), &Sequence::push_back);
}

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

Search for all occurrences

Definition at line 135 of file qtconcurrentfilter.h.

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

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

Search for all occurrences

Definition at line 144 of file qtconcurrentfilter.h.

{
    return filteredReduced<ResultType>(sequence,
                                       FunctionWrapper1<bool, T>(filter),
                                       reduce,
                                       options);
}

QFuture<ResultType> QtConcurrent::filteredReduced	(	const Sequence &	sequence,
		bool(C::*)() const	filter,
		ReduceFunctor	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 156 of file qtconcurrentfilter.h.

{
    return filteredReduced<ResultType>(sequence,
                                       ConstMemberFunctionWrapper<bool, C>(filter),
                                       reduce,
                                       options);
}

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

Search for all occurrences

Definition at line 168 of file qtconcurrentfilter.h.

{
    return filteredReduced<U>(sequence,
                              keep,
                              FunctionWrapper2<T, U &, V>(reduce),
                              options);
}

QFuture<C> QtConcurrent::filteredReduced	(	const Sequence &	sequence,
		KeepFunctor	keep,
		T(C::*)(U)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 180 of file qtconcurrentfilter.h.

{
    return filteredReduced<C>(sequence,
                              keep,
                              MemberFunctionWrapper1<T, C, U>(reduce),
                              options);
}

QFuture<V> QtConcurrent::filteredReduced	(	const Sequence &	sequence,
		bool(keep)(T)	,
		U(reduce)(V &, W)	,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 192 of file qtconcurrentfilter.h.

{
    return filteredReduced<V>(sequence,
                              FunctionWrapper1<bool, T>(keep),
                              FunctionWrapper2<U, V &, W>(reduce),
                              options);
}

QFuture<U> QtConcurrent::filteredReduced	(	const Sequence &	sequence,
		bool(C::*)() const	keep,
		T(reduce)(U &, V)	,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 204 of file qtconcurrentfilter.h.

{
    return filteredReduced<U>(sequence,
                              ConstMemberFunctionWrapper<bool, C>(keep),
                              FunctionWrapper2<T, U &, V>(reduce),
                              options);
}

QFuture<C> QtConcurrent::filteredReduced	(	const Sequence &	sequence,
		bool(keep)(T)	,
		U(C::*)(V)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 216 of file qtconcurrentfilter.h.

{
    return filteredReduced<C>(sequence,
                              FunctionWrapper1<bool, T>(keep),
                              MemberFunctionWrapper1<U, C, V>(reduce),
                              options);
}

QFuture<D> QtConcurrent::filteredReduced	(	const Sequence &	sequence,
		bool(C::*)() const	keep,
		T(D::*)(U)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 228 of file qtconcurrentfilter.h.

{
    return filteredReduced<D>(sequence,
                              ConstMemberFunctionWrapper<bool, C>(keep),
                              MemberFunctionWrapper1<T, D, U>(reduce),
                              options);
}

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

Search for all occurrences

Definition at line 241 of file qtconcurrentfilter.h.

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

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

Search for all occurrences

Definition at line 251 of file qtconcurrentfilter.h.

{
    return filteredReduced<ResultType>(begin,
                                       end,
                                       FunctionWrapper1<bool, T>(filter),
                                       reduce,
                                       options);
}

QFuture<ResultType> QtConcurrent::filteredReduced	(	Iterator	begin,
		Iterator	end,
		bool(C::*)() const	filter,
		ReduceFunctor	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 265 of file qtconcurrentfilter.h.

{
    return filteredReduced<ResultType>(begin,
                                       end,
                                       ConstMemberFunctionWrapper<bool, C>(filter),
                                       reduce,
                                       options);
}

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

Search for all occurrences

Definition at line 279 of file qtconcurrentfilter.h.

{
    return filteredReduced<U>(begin,
                              end,
                              keep,
                              FunctionWrapper2<T, U &, V>(reduce),
                              options);
}

QFuture<C> QtConcurrent::filteredReduced	(	Iterator	begin,
		Iterator	end,
		KeepFunctor	keep,
		T(C::*)(U)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 293 of file qtconcurrentfilter.h.

{
    return filteredReduced<C>(begin,
                              end,
                              keep,
                              MemberFunctionWrapper1<T, C, U>(reduce),
                              options);
}

QFuture<V> QtConcurrent::filteredReduced	(	Iterator	begin,
		Iterator	end,
		bool(keep)(T)	,
		U(reduce)(V &, W)	,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 307 of file qtconcurrentfilter.h.

{
    return filteredReduced<V>(begin,
                              end,
                              FunctionWrapper1<bool, T>(keep),
                              FunctionWrapper2<U, V &, W>(reduce),
                              options);
}

QFuture<U> QtConcurrent::filteredReduced	(	Iterator	begin,
		Iterator	end,
		bool(C::*)() const	keep,
		T(reduce)(U &, V)	,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 321 of file qtconcurrentfilter.h.

{
    return filteredReduced<U>(begin,
                              end,
                              ConstMemberFunctionWrapper<bool, C>(keep),
                              FunctionWrapper2<T, U &, V>(reduce),
                              options);
}

QFuture<C> QtConcurrent::filteredReduced	(	Iterator	begin,
		Iterator	end,
		bool(keep)(T)	,
		U(C::*)(V)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 335 of file qtconcurrentfilter.h.

{
    return filteredReduced<C>(begin,
                              end,
                              FunctionWrapper1<bool, T>(keep),
                              MemberFunctionWrapper1<U, C, V>(reduce),
                              options);
}

QFuture<D> QtConcurrent::filteredReduced	(	Iterator	begin,
		Iterator	end,
		bool(C::*)() const	keep,
		T(D::*)(U)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 349 of file qtconcurrentfilter.h.

{
    return filteredReduced<D>(begin,
                              end,
                              ConstMemberFunctionWrapper<bool, C>(keep),
                              MemberFunctionWrapper1<T, D, U>(reduce),
                              options);
}

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

Search for all occurrences

Definition at line 365 of file qtconcurrentfilter.h.

{
    return startFiltered(sequence, keep);
}

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

Search for all occurrences

Definition at line 371 of file qtconcurrentfilter.h.

{
    return startFiltered(sequence, FunctionWrapper1<bool, T>(keep));
}

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

Search for all occurrences

Definition at line 377 of file qtconcurrentfilter.h.

{
    return startFiltered(sequence, ConstMemberFunctionWrapper<bool, C>(keep));
}

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

Search for all occurrences

Definition at line 384 of file qtconcurrentfilter.h.

{
    return startFiltered(begin, end, keep);
}

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

Search for all occurrences

Definition at line 390 of file qtconcurrentfilter.h.

{
    return startFiltered(begin, end, FunctionWrapper1<bool, T>(keep));
}

QFuture<typename qValueType<Iterator>::value_type> QtConcurrent::filtered	(	Iterator	begin,
		Iterator	end,
		bool(C::*)() const	keep
	)

Search for all occurrences

Definition at line 396 of file qtconcurrentfilter.h.

{
    return startFiltered(begin, end, ConstMemberFunctionWrapper<bool, C>(keep));
}

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

Search for all occurrences

Definition at line 406 of file qtconcurrentfilter.h.

{
    filterInternal(sequence, keep, &Sequence::push_back).startBlocking();
}

void QtConcurrent::blockingFilter	(	Sequence &	sequence,
		bool(keep)(T)
	)

Search for all occurrences

Definition at line 412 of file qtconcurrentfilter.h.

{
    filterInternal(sequence, FunctionWrapper1<bool, T>(keep), &Sequence::push_back)
        .startBlocking();
}

void QtConcurrent::blockingFilter	(	Sequence &	sequence,
		bool(C::*)() const	keep
	)

Search for all occurrences

Definition at line 419 of file qtconcurrentfilter.h.

{
    filterInternal(sequence,
                   ConstMemberFunctionWrapper<bool, C>(keep),
                   &Sequence::push_back)
        .startBlocking();
}

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

Search for all occurrences

Definition at line 429 of file qtconcurrentfilter.h.

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

ResultType QtConcurrent::blockingFilteredReduced	(	const Sequence &	sequence,
		bool(filter)(T)	,
		ReduceFunctor	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 439 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<ResultType>
        (sequence,
         FunctionWrapper1<bool, T>(filter),
         reduce,
         options);
}

ResultType QtConcurrent::blockingFilteredReduced	(	const Sequence &	sequence,
		bool(C::*)() const	filter,
		ReduceFunctor	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 452 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<ResultType>
        (sequence,
         ConstMemberFunctionWrapper<bool, C>(filter),
         reduce,
         options);
}

U QtConcurrent::blockingFilteredReduced	(	const Sequence &	sequence,
		KeepFunctor	keep,
		T(reduce)(U &, V)	,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 465 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<U>
        (sequence,
         keep,
         FunctionWrapper2<T, U &, V>(reduce),
         options);
}

C QtConcurrent::blockingFilteredReduced	(	const Sequence &	sequence,
		KeepFunctor	keep,
		T(C::*)(U)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 478 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<C>
        (sequence,
         keep,
         MemberFunctionWrapper1<T, C, U>(reduce),
         options);
}

V QtConcurrent::blockingFilteredReduced	(	const Sequence &	sequence,
		bool(keep)(T)	,
		U(reduce)(V &, W)	,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 491 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<V>
        (sequence,
         FunctionWrapper1<bool, T>(keep),
         FunctionWrapper2<U, V &, W>(reduce),
         options);
}

U QtConcurrent::blockingFilteredReduced	(	const Sequence &	sequence,
		bool(C::*)() const	keep,
		T(reduce)(U &, V)	,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 504 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<U>
        (sequence,
         ConstMemberFunctionWrapper<bool, C>(keep),
         FunctionWrapper2<T, U &, V>(reduce),
         options);
}

C QtConcurrent::blockingFilteredReduced	(	const Sequence &	sequence,
		bool(keep)(T)	,
		U(C::*)(V)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 517 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<C>
        (sequence,
         FunctionWrapper1<bool, T>(keep),
         MemberFunctionWrapper1<U, C, V>(reduce),
         options);
}

D QtConcurrent::blockingFilteredReduced	(	const Sequence &	sequence,
		bool(C::*)() const	keep,
		T(D::*)(U)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 530 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<D>
        (sequence,
         ConstMemberFunctionWrapper<bool, C>(keep),
         MemberFunctionWrapper1<T, D, U>(reduce),
         options);
}

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

Search for all occurrences

Definition at line 544 of file qtconcurrentfilter.h.

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

ResultType QtConcurrent::blockingFilteredReduced	(	Iterator	begin,
		Iterator	end,
		bool(filter)(T)	,
		ReduceFunctor	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 555 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<ResultType>
        (begin,
         end,
         FunctionWrapper1<bool, T>(filter),
         reduce,
         options);
}

ResultType QtConcurrent::blockingFilteredReduced	(	Iterator	begin,
		Iterator	end,
		bool(C::*)() const	filter,
		ReduceFunctor	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 570 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<ResultType>
        (begin,
         end,
         ConstMemberFunctionWrapper<bool, C>(filter),
         reduce,
         options);
}

U QtConcurrent::blockingFilteredReduced	(	Iterator	begin,
		Iterator	end,
		KeepFunctor	keep,
		T(reduce)(U &, V)	,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 585 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<U>
        (begin,
         end,
         keep,
         FunctionWrapper2<T, U &, V>(reduce),
         options);
}

C QtConcurrent::blockingFilteredReduced	(	Iterator	begin,
		Iterator	end,
		KeepFunctor	keep,
		T(C::*)(U)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 600 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<C>
        (begin,
         end,
         keep,
         MemberFunctionWrapper1<T, C, U>(reduce),
         options);
}

V QtConcurrent::blockingFilteredReduced	(	Iterator	begin,
		Iterator	end,
		bool(keep)(T)	,
		U(reduce)(V &, W)	,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 615 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<V>
        (begin,
         end,
         FunctionWrapper1<bool, T>(keep),
         FunctionWrapper2<U, V &, W>(reduce),
         options);
}

U QtConcurrent::blockingFilteredReduced	(	Iterator	begin,
		Iterator	end,
		bool(C::*)() const	keep,
		T(reduce)(U &, V)	,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 630 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<U>
        (begin,
         end,
         ConstMemberFunctionWrapper<bool, C>(keep),
         FunctionWrapper2<T, U &, V>(reduce),
         options);
}

C QtConcurrent::blockingFilteredReduced	(	Iterator	begin,
		Iterator	end,
		bool(keep)(T)	,
		U(C::*)(V)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 645 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<C>
        (begin,
         end,
         FunctionWrapper1<bool, T>(keep),
         MemberFunctionWrapper1<U, C, V>(reduce),
         options);
}

D QtConcurrent::blockingFilteredReduced	(	Iterator	begin,
		Iterator	end,
		bool(C::*)() const	keep,
		T(D::*)(U)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 660 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced<D>
        (begin,
         end,
         ConstMemberFunctionWrapper<bool, C>(keep),
         MemberFunctionWrapper1<T, D, U>(reduce),
         options);
}

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

Search for all occurrences

Definition at line 676 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced(sequence, keep, &Sequence::push_back, OrderedReduce);
}

Sequence QtConcurrent::blockingFiltered	(	const Sequence &	sequence,
		bool(keep)(T)
	)

Search for all occurrences

Definition at line 682 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced(sequence, keep, &Sequence::push_back, OrderedReduce);
}

Sequence QtConcurrent::blockingFiltered	(	const Sequence &	sequence,
		bool(C::*)() const	filter
	)

Search for all occurrences

Definition at line 688 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced(sequence,
                                   filter,
                                   &Sequence::push_back,
                                   OrderedReduce);
}

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

Search for all occurrences

Definition at line 698 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced(begin,
                                   end,
                                   keep,
                                   &OutputSequence::push_back,
                                   OrderedReduce);
}

OutputSequence QtConcurrent::blockingFiltered	(	Iterator	begin,
		Iterator	end,
		bool(keep)(T)
	)

Search for all occurrences

Definition at line 708 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced(begin,
                                   end,
                                   keep,
                                   &OutputSequence::push_back,
                                   OrderedReduce);
}

OutputSequence QtConcurrent::blockingFiltered	(	Iterator	begin,
		Iterator	end,
		bool(C::*)() const	filter
	)

Search for all occurrences

Definition at line 718 of file qtconcurrentfilter.h.

{
    return blockingFilteredReduced(begin,
                                   end,
                                   filter,
                                   &OutputSequence::push_back,
                                   OrderedReduce);
}

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

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

Definition at line 154 of file qtconcurrentiteratekernel.h.

{
    return false; // while
}

bool QtConcurrent::selectIteration

(

std::forward_iterator_tag

)

[inline]

Search for all occurrences

Definition at line 159 of file qtconcurrentiteratekernel.h.

{
    return false; // while
}

bool QtConcurrent::selectIteration

(

std::random_access_iterator_tag

)

[inline]

Search for all occurrences

Definition at line 164 of file qtconcurrentiteratekernel.h.

{
    return true; // for
}

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

Search for all occurrences

Definition at line 111 of file qtconcurrentmap.h.

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

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

Search for all occurrences

Definition at line 117 of file qtconcurrentmap.h.

{
    return startMap(sequence.begin(), sequence.end(), FunctionWrapper1<T, U>(map));
}

QFuture<void> QtConcurrent::map	(	Sequence &	sequence,
		T(C::*)()	map
	)

Search for all occurrences

Definition at line 123 of file qtconcurrentmap.h.

{
    return startMap(sequence.begin(), sequence.end(), MemberFunctionWrapper<T, C>(map));
}

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

Search for all occurrences

Definition at line 130 of file qtconcurrentmap.h.

{
    return startMap(begin, end, map);
}

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

Search for all occurrences

Definition at line 136 of file qtconcurrentmap.h.

{
    return startMap(begin, end, FunctionWrapper1<T, U>(map));
}

QFuture<void> QtConcurrent::map	(	Iterator	begin,
		Iterator	end,
		T(C::*)()	map
	)

Search for all occurrences

Definition at line 142 of file qtconcurrentmap.h.

{
    return startMap(begin, end, MemberFunctionWrapper<T, C>(map));
}

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

Search for all occurrences

Definition at line 149 of file qtconcurrentmap.h.

{
    return startMappedReduced<typename MapFunctor::result_type, ResultType>
    (sequence, map, reduce, options);
}

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

Search for all occurrences

Definition at line 159 of file qtconcurrentmap.h.

{
    return startMappedReduced<typename MapFunctor::result_type, U>
    (sequence, map, FunctionWrapper2<T, U &, V>(reduce), options);
}

QFuture<C> QtConcurrent::mappedReduced	(	const Sequence &	sequence,
		MapFunctor	map,
		T(C::*)(U)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 169 of file qtconcurrentmap.h.

{
    return startMappedReduced<typename MapFunctor::result_type, C>
    (sequence, map, MemberFunctionWrapper1<T, C, U>(reduce), options);
}

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

Search for all occurrences

Definition at line 179 of file qtconcurrentmap.h.

{
    return startMappedReduced<T, ResultType>
    (sequence, FunctionWrapper1<T, U>(map), reduce, options);
}

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

Search for all occurrences

Definition at line 189 of file qtconcurrentmap.h.

{
    return startMappedReduced<T, ResultType>
    (sequence, ConstMemberFunctionWrapper<T, C>(map), reduce, options);
}

QFuture<W> QtConcurrent::mappedReduced	(	const Sequence &	sequence,
		T(map)(U)	,
		V(reduce)(W &, X)	,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 199 of file qtconcurrentmap.h.

{
    return startMappedReduced<T, W>
    (sequence, FunctionWrapper1<T, U>(map), FunctionWrapper2<V, W &, X>(reduce), options);
}

QFuture<V> QtConcurrent::mappedReduced	(	const Sequence &	sequence,
		T(C::*)() const	map,
		U(reduce)(V &, W)	,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 209 of file qtconcurrentmap.h.

{
    return startMappedReduced<T, V> (sequence, ConstMemberFunctionWrapper<T, C>(map),
                                    FunctionWrapper2<U, V &, W>(reduce), options);
}

QFuture<C> QtConcurrent::mappedReduced	(	const Sequence &	sequence,
		T(map)(U)	,
		V(C::*)(W)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 219 of file qtconcurrentmap.h.

{
    return startMappedReduced<T, C> (sequence, FunctionWrapper1<T, U>(map),
                                     MemberFunctionWrapper1<V, C, W>(reduce), options);
}

QFuture<D> QtConcurrent::mappedReduced	(	const Sequence &	sequence,
		T(C::*)() const	map,
		U(D::*)(V)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 229 of file qtconcurrentmap.h.

{
    return startMappedReduced<T, D>(sequence, ConstMemberFunctionWrapper<T, C>(map),
                                    MemberFunctionWrapper1<U, D, V>(reduce), options);
}

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

Search for all occurrences

Definition at line 240 of file qtconcurrentmap.h.

{
    return startMappedReduced<ResultType, typename MapFunctor::result_type>
    (begin, end, map, reduce, options);
}

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

Search for all occurrences

Definition at line 251 of file qtconcurrentmap.h.

{
    return startMappedReduced<typename MapFunctor::result_type, U>
    (begin, end, map, FunctionWrapper2<T, U &, V>(reduce), options);
}

QFuture<C> QtConcurrent::mappedReduced	(	Iterator	begin,
		Iterator	end,
		MapFunctor	map,
		T(C::*)(U)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 262 of file qtconcurrentmap.h.

{
    return startMappedReduced<typename MapFunctor::result_type, C>
    (begin, end, map, MemberFunctionWrapper1<T, C, U>(reduce), options);
}

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

Search for all occurrences

Definition at line 273 of file qtconcurrentmap.h.

{
    return startMappedReduced<T, ResultType>
    (begin, end, FunctionWrapper1<T, U>(map), reduce, options);
}

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

Search for all occurrences

Definition at line 284 of file qtconcurrentmap.h.

{
    return startMappedReduced<T, ResultType>
    (begin, end, ConstMemberFunctionWrapper<T, C>(map), reduce, options);
}

QFuture<W> QtConcurrent::mappedReduced	(	Iterator	begin,
		Iterator	end,
		T(map)(U)	,
		V(reduce)(W &, X)	,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 295 of file qtconcurrentmap.h.

{
    return startMappedReduced<T, W>
    (begin, end, FunctionWrapper1<T, U>(map), FunctionWrapper2<V, W &, X>(reduce), options);
}

QFuture<V> QtConcurrent::mappedReduced	(	Iterator	begin,
		Iterator	end,
		T(C::*)() const	map,
		U(reduce)(V &, W)	,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 306 of file qtconcurrentmap.h.

{
    return startMappedReduced<T, V>(begin, end, ConstMemberFunctionWrapper<T, C>(map),
                                   FunctionWrapper2<U, V &, W>(reduce), options);
}

QFuture<C> QtConcurrent::mappedReduced	(	Iterator	begin,
		Iterator	end,
		T(map)(U)	,
		V(C::*)(W)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 317 of file qtconcurrentmap.h.

{
    return startMappedReduced<T, C>
    (begin, end, FunctionWrapper1<T, U>(map), MemberFunctionWrapper1<V, C, W>(reduce), options);
}

QFuture<D> QtConcurrent::mappedReduced	(	Iterator	begin,
		Iterator	end,
		T(C::*)() const	map,
		U(D::*)(V)	reduce,
		ReduceOptions	options = ReduceOptions(UnorderedReduce | SequentialReduce)
	)

Search for all occurrences

Definition at line 328 of file qtconcurrentmap.h.

{
    return startMappedReduced<T, D>(begin, end, ConstMemberFunctionWrapper<T, C>(map),
                                    MemberFunctionWrapper1<U, D, V>(reduce), options);
}

QFuture<typename MapFunctor::result_type> QtConcurrent::mapped	(	const Sequence &	sequence,
		MapFunctor	map
	)

Search for all occurrences

Definition at line 340 of file qtconcurrentmap.h.

{
    return startMapped<typename MapFunctor::result_type>(sequence, map);
}

QFuture<T> QtConcurrent::mapped	(	const Sequence &	sequence,
		T(map)(U)
	)

Search for all occurrences

Definition at line 346 of file qtconcurrentmap.h.

{
   return startMapped<T>(sequence, FunctionWrapper1<T, U>(map));
}

QFuture<T> QtConcurrent::mapped	(	const Sequence &	sequence,
		T(C::*)() const	map
	)

Search for all occurrences

Definition at line 352 of file qtconcurrentmap.h.

{
    return startMapped<T>(sequence, ConstMemberFunctionWrapper<T, C>(map));
}

QFuture<typename MapFunctor::result_type> QtConcurrent::mapped	(	Iterator	begin,
		Iterator	end,
		MapFunctor	map
	)

Search for all occurrences

Definition at line 359 of file qtconcurrentmap.h.

{
    return startMapped<Q_TYPENAME MapFunctor::result_type>(begin, end, map);
}

QFuture<T> QtConcurrent::mapped	(	Iterator	begin,
		Iterator	end,
		T(map)(U)
	)

Search for all occurrences

Definition at line 365 of file qtconcurrentmap.h.

{
    return startMapped<T>(begin, end, FunctionWrapper1<T, U>(map));
}

QFuture<T> QtConcurrent::mapped	(	Iterator	begin,
		Iterator	end,
		T(C::*)() const	map
	)

Search for all occurrences

Definition at line 371 of file qtconcurrentmap.h.

{
    return startMapped<T>(begin, end, ConstMemberFunctionWrapper<T, C>(map));
}

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

Search for all occurrences

Definition at line 378 of file qtconcurrentmap.h.

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

void QtConcurrent::blockingMap	(	Sequence &	sequence,
		T(map)(U)
	)

Search for all occurrences

Definition at line 384 of file qtconcurrentmap.h.

{
    startMap(sequence.begin(), sequence.end(), QtConcurrent::FunctionWrapper1<T, U>(map)).startBlocking();
}

void QtConcurrent::blockingMap	(	Sequence &	sequence,
		T(C::*)()	map
	)

Search for all occurrences

Definition at line 390 of file qtconcurrentmap.h.

{
    startMap(sequence.begin(), sequence.end(), QtConcurrent::MemberFunctionWrapper<T, C>(map)).startBlocking();
}

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

Search for all occurrences

Definition at line 396 of file qtconcurrentmap.h.

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

void QtConcurrent::blockingMap	(	Iterator	begin,
		Iterator	end,
		T(map)(U)
	)

Search for all occurrences

Definition at line 402 of file qtconcurrentmap.h.

{
    startMap(begin, end, QtConcurrent::FunctionWrapper1<T, U>(map)).startBlocking();
}

void QtConcurrent::blockingMap	(	Iterator	begin,
		Iterator	end,
		T(C::*)()	map
	)

Search for all occurrences

Definition at line 408 of file qtconcurrentmap.h.

{
    startMap(begin, end, QtConcurrent::MemberFunctionWrapper<T, C>(map)).startBlocking();
}

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

Search for all occurrences

Definition at line 414 of file qtconcurrentmap.h.

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

U QtConcurrent::blockingMappedReduced	(	const Sequence &	sequence,
		MapFunctor	map,
		T(reduce)(U &, V)	,
		QtConcurrent::ReduceOptions	options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)
	)

Search for all occurrences

Definition at line 424 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, U>
        (sequence,
         map,
         QtConcurrent::FunctionWrapper2<T, U &, V>(reduce),
         options)
        .startBlocking();
}

C QtConcurrent::blockingMappedReduced	(	const Sequence &	sequence,
		MapFunctor	map,
		T(C::*)(U)	reduce,
		QtConcurrent::ReduceOptions	options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)
	)

Search for all occurrences

Definition at line 438 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, C>
        (sequence,
         map,
         QtConcurrent::MemberFunctionWrapper1<T, C, U>(reduce),
         options)
        .startBlocking();
}

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

Search for all occurrences

Definition at line 452 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<T, ResultType>
        (sequence,
         QtConcurrent::FunctionWrapper1<T, U>(map),
         reduce,
         options)
        .startBlocking();
}

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

Search for all occurrences

Definition at line 466 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<T, ResultType>
        (sequence,
         QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
         reduce,
         options)
        .startBlocking();
}

W QtConcurrent::blockingMappedReduced	(	const Sequence &	sequence,
		T(map)(U)	,
		V(reduce)(W &, X)	,
		QtConcurrent::ReduceOptions	options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)
	)

Search for all occurrences

Definition at line 480 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<T, W>
        (sequence,
         QtConcurrent::FunctionWrapper1<T, U>(map),
         QtConcurrent::FunctionWrapper2<V, W &, X>(reduce),
         options)
        .startBlocking();
}

V QtConcurrent::blockingMappedReduced	(	const Sequence &	sequence,
		T(C::*)() const	map,
		U(reduce)(V &, W)	,
		QtConcurrent::ReduceOptions	options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)
	)

Search for all occurrences

Definition at line 494 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<T, V>
        (sequence,
         QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
         QtConcurrent::FunctionWrapper2<U, V &, W>(reduce),
         options)
        .startBlocking();
}

C QtConcurrent::blockingMappedReduced	(	const Sequence &	sequence,
		T(map)(U)	,
		V(C::*)(W)	reduce,
		QtConcurrent::ReduceOptions	options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)
	)

Search for all occurrences

Definition at line 508 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<T, C>
        (sequence,
         QtConcurrent::FunctionWrapper1<T, U>(map),
         QtConcurrent::MemberFunctionWrapper1<V, C, W>(reduce),
         options)
        .startBlocking();
}

D QtConcurrent::blockingMappedReduced	(	const Sequence &	sequence,
		T(C::*)() const	map,
		U(D::*)(V)	reduce,
		QtConcurrent::ReduceOptions	options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)
	)

Search for all occurrences

Definition at line 522 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<T, D>
        (sequence,
         QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
         QtConcurrent::MemberFunctionWrapper1<U, D, V>(reduce),
         options)
        .startBlocking();
}

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

Search for all occurrences

Definition at line 536 of file qtconcurrentmap.h.

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

U QtConcurrent::blockingMappedReduced	(	Iterator	begin,
		Iterator	end,
		MapFunctor	map,
		T(reduce)(U &, V)	,
		QtConcurrent::ReduceOptions	options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)
	)

Search for all occurrences

Definition at line 547 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, U>
        (begin,
         end,
         map,
         QtConcurrent::FunctionWrapper2<T, U &, V>(reduce),
         options)
        .startBlocking();
}

C QtConcurrent::blockingMappedReduced	(	Iterator	begin,
		Iterator	end,
		MapFunctor	map,
		T(C::*)(U)	reduce,
		QtConcurrent::ReduceOptions	options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)
	)

Search for all occurrences

Definition at line 563 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, C>
        (begin,
         end,
         map,
         QtConcurrent::MemberFunctionWrapper1<T, C, U>(reduce),
         options)
        .startBlocking();
}

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

Search for all occurrences

Definition at line 579 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<T, ResultType>
        (begin,
         end,
         QtConcurrent::FunctionWrapper1<T, U>(map),
         reduce,
         options)
        .startBlocking();
}

ResultType QtConcurrent::blockingMappedReduced	(	Iterator	begin,
		Iterator	end,
		T(C::*)() const	map,
		ReduceFunctor	reduce,
		QtConcurrent::ReduceOptions	options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)
	)

Search for all occurrences

Definition at line 595 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<T, ResultType>
        (begin,
         end,
         QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
         reduce,
         options)
        .startBlocking();
}

W QtConcurrent::blockingMappedReduced	(	Iterator	begin,
		Iterator	end,
		T(map)(U)	,
		V(reduce)(W &, X)	,
		QtConcurrent::ReduceOptions	options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)
	)

Search for all occurrences

Definition at line 611 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<T, W>
        (begin,
         end,
         QtConcurrent::FunctionWrapper1<T, U>(map),
         QtConcurrent::FunctionWrapper2<V, W &, X>(reduce),
         options)
        .startBlocking();
}

V QtConcurrent::blockingMappedReduced	(	Iterator	begin,
		Iterator	end,
		T(C::*)() const	map,
		U(reduce)(V &, W)	,
		QtConcurrent::ReduceOptions	options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)
	)

Search for all occurrences

Definition at line 627 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<T, V>
        (begin,
         end,
         QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
         QtConcurrent::FunctionWrapper2<U, V &, W>(reduce),
         options)
        .startBlocking();
}

C QtConcurrent::blockingMappedReduced	(	Iterator	begin,
		Iterator	end,
		T(map)(U)	,
		V(C::*)(W)	reduce,
		QtConcurrent::ReduceOptions	options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)
	)

Search for all occurrences

Definition at line 643 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<T, C>
        (begin,
         end,
         QtConcurrent::FunctionWrapper1<T, U>(map),
         QtConcurrent::MemberFunctionWrapper1<V, C, W>(reduce),
         options)
        .startBlocking();
}

D QtConcurrent::blockingMappedReduced	(	Iterator	begin,
		Iterator	end,
		T(C::*)() const	map,
		U(D::*)(V)	reduce,
		QtConcurrent::ReduceOptions	options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)
	)

Search for all occurrences

Definition at line 659 of file qtconcurrentmap.h.

{
    return QtConcurrent::startMappedReduced<T, D>
        (begin,
         end,
         QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
         QtConcurrent::MemberFunctionWrapper1<U, D, V>(reduce),
         options)
        .startBlocking();
}

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

Search for all occurrences

Definition at line 676 of file qtconcurrentmap.h.

{
    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
                                 QtConcurrent::OrderedReduce);
}

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

Search for all occurrences

Definition at line 683 of file qtconcurrentmap.h.

{
    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
                                 QtConcurrent::OrderedReduce);
}

OutputSequence QtConcurrent::blockingMapped	(	const InputSequence &	sequence,
		T(C::*)() const	map
	)

Search for all occurrences

Definition at line 690 of file qtconcurrentmap.h.

{
    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
                                 QtConcurrent::OrderedReduce);
}

Sequence<typename MapFunctor::result_type> QtConcurrent::blockingMapped	(	const Sequence< T > &	sequence,
		MapFunctor	map
	)

Search for all occurrences

Definition at line 699 of file qtconcurrentmap.h.

{
    typedef Sequence<typename MapFunctor::result_type> OutputSequence;
    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
                                               QtConcurrent::OrderedReduce);
}

Sequence<U> QtConcurrent::blockingMapped	(	const Sequence< T > &	sequence,
		U(map)(V)
	)

Search for all occurrences

Definition at line 707 of file qtconcurrentmap.h.

{
    typedef Sequence<U> OutputSequence;
    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
                                               QtConcurrent::OrderedReduce);
}

Sequence<U> QtConcurrent::blockingMapped	(	const Sequence< T > &	sequence,
		U(C::*)() const	map
	)

Search for all occurrences

Definition at line 715 of file qtconcurrentmap.h.

{
    typedef Sequence<U> OutputSequence;
    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
                                               QtConcurrent::OrderedReduce);
}

QList<typename MapFunctor::result_type> QtConcurrent::blockingMapped	(	const QStringList &	sequence,
		MapFunctor	map
	)

Search for all occurrences

Definition at line 726 of file qtconcurrentmap.h.

{
    typedef QList<typename MapFunctor::result_type> OutputSequence;
    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
                                 QtConcurrent::OrderedReduce);
}

QList<U> QtConcurrent::blockingMapped	(	const QStringList &	sequence,
		U(map)(V)
	)

Search for all occurrences

Definition at line 734 of file qtconcurrentmap.h.

{
    typedef QList<U> OutputSequence;
    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
                                 QtConcurrent::OrderedReduce);
}

QList<U> QtConcurrent::blockingMapped	(	const QStringList &	sequence,
		U(C::*)() const	map
	)

Search for all occurrences

Definition at line 742 of file qtconcurrentmap.h.

{
    typedef QList<U> OutputSequence;
    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
                                 QtConcurrent::OrderedReduce);
}

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

Search for all occurrences

Definition at line 751 of file qtconcurrentmap.h.

{
    return blockingMappedReduced(begin, end, map, &Sequence::push_back,
                                 QtConcurrent::OrderedReduce);
}

Sequence QtConcurrent::blockingMapped	(	Iterator	begin,
		Iterator	end,
		T(map)(U)
	)

Search for all occurrences

Definition at line 758 of file qtconcurrentmap.h.

{
    return blockingMappedReduced(begin, end, map, &Sequence::push_back,
                                 QtConcurrent::OrderedReduce);
}

Sequence QtConcurrent::blockingMapped	(	Iterator	begin,
		Iterator	end,
		T(C::*)() const	map
	)

Search for all occurrences

Definition at line 765 of file qtconcurrentmap.h.

{
    return blockingMappedReduced(begin, end, map, &Sequence::push_back,
                                 QtConcurrent::OrderedReduce);
}

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

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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

)

Search for all occurrences

Definition at line 72 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredFunctorCall0<T, T (*)()>::type(functionPointer))->start();
}

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

Search for all occurrences

Definition at line 77 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredFunctorCall1<T, T (*)(Param1), Arg1>::type(functionPointer, arg1))->start();
}

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

Search for all occurrences

Definition at line 82 of file qtconcurrentrun.h.

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

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

Search for all occurrences

Definition at line 87 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredFunctorCall3<T, T (*)(Param1, Param2, Param3), Arg1, Arg2, Arg3>::type(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
	)

Search for all occurrences

Definition at line 92 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredFunctorCall4<T, T (*)(Param1, Param2, Param3, Param4), Arg1, Arg2, Arg3, Arg4>::type(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
	)

Search for all occurrences

Definition at line 97 of file qtconcurrentrun.h.

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

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

(

FunctionObject

functionObject

)

Search for all occurrences

Definition at line 103 of file qtconcurrentrun.h.

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

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

Search for all occurrences

Definition at line 108 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredFunctorCall1<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
	)

Search for all occurrences

Definition at line 113 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredFunctorCall2<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
	)

Search for all occurrences

Definition at line 118 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredFunctorCall3<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
	)

Search for all occurrences

Definition at line 123 of file qtconcurrentrun.h.

{
    return (new QT_TYPENAME SelectStoredFunctorCall4<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
	)

Search for all occurrences

Definition at line 128 of file qtconcurrentrun.h.

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

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

(

FunctionObject *

functionObject

)

Search for all occurrences

Definition at line 134 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
	)

Search for all occurrences

Definition at line 139 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
	)

Search for all occurrences

Definition at line 144 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
	)

Search for all occurrences

Definition at line 149 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
	)

Search for all occurrences

Definition at line 154 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
	)

Search for all occurrences

Definition at line 159 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
	)

Search for all occurrences

Definition at line 165 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
	)

Search for all occurrences

Definition at line 170 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
	)

Search for all occurrences

Definition at line 175 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
	)

Search for all occurrences

Definition at line 180 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
	)

Search for all occurrences

Definition at line 185 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
	)

Search for all occurrences

Definition at line 190 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
	)

Search for all occurrences

Definition at line 227 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
	)

Search for all occurrences

Definition at line 232 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
	)

Search for all occurrences

Definition at line 237 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
	)

Search for all occurrences

Definition at line 242 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
	)

Search for all occurrences

Definition at line 247 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
	)

Search for all occurrences

Definition at line 252 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
	)

Search for all occurrences

Definition at line 258 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
	)

Search for all occurrences

Definition at line 263 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
	)

Search for all occurrences

Definition at line 268 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
	)

Search for all occurrences

Definition at line 273 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
	)

Search for all occurrences

Definition at line 278 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
	)

Search for all occurrences

Definition at line 283 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]

Search for all occurrences

Definition at line 271 of file qtconcurrentthreadengine.h.

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