namespace QtConcurrent {
-template <typename Sequence, typename KeepFunctor, typename T, typename C, typename U>
-ThreadEngineStarter<void> filterInternal(Sequence &sequence, KeepFunctor keep, T (C::*reduce)(U))
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+ThreadEngineStarter<void> filterInternal(Sequence &sequence, KeepFunctor keep, ReduceFunctor reduce)
{
- typedef MemberFunctionWrapper1<T, C, U> ReduceFunctor;
typedef typename Sequence::const_iterator Iterator;
typedef FilterKernel<Sequence, KeepFunctor, ReduceFunctor> KernelType;
return startThreadEngine(new KernelType(sequence, keep, reduce));
template <typename Sequence, typename KeepFunctor>
QFuture<void> filter(Sequence &sequence, KeepFunctor keep)
{
- return filterInternal(sequence, QtPrivate::createFunctionWrapper(keep), &Sequence::push_back);
+ return filterInternal(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::PushBackWrapper());
}
// filteredReduced() on sequences
template <typename Sequence, typename KeepFunctor>
void blockingFilter(Sequence &sequence, KeepFunctor keep)
{
- filterInternal(sequence, QtPrivate::createFunctionWrapper(keep), &Sequence::push_back).startBlocking();
+ filterInternal(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::PushBackWrapper()).startBlocking();
}
// blocking filteredReduced() on sequences
template <typename Sequence, typename KeepFunctor>
Sequence blockingFiltered(const Sequence &sequence, KeepFunctor keep)
{
- return blockingFilteredReduced(sequence, QtPrivate::createFunctionWrapper(keep), &Sequence::push_back, OrderedReduce);
+ return startFilteredReduced<Sequence>(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::PushBackWrapper(), OrderedReduce).startBlocking();
}
// blocking filtered() on iterators
template <typename OutputSequence, typename Iterator, typename KeepFunctor>
OutputSequence blockingFiltered(Iterator begin, Iterator end, KeepFunctor keep)
{
- return blockingFilteredReduced(begin,
- end,
- QtPrivate::createFunctionWrapper(keep),
- &OutputSequence::push_back,
- OrderedReduce);
+ return startFilteredReduced<OutputSequence>(begin, end,
+ QtPrivate::createFunctionWrapper(keep),
+ QtPrivate::PushBackWrapper(),
+ OrderedReduce).startBlocking();
}
} // namespace QtConcurrent
return QtConcurrent::ConstMemberFunctionWrapper<T, C>(func);
}
+struct PushBackWrapper
+{
+ typedef void result_type;
+
+ template <class C, class U>
+ inline void operator()(C &c, const U &u) const
+ {
+ return c.push_back(u);
+ }
+
+#ifdef Q_COMPILER_RVALUE_REFS
+ template <class C, class U>
+ inline void operator()(C &c, U &&u) const
+ {
+ return c.push_back(u);
+ }
+#endif
+};
+
template <typename Functor, bool foo = HasResultType<Functor>::Value>
struct LazyResultType { typedef typename Functor::result_type Type; };
template <typename Functor>
return blockingMappedReduced<OutputSequence>
(sequence,
QtPrivate::createFunctionWrapper(map),
- &OutputSequence::push_back,
+ QtPrivate::PushBackWrapper(),
QtConcurrent::OrderedReduce);
}
return blockingMappedReduced<OutputSequence>
(sequence,
QtPrivate::createFunctionWrapper(map),
- &OutputSequence::push_back,
+ QtPrivate::PushBackWrapper(),
QtConcurrent::OrderedReduce);
}
return blockingMappedReduced<Sequence>
(begin, end,
QtPrivate::createFunctionWrapper(map),
- &Sequence::push_back,
+ QtPrivate::PushBackWrapper(),
QtConcurrent::OrderedReduce);
}
return blockingMappedReduced<OutputSequence>
(begin, end,
QtPrivate::createFunctionWrapper(map),
- &OutputSequence::push_back,
+ QtPrivate::PushBackWrapper(),
QtConcurrent::OrderedReduce);
}