/**************************************************************************** ** ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). ** All rights reserved. ** Contact: Nokia Corporation (qt-info@nokia.com) ** ** This file is part of the QtCore module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** No Commercial Usage ** This file contains pre-release code and may not be distributed. ** You may use this file in accordance with the terms and conditions ** contained in the Technology Preview License Agreement accompanying ** this package. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 2.1 as published by the Free Software ** Foundation and appearing in the file LICENSE.LGPL included in the ** packaging of this file. Please review the following information to ** ensure the GNU Lesser General Public License version 2.1 requirements ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, Nokia gives you certain additional ** rights. These rights are described in the Nokia Qt LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ** If you have questions regarding the use of this file, please contact ** Nokia at qt-info@nokia.com. ** ** ** ** ** ** ** ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #ifndef QTCONCURRENT_MAP_H #define QTCONCURRENT_MAP_H #include <QtCore/qglobal.h> #ifndef QT_NO_CONCURRENT #include <QtCore/qtconcurrentmapkernel.h> #include <QtCore/qtconcurrentreducekernel.h> #include <QtCore/qtconcurrentfunctionwrappers.h> #include <QtCore/qstringlist.h> QT_BEGIN_HEADER QT_BEGIN_NAMESPACE QT_MODULE(Core) #ifdef qdoc namespace QtConcurrent { QFuture<void> map(Sequence &sequence, MapFunction function); QFuture<void> map(Iterator begin, Iterator end, MapFunction function); template <typename T> QFuture<T> mapped(const Sequence &sequence, MapFunction function); template <typename T> QFuture<T> mapped(ConstIterator begin, ConstIterator end, MapFunction function); template <typename T> QFuture<T> mappedReduced(const Sequence &sequence, MapFunction function, ReduceFunction function, QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce); template <typename T> QFuture<T> mappedReduced(ConstIterator begin, ConstIterator end, MapFunction function, ReduceFunction function, QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce); void blockingMap(Sequence &sequence, MapFunction function); void blockingMap(Iterator begin, Iterator end, MapFunction function); template <typename T> T blockingMapped(const Sequence &sequence, MapFunction function); template <typename T> T blockingMapped(ConstIterator begin, ConstIterator end, MapFunction function); template <typename T> T blockingMappedReduced(const Sequence &sequence, MapFunction function, ReduceFunction function, QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce); template <typename T> T blockingMappedReduced(ConstIterator begin, ConstIterator end, MapFunction function, ReduceFunction function, QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce); } // namespace QtConcurrent #else namespace QtConcurrent { // map() on sequences 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)); } // 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)); } // mappedReduced() for sequences. template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor> QFuture<ResultType> mappedReduced(const Sequence &sequence, MapFunctor map, ReduceFunctor reduce, ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce)) { return startMappedReduced<typename MapFunctor::result_type, ResultType> (sequence, map, 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), 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); } // mappedReduced() for iterators 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)) { return startMappedReduced<ResultType, typename MapFunctor::result_type> (begin, end, map, 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, Iterator end, T (map)(U), 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); } // mapped() for sequences template <typename Sequence, typename MapFunctor> QFuture<typename MapFunctor::result_type> 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)); } // mapped() for iterator ranges. template <typename Iterator, typename MapFunctor> QFuture<typename MapFunctor::result_type> mapped(Iterator begin, Iterator end, MapFunctor map) { return startMapped<Q_TYPENAME MapFunctor::result_type>(begin, end, 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)); } 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(); } 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(); } template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor> ResultType 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> (sequence, map, QtConcurrent::FunctionWrapper2<T, U &, V>(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), ReduceFunctor reduce, QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)) { return QtConcurrent::startMappedReduced<T, 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), options) .startBlocking(); } 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)) { 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), 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, Iterator end, T (map)(U), 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), 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) { return blockingMappedReduced(sequence, map, &OutputSequence::push_back, QtConcurrent::OrderedReduce); } template <typename OutputSequence, typename InputSequence, typename T, typename U> OutputSequence blockingMapped(const InputSequence &sequence, T (map)(U)) { 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); } // 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); } template <typename Sequence, typename Iterator, typename T, typename U> Sequence blockingMapped(Iterator begin, Iterator end, T (map)(U)) { 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); } } // namespace QtConcurrent #endif // qdoc QT_END_NAMESPACE QT_END_HEADER #endif // QT_NO_CONCURRENT #endif