- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files
- Directories
- Examples

- Namespace List
- Namespace Members

Namespaces | Classes | Enumerations | Functions

# 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);
    }