1/****************************************************************************
2**
3** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
4** Contact: http://www.qt-project.org/legal
5**
6** This file is part of the QtCore module of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial License Usage
10** Licensees holding valid commercial Qt licenses may use this file in
11** accordance with the commercial license agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and Digia. For licensing terms and
14** conditions see http://qt.digia.com/licensing. For further information
15** use the contact form at http://qt.digia.com/contact-us.
16**
17** GNU Lesser General Public License Usage
18** Alternatively, this file may be used under the terms of the GNU Lesser
19** General Public License version 2.1 as published by the Free Software
20** Foundation and appearing in the file LICENSE.LGPL included in the
21** packaging of this file. Please review the following information to
22** ensure the GNU Lesser General Public License version 2.1 requirements
23** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24**
25** In addition, as a special exception, Digia gives you certain additional
26** rights. These rights are described in the Digia Qt LGPL Exception
27** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
28**
29** GNU General Public License Usage
30** Alternatively, this file may be used under the terms of the GNU
31** General Public License version 3.0 as published by the Free Software
32** Foundation and appearing in the file LICENSE.GPL included in the
33** packaging of this file. Please review the following information to
34** ensure the GNU General Public License version 3.0 requirements will be
35** met: http://www.gnu.org/copyleft/gpl.html.
36**
37**
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#ifndef QTCONCURRENT_MAP_H
43#define QTCONCURRENT_MAP_H
44
45#include <QtCore/qglobal.h>
46
47#ifndef QT_NO_CONCURRENT
48
49#include <QtCore/qtconcurrentmapkernel.h>
50#include <QtCore/qtconcurrentreducekernel.h>
51#include <QtCore/qtconcurrentfunctionwrappers.h>
52#include <QtCore/qstringlist.h>
53
54QT_BEGIN_HEADER
55QT_BEGIN_NAMESPACE
56
57QT_MODULE(Core)
58
59#ifdef qdoc
60
61namespace QtConcurrent {
62
63 QFuture<void> map(Sequence &sequence, MapFunction function);
64 QFuture<void> map(Iterator begin, Iterator end, MapFunction function);
65
66 template <typename T>
67 QFuture<T> mapped(const Sequence &sequence, MapFunction function);
68 template <typename T>
69 QFuture<T> mapped(ConstIterator begin, ConstIterator end, MapFunction function);
70
71 template <typename T>
72 QFuture<T> mappedReduced(const Sequence &sequence,
73 MapFunction function,
74 ReduceFunction function,
75 QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce);
76 template <typename T>
77 QFuture<T> mappedReduced(ConstIterator begin,
78 ConstIterator end,
79 MapFunction function,
80 ReduceFunction function,
81 QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce);
82
83 void blockingMap(Sequence &sequence, MapFunction function);
84 void blockingMap(Iterator begin, Iterator end, MapFunction function);
85
86 template <typename T>
87 T blockingMapped(const Sequence &sequence, MapFunction function);
88 template <typename T>
89 T blockingMapped(ConstIterator begin, ConstIterator end, MapFunction function);
90
91 template <typename T>
92 T blockingMappedReduced(const Sequence &sequence,
93 MapFunction function,
94 ReduceFunction function,
95 QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce);
96 template <typename T>
97 T blockingMappedReduced(ConstIterator begin,
98 ConstIterator end,
99 MapFunction function,
100 ReduceFunction function,
101 QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce);
102
103} // namespace QtConcurrent
104
105#else
106
107namespace QtConcurrent {
108
109// map() on sequences
110template <typename Sequence, typename MapFunctor>
111QFuture<void> map(Sequence &sequence, MapFunctor map)
112{
113 return startMap(sequence.begin(), sequence.end(), QtPrivate::createFunctionWrapper(map));
114}
115
116// map() on iterators
117template <typename Iterator, typename MapFunctor>
118QFuture<void> map(Iterator begin, Iterator end, MapFunctor map)
119{
120 return startMap(begin, end, QtPrivate::createFunctionWrapper(map));
121}
122
123// mappedReduced() for sequences.
124template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
125QFuture<ResultType> mappedReduced(const Sequence &sequence,
126 MapFunctor map,
127 ReduceFunctor reduce,
128 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
129{
130 return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
131 (sequence,
132 QtPrivate::createFunctionWrapper(map),
133 QtPrivate::createFunctionWrapper(reduce),
134 options);
135}
136
137template <typename Sequence, typename MapFunctor, typename ReduceFunctor>
138QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(const Sequence &sequence,
139 MapFunctor map,
140 ReduceFunctor reduce,
141 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
142{
143 return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
144 (sequence,
145 QtPrivate::createFunctionWrapper(map),
146 QtPrivate::createFunctionWrapper(reduce),
147 options);
148}
149
150// mappedReduced() for iterators
151template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
152QFuture<ResultType> mappedReduced(Iterator begin,
153 Iterator end,
154 MapFunctor map,
155 ReduceFunctor reduce,
156 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
157{
158 return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
159 (begin, end,
160 QtPrivate::createFunctionWrapper(map),
161 QtPrivate::createFunctionWrapper(reduce),
162 options);
163}
164
165template <typename Iterator, typename MapFunctor, typename ReduceFunctor>
166QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(Iterator begin,
167 Iterator end,
168 MapFunctor map,
169 ReduceFunctor reduce,
170 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
171{
172 return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
173 (begin, end,
174 QtPrivate::createFunctionWrapper(map),
175 QtPrivate::createFunctionWrapper(reduce),
176 options);
177}
178
179// mapped() for sequences
180template <typename Sequence, typename MapFunctor>
181QFuture<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType> mapped(const Sequence &sequence, MapFunctor map)
182{
183 return startMapped<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType>(sequence, QtPrivate::createFunctionWrapper(map));
184}
185
186// mapped() for iterator ranges.
187template <typename Iterator, typename MapFunctor>
188QFuture<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType> mapped(Iterator begin, Iterator end, MapFunctor map)
189{
190 return startMapped<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType>(begin, end, QtPrivate::createFunctionWrapper(map));
191}
192
193// blockingMap() for sequences
194template <typename Sequence, typename MapFunctor>
195void blockingMap(Sequence &sequence, MapFunctor map)
196{
197 startMap(sequence.begin(), sequence.end(), QtPrivate::createFunctionWrapper(map)).startBlocking();
198}
199
200// blockingMap() for iterator ranges
201template <typename Iterator, typename MapFunctor>
202void blockingMap(Iterator begin, Iterator end, MapFunctor map)
203{
204 startMap(begin, end, QtPrivate::createFunctionWrapper(map)).startBlocking();
205}
206
207// blockingMappedReduced() for sequences
208template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
209ResultType blockingMappedReduced(const Sequence &sequence,
210 MapFunctor map,
211 ReduceFunctor reduce,
212 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
213{
214 return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
215 (sequence,
216 QtPrivate::createFunctionWrapper(map),
217 QtPrivate::createFunctionWrapper(reduce),
218 options)
219 .startBlocking();
220}
221
222template <typename MapFunctor, typename ReduceFunctor, typename Sequence>
223typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(const Sequence &sequence,
224 MapFunctor map,
225 ReduceFunctor reduce,
226 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
227{
228 return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
229 (sequence,
230 QtPrivate::createFunctionWrapper(map),
231 QtPrivate::createFunctionWrapper(reduce),
232 options)
233 .startBlocking();
234}
235
236// blockingMappedReduced() for iterator ranges
237template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
238ResultType blockingMappedReduced(Iterator begin,
239 Iterator end,
240 MapFunctor map,
241 ReduceFunctor reduce,
242 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
243{
244 return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
245 (begin, end,
246 QtPrivate::createFunctionWrapper(map),
247 QtPrivate::createFunctionWrapper(reduce),
248 options)
249 .startBlocking();
250}
251
252template <typename Iterator, typename MapFunctor, typename ReduceFunctor>
253typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(Iterator begin,
254 Iterator end,
255 MapFunctor map,
256 ReduceFunctor reduce,
257 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
258{
259 return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
260 (begin, end,
261 QtPrivate::createFunctionWrapper(map),
262 QtPrivate::createFunctionWrapper(reduce),
263 options)
264 .startBlocking();
265}
266
267// mapped() for sequences with a different putput sequence type.
268template <typename OutputSequence, typename InputSequence, typename MapFunctor>
269OutputSequence blockingMapped(const InputSequence &sequence, MapFunctor map)
270{
271 return blockingMappedReduced<OutputSequence>
272 (sequence,
273 QtPrivate::createFunctionWrapper(map),
274 QtPrivate::PushBackWrapper(),
275 QtConcurrent::OrderedReduce);
276}
277
278template <typename MapFunctor, typename InputSequence>
279typename QtPrivate::MapResultType<InputSequence, MapFunctor>::ResultType blockingMapped(const InputSequence &sequence, MapFunctor map)
280{
281 typedef typename QtPrivate::MapResultType<InputSequence, MapFunctor>::ResultType OutputSequence;
282 return blockingMappedReduced<OutputSequence>
283 (sequence,
284 QtPrivate::createFunctionWrapper(map),
285 QtPrivate::PushBackWrapper(),
286 QtConcurrent::OrderedReduce);
287}
288
289// mapped() for iterator ranges
290template <typename Sequence, typename Iterator, typename MapFunctor>
291Sequence blockingMapped(Iterator begin, Iterator end, MapFunctor map)
292{
293 return blockingMappedReduced<Sequence>
294 (begin, end,
295 QtPrivate::createFunctionWrapper(map),
296 QtPrivate::PushBackWrapper(),
297 QtConcurrent::OrderedReduce);
298}
299
300template <typename Iterator, typename MapFunctor>
301typename QtPrivate::MapResultType<Iterator, MapFunctor>::ResultType blockingMapped(Iterator begin, Iterator end, MapFunctor map)
302{
303 typedef typename QtPrivate::MapResultType<Iterator, MapFunctor>::ResultType OutputSequence;
304 return blockingMappedReduced<OutputSequence>
305 (begin, end,
306 QtPrivate::createFunctionWrapper(map),
307 QtPrivate::PushBackWrapper(),
308 QtConcurrent::OrderedReduce);
309}
310
311} // namespace QtConcurrent
312
313#endif // qdoc
314
315QT_END_NAMESPACE
316QT_END_HEADER
317
318#endif // QT_NO_CONCURRENT
319
320#endif
321