source: trunk/src/corelib/concurrent/qtconcurrentmap.h@ 83

Last change on this file since 83 was 2, checked in by Dmitry A. Kuminov, 16 years ago

Initially imported qt-all-opensource-src-4.5.1 from Trolltech.
File size: 31.7 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
4** Contact: Qt Software Information ([email protected])
5**
6** This file is part of the QtCore module of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial Usage
10** Licensees holding valid Qt Commercial licenses may use this file in
11** accordance with the Qt Commercial License Agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and Nokia.
14**
15** GNU Lesser General Public License Usage
16** Alternatively, this file may be used under the terms of the GNU Lesser
17** General Public License version 2.1 as published by the Free Software
18** Foundation and appearing in the file LICENSE.LGPL included in the
19** packaging of this file. Please review the following information to
20** ensure the GNU Lesser General Public License version 2.1 requirements
21** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
22**
23** In addition, as a special exception, Nokia gives you certain
24** additional rights. These rights are described in the Nokia Qt LGPL
25** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
26** package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you are unsure which license is appropriate for your use, please
37** contact the sales department at [email protected].
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(), map);
114}
115
116template <typename Sequence, typename T, typename U>
117QFuture<void> map(Sequence &sequence, T (map)(U))
118{
119 return startMap(sequence.begin(), sequence.end(), FunctionWrapper1<T, U>(map));
120}
121
122template <typename Sequence, typename T, typename C>
123QFuture<void> map(Sequence &sequence, T (C::*map)())
124{
125 return startMap(sequence.begin(), sequence.end(), MemberFunctionWrapper<T, C>(map));
126}
127
128// map() on iterators
129template <typename Iterator, typename MapFunctor>
130QFuture<void> map(Iterator begin, Iterator end, MapFunctor map)
131{
132 return startMap(begin, end, map);
133}
134
135template <typename Iterator, typename T, typename U>
136QFuture<void> map(Iterator begin, Iterator end, T (map)(U))
137{
138 return startMap(begin, end, FunctionWrapper1<T, U>(map));
139}
140
141template <typename Iterator, typename T, typename C>
142QFuture<void> map(Iterator begin, Iterator end, T (C::*map)())
143{
144 return startMap(begin, end, MemberFunctionWrapper<T, C>(map));
145}
146
147// mappedReduced() for sequences.
148template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
149QFuture<ResultType> mappedReduced(const Sequence &sequence,
150 MapFunctor map,
151 ReduceFunctor reduce,
152 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
153{
154 return startMappedReduced<typename MapFunctor::result_type, ResultType>
155 (sequence, map, reduce, options);
156}
157
158template <typename Sequence, typename MapFunctor, typename T, typename U, typename V>
159QFuture<U> mappedReduced(const Sequence &sequence,
160 MapFunctor map,
161 T (reduce)(U &, V),
162 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
163{
164 return startMappedReduced<typename MapFunctor::result_type, U>
165 (sequence, map, FunctionWrapper2<T, U &, V>(reduce), options);
166}
167
168template <typename Sequence, typename MapFunctor, typename T, typename C, typename U>
169QFuture<C> mappedReduced(const Sequence &sequence,
170 MapFunctor map,
171 T (C::*reduce)(U),
172 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
173{
174 return startMappedReduced<typename MapFunctor::result_type, C>
175 (sequence, map, MemberFunctionWrapper1<T, C, U>(reduce), options);
176}
177
178template <typename ResultType, typename Sequence, typename T, typename U, typename ReduceFunctor>
179QFuture<ResultType> mappedReduced(const Sequence &sequence,
180 T (map)(U),
181 ReduceFunctor reduce,
182 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
183{
184 return startMappedReduced<T, ResultType>
185 (sequence, FunctionWrapper1<T, U>(map), reduce, options);
186}
187
188template <typename ResultType, typename Sequence, typename T, typename C, typename ReduceFunctor>
189QFuture<ResultType> mappedReduced(const Sequence &sequence,
190 T (C::*map)() const,
191 ReduceFunctor reduce,
192 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
193{
194 return startMappedReduced<T, ResultType>
195 (sequence, ConstMemberFunctionWrapper<T, C>(map), reduce, options);
196}
197
198template <typename Sequence, typename T, typename U, typename V, typename W, typename X>
199QFuture<W> mappedReduced(const Sequence &sequence,
200 T (map)(U),
201 V (reduce)(W &, X),
202 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
203{
204 return startMappedReduced<T, W>
205 (sequence, FunctionWrapper1<T, U>(map), FunctionWrapper2<V, W &, X>(reduce), options);
206}
207
208template <typename Sequence, typename T, typename C, typename U, typename V, typename W>
209QFuture<V> mappedReduced(const Sequence &sequence,
210 T (C::*map)() const,
211 U (reduce)(V &, W),
212 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
213{
214 return startMappedReduced<T, V> (sequence, ConstMemberFunctionWrapper<T, C>(map),
215 FunctionWrapper2<U, V &, W>(reduce), options);
216}
217
218template <typename Sequence, typename T, typename U, typename V, typename C, typename W>
219QFuture<C> mappedReduced(const Sequence &sequence,
220 T (map)(U),
221 V (C::*reduce)(W),
222 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
223{
224 return startMappedReduced<T, C> (sequence, FunctionWrapper1<T, U>(map),
225 MemberFunctionWrapper1<V, C, W>(reduce), options);
226}
227
228template <typename Sequence, typename T, typename C, typename U,typename D, typename V>
229QFuture<D> mappedReduced(const Sequence &sequence,
230 T (C::*map)() const,
231 U (D::*reduce)(V),
232 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
233{
234 return startMappedReduced<T, D>(sequence, ConstMemberFunctionWrapper<T, C>(map),
235 MemberFunctionWrapper1<U, D, V>(reduce), options);
236}
237
238// mappedReduced() for iterators
239template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
240QFuture<ResultType> mappedReduced(Iterator begin,
241 Iterator end,
242 MapFunctor map,
243 ReduceFunctor reduce,
244 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
245{
246 return startMappedReduced<ResultType, typename MapFunctor::result_type>
247 (begin, end, map, reduce, options);
248}
249
250template <typename Iterator, typename MapFunctor, typename T, typename U, typename V>
251QFuture<U> mappedReduced(Iterator begin,
252 Iterator end,
253 MapFunctor map,
254 T (reduce)(U &, V),
255 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
256{
257 return startMappedReduced<typename MapFunctor::result_type, U>
258 (begin, end, map, FunctionWrapper2<T, U &, V>(reduce), options);
259}
260
261template <typename Iterator, typename MapFunctor, typename T, typename C, typename U>
262QFuture<C> mappedReduced(Iterator begin,
263 Iterator end,
264 MapFunctor map,
265 T (C::*reduce)(U),
266 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
267{
268 return startMappedReduced<typename MapFunctor::result_type, C>
269 (begin, end, map, MemberFunctionWrapper1<T, C, U>(reduce), options);
270}
271
272template <typename ResultType, typename Iterator, typename T, typename U, typename ReduceFunctor>
273QFuture<ResultType> mappedReduced(Iterator begin,
274 Iterator end,
275 T (map)(U),
276 ReduceFunctor reduce,
277 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
278{
279 return startMappedReduced<T, ResultType>
280 (begin, end, FunctionWrapper1<T, U>(map), reduce, options);
281}
282
283template <typename ResultType, typename Iterator, typename T, typename C, typename ReduceFunctor>
284QFuture<ResultType> mappedReduced(Iterator begin,
285 Iterator end,
286 T (C::*map)() const,
287 ReduceFunctor reduce,
288 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
289{
290 return startMappedReduced<T, ResultType>
291 (begin, end, ConstMemberFunctionWrapper<T, C>(map), reduce, options);
292}
293
294template <typename Iterator, typename T, typename U, typename V, typename W, typename X>
295QFuture<W> mappedReduced(Iterator begin,
296 Iterator end,
297 T (map)(U),
298 V (reduce)(W &, X),
299 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
300{
301 return startMappedReduced<T, W>
302 (begin, end, FunctionWrapper1<T, U>(map), FunctionWrapper2<V, W &, X>(reduce), options);
303}
304
305template <typename Iterator, typename T, typename C, typename U, typename V, typename W>
306QFuture<V> mappedReduced(Iterator begin,
307 Iterator end,
308 T (C::*map)() const,
309 U (reduce)(V &, W),
310 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
311{
312 return startMappedReduced<T, V>(begin, end, ConstMemberFunctionWrapper<T, C>(map),
313 FunctionWrapper2<U, V &, W>(reduce), options);
314}
315
316template <typename Iterator, typename T, typename U, typename V, typename C, typename W>
317QFuture<C> mappedReduced(Iterator begin,
318 Iterator end,
319 T (map)(U),
320 V (C::*reduce)(W),
321 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
322{
323 return startMappedReduced<T, C>
324 (begin, end, FunctionWrapper1<T, U>(map), MemberFunctionWrapper1<V, C, W>(reduce), options);
325}
326
327template <typename Iterator, typename T, typename C, typename U,typename D, typename V>
328QFuture<D> mappedReduced(Iterator begin,
329 Iterator end,
330 T (C::*map)() const,
331 U (D::*reduce)(V),
332 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
333{
334 return startMappedReduced<T, D>(begin, end, ConstMemberFunctionWrapper<T, C>(map),
335 MemberFunctionWrapper1<U, D, V>(reduce), options);
336}
337
338// mapped() for sequences
339template <typename Sequence, typename MapFunctor>
340QFuture<typename MapFunctor::result_type> mapped(const Sequence &sequence, MapFunctor map)
341{
342 return startMapped<typename MapFunctor::result_type>(sequence, map);
343}
344
345template <typename Sequence, typename T, typename U>
346QFuture<T> mapped(const Sequence &sequence, T (map)(U))
347{
348 return startMapped<T>(sequence, FunctionWrapper1<T, U>(map));
349}
350
351template <typename Sequence, typename T, typename C>
352QFuture<T> mapped(const Sequence &sequence, T (C::*map)() const)
353{
354 return startMapped<T>(sequence, ConstMemberFunctionWrapper<T, C>(map));
355}
356
357// mapped() for iterator ranges.
358template <typename Iterator, typename MapFunctor>
359QFuture<typename MapFunctor::result_type> mapped(Iterator begin, Iterator end, MapFunctor map)
360{
361 return startMapped<Q_TYPENAME MapFunctor::result_type>(begin, end, map);
362}
363
364template <typename Iterator, typename T, typename U>
365QFuture<T> mapped(Iterator begin, Iterator end, T (map)(U))
366{
367 return startMapped<T>(begin, end, FunctionWrapper1<T, U>(map));
368}
369
370template <typename Iterator, typename T, typename C>
371QFuture<T> mapped(Iterator begin, Iterator end, T (C::*map)() const)
372{
373 return startMapped<T>(begin, end, ConstMemberFunctionWrapper<T, C>(map));
374}
375
376
377template <typename Sequence, typename MapFunctor>
378void blockingMap(Sequence &sequence, MapFunctor map)
379{
380 startMap(sequence.begin(), sequence.end(), map).startBlocking();
381}
382
383template <typename Sequence, typename T, typename U>
384void blockingMap(Sequence &sequence, T (map)(U))
385{
386 startMap(sequence.begin(), sequence.end(), QtConcurrent::FunctionWrapper1<T, U>(map)).startBlocking();
387}
388
389template <typename Sequence, typename T, typename C>
390void blockingMap(Sequence &sequence, T (C::*map)())
391{
392 startMap(sequence.begin(), sequence.end(), QtConcurrent::MemberFunctionWrapper<T, C>(map)).startBlocking();
393}
394
395template <typename Iterator, typename MapFunctor>
396void blockingMap(Iterator begin, Iterator end, MapFunctor map)
397{
398 startMap(begin, end, map).startBlocking();
399}
400
401template <typename Iterator, typename T, typename U>
402void blockingMap(Iterator begin, Iterator end, T (map)(U))
403{
404 startMap(begin, end, QtConcurrent::FunctionWrapper1<T, U>(map)).startBlocking();
405}
406
407template <typename Iterator, typename T, typename C>
408void blockingMap(Iterator begin, Iterator end, T (C::*map)())
409{
410 startMap(begin, end, QtConcurrent::MemberFunctionWrapper<T, C>(map)).startBlocking();
411}
412
413template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
414ResultType blockingMappedReduced(const Sequence &sequence,
415 MapFunctor map,
416 ReduceFunctor reduce,
417 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
418{
419 return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, ResultType>
420 (sequence, map, reduce, options).startBlocking();
421}
422
423template <typename Sequence, typename MapFunctor, typename T, typename U, typename V>
424U blockingMappedReduced(const Sequence &sequence,
425 MapFunctor map,
426 T (reduce)(U &, V),
427 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
428{
429 return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, U>
430 (sequence,
431 map,
432 QtConcurrent::FunctionWrapper2<T, U &, V>(reduce),
433 options)
434 .startBlocking();
435}
436
437template <typename Sequence, typename MapFunctor, typename T, typename C, typename U>
438C blockingMappedReduced(const Sequence &sequence,
439 MapFunctor map,
440 T (C::*reduce)(U),
441 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
442{
443 return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, C>
444 (sequence,
445 map,
446 QtConcurrent::MemberFunctionWrapper1<T, C, U>(reduce),
447 options)
448 .startBlocking();
449}
450
451template <typename ResultType, typename Sequence, typename T, typename U, typename ReduceFunctor>
452ResultType blockingMappedReduced(const Sequence &sequence,
453 T (map)(U),
454 ReduceFunctor reduce,
455 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
456{
457 return QtConcurrent::startMappedReduced<T, ResultType>
458 (sequence,
459 QtConcurrent::FunctionWrapper1<T, U>(map),
460 reduce,
461 options)
462 .startBlocking();
463}
464
465template <typename ResultType, typename Sequence, typename T, typename C, typename ReduceFunctor>
466ResultType blockingMappedReduced(const Sequence &sequence,
467 T (C::*map)() const,
468 ReduceFunctor reduce,
469 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
470{
471 return QtConcurrent::startMappedReduced<T, ResultType>
472 (sequence,
473 QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
474 reduce,
475 options)
476 .startBlocking();
477}
478
479template <typename Sequence, typename T, typename U, typename V, typename W, typename X>
480W blockingMappedReduced(const Sequence &sequence,
481 T (map)(U),
482 V (reduce)(W &, X),
483 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
484{
485 return QtConcurrent::startMappedReduced<T, W>
486 (sequence,
487 QtConcurrent::FunctionWrapper1<T, U>(map),
488 QtConcurrent::FunctionWrapper2<V, W &, X>(reduce),
489 options)
490 .startBlocking();
491}
492
493template <typename Sequence, typename T, typename C, typename U, typename V, typename W>
494V blockingMappedReduced(const Sequence &sequence,
495 T (C::*map)() const,
496 U (reduce)(V &, W),
497 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
498{
499 return QtConcurrent::startMappedReduced<T, V>
500 (sequence,
501 QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
502 QtConcurrent::FunctionWrapper2<U, V &, W>(reduce),
503 options)
504 .startBlocking();
505}
506
507template <typename Sequence, typename T, typename U, typename V, typename C, typename W>
508C blockingMappedReduced(const Sequence &sequence,
509 T (map)(U),
510 V (C::*reduce)(W),
511 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
512{
513 return QtConcurrent::startMappedReduced<T, C>
514 (sequence,
515 QtConcurrent::FunctionWrapper1<T, U>(map),
516 QtConcurrent::MemberFunctionWrapper1<V, C, W>(reduce),
517 options)
518 .startBlocking();
519}
520
521template <typename Sequence, typename T, typename C, typename U,typename D, typename V>
522D blockingMappedReduced(const Sequence &sequence,
523 T (C::*map)() const,
524 U (D::*reduce)(V),
525 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
526{
527 return QtConcurrent::startMappedReduced<T, D>
528 (sequence,
529 QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
530 QtConcurrent::MemberFunctionWrapper1<U, D, V>(reduce),
531 options)
532 .startBlocking();
533}
534
535template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
536ResultType blockingMappedReduced(Iterator begin,
537 Iterator end,
538 MapFunctor map,
539 ReduceFunctor reduce,
540 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
541{
542 return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, ResultType>
543 (begin, end, map, reduce, options).startBlocking();
544}
545
546template <typename Iterator, typename MapFunctor, typename T, typename U, typename V>
547U blockingMappedReduced(Iterator begin,
548 Iterator end,
549 MapFunctor map,
550 T (reduce)(U &, V),
551 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
552{
553 return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, U>
554 (begin,
555 end,
556 map,
557 QtConcurrent::FunctionWrapper2<T, U &, V>(reduce),
558 options)
559 .startBlocking();
560}
561
562template <typename Iterator, typename MapFunctor, typename T, typename C, typename U>
563C blockingMappedReduced(Iterator begin,
564 Iterator end,
565 MapFunctor map,
566 T (C::*reduce)(U),
567 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
568{
569 return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, C>
570 (begin,
571 end,
572 map,
573 QtConcurrent::MemberFunctionWrapper1<T, C, U>(reduce),
574 options)
575 .startBlocking();
576}
577
578template <typename ResultType, typename Iterator, typename T, typename U, typename ReduceFunctor>
579ResultType blockingMappedReduced(Iterator begin,
580 Iterator end,
581 T (map)(U),
582 ReduceFunctor reduce,
583 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
584{
585 return QtConcurrent::startMappedReduced<T, ResultType>
586 (begin,
587 end,
588 QtConcurrent::FunctionWrapper1<T, U>(map),
589 reduce,
590 options)
591 .startBlocking();
592}
593
594template <typename ResultType, typename Iterator, typename T, typename C, typename ReduceFunctor>
595ResultType blockingMappedReduced(Iterator begin,
596 Iterator end,
597 T (C::*map)() const,
598 ReduceFunctor reduce,
599 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
600{
601 return QtConcurrent::startMappedReduced<T, ResultType>
602 (begin,
603 end,
604 QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
605 reduce,
606 options)
607 .startBlocking();
608}
609
610template <typename Iterator, typename T, typename U, typename V, typename W, typename X>
611W blockingMappedReduced(Iterator begin,
612 Iterator end,
613 T (map)(U),
614 V (reduce)(W &, X),
615 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
616{
617 return QtConcurrent::startMappedReduced<T, W>
618 (begin,
619 end,
620 QtConcurrent::FunctionWrapper1<T, U>(map),
621 QtConcurrent::FunctionWrapper2<V, W &, X>(reduce),
622 options)
623 .startBlocking();
624}
625
626template <typename Iterator, typename T, typename C, typename U, typename V, typename W>
627V blockingMappedReduced(Iterator begin,
628 Iterator end,
629 T (C::*map)() const,
630 U (reduce)(V &, W),
631 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
632{
633 return QtConcurrent::startMappedReduced<T, V>
634 (begin,
635 end,
636 QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
637 QtConcurrent::FunctionWrapper2<U, V &, W>(reduce),
638 options)
639 .startBlocking();
640}
641
642template <typename Iterator, typename T, typename U, typename V, typename C, typename W>
643C blockingMappedReduced(Iterator begin,
644 Iterator end,
645 T (map)(U),
646 V (C::*reduce)(W),
647 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
648{
649 return QtConcurrent::startMappedReduced<T, C>
650 (begin,
651 end,
652 QtConcurrent::FunctionWrapper1<T, U>(map),
653 QtConcurrent::MemberFunctionWrapper1<V, C, W>(reduce),
654 options)
655 .startBlocking();
656}
657
658template <typename Iterator, typename T, typename C, typename U,typename D, typename V>
659D blockingMappedReduced(Iterator begin,
660 Iterator end,
661 T (C::*map)() const,
662 U (D::*reduce)(V),
663 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
664{
665 return QtConcurrent::startMappedReduced<T, D>
666 (begin,
667 end,
668 QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
669 QtConcurrent::MemberFunctionWrapper1<U, D, V>(reduce),
670 options)
671 .startBlocking();
672}
673
674// mapped() for sequences with a different putput sequence type.
675template <typename OutputSequence, typename InputSequence, typename MapFunctor>
676OutputSequence blockingMapped(const InputSequence &sequence, MapFunctor map)
677{
678 return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
679 QtConcurrent::OrderedReduce);
680}
681
682template <typename OutputSequence, typename InputSequence, typename T, typename U>
683OutputSequence blockingMapped(const InputSequence &sequence, T (map)(U))
684{
685 return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
686 QtConcurrent::OrderedReduce);
687}
688
689template <typename OutputSequence, typename InputSequence, typename T, typename C>
690OutputSequence blockingMapped(const InputSequence &sequence, T (C::*map)() const)
691{
692 return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
693 QtConcurrent::OrderedReduce);
694}
695#ifndef QT_NO_TEMPLATE_TEMPLATE_PARAMETERS
696
697// overloads for changing the container value type:
698template <template <typename> class Sequence, typename MapFunctor, typename T>
699Sequence<typename MapFunctor::result_type> blockingMapped(const Sequence<T> &sequence, MapFunctor map)
700{
701 typedef Sequence<typename MapFunctor::result_type> OutputSequence;
702 return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
703 QtConcurrent::OrderedReduce);
704}
705
706template <template <typename> class Sequence, typename T, typename U, typename V>
707Sequence<U> blockingMapped(const Sequence<T> &sequence, U (map)(V))
708{
709 typedef Sequence<U> OutputSequence;
710 return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
711 QtConcurrent::OrderedReduce);
712}
713
714template <template <typename> class Sequence, typename T, typename U, typename C>
715Sequence<U> blockingMapped(const Sequence<T> &sequence, U (C::*map)() const)
716{
717 typedef Sequence<U> OutputSequence;
718 return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
719 QtConcurrent::OrderedReduce);
720}
721
722#endif // QT_NO_TEMPLATE_TEMPLATE_PARAMETER
723
724// overloads for changing the container value type from a QStringList:
725template <typename MapFunctor>
726QList<typename MapFunctor::result_type> blockingMapped(const QStringList &sequence, MapFunctor map)
727{
728 typedef QList<typename MapFunctor::result_type> OutputSequence;
729 return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
730 QtConcurrent::OrderedReduce);
731}
732
733template <typename U, typename V>
734QList<U> blockingMapped(const QStringList &sequence, U (map)(V))
735{
736 typedef QList<U> OutputSequence;
737 return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
738 QtConcurrent::OrderedReduce);
739}
740
741template <typename U, typename C>
742QList<U> blockingMapped(const QStringList &sequence, U (C::*map)() const)
743{
744 typedef QList<U> OutputSequence;
745 return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
746 QtConcurrent::OrderedReduce);
747}
748
749// mapped() for iterator ranges
750template <typename Sequence, typename Iterator, typename MapFunctor>
751Sequence blockingMapped(Iterator begin, Iterator end, MapFunctor map)
752{
753 return blockingMappedReduced(begin, end, map, &Sequence::push_back,
754 QtConcurrent::OrderedReduce);
755}
756
757template <typename Sequence, typename Iterator, typename T, typename U>
758Sequence blockingMapped(Iterator begin, Iterator end, T (map)(U))
759{
760 return blockingMappedReduced(begin, end, map, &Sequence::push_back,
761 QtConcurrent::OrderedReduce);
762}
763
764template <typename Sequence, typename Iterator, typename T, typename C>
765Sequence blockingMapped(Iterator begin, Iterator end, T (C::*map)() const)
766{
767 return blockingMappedReduced(begin, end, map, &Sequence::push_back,
768 QtConcurrent::OrderedReduce);
769}
770
771} // namespace QtConcurrent
772
773#endif // qdoc
774
775QT_END_NAMESPACE
776QT_END_HEADER
777
778#endif // QT_NO_CONCURRENT
779
780#endif
Note: See TracBrowser for help on using the repository browser.