Logo Search packages:      
Sourcecode: qt4-x11 version File versions  Download package

QtConcurrent Namespace Reference


Detailed Description

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

Since:
4.4 See the {threads.html::qtconcurrent-intro}{Qt Concurrent} section in the {threads.html}{threading} documentation.


Classes

class  BlockSizeManager
class  ConstMemberFunctionWrapper
class  Exception
 The Exception class provides a base class for exceptions that can transferred across threads. More...
class  FilteredEachKernel
class  FilteredReducedKernel
class  FilterKernel
class  FunctionWrapper0
class  FunctionWrapper1
class  FunctionWrapper2
class  IntermediateResults
class  IterateKernel
class  MapKernel
class  MappedEachKernel
class  MappedReducedKernel
class  Median
class  MemberFunctionWrapper
class  MemberFunctionWrapper1
struct  qValueType
struct  qValueType< const T * >
struct  qValueType< T * >
class  ReduceKernel
class  ResultItem
class  ResultIterator
class  ResultIteratorBase
class  ResultReporter
class  ResultReporter< void >
class  ResultStore
class  ResultStoreBase
class  RunFunctionTask
class  RunFunctionTask< void >
class  RunFunctionTaskBase
struct  SelectSpecialization
struct  SelectSpecialization< void >
struct  SelectStoredConstMemberFunctionCall0
struct  SelectStoredConstMemberFunctionCall1
struct  SelectStoredConstMemberFunctionCall2
struct  SelectStoredConstMemberFunctionCall3
struct  SelectStoredConstMemberFunctionCall4
struct  SelectStoredConstMemberFunctionCall5
struct  SelectStoredConstMemberFunctionPointerCall0
struct  SelectStoredConstMemberFunctionPointerCall1
struct  SelectStoredConstMemberFunctionPointerCall2
struct  SelectStoredConstMemberFunctionPointerCall3
struct  SelectStoredConstMemberFunctionPointerCall4
struct  SelectStoredConstMemberFunctionPointerCall5
struct  SelectStoredFunctorCall0
struct  SelectStoredFunctorCall1
struct  SelectStoredFunctorCall2
struct  SelectStoredFunctorCall3
struct  SelectStoredFunctorCall4
struct  SelectStoredFunctorCall5
struct  SelectStoredFunctorPointerCall0
struct  SelectStoredFunctorPointerCall1
struct  SelectStoredFunctorPointerCall2
struct  SelectStoredFunctorPointerCall3
struct  SelectStoredFunctorPointerCall4
struct  SelectStoredFunctorPointerCall5
struct  SelectStoredMemberFunctionCall0
struct  SelectStoredMemberFunctionCall1
struct  SelectStoredMemberFunctionCall2
struct  SelectStoredMemberFunctionCall3
struct  SelectStoredMemberFunctionCall4
struct  SelectStoredMemberFunctionCall5
struct  SelectStoredMemberFunctionPointerCall0
struct  SelectStoredMemberFunctionPointerCall1
struct  SelectStoredMemberFunctionPointerCall2
struct  SelectStoredMemberFunctionPointerCall3
struct  SelectStoredMemberFunctionPointerCall4
struct  SelectStoredMemberFunctionPointerCall5
struct  SequenceHolder1
struct  SequenceHolder2
class  StoredConstMemberFunctionCall0
class  StoredConstMemberFunctionCall1
class  StoredConstMemberFunctionCall2
class  StoredConstMemberFunctionCall3
class  StoredConstMemberFunctionCall4
class  StoredConstMemberFunctionCall5
class  StoredConstMemberFunctionPointerCall0
class  StoredConstMemberFunctionPointerCall1
class  StoredConstMemberFunctionPointerCall2
class  StoredConstMemberFunctionPointerCall3
class  StoredConstMemberFunctionPointerCall4
class  StoredConstMemberFunctionPointerCall5
struct  StoredFunctorCall0
struct  StoredFunctorCall1
struct  StoredFunctorCall2
struct  StoredFunctorCall3
struct  StoredFunctorCall4
struct  StoredFunctorCall5
struct  StoredFunctorPointerCall0
struct  StoredFunctorPointerCall1
struct  StoredFunctorPointerCall2
struct  StoredFunctorPointerCall3
struct  StoredFunctorPointerCall4
struct  StoredFunctorPointerCall5
class  StoredMemberFunctionCall0
class  StoredMemberFunctionCall1
class  StoredMemberFunctionCall2
class  StoredMemberFunctionCall3
class  StoredMemberFunctionCall4
class  StoredMemberFunctionCall5
class  StoredMemberFunctionPointerCall0
class  StoredMemberFunctionPointerCall1
class  StoredMemberFunctionPointerCall2
class  StoredMemberFunctionPointerCall3
class  StoredMemberFunctionPointerCall4
class  StoredMemberFunctionPointerCall5
class  ThreadEngine
class  ThreadEngineBase
class  ThreadEngineSemaphore
class  ThreadEngineStarter
class  ThreadEngineStarter< void >
class  ThreadEngineStarterBase
class  UnhandledException
 The UnhandledException class represents an unhandled exception in a worker thread. More...
class  VoidStoredConstMemberFunctionCall0
class  VoidStoredConstMemberFunctionCall1
class  VoidStoredConstMemberFunctionCall2
class  VoidStoredConstMemberFunctionCall3
class  VoidStoredConstMemberFunctionCall4
class  VoidStoredConstMemberFunctionCall5
class  VoidStoredConstMemberFunctionPointerCall0
class  VoidStoredConstMemberFunctionPointerCall1
class  VoidStoredConstMemberFunctionPointerCall2
class  VoidStoredConstMemberFunctionPointerCall3
class  VoidStoredConstMemberFunctionPointerCall4
class  VoidStoredConstMemberFunctionPointerCall5
struct  VoidStoredFunctorCall0
struct  VoidStoredFunctorCall1
struct  VoidStoredFunctorCall2
struct  VoidStoredFunctorCall3
struct  VoidStoredFunctorCall4
struct  VoidStoredFunctorCall5
struct  VoidStoredFunctorPointerCall0
struct  VoidStoredFunctorPointerCall1
struct  VoidStoredFunctorPointerCall2
struct  VoidStoredFunctorPointerCall3
struct  VoidStoredFunctorPointerCall4
struct  VoidStoredFunctorPointerCall5
class  VoidStoredMemberFunctionCall0
class  VoidStoredMemberFunctionCall1
class  VoidStoredMemberFunctionCall2
class  VoidStoredMemberFunctionCall3
class  VoidStoredMemberFunctionCall4
class  VoidStoredMemberFunctionCall5
class  VoidStoredMemberFunctionPointerCall0
class  VoidStoredMemberFunctionPointerCall1
class  VoidStoredMemberFunctionPointerCall2
class  VoidStoredMemberFunctionPointerCall3
class  VoidStoredMemberFunctionPointerCall4
class  VoidStoredMemberFunctionPointerCall5

Namespaces

namespace  internal
 The QtConcurrent::internal namespace contains QtConcurrent implementation details.

Enumerations

enum  { ReduceQueueStartLimit = 20, ReduceQueueThrottleLimit = 30 }
enum  ReduceOption { UnorderedReduce = 0x1, OrderedReduce = 0x2, SequentialReduce = 0x4 }
enum  ThreadFunctionResult { ThrottleThread, ThreadFinished }

Functions

template<typename Sequence, typename C>
void blockingFilter (Sequence &sequence, bool(C::*keep)() const)
template<typename Sequence, typename T>
void blockingFilter (Sequence &sequence, bool(keep)(T))
template<typename Sequence, typename KeepFunctor>
void blockingFilter (Sequence &sequence, KeepFunctor keep)
 blockingFilter (strings, allLowerCase)
template<typename OutputSequence, typename Iterator, typename C>
OutputSequence blockingFiltered (Iterator begin, Iterator end, bool(C::*filter)() const)
template<typename OutputSequence, typename Iterator, typename T>
OutputSequence blockingFiltered (Iterator begin, Iterator end, bool(keep)(T))
template<typename OutputSequence, typename Iterator, typename KeepFunctor>
OutputSequence blockingFiltered (Iterator begin, Iterator end, KeepFunctor keep)
template<typename Sequence, typename C>
Sequence blockingFiltered (const Sequence &sequence, bool(C::*filter)() const)
template<typename Sequence, typename T>
Sequence blockingFiltered (const Sequence &sequence, bool(keep)(T))
template<typename Sequence, typename KeepFunctor>
Sequence blockingFiltered (const Sequence &sequence, KeepFunctor keep)
template<typename Iterator, typename C, typename T, typename D, typename U>
blockingFilteredReduced (Iterator begin, Iterator end, bool(C::*keep)() const, T(D::*reduce)(U), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator, typename T, typename U, typename C, typename V>
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 U, typename V>
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 V, typename W>
blockingFilteredReduced (Iterator begin, Iterator end, bool(keep)(T), U(reduce)(V &, W), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator, typename KeepFunctor, typename T, typename C, typename U>
blockingFilteredReduced (Iterator begin, Iterator end, KeepFunctor keep, T(C::*reduce)(U), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator, typename KeepFunctor, typename T, typename U, typename V>
blockingFilteredReduced (Iterator begin, Iterator end, KeepFunctor keep, T(reduce)(U &, V), 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 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 KeepFunctor, typename ReduceFunctor>
ResultType blockingFilteredReduced (Iterator begin, Iterator end, KeepFunctor keep, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename C, typename T, typename D, typename U>
blockingFilteredReduced (const Sequence &sequence, bool(C::*keep)() const, T(D::*reduce)(U), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename T, typename U, typename C, typename V>
blockingFilteredReduced (const Sequence &sequence, bool(keep)(T), U(C::*reduce)(V), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename C, typename T, typename U, typename V>
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 V, typename W>
blockingFilteredReduced (const Sequence &sequence, bool(keep)(T), U(reduce)(V &, W), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename KeepFunctor, typename T, typename C, typename U>
blockingFilteredReduced (const Sequence &sequence, KeepFunctor keep, T(C::*reduce)(U), ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename KeepFunctor, typename T, typename U, typename V>
blockingFilteredReduced (const Sequence &sequence, KeepFunctor keep, T(reduce)(U &, V), 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 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 KeepFunctor, typename ReduceFunctor>
ResultType blockingFilteredReduced (const Sequence &sequence, KeepFunctor keep, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Iterator, typename T, typename C>
void blockingMap (Iterator begin, Iterator end, T(C::*map)())
template<typename Iterator, typename T, typename U>
void blockingMap (Iterator begin, Iterator end, T(map)(U))
template<typename Iterator, typename MapFunctor>
void blockingMap (Iterator begin, Iterator end, MapFunctor map)
template<typename Sequence, typename T, typename C>
void blockingMap (Sequence &sequence, T(C::*map)())
template<typename Sequence, typename T, typename U>
void blockingMap (Sequence &sequence, T(map)(U))
template<typename Sequence, typename MapFunctor>
void blockingMap (Sequence &sequence, MapFunctor map)
 blockingMap (images, scale)
template<typename Sequence, typename Iterator, typename T, typename C>
Sequence blockingMapped (Iterator begin, Iterator end, T(C::*map)() const)
template<typename Sequence, typename Iterator, typename T, typename U>
Sequence blockingMapped (Iterator begin, Iterator end, T(map)(U))
template<typename Sequence, typename Iterator, typename MapFunctor>
Sequence blockingMapped (Iterator begin, Iterator end, MapFunctor map)
template<typename U, typename C>
QList< U > blockingMapped (const QStringList &sequence, U(C::*map)() const)
template<typename U, typename V>
QList< U > blockingMapped (const QStringList &sequence, U(map)(V))
template<typename MapFunctor>
QList< typename
MapFunctor::result_type > 
blockingMapped (const QStringList &sequence, MapFunctor map)
template<template< typename > class Sequence, typename T, typename U, typename C>
Sequence< U > blockingMapped (const Sequence< T > &sequence, U(C::*map)() const)
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 MapFunctor, typename T>
Sequence< typename
MapFunctor::result_type > 
blockingMapped (const Sequence< T > &sequence, MapFunctor map)
template<typename OutputSequence, typename InputSequence, typename T, typename C>
OutputSequence blockingMapped (const InputSequence &sequence, T(C::*map)() const)
template<typename OutputSequence, typename InputSequence, typename T, typename U>
OutputSequence blockingMapped (const InputSequence &sequence, T(map)(U))
template<typename OutputSequence, typename InputSequence, typename MapFunctor>
OutputSequence blockingMapped (const InputSequence &sequence, MapFunctor map)
template<typename Iterator, typename T, typename C, typename U, typename D, typename V>
blockingMappedReduced (Iterator begin, Iterator end, T(C::*map)() const, U(D::*reduce)(V), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename Iterator, typename T, typename U, typename V, typename C, typename W>
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 V, typename W>
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 W, typename X>
blockingMappedReduced (Iterator begin, Iterator end, T(map)(U), V(reduce)(W &, X), 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 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 Iterator, typename MapFunctor, typename T, typename C, typename U>
blockingMappedReduced (Iterator begin, Iterator end, MapFunctor map, T(C::*reduce)(U), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename Iterator, typename MapFunctor, typename T, typename U, typename V>
blockingMappedReduced (Iterator begin, Iterator end, MapFunctor map, T(reduce)(U &, 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 Sequence, typename T, typename C, typename U, typename D, typename V>
blockingMappedReduced (const Sequence &sequence, T(C::*map)() const, U(D::*reduce)(V), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename Sequence, typename T, typename U, typename V, typename C, typename W>
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 V, typename W>
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 W, typename X>
blockingMappedReduced (const Sequence &sequence, T(map)(U), V(reduce)(W &, X), 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 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 Sequence, typename MapFunctor, typename T, typename C, typename U>
blockingMappedReduced (const Sequence &sequence, MapFunctor map, T(C::*reduce)(U), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
template<typename Sequence, typename MapFunctor, typename T, typename U, typename V>
blockingMappedReduced (const Sequence &sequence, MapFunctor map, T(reduce)(U &, V), QtConcurrent::ReduceOptions options=QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce|QtConcurrent::SequentialReduce))
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 C>
QFuture< void > filter (Sequence &sequence, bool(C::*keep)() const)
template<typename Sequence, typename T>
QFuture< void > filter (Sequence &sequence, bool(keep)(T))
template<typename Sequence, typename KeepFunctor>
QFuture< void > filter (Sequence &sequence, KeepFunctor keep)
template<typename Iterator, typename C>
QFuture< typename qValueType
< Iterator >::value_type > 
filtered (Iterator begin, Iterator end, bool(C::*keep)() const)
template<typename Iterator, typename T>
QFuture< typename qValueType
< Iterator >::value_type > 
filtered (Iterator begin, Iterator end, bool(keep)(T))
template<typename Iterator, typename KeepFunctor>
QFuture< typename qValueType
< Iterator >::value_type > 
filtered (Iterator begin, Iterator end, KeepFunctor keep)
template<typename Sequence, typename C>
QFuture< typename
Sequence::value_type > 
filtered (const Sequence &sequence, bool(C::*keep)() const)
template<typename Sequence, typename T>
QFuture< typename
Sequence::value_type > 
filtered (const Sequence &sequence, bool(keep)(T))
template<typename Sequence, typename KeepFunctor>
QFuture< typename
Sequence::value_type > 
filtered (const Sequence &sequence, KeepFunctor keep)
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 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 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 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 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 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 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 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 KeepFunctor, typename ReduceFunctor>
QFuture< ResultType > filteredReduced (Iterator begin, Iterator end, KeepFunctor keep, ReduceFunctor reduce, 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 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 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 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 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 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 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 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 KeepFunctor, typename ReduceFunctor>
QFuture< ResultType > filteredReduced (const Sequence &sequence, KeepFunctor keep, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename Sequence, typename KeepFunctor, typename T, typename C, typename U>
ThreadEngineStarter< void > filterInternal (Sequence &sequence, KeepFunctor keep, T(C::*reduce)(U))
template<typename Iterator, typename T, typename C>
QFuture< void > map (Iterator begin, Iterator end, T(C::*map)())
template<typename Iterator, typename T, typename U>
QFuture< void > map (Iterator begin, Iterator end, T(map)(U))
template<typename Iterator, typename MapFunctor>
QFuture< void > map (Iterator begin, Iterator end, MapFunctor map)
template<typename Sequence, typename T, typename C>
QFuture< void > map (Sequence &sequence, T(C::*map)())
template<typename Sequence, typename T, typename U>
QFuture< void > map (Sequence &sequence, T(map)(U))
template<typename Sequence, typename MapFunctor>
QFuture< void > map (Sequence &sequence, MapFunctor map)
template<typename Iterator, typename T, typename C>
QFuture< T > mapped (Iterator begin, Iterator end, T(C::*map)() const)
template<typename Iterator, typename T, typename U>
QFuture< T > mapped (Iterator begin, Iterator end, T(map)(U))
template<typename Iterator, typename MapFunctor>
QFuture< typename
MapFunctor::result_type > 
mapped (Iterator begin, Iterator end, MapFunctor map)
template<typename Sequence, typename T, typename C>
QFuture< T > mapped (const Sequence &sequence, T(C::*map)() const)
template<typename Sequence, typename T, typename U>
QFuture< T > mapped (const Sequence &sequence, T(map)(U))
template<typename Sequence, typename MapFunctor>
QFuture< typename
MapFunctor::result_type > 
mapped (const Sequence &sequence, MapFunctor map)
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 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 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 W, typename X>
QFuture< W > mappedReduced (Iterator begin, Iterator end, T(map)(U), V(reduce)(W &, X), 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 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 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 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 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 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 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 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 W, typename X>
QFuture< W > mappedReduced (const Sequence &sequence, T(map)(U), V(reduce)(W &, X), 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 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 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 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 ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
QFuture< ResultType > mappedReduced (const Sequence &sequence, MapFunctor map, ReduceFunctor reduce, ReduceOptions options=ReduceOptions(UnorderedReduce|SequentialReduce))
template<typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
QFuture< T > run (const Class *object, T(Class::*fn)(Param1, Param2, Param3, Param4, Param5) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
template<typename T, 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>
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>
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>
QFuture< T > run (const Class *object, T(Class::*fn)(Param1) const, const Arg1 &arg1)
template<typename T, typename Class>
QFuture< T > run (const Class *object, T(Class::*fn)() const)
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, 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>
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>
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>
QFuture< T > run (Class *object, T(Class::*fn)(Param1), const Arg1 &arg1)
template<typename T, typename Class>
QFuture< T > run (Class *object, T(Class::*fn)())
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, 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>
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>
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>
QFuture< T > run (const Class &object, T(Class::*fn)(Param1), const Arg1 &arg1)
template<typename T, typename Class>
QFuture< T > run (const Class &object, T(Class::*fn)())
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, 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>
QFuture< typename
FunctionObject::result_type > 
run (FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
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>
QFuture< typename
FunctionObject::result_type > 
run (FunctionObject *functionObject, const Arg1 &arg1)
template<typename FunctionObject>
QFuture< typename
FunctionObject::result_type > 
run (FunctionObject *functionObject)
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, 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>
QFuture< typename
FunctionObject::result_type > 
run (FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
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>
QFuture< typename
FunctionObject::result_type > 
run (FunctionObject functionObject, const Arg1 &arg1)
template<typename FunctionObject>
QFuture< typename
FunctionObject::result_type > 
run (FunctionObject functionObject)
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 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>
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>
QFuture< T > run (T(*functionPointer)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)
template<typename T, typename Param1, typename Arg1>
QFuture< T > run (T(*functionPointer)(Param1), const Arg1 &arg1)
template<typename T>
QFuture< T > run (T(*functionPointer)())
bool selectIteration (std::random_access_iterator_tag)
bool selectIteration (std::forward_iterator_tag)
bool selectIteration (std::bidirectional_iterator_tag)
template<typename Sequence, typename KeepFunctor>
ThreadEngineStarter< typename
Sequence::value_type > 
startFiltered (const Sequence &sequence, KeepFunctor functor)
template<typename Iterator, typename KeepFunctor>
ThreadEngineStarter< typename
qValueType< Iterator >
::value_type > 
startFiltered (Iterator begin, Iterator end, KeepFunctor functor)
template<typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
ThreadEngineStarter< ResultType > startFilteredReduced (Iterator begin, Iterator end, MapFunctor mapFunctor, ReduceFunctor reduceFunctor, ReduceOptions options)
template<typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
ThreadEngineStarter< ResultType > startFilteredReduced (const Sequence &sequence, MapFunctor mapFunctor, ReduceFunctor reduceFunctor, ReduceOptions options)
template<typename Iterator, typename Functor>
ThreadEngineStarter< void > startMap (Iterator begin, Iterator end, Functor functor)
template<typename T, typename Sequence, typename Functor>
ThreadEngineStarter< T > startMapped (const Sequence &sequence, Functor functor)
template<typename T, typename Iterator, typename Functor>
ThreadEngineStarter< T > startMapped (Iterator begin, Iterator end, Functor functor)
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 IntermediateType, typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
ThreadEngineStarter< ResultType > startMappedReduced (const Sequence &sequence, MapFunctor mapFunctor, ReduceFunctor reduceFunctor, ReduceOptions options)
template<typename ThreadEngine>
ThreadEngineStarter< typename
ThreadEngine::ResultType > 
startThreadEngine (ThreadEngine *threadEngine)


Generated by  Doxygen 1.6.0   Back to index