Rewrite the interfaces of QtConcurrent.
At least make RVCT 2.2 work. Task-number: QTBUG-5182 Task-number: QTBUG-9070 Reviewed-by: Olivier Goffart Reviewed-by: joao (cherry picked from commit 0ba0c374fe055623381e3795daa6743c5c995bbc)
This commit is contained in:
Liang Qi
Olivier Goffart
parent
a9a850952b
commit
5d85018720
@ -115,19 +115,7 @@ ThreadEngineStarter<void> filterInternal(Sequence &sequence, KeepFunctor keep, T
|
||||
template <typename Sequence, typename KeepFunctor>
|
||||
QFuture<void> filter(Sequence &sequence, KeepFunctor keep)
|
||||
{
|
||||
return filterInternal(sequence, keep, &Sequence::push_back);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T>
|
||||
QFuture<void> filter(Sequence &sequence, bool (keep)(T))
|
||||
{
|
||||
return filterInternal(sequence, FunctionWrapper1<bool, T>(keep), &Sequence::push_back);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename C>
|
||||
QFuture<void> filter(Sequence &sequence, bool (C::*keep)() const)
|
||||
{
|
||||
return filterInternal(sequence, ConstMemberFunctionWrapper<bool, C>(keep), &Sequence::push_back);
|
||||
return filterInternal(sequence, QtPrivate::createFunctionWrapper(keep), &Sequence::push_back);
|
||||
}
|
||||
|
||||
// filteredReduced() on sequences
|
||||
@ -137,103 +125,20 @@ QFuture<ResultType> filteredReduced(const Sequence &sequence,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startFilteredReduced<ResultType>(sequence, keep, reduce, options);
|
||||
}
|
||||
return startFilteredReduced<ResultType>(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options);
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Sequence, typename T, typename ReduceFunctor>
|
||||
QFuture<ResultType> filteredReduced(const Sequence &sequence,
|
||||
bool (filter)(T),
|
||||
template <typename Sequence, typename KeepFunctor, typename ReduceFunctor>
|
||||
QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> filteredReduced(const Sequence &sequence,
|
||||
KeepFunctor keep,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<ResultType>(sequence,
|
||||
FunctionWrapper1<bool, T>(filter),
|
||||
reduce,
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return filteredReduced<ResultType>(sequence,
|
||||
ConstMemberFunctionWrapper<bool, C>(filter),
|
||||
reduce,
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return filteredReduced<U>(sequence,
|
||||
keep,
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return filteredReduced<C>(sequence,
|
||||
keep,
|
||||
MemberFunctionWrapper1<T, C, U>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return filteredReduced<V>(sequence,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
FunctionWrapper2<U, V &, W>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return filteredReduced<U>(sequence,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return filteredReduced<C>(sequence,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
MemberFunctionWrapper1<U, C, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return filteredReduced<D>(sequence,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
MemberFunctionWrapper1<T, D, U>(reduce),
|
||||
options);
|
||||
return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(sequence,
|
||||
QtPrivate::createFunctionWrapper(keep),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
// filteredReduced() on iterators
|
||||
@ -244,184 +149,42 @@ QFuture<ResultType> filteredReduced(Iterator begin,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startFilteredReduced<ResultType>(begin, end, keep, reduce, options);
|
||||
return startFilteredReduced<ResultType>(begin, end, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options);
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Iterator, typename T, typename ReduceFunctor>
|
||||
QFuture<ResultType> filteredReduced(Iterator begin,
|
||||
template <typename Iterator, typename KeepFunctor, typename ReduceFunctor>
|
||||
QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> filteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
bool (filter)(T),
|
||||
KeepFunctor keep,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<ResultType>(begin,
|
||||
end,
|
||||
FunctionWrapper1<bool, T>(filter),
|
||||
reduce,
|
||||
options);
|
||||
return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(keep),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return filteredReduced<ResultType>(begin,
|
||||
end,
|
||||
ConstMemberFunctionWrapper<bool, C>(filter),
|
||||
reduce,
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return filteredReduced<U>(begin,
|
||||
end,
|
||||
keep,
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return filteredReduced<C>(begin,
|
||||
end,
|
||||
keep,
|
||||
MemberFunctionWrapper1<T, C, U>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return filteredReduced<V>(begin,
|
||||
end,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
FunctionWrapper2<U, V &, W>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return filteredReduced<U>(begin,
|
||||
end,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return filteredReduced<C>(begin,
|
||||
end,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
MemberFunctionWrapper1<U, C, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return filteredReduced<D>(begin,
|
||||
end,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
MemberFunctionWrapper1<T, D, U>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
|
||||
// filtered() on sequences
|
||||
template <typename Sequence, typename KeepFunctor>
|
||||
QFuture<typename Sequence::value_type> filtered(const Sequence &sequence, KeepFunctor keep)
|
||||
{
|
||||
return startFiltered(sequence, keep);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T>
|
||||
QFuture<typename Sequence::value_type> filtered(const Sequence &sequence, bool (keep)(T))
|
||||
{
|
||||
return startFiltered(sequence, FunctionWrapper1<bool, T>(keep));
|
||||
}
|
||||
|
||||
template <typename Sequence, typename C>
|
||||
QFuture<typename Sequence::value_type> filtered(const Sequence &sequence, bool (C::*keep)() const)
|
||||
{
|
||||
return startFiltered(sequence, ConstMemberFunctionWrapper<bool, C>(keep));
|
||||
return startFiltered(sequence, QtPrivate::createFunctionWrapper(keep));
|
||||
}
|
||||
|
||||
// filtered() on iterators
|
||||
template <typename Iterator, typename KeepFunctor>
|
||||
QFuture<typename qValueType<Iterator>::value_type> filtered(Iterator begin, Iterator end, KeepFunctor keep)
|
||||
{
|
||||
return startFiltered(begin, end, keep);
|
||||
return startFiltered(begin, end, QtPrivate::createFunctionWrapper(keep));
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T>
|
||||
QFuture<typename qValueType<Iterator>::value_type> filtered(Iterator begin, Iterator end, bool (keep)(T))
|
||||
{
|
||||
return startFiltered(begin, end, FunctionWrapper1<bool, T>(keep));
|
||||
}
|
||||
|
||||
template <typename Iterator, typename C>
|
||||
QFuture<typename qValueType<Iterator>::value_type> filtered(Iterator begin,
|
||||
Iterator end,
|
||||
bool (C::*keep)() const)
|
||||
{
|
||||
return startFiltered(begin, end, ConstMemberFunctionWrapper<bool, C>(keep));
|
||||
}
|
||||
|
||||
|
||||
// blocking filter() on sequences
|
||||
template <typename Sequence, typename KeepFunctor>
|
||||
void blockingFilter(Sequence &sequence, KeepFunctor keep)
|
||||
{
|
||||
filterInternal(sequence, keep, &Sequence::push_back).startBlocking();
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T>
|
||||
void blockingFilter(Sequence &sequence, bool (keep)(T))
|
||||
{
|
||||
filterInternal(sequence, FunctionWrapper1<bool, T>(keep), &Sequence::push_back)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename Sequence, typename C>
|
||||
void blockingFilter(Sequence &sequence, bool (C::*keep)() const)
|
||||
{
|
||||
filterInternal(sequence,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
&Sequence::push_back)
|
||||
.startBlocking();
|
||||
filterInternal(sequence, QtPrivate::createFunctionWrapper(keep), &Sequence::push_back).startBlocking();
|
||||
}
|
||||
|
||||
// blocking filteredReduced() on sequences
|
||||
@ -431,111 +194,20 @@ ResultType blockingFilteredReduced(const Sequence &sequence,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startFilteredReduced<ResultType>(sequence, keep, reduce, options)
|
||||
return startFilteredReduced<ResultType>(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Sequence, typename T, typename ReduceFunctor>
|
||||
ResultType blockingFilteredReduced(const Sequence &sequence,
|
||||
bool (filter)(T),
|
||||
template <typename Sequence, typename KeepFunctor, typename ReduceFunctor>
|
||||
typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingFilteredReduced(const Sequence &sequence,
|
||||
KeepFunctor keep,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<ResultType>
|
||||
return blockingFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(sequence,
|
||||
FunctionWrapper1<bool, T>(filter),
|
||||
reduce,
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return blockingFilteredReduced<ResultType>
|
||||
(sequence,
|
||||
ConstMemberFunctionWrapper<bool, C>(filter),
|
||||
reduce,
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return blockingFilteredReduced<U>
|
||||
(sequence,
|
||||
keep,
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return blockingFilteredReduced<C>
|
||||
(sequence,
|
||||
keep,
|
||||
MemberFunctionWrapper1<T, C, U>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return blockingFilteredReduced<V>
|
||||
(sequence,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
FunctionWrapper2<U, V &, W>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return blockingFilteredReduced<U>
|
||||
(sequence,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return blockingFilteredReduced<C>
|
||||
(sequence,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
MemberFunctionWrapper1<U, C, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return blockingFilteredReduced<D>
|
||||
(sequence,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
MemberFunctionWrapper1<T, D, U>(reduce),
|
||||
QtPrivate::createFunctionWrapper(keep),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
@ -547,150 +219,34 @@ ResultType blockingFilteredReduced(Iterator begin,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startFilteredReduced<ResultType>(begin, end, keep, reduce, options)
|
||||
return startFilteredReduced<ResultType>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(keep),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Iterator, typename T, typename ReduceFunctor>
|
||||
ResultType blockingFilteredReduced(Iterator begin,
|
||||
template <typename Iterator, typename KeepFunctor, typename ReduceFunctor>
|
||||
typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingFilteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
bool (filter)(T),
|
||||
KeepFunctor keep,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<ResultType>
|
||||
(begin,
|
||||
end,
|
||||
FunctionWrapper1<bool, T>(filter),
|
||||
reduce,
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return blockingFilteredReduced<ResultType>
|
||||
(begin,
|
||||
end,
|
||||
ConstMemberFunctionWrapper<bool, C>(filter),
|
||||
reduce,
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return blockingFilteredReduced<U>
|
||||
(begin,
|
||||
end,
|
||||
keep,
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return blockingFilteredReduced<C>
|
||||
(begin,
|
||||
end,
|
||||
keep,
|
||||
MemberFunctionWrapper1<T, C, U>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return blockingFilteredReduced<V>
|
||||
(begin,
|
||||
end,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
FunctionWrapper2<U, V &, W>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return blockingFilteredReduced<U>
|
||||
(begin,
|
||||
end,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return blockingFilteredReduced<C>
|
||||
(begin,
|
||||
end,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
MemberFunctionWrapper1<U, C, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return blockingFilteredReduced<D>
|
||||
(begin,
|
||||
end,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
MemberFunctionWrapper1<T, D, U>(reduce),
|
||||
options);
|
||||
return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(keep),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
// blocking filtered() on sequences
|
||||
template <typename Sequence, typename KeepFunctor>
|
||||
Sequence blockingFiltered(const Sequence &sequence, KeepFunctor keep)
|
||||
{
|
||||
return blockingFilteredReduced(sequence, keep, &Sequence::push_back, OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T>
|
||||
Sequence blockingFiltered(const Sequence &sequence, bool (keep)(T))
|
||||
{
|
||||
return blockingFilteredReduced(sequence, keep, &Sequence::push_back, OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename C>
|
||||
Sequence blockingFiltered(const Sequence &sequence, bool (C::*filter)() const)
|
||||
{
|
||||
return blockingFilteredReduced(sequence,
|
||||
filter,
|
||||
&Sequence::push_back,
|
||||
OrderedReduce);
|
||||
return blockingFilteredReduced(sequence, QtPrivate::createFunctionWrapper(keep), &Sequence::push_back, OrderedReduce);
|
||||
}
|
||||
|
||||
// blocking filtered() on iterators
|
||||
@ -699,27 +255,7 @@ OutputSequence blockingFiltered(Iterator begin, Iterator end, KeepFunctor keep)
|
||||
{
|
||||
return blockingFilteredReduced(begin,
|
||||
end,
|
||||
keep,
|
||||
&OutputSequence::push_back,
|
||||
OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename OutputSequence, typename Iterator, typename T>
|
||||
OutputSequence blockingFiltered(Iterator begin, Iterator end, bool (keep)(T))
|
||||
{
|
||||
return blockingFilteredReduced(begin,
|
||||
end,
|
||||
keep,
|
||||
&OutputSequence::push_back,
|
||||
OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename OutputSequence, typename Iterator, typename C>
|
||||
OutputSequence blockingFiltered(Iterator begin, Iterator end, bool (C::*filter)() const)
|
||||
{
|
||||
return blockingFilteredReduced(begin,
|
||||
end,
|
||||
filter,
|
||||
QtPrivate::createFunctionWrapper(keep),
|
||||
&OutputSequence::push_back,
|
||||
OrderedReduce);
|
||||
}
|
||||
|
||||
@ -163,6 +163,143 @@ private:
|
||||
|
||||
} // namespace QtConcurrent.
|
||||
|
||||
namespace QtPrivate {
|
||||
|
||||
template <typename T>
|
||||
const T& createFunctionWrapper(const T& t)
|
||||
{
|
||||
return t;
|
||||
}
|
||||
|
||||
template <typename T, typename U>
|
||||
QtConcurrent::FunctionWrapper1<T, U> createFunctionWrapper(T (*func)(U))
|
||||
{
|
||||
return QtConcurrent::FunctionWrapper1<T, U>(func);
|
||||
}
|
||||
|
||||
template <typename T, typename C>
|
||||
QtConcurrent::MemberFunctionWrapper<T, C> createFunctionWrapper(T (C::*func)())
|
||||
{
|
||||
return QtConcurrent::MemberFunctionWrapper<T, C>(func);
|
||||
}
|
||||
|
||||
template <typename T, typename C, typename U>
|
||||
QtConcurrent::MemberFunctionWrapper1<T, C, U> createFunctionWrapper(T (C::*func)(U))
|
||||
{
|
||||
return QtConcurrent::MemberFunctionWrapper1<T, C, U>(func);
|
||||
}
|
||||
|
||||
template <typename T, typename C>
|
||||
QtConcurrent::ConstMemberFunctionWrapper<T, C> createFunctionWrapper(T (C::*func)() const)
|
||||
{
|
||||
return QtConcurrent::ConstMemberFunctionWrapper<T, C>(func);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
struct ReduceResultType;
|
||||
|
||||
template <class U, class V>
|
||||
struct ReduceResultType<void(*)(U&,V)>
|
||||
{
|
||||
typedef U ResultType;
|
||||
};
|
||||
|
||||
template <class T, class C, class U>
|
||||
struct ReduceResultType<T(C::*)(U)>
|
||||
{
|
||||
typedef C ResultType;
|
||||
};
|
||||
|
||||
template <class InputSequence, class MapFunctor>
|
||||
struct MapResultType
|
||||
{
|
||||
typedef typename MapFunctor::result_type ResultType;
|
||||
};
|
||||
|
||||
template <class InputSequence, class U, class V>
|
||||
struct MapResultType<InputSequence, U (*)(V)>
|
||||
{
|
||||
typedef U ResultType;
|
||||
};
|
||||
|
||||
template <class InputSequence, class T, class C>
|
||||
struct MapResultType<InputSequence, T(C::*)() const>
|
||||
{
|
||||
typedef T ResultType;
|
||||
};
|
||||
|
||||
#ifndef QT_NO_TEMPLATE_TEMPLATE_PARAMETERS
|
||||
|
||||
template <template <typename> class InputSequence, typename MapFunctor, typename T>
|
||||
struct MapResultType<InputSequence<T>, MapFunctor>
|
||||
{
|
||||
typedef InputSequence<typename MapFunctor::result_type> ResultType;
|
||||
};
|
||||
|
||||
template <template <typename> class InputSequence, class T, class U, class V>
|
||||
struct MapResultType<InputSequence<T>, U (*)(V)>
|
||||
{
|
||||
typedef InputSequence<U> ResultType;
|
||||
};
|
||||
|
||||
template <template <typename> class InputSequence, class T, class U, class C>
|
||||
struct MapResultType<InputSequence<T>, U(C::*)() const>
|
||||
{
|
||||
typedef InputSequence<U> ResultType;
|
||||
};
|
||||
|
||||
template <template <typename, typename> class InputSequence, typename MapFunctor, typename T, typename T2>
|
||||
struct MapResultType<InputSequence<T, T2>, MapFunctor>
|
||||
{
|
||||
typedef InputSequence<typename MapFunctor::result_type, T2> ResultType;
|
||||
};
|
||||
|
||||
template <template <typename, typename> class InputSequence, class T, typename T2, class U, class V>
|
||||
struct MapResultType<InputSequence<T, T2>, U (*)(V)>
|
||||
{
|
||||
typedef InputSequence<U, T2> ResultType;
|
||||
};
|
||||
|
||||
template <template <typename, typename> class InputSequence, class T, typename T2, class U, class C>
|
||||
struct MapResultType<InputSequence<T, T2>, U(C::*)() const>
|
||||
{
|
||||
typedef InputSequence<U, T2> ResultType;
|
||||
};
|
||||
|
||||
#endif // QT_NO_TEMPLATE_TEMPLATE_PARAMETER
|
||||
|
||||
template <class MapFunctor>
|
||||
struct MapResultType<QStringList, MapFunctor>
|
||||
{
|
||||
typedef QList<typename MapFunctor::result_type> ResultType;
|
||||
};
|
||||
|
||||
template <class U, class V>
|
||||
struct MapResultType<QStringList, U (*)(V)>
|
||||
{
|
||||
typedef QList<U> ResultType;
|
||||
};
|
||||
|
||||
template <class U, class C>
|
||||
struct MapResultType<QStringList, U(C::*)() const>
|
||||
{
|
||||
typedef QList<U> ResultType;
|
||||
};
|
||||
|
||||
template <typename ReturnType, typename T>
|
||||
struct DisableIfSame
|
||||
{
|
||||
typedef ReturnType Type;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct DisableIfSame<T, T>
|
||||
{
|
||||
|
||||
};
|
||||
|
||||
} // namespace QtPrivate.
|
||||
|
||||
#endif //qdoc
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
||||
@ -110,38 +110,14 @@ namespace QtConcurrent {
|
||||
template <typename Sequence, typename MapFunctor>
|
||||
QFuture<void> map(Sequence &sequence, MapFunctor map)
|
||||
{
|
||||
return startMap(sequence.begin(), sequence.end(), map);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename U>
|
||||
QFuture<void> map(Sequence &sequence, T (map)(U))
|
||||
{
|
||||
return startMap(sequence.begin(), sequence.end(), FunctionWrapper1<T, U>(map));
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename C>
|
||||
QFuture<void> map(Sequence &sequence, T (C::*map)())
|
||||
{
|
||||
return startMap(sequence.begin(), sequence.end(), MemberFunctionWrapper<T, C>(map));
|
||||
return startMap(sequence.begin(), sequence.end(), QtPrivate::createFunctionWrapper(map));
|
||||
}
|
||||
|
||||
// map() on iterators
|
||||
template <typename Iterator, typename MapFunctor>
|
||||
QFuture<void> map(Iterator begin, Iterator end, MapFunctor map)
|
||||
{
|
||||
return startMap(begin, end, map);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename U>
|
||||
QFuture<void> map(Iterator begin, Iterator end, T (map)(U))
|
||||
{
|
||||
return startMap(begin, end, FunctionWrapper1<T, U>(map));
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename C>
|
||||
QFuture<void> map(Iterator begin, Iterator end, T (C::*map)())
|
||||
{
|
||||
return startMap(begin, end, MemberFunctionWrapper<T, C>(map));
|
||||
return startMap(begin, end, QtPrivate::createFunctionWrapper(map));
|
||||
}
|
||||
|
||||
// mappedReduced() for sequences.
|
||||
@ -151,88 +127,24 @@ QFuture<ResultType> mappedReduced(const Sequence &sequence,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<typename MapFunctor::result_type, ResultType>
|
||||
(sequence, map, reduce, options);
|
||||
return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
|
||||
(sequence,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return startMappedReduced<typename MapFunctor::result_type, U>
|
||||
(sequence, map, FunctionWrapper2<T, U &, V>(reduce), options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return startMappedReduced<typename MapFunctor::result_type, C>
|
||||
(sequence, map, MemberFunctionWrapper1<T, C, U>(reduce), options);
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Sequence, typename T, typename U, typename ReduceFunctor>
|
||||
QFuture<ResultType> mappedReduced(const Sequence &sequence,
|
||||
T (map)(U),
|
||||
template <typename Sequence, typename MapFunctor, typename ReduceFunctor>
|
||||
QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(const Sequence &sequence,
|
||||
MapFunctor map,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<T, ResultType>
|
||||
(sequence, FunctionWrapper1<T, U>(map), reduce, options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return startMappedReduced<T, ResultType>
|
||||
(sequence, ConstMemberFunctionWrapper<T, C>(map), reduce, options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return startMappedReduced<T, W>
|
||||
(sequence, FunctionWrapper1<T, U>(map), FunctionWrapper2<V, W &, X>(reduce), options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return startMappedReduced<T, V> (sequence, ConstMemberFunctionWrapper<T, C>(map),
|
||||
FunctionWrapper2<U, V &, W>(reduce), options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return startMappedReduced<T, C> (sequence, FunctionWrapper1<T, U>(map),
|
||||
MemberFunctionWrapper1<V, C, W>(reduce), options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return startMappedReduced<T, D>(sequence, ConstMemberFunctionWrapper<T, C>(map),
|
||||
MemberFunctionWrapper1<U, D, V>(reduce), options);
|
||||
return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(sequence,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
// mappedReduced() for iterators
|
||||
@ -243,295 +155,85 @@ QFuture<ResultType> mappedReduced(Iterator begin,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<ResultType, typename MapFunctor::result_type>
|
||||
(begin, end, map, reduce, options);
|
||||
return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return startMappedReduced<typename MapFunctor::result_type, U>
|
||||
(begin, end, map, FunctionWrapper2<T, U &, V>(reduce), options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return startMappedReduced<typename MapFunctor::result_type, C>
|
||||
(begin, end, map, MemberFunctionWrapper1<T, C, U>(reduce), options);
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Iterator, typename T, typename U, typename ReduceFunctor>
|
||||
QFuture<ResultType> mappedReduced(Iterator begin,
|
||||
template <typename Iterator, typename MapFunctor, typename ReduceFunctor>
|
||||
QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
T (map)(U),
|
||||
MapFunctor map,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<T, ResultType>
|
||||
(begin, end, FunctionWrapper1<T, U>(map), reduce, options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return startMappedReduced<T, ResultType>
|
||||
(begin, end, ConstMemberFunctionWrapper<T, C>(map), reduce, options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return startMappedReduced<T, W>
|
||||
(begin, end, FunctionWrapper1<T, U>(map), FunctionWrapper2<V, W &, X>(reduce), options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return startMappedReduced<T, V>(begin, end, ConstMemberFunctionWrapper<T, C>(map),
|
||||
FunctionWrapper2<U, V &, W>(reduce), options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return startMappedReduced<T, C>
|
||||
(begin, end, FunctionWrapper1<T, U>(map), MemberFunctionWrapper1<V, C, W>(reduce), options);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return startMappedReduced<T, D>(begin, end, ConstMemberFunctionWrapper<T, C>(map),
|
||||
MemberFunctionWrapper1<U, D, V>(reduce), options);
|
||||
return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
// mapped() for sequences
|
||||
template <typename Sequence, typename MapFunctor>
|
||||
QFuture<typename MapFunctor::result_type> mapped(const Sequence &sequence, MapFunctor map)
|
||||
QFuture<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType> mapped(const Sequence &sequence, MapFunctor map)
|
||||
{
|
||||
return startMapped<typename MapFunctor::result_type>(sequence, map);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename U>
|
||||
QFuture<T> mapped(const Sequence &sequence, T (map)(U))
|
||||
{
|
||||
return startMapped<T>(sequence, FunctionWrapper1<T, U>(map));
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename C>
|
||||
QFuture<T> mapped(const Sequence &sequence, T (C::*map)() const)
|
||||
{
|
||||
return startMapped<T>(sequence, ConstMemberFunctionWrapper<T, C>(map));
|
||||
return startMapped<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType>(sequence, QtPrivate::createFunctionWrapper(map));
|
||||
}
|
||||
|
||||
// mapped() for iterator ranges.
|
||||
template <typename Iterator, typename MapFunctor>
|
||||
QFuture<typename MapFunctor::result_type> mapped(Iterator begin, Iterator end, MapFunctor map)
|
||||
QFuture<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType> mapped(Iterator begin, Iterator end, MapFunctor map)
|
||||
{
|
||||
return startMapped<Q_TYPENAME MapFunctor::result_type>(begin, end, map);
|
||||
return startMapped<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType>(begin, end, QtPrivate::createFunctionWrapper(map));
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename U>
|
||||
QFuture<T> mapped(Iterator begin, Iterator end, T (map)(U))
|
||||
{
|
||||
return startMapped<T>(begin, end, FunctionWrapper1<T, U>(map));
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename C>
|
||||
QFuture<T> mapped(Iterator begin, Iterator end, T (C::*map)() const)
|
||||
{
|
||||
return startMapped<T>(begin, end, ConstMemberFunctionWrapper<T, C>(map));
|
||||
}
|
||||
|
||||
|
||||
// blockingMap() for sequences
|
||||
template <typename Sequence, typename MapFunctor>
|
||||
void blockingMap(Sequence &sequence, MapFunctor map)
|
||||
{
|
||||
startMap(sequence.begin(), sequence.end(), map).startBlocking();
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename U>
|
||||
void blockingMap(Sequence &sequence, T (map)(U))
|
||||
{
|
||||
startMap(sequence.begin(), sequence.end(), QtConcurrent::FunctionWrapper1<T, U>(map)).startBlocking();
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename C>
|
||||
void blockingMap(Sequence &sequence, T (C::*map)())
|
||||
{
|
||||
startMap(sequence.begin(), sequence.end(), QtConcurrent::MemberFunctionWrapper<T, C>(map)).startBlocking();
|
||||
startMap(sequence.begin(), sequence.end(), QtPrivate::createFunctionWrapper(map)).startBlocking();
|
||||
}
|
||||
|
||||
// blockingMap() for iterator ranges
|
||||
template <typename Iterator, typename MapFunctor>
|
||||
void blockingMap(Iterator begin, Iterator end, MapFunctor map)
|
||||
{
|
||||
startMap(begin, end, map).startBlocking();
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename U>
|
||||
void blockingMap(Iterator begin, Iterator end, T (map)(U))
|
||||
{
|
||||
startMap(begin, end, QtConcurrent::FunctionWrapper1<T, U>(map)).startBlocking();
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename C>
|
||||
void blockingMap(Iterator begin, Iterator end, T (C::*map)())
|
||||
{
|
||||
startMap(begin, end, QtConcurrent::MemberFunctionWrapper<T, C>(map)).startBlocking();
|
||||
startMap(begin, end, QtPrivate::createFunctionWrapper(map)).startBlocking();
|
||||
}
|
||||
|
||||
// blockingMappedReduced() for sequences
|
||||
template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
|
||||
ResultType blockingMappedReduced(const Sequence &sequence,
|
||||
typename QtPrivate::DisableIfSame<ResultType, Sequence>::Type blockingMappedReduced(const Sequence &sequence,
|
||||
MapFunctor map,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, ResultType>
|
||||
(sequence, map, reduce, options).startBlocking();
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, U>
|
||||
return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
|
||||
(sequence,
|
||||
map,
|
||||
QtConcurrent::FunctionWrapper2<T, U &, V>(reduce),
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, C>
|
||||
(sequence,
|
||||
map,
|
||||
QtConcurrent::MemberFunctionWrapper1<T, C, U>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Sequence, typename T, typename U, typename ReduceFunctor>
|
||||
ResultType blockingMappedReduced(const Sequence &sequence,
|
||||
T (map)(U),
|
||||
template <typename Sequence, typename MapFunctor, typename ReduceFunctor>
|
||||
typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(const Sequence &sequence,
|
||||
MapFunctor map,
|
||||
ReduceFunctor reduce,
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, ResultType>
|
||||
return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(sequence,
|
||||
QtConcurrent::FunctionWrapper1<T, U>(map),
|
||||
reduce,
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, ResultType>
|
||||
(sequence,
|
||||
QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
|
||||
reduce,
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, W>
|
||||
(sequence,
|
||||
QtConcurrent::FunctionWrapper1<T, U>(map),
|
||||
QtConcurrent::FunctionWrapper2<V, W &, X>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, V>
|
||||
(sequence,
|
||||
QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
|
||||
QtConcurrent::FunctionWrapper2<U, V &, W>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, C>
|
||||
(sequence,
|
||||
QtConcurrent::FunctionWrapper1<T, U>(map),
|
||||
QtConcurrent::MemberFunctionWrapper1<V, C, W>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, D>
|
||||
(sequence,
|
||||
QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
|
||||
QtConcurrent::MemberFunctionWrapper1<U, D, V>(reduce),
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
// blockingMappedReduced() for iterator ranges
|
||||
template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
|
||||
ResultType blockingMappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
@ -539,233 +241,71 @@ ResultType blockingMappedReduced(Iterator begin,
|
||||
ReduceFunctor reduce,
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, ResultType>
|
||||
(begin, end, map, reduce, options).startBlocking();
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, U>
|
||||
(begin,
|
||||
end,
|
||||
map,
|
||||
QtConcurrent::FunctionWrapper2<T, U &, V>(reduce),
|
||||
return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, C>
|
||||
(begin,
|
||||
end,
|
||||
map,
|
||||
QtConcurrent::MemberFunctionWrapper1<T, C, U>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Iterator, typename T, typename U, typename ReduceFunctor>
|
||||
ResultType blockingMappedReduced(Iterator begin,
|
||||
template <typename Iterator, typename MapFunctor, typename ReduceFunctor>
|
||||
typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
T (map)(U),
|
||||
MapFunctor map,
|
||||
ReduceFunctor reduce,
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, ResultType>
|
||||
(begin,
|
||||
end,
|
||||
QtConcurrent::FunctionWrapper1<T, U>(map),
|
||||
reduce,
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, ResultType>
|
||||
(begin,
|
||||
end,
|
||||
QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
|
||||
reduce,
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, W>
|
||||
(begin,
|
||||
end,
|
||||
QtConcurrent::FunctionWrapper1<T, U>(map),
|
||||
QtConcurrent::FunctionWrapper2<V, W &, X>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, V>
|
||||
(begin,
|
||||
end,
|
||||
QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
|
||||
QtConcurrent::FunctionWrapper2<U, V &, W>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, C>
|
||||
(begin,
|
||||
end,
|
||||
QtConcurrent::FunctionWrapper1<T, U>(map),
|
||||
QtConcurrent::MemberFunctionWrapper1<V, C, W>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, D>
|
||||
(begin,
|
||||
end,
|
||||
QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
|
||||
QtConcurrent::MemberFunctionWrapper1<U, D, V>(reduce),
|
||||
return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
// mapped() for sequences with a different putput sequence type.
|
||||
template <typename OutputSequence, typename InputSequence, typename MapFunctor>
|
||||
OutputSequence blockingMapped(const InputSequence &sequence, MapFunctor map)
|
||||
typename QtPrivate::DisableIfSame<OutputSequence, InputSequence>::Type blockingMapped(const InputSequence &sequence, MapFunctor map)
|
||||
{
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
return blockingMappedReduced<OutputSequence>
|
||||
(sequence,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
&OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename OutputSequence, typename InputSequence, typename T, typename U>
|
||||
OutputSequence blockingMapped(const InputSequence &sequence, T (map)(U))
|
||||
template <typename InputSequence, typename MapFunctor>
|
||||
typename QtPrivate::MapResultType<InputSequence, MapFunctor>::ResultType blockingMapped(const InputSequence &sequence, MapFunctor map)
|
||||
{
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename OutputSequence, typename InputSequence, typename T, typename C>
|
||||
OutputSequence blockingMapped(const InputSequence &sequence, T (C::*map)() const)
|
||||
{
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
#ifndef QT_NO_TEMPLATE_TEMPLATE_PARAMETERS
|
||||
|
||||
// overloads for changing the container value type:
|
||||
template <template <typename> class Sequence, typename MapFunctor, typename T>
|
||||
Sequence<typename MapFunctor::result_type> blockingMapped(const Sequence<T> &sequence, MapFunctor map)
|
||||
{
|
||||
typedef Sequence<typename MapFunctor::result_type> OutputSequence;
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <template <typename> class Sequence, typename T, typename U, typename V>
|
||||
Sequence<U> blockingMapped(const Sequence<T> &sequence, U (map)(V))
|
||||
{
|
||||
typedef Sequence<U> OutputSequence;
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <template <typename> class Sequence, typename T, typename U, typename C>
|
||||
Sequence<U> blockingMapped(const Sequence<T> &sequence, U (C::*map)() const)
|
||||
{
|
||||
typedef Sequence<U> OutputSequence;
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
#endif // QT_NO_TEMPLATE_TEMPLATE_PARAMETER
|
||||
|
||||
// overloads for changing the container value type from a QStringList:
|
||||
template <typename MapFunctor>
|
||||
QList<typename MapFunctor::result_type> blockingMapped(const QStringList &sequence, MapFunctor map)
|
||||
{
|
||||
typedef QList<typename MapFunctor::result_type> OutputSequence;
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename U, typename V>
|
||||
QList<U> blockingMapped(const QStringList &sequence, U (map)(V))
|
||||
{
|
||||
typedef QList<U> OutputSequence;
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename U, typename C>
|
||||
QList<U> blockingMapped(const QStringList &sequence, U (C::*map)() const)
|
||||
{
|
||||
typedef QList<U> OutputSequence;
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
typedef typename QtPrivate::MapResultType<InputSequence, MapFunctor>::ResultType OutputSequence;
|
||||
return blockingMappedReduced<OutputSequence>
|
||||
(sequence,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
&OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
// mapped() for iterator ranges
|
||||
template <typename Sequence, typename Iterator, typename MapFunctor>
|
||||
Sequence blockingMapped(Iterator begin, Iterator end, MapFunctor map)
|
||||
{
|
||||
return blockingMappedReduced(begin, end, map, &Sequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
return blockingMappedReduced<Sequence>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
&Sequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename Iterator, typename T, typename U>
|
||||
Sequence blockingMapped(Iterator begin, Iterator end, T (map)(U))
|
||||
template <typename Iterator, typename MapFunctor>
|
||||
typename QtPrivate::MapResultType<Iterator, MapFunctor>::ResultType blockingMapped(Iterator begin, Iterator end, MapFunctor map)
|
||||
{
|
||||
return blockingMappedReduced(begin, end, map, &Sequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename Iterator, typename T, typename C>
|
||||
Sequence blockingMapped(Iterator begin, Iterator end, T (C::*map)() const)
|
||||
{
|
||||
return blockingMappedReduced(begin, end, map, &Sequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
typedef typename QtPrivate::MapResultType<Iterator, MapFunctor>::ResultType OutputSequence;
|
||||
return blockingMappedReduced<OutputSequence>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
&OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
} // namespace QtConcurrent
|
||||
|
||||
Loading…
Reference in New Issue
Block a user