diff options
Diffstat (limited to 'src/concurrent/qtconcurrentmap.h')
| -rw-r--r-- | src/concurrent/qtconcurrentmap.h | 319 |
1 files changed, 319 insertions, 0 deletions
diff --git a/src/concurrent/qtconcurrentmap.h b/src/concurrent/qtconcurrentmap.h new file mode 100644 index 0000000000..8a5557183d --- /dev/null +++ b/src/concurrent/qtconcurrentmap.h @@ -0,0 +1,319 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QTCONCURRENT_MAP_H +#define QTCONCURRENT_MAP_H + +#include <QtCore/qglobal.h> + +#ifndef QT_NO_CONCURRENT + +#include <QtConcurrent/qtconcurrentmapkernel.h> +#include <QtConcurrent/qtconcurrentreducekernel.h> +#include <QtConcurrent/qtconcurrentfunctionwrappers.h> +#include <QtCore/qstringlist.h> + +QT_BEGIN_HEADER +QT_BEGIN_NAMESPACE + + +#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(), QtPrivate::createFunctionWrapper(map)); +} + +// map() on iterators +template <typename Iterator, typename MapFunctor> +QFuture<void> map(Iterator begin, Iterator end, MapFunctor map) +{ + return startMap(begin, end, QtPrivate::createFunctionWrapper(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 QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType> + (sequence, + QtPrivate::createFunctionWrapper(map), + QtPrivate::createFunctionWrapper(reduce), + options); +} + +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<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> + (sequence, + QtPrivate::createFunctionWrapper(map), + QtPrivate::createFunctionWrapper(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<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType> + (begin, end, + QtPrivate::createFunctionWrapper(map), + QtPrivate::createFunctionWrapper(reduce), + options); +} + +template <typename Iterator, typename MapFunctor, typename ReduceFunctor> +QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(Iterator begin, + Iterator end, + MapFunctor map, + ReduceFunctor reduce, + ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce)) +{ + 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 QtPrivate::MapResultType<void, MapFunctor>::ResultType> mapped(const Sequence &sequence, MapFunctor map) +{ + return startMapped<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType>(sequence, QtPrivate::createFunctionWrapper(map)); +} + +// mapped() for iterator ranges. +template <typename Iterator, typename MapFunctor> +QFuture<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType> mapped(Iterator begin, Iterator end, MapFunctor map) +{ + return startMapped<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType>(begin, end, QtPrivate::createFunctionWrapper(map)); +} + +// blockingMap() for sequences +template <typename Sequence, typename MapFunctor> +void blockingMap(Sequence &sequence, MapFunctor map) +{ + 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, QtPrivate::createFunctionWrapper(map)).startBlocking(); +} + +// blockingMappedReduced() for sequences +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 QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType> + (sequence, + QtPrivate::createFunctionWrapper(map), + QtPrivate::createFunctionWrapper(reduce), + options) + .startBlocking(); +} + +template <typename MapFunctor, typename ReduceFunctor, typename Sequence> +typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(const Sequence &sequence, + MapFunctor map, + ReduceFunctor reduce, + ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce)) +{ + return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> + (sequence, + 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, + MapFunctor map, + ReduceFunctor reduce, + QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)) +{ + 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 ReduceFunctor> +typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(Iterator begin, + Iterator end, + MapFunctor map, + ReduceFunctor reduce, + QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce)) +{ + 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) +{ + return blockingMappedReduced<OutputSequence> + (sequence, + QtPrivate::createFunctionWrapper(map), + QtPrivate::PushBackWrapper(), + QtConcurrent::OrderedReduce); +} + +template <typename MapFunctor, typename InputSequence> +typename QtPrivate::MapResultType<InputSequence, MapFunctor>::ResultType blockingMapped(const InputSequence &sequence, MapFunctor map) +{ + typedef typename QtPrivate::MapResultType<InputSequence, MapFunctor>::ResultType OutputSequence; + return blockingMappedReduced<OutputSequence> + (sequence, + QtPrivate::createFunctionWrapper(map), + QtPrivate::PushBackWrapper(), + QtConcurrent::OrderedReduce); +} + +// mapped() for iterator ranges +template <typename Sequence, typename Iterator, typename MapFunctor> +Sequence blockingMapped(Iterator begin, Iterator end, MapFunctor map) +{ + return blockingMappedReduced<Sequence> + (begin, end, + QtPrivate::createFunctionWrapper(map), + QtPrivate::PushBackWrapper(), + QtConcurrent::OrderedReduce); +} + +template <typename Iterator, typename MapFunctor> +typename QtPrivate::MapResultType<Iterator, MapFunctor>::ResultType blockingMapped(Iterator begin, Iterator end, MapFunctor map) +{ + typedef typename QtPrivate::MapResultType<Iterator, MapFunctor>::ResultType OutputSequence; + return blockingMappedReduced<OutputSequence> + (begin, end, + QtPrivate::createFunctionWrapper(map), + QtPrivate::PushBackWrapper(), + QtConcurrent::OrderedReduce); +} + +} // namespace QtConcurrent + +#endif // qdoc + +QT_END_NAMESPACE +QT_END_HEADER + +#endif // QT_NO_CONCURRENT + +#endif |