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// Generated code, do not edit! Use generator at tools/qtconcurrent/generaterun/
43#ifndef QTCONCURRENT_STOREDFUNCTIONCALL_H
44#define QTCONCURRENT_STOREDFUNCTIONCALL_H
45
46#include <QtCore/qglobal.h>
47
48#ifndef QT_NO_CONCURRENT
49#include <QtCore/qtconcurrentrunbase.h>
50
51QT_BEGIN_HEADER
52QT_BEGIN_NAMESPACE
53
54QT_MODULE(Core)
55
56#ifndef qdoc
57
58namespace QtConcurrent {
59template <typename T, typename FunctionPointer>
60struct StoredFunctorCall0: public RunFunctionTask<T>
61{
62 inline StoredFunctorCall0(FunctionPointer _function)
63 : function(_function) {}
64 void runFunctor() { this->result = function(); }
65 FunctionPointer function;
66
67};
68
69template <typename FunctionPointer>
70struct StoredFunctorCall0<void, FunctionPointer>: public RunFunctionTask<void>
71{
72 inline StoredFunctorCall0(FunctionPointer _function)
73 : function(_function) {}
74 void runFunctor() { function(); }
75 FunctionPointer function;
76
77};
78
79template <typename T, typename FunctionPointer>
80struct StoredFunctorPointerCall0: public RunFunctionTask<T>
81{
82 inline StoredFunctorPointerCall0(FunctionPointer * _function)
83 : function(_function) {}
84 void runFunctor() { this->result =(*function)(); }
85 FunctionPointer * function;
86
87};
88
89template <typename T, typename FunctionPointer>
90struct VoidStoredFunctorPointerCall0: public RunFunctionTask<T>
91{
92 inline VoidStoredFunctorPointerCall0(FunctionPointer * _function)
93 : function(_function) {}
94 void runFunctor() {(*function)(); }
95 FunctionPointer * function;
96
97};
98
99template <typename T, typename FunctionPointer>
100struct SelectStoredFunctorPointerCall0
101{
102 typedef typename SelectSpecialization<T>::template
103 Type<StoredFunctorPointerCall0 <T, FunctionPointer>,
104 VoidStoredFunctorPointerCall0<T, FunctionPointer> >::type type;
105};
106template <typename T, typename Class>
107class StoredMemberFunctionCall0 : public RunFunctionTask<T>
108{
109public:
110 StoredMemberFunctionCall0(T (Class::*_fn)() , const Class &_object)
111 : fn(_fn), object(_object){ }
112
113 void runFunctor()
114 {
115 this->result = (object.*fn)();
116 }
117private:
118 T (Class::*fn)();
119 Class object;
120
121};
122template <typename T, typename Class>
123class VoidStoredMemberFunctionCall0 : public RunFunctionTask<T>
124{
125public:
126 VoidStoredMemberFunctionCall0(T (Class::*_fn)() , const Class &_object)
127 : fn(_fn), object(_object){ }
128
129 void runFunctor()
130 {
131 (object.*fn)();
132 }
133private:
134 T (Class::*fn)();
135 Class object;
136
137};
138template <typename T, typename Class>
139struct SelectStoredMemberFunctionCall0
140{
141 typedef typename SelectSpecialization<T>::template
142 Type<StoredMemberFunctionCall0 <T, Class>,
143 VoidStoredMemberFunctionCall0<T, Class> >::type type;
144};
145template <typename T, typename Class>
146class StoredConstMemberFunctionCall0 : public RunFunctionTask<T>
147{
148public:
149 StoredConstMemberFunctionCall0(T (Class::*_fn)() const, const Class &_object)
150 : fn(_fn), object(_object){ }
151
152 void runFunctor()
153 {
154 this->result = (object.*fn)();
155 }
156private:
157 T (Class::*fn)()const;
158 const Class object;
159
160};
161template <typename T, typename Class>
162class VoidStoredConstMemberFunctionCall0 : public RunFunctionTask<T>
163{
164public:
165 VoidStoredConstMemberFunctionCall0(T (Class::*_fn)() const, const Class &_object)
166 : fn(_fn), object(_object){ }
167
168 void runFunctor()
169 {
170 (object.*fn)();
171 }
172private:
173 T (Class::*fn)()const;
174 const Class object;
175
176};
177template <typename T, typename Class>
178struct SelectStoredConstMemberFunctionCall0
179{
180 typedef typename SelectSpecialization<T>::template
181 Type<StoredConstMemberFunctionCall0 <T, Class>,
182 VoidStoredConstMemberFunctionCall0<T, Class> >::type type;
183};
184template <typename T, typename Class>
185class StoredMemberFunctionPointerCall0 : public RunFunctionTask<T>
186{
187public:
188 StoredMemberFunctionPointerCall0(T (Class::*_fn)() , Class *_object)
189 : fn(_fn), object(_object){ }
190
191 void runFunctor()
192 {
193 this->result = (object->*fn)();
194 }
195private:
196 T (Class::*fn)();
197 Class *object;
198
199};
200template <typename T, typename Class>
201class VoidStoredMemberFunctionPointerCall0 : public RunFunctionTask<T>
202{
203public:
204 VoidStoredMemberFunctionPointerCall0(T (Class::*_fn)() , Class *_object)
205 : fn(_fn), object(_object){ }
206
207 void runFunctor()
208 {
209 (object->*fn)();
210 }
211private:
212 T (Class::*fn)();
213 Class *object;
214
215};
216template <typename T, typename Class>
217struct SelectStoredMemberFunctionPointerCall0
218{
219 typedef typename SelectSpecialization<T>::template
220 Type<StoredMemberFunctionPointerCall0 <T, Class>,
221 VoidStoredMemberFunctionPointerCall0<T, Class> >::type type;
222};
223template <typename T, typename Class>
224class StoredConstMemberFunctionPointerCall0 : public RunFunctionTask<T>
225{
226public:
227 StoredConstMemberFunctionPointerCall0(T (Class::*_fn)() const, Class const *_object)
228 : fn(_fn), object(_object){ }
229
230 void runFunctor()
231 {
232 this->result = (object->*fn)();
233 }
234private:
235 T (Class::*fn)()const;
236 Class const *object;
237
238};
239template <typename T, typename Class>
240class VoidStoredConstMemberFunctionPointerCall0 : public RunFunctionTask<T>
241{
242public:
243 VoidStoredConstMemberFunctionPointerCall0(T (Class::*_fn)() const, Class const *_object)
244 : fn(_fn), object(_object){ }
245
246 void runFunctor()
247 {
248 (object->*fn)();
249 }
250private:
251 T (Class::*fn)()const;
252 Class const *object;
253
254};
255template <typename T, typename Class>
256struct SelectStoredConstMemberFunctionPointerCall0
257{
258 typedef typename SelectSpecialization<T>::template
259 Type<StoredConstMemberFunctionPointerCall0 <T, Class>,
260 VoidStoredConstMemberFunctionPointerCall0<T, Class> >::type type;
261};
262template <typename T, typename FunctionPointer, typename Arg1>
263struct StoredFunctorCall1: public RunFunctionTask<T>
264{
265 inline StoredFunctorCall1(FunctionPointer _function, const Arg1 &_arg1)
266 : function(_function), arg1(_arg1) {}
267 void runFunctor() { this->result = function(arg1); }
268 FunctionPointer function;
269 Arg1 arg1;
270};
271
272template <typename FunctionPointer, typename Arg1>
273struct StoredFunctorCall1<void, FunctionPointer, Arg1>: public RunFunctionTask<void>
274{
275 inline StoredFunctorCall1(FunctionPointer _function, const Arg1 &_arg1)
276 : function(_function), arg1(_arg1) {}
277 void runFunctor() { function(arg1); }
278 FunctionPointer function;
279 Arg1 arg1;
280};
281
282template <typename T, typename FunctionPointer, typename Arg1>
283struct StoredFunctorPointerCall1: public RunFunctionTask<T>
284{
285 inline StoredFunctorPointerCall1(FunctionPointer * _function, const Arg1 &_arg1)
286 : function(_function), arg1(_arg1) {}
287 void runFunctor() { this->result =(*function)(arg1); }
288 FunctionPointer * function;
289 Arg1 arg1;
290};
291
292template <typename T, typename FunctionPointer, typename Arg1>
293struct VoidStoredFunctorPointerCall1: public RunFunctionTask<T>
294{
295 inline VoidStoredFunctorPointerCall1(FunctionPointer * _function, const Arg1 &_arg1)
296 : function(_function), arg1(_arg1) {}
297 void runFunctor() {(*function)(arg1); }
298 FunctionPointer * function;
299 Arg1 arg1;
300};
301
302template <typename T, typename FunctionPointer, typename Arg1>
303struct SelectStoredFunctorPointerCall1
304{
305 typedef typename SelectSpecialization<T>::template
306 Type<StoredFunctorPointerCall1 <T, FunctionPointer, Arg1>,
307 VoidStoredFunctorPointerCall1<T, FunctionPointer, Arg1> >::type type;
308};
309template <typename T, typename Class, typename Param1, typename Arg1>
310class StoredMemberFunctionCall1 : public RunFunctionTask<T>
311{
312public:
313 StoredMemberFunctionCall1(T (Class::*_fn)(Param1) , const Class &_object, const Arg1 &_arg1)
314 : fn(_fn), object(_object), arg1(_arg1){ }
315
316 void runFunctor()
317 {
318 this->result = (object.*fn)(arg1);
319 }
320private:
321 T (Class::*fn)(Param1);
322 Class object;
323 Arg1 arg1;
324};
325template <typename T, typename Class, typename Param1, typename Arg1>
326class VoidStoredMemberFunctionCall1 : public RunFunctionTask<T>
327{
328public:
329 VoidStoredMemberFunctionCall1(T (Class::*_fn)(Param1) , const Class &_object, const Arg1 &_arg1)
330 : fn(_fn), object(_object), arg1(_arg1){ }
331
332 void runFunctor()
333 {
334 (object.*fn)(arg1);
335 }
336private:
337 T (Class::*fn)(Param1);
338 Class object;
339 Arg1 arg1;
340};
341template <typename T, typename Class, typename Param1, typename Arg1>
342struct SelectStoredMemberFunctionCall1
343{
344 typedef typename SelectSpecialization<T>::template
345 Type<StoredMemberFunctionCall1 <T, Class, Param1, Arg1>,
346 VoidStoredMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
347};
348template <typename T, typename Class, typename Param1, typename Arg1>
349class StoredConstMemberFunctionCall1 : public RunFunctionTask<T>
350{
351public:
352 StoredConstMemberFunctionCall1(T (Class::*_fn)(Param1) const, const Class &_object, const Arg1 &_arg1)
353 : fn(_fn), object(_object), arg1(_arg1){ }
354
355 void runFunctor()
356 {
357 this->result = (object.*fn)(arg1);
358 }
359private:
360 T (Class::*fn)(Param1)const;
361 const Class object;
362 Arg1 arg1;
363};
364template <typename T, typename Class, typename Param1, typename Arg1>
365class VoidStoredConstMemberFunctionCall1 : public RunFunctionTask<T>
366{
367public:
368 VoidStoredConstMemberFunctionCall1(T (Class::*_fn)(Param1) const, const Class &_object, const Arg1 &_arg1)
369 : fn(_fn), object(_object), arg1(_arg1){ }
370
371 void runFunctor()
372 {
373 (object.*fn)(arg1);
374 }
375private:
376 T (Class::*fn)(Param1)const;
377 const Class object;
378 Arg1 arg1;
379};
380template <typename T, typename Class, typename Param1, typename Arg1>
381struct SelectStoredConstMemberFunctionCall1
382{
383 typedef typename SelectSpecialization<T>::template
384 Type<StoredConstMemberFunctionCall1 <T, Class, Param1, Arg1>,
385 VoidStoredConstMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
386};
387template <typename T, typename Class, typename Param1, typename Arg1>
388class StoredMemberFunctionPointerCall1 : public RunFunctionTask<T>
389{
390public:
391 StoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1) , Class *_object, const Arg1 &_arg1)
392 : fn(_fn), object(_object), arg1(_arg1){ }
393
394 void runFunctor()
395 {
396 this->result = (object->*fn)(arg1);
397 }
398private:
399 T (Class::*fn)(Param1);
400 Class *object;
401 Arg1 arg1;
402};
403template <typename T, typename Class, typename Param1, typename Arg1>
404class VoidStoredMemberFunctionPointerCall1 : public RunFunctionTask<T>
405{
406public:
407 VoidStoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1) , Class *_object, const Arg1 &_arg1)
408 : fn(_fn), object(_object), arg1(_arg1){ }
409
410 void runFunctor()
411 {
412 (object->*fn)(arg1);
413 }
414private:
415 T (Class::*fn)(Param1);
416 Class *object;
417 Arg1 arg1;
418};
419template <typename T, typename Class, typename Param1, typename Arg1>
420struct SelectStoredMemberFunctionPointerCall1
421{
422 typedef typename SelectSpecialization<T>::template
423 Type<StoredMemberFunctionPointerCall1 <T, Class, Param1, Arg1>,
424 VoidStoredMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
425};
426template <typename T, typename Class, typename Param1, typename Arg1>
427class StoredConstMemberFunctionPointerCall1 : public RunFunctionTask<T>
428{
429public:
430 StoredConstMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const, Class const *_object, const Arg1 &_arg1)
431 : fn(_fn), object(_object), arg1(_arg1){ }
432
433 void runFunctor()
434 {
435 this->result = (object->*fn)(arg1);
436 }
437private:
438 T (Class::*fn)(Param1)const;
439 Class const *object;
440 Arg1 arg1;
441};
442template <typename T, typename Class, typename Param1, typename Arg1>
443class VoidStoredConstMemberFunctionPointerCall1 : public RunFunctionTask<T>
444{
445public:
446 VoidStoredConstMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const, Class const *_object, const Arg1 &_arg1)
447 : fn(_fn), object(_object), arg1(_arg1){ }
448
449 void runFunctor()
450 {
451 (object->*fn)(arg1);
452 }
453private:
454 T (Class::*fn)(Param1)const;
455 Class const *object;
456 Arg1 arg1;
457};
458template <typename T, typename Class, typename Param1, typename Arg1>
459struct SelectStoredConstMemberFunctionPointerCall1
460{
461 typedef typename SelectSpecialization<T>::template
462 Type<StoredConstMemberFunctionPointerCall1 <T, Class, Param1, Arg1>,
463 VoidStoredConstMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
464};
465template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
466struct StoredFunctorCall2: public RunFunctionTask<T>
467{
468 inline StoredFunctorCall2(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2)
469 : function(_function), arg1(_arg1), arg2(_arg2) {}
470 void runFunctor() { this->result = function(arg1, arg2); }
471 FunctionPointer function;
472 Arg1 arg1; Arg2 arg2;
473};
474
475template <typename FunctionPointer, typename Arg1, typename Arg2>
476struct StoredFunctorCall2<void, FunctionPointer, Arg1, Arg2>: public RunFunctionTask<void>
477{
478 inline StoredFunctorCall2(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2)
479 : function(_function), arg1(_arg1), arg2(_arg2) {}
480 void runFunctor() { function(arg1, arg2); }
481 FunctionPointer function;
482 Arg1 arg1; Arg2 arg2;
483};
484
485template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
486struct StoredFunctorPointerCall2: public RunFunctionTask<T>
487{
488 inline StoredFunctorPointerCall2(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2)
489 : function(_function), arg1(_arg1), arg2(_arg2) {}
490 void runFunctor() { this->result =(*function)(arg1, arg2); }
491 FunctionPointer * function;
492 Arg1 arg1; Arg2 arg2;
493};
494
495template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
496struct VoidStoredFunctorPointerCall2: public RunFunctionTask<T>
497{
498 inline VoidStoredFunctorPointerCall2(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2)
499 : function(_function), arg1(_arg1), arg2(_arg2) {}
500 void runFunctor() {(*function)(arg1, arg2); }
501 FunctionPointer * function;
502 Arg1 arg1; Arg2 arg2;
503};
504
505template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
506struct SelectStoredFunctorPointerCall2
507{
508 typedef typename SelectSpecialization<T>::template
509 Type<StoredFunctorPointerCall2 <T, FunctionPointer, Arg1, Arg2>,
510 VoidStoredFunctorPointerCall2<T, FunctionPointer, Arg1, Arg2> >::type type;
511};
512template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
513class StoredMemberFunctionCall2 : public RunFunctionTask<T>
514{
515public:
516 StoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
517 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
518
519 void runFunctor()
520 {
521 this->result = (object.*fn)(arg1, arg2);
522 }
523private:
524 T (Class::*fn)(Param1, Param2);
525 Class object;
526 Arg1 arg1; Arg2 arg2;
527};
528template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
529class VoidStoredMemberFunctionCall2 : public RunFunctionTask<T>
530{
531public:
532 VoidStoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
533 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
534
535 void runFunctor()
536 {
537 (object.*fn)(arg1, arg2);
538 }
539private:
540 T (Class::*fn)(Param1, Param2);
541 Class object;
542 Arg1 arg1; Arg2 arg2;
543};
544template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
545struct SelectStoredMemberFunctionCall2
546{
547 typedef typename SelectSpecialization<T>::template
548 Type<StoredMemberFunctionCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
549 VoidStoredMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
550};
551template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
552class StoredConstMemberFunctionCall2 : public RunFunctionTask<T>
553{
554public:
555 StoredConstMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
556 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
557
558 void runFunctor()
559 {
560 this->result = (object.*fn)(arg1, arg2);
561 }
562private:
563 T (Class::*fn)(Param1, Param2)const;
564 const Class object;
565 Arg1 arg1; Arg2 arg2;
566};
567template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
568class VoidStoredConstMemberFunctionCall2 : public RunFunctionTask<T>
569{
570public:
571 VoidStoredConstMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
572 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
573
574 void runFunctor()
575 {
576 (object.*fn)(arg1, arg2);
577 }
578private:
579 T (Class::*fn)(Param1, Param2)const;
580 const Class object;
581 Arg1 arg1; Arg2 arg2;
582};
583template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
584struct SelectStoredConstMemberFunctionCall2
585{
586 typedef typename SelectSpecialization<T>::template
587 Type<StoredConstMemberFunctionCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
588 VoidStoredConstMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
589};
590template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
591class StoredMemberFunctionPointerCall2 : public RunFunctionTask<T>
592{
593public:
594 StoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
595 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
596
597 void runFunctor()
598 {
599 this->result = (object->*fn)(arg1, arg2);
600 }
601private:
602 T (Class::*fn)(Param1, Param2);
603 Class *object;
604 Arg1 arg1; Arg2 arg2;
605};
606template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
607class VoidStoredMemberFunctionPointerCall2 : public RunFunctionTask<T>
608{
609public:
610 VoidStoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
611 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
612
613 void runFunctor()
614 {
615 (object->*fn)(arg1, arg2);
616 }
617private:
618 T (Class::*fn)(Param1, Param2);
619 Class *object;
620 Arg1 arg1; Arg2 arg2;
621};
622template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
623struct SelectStoredMemberFunctionPointerCall2
624{
625 typedef typename SelectSpecialization<T>::template
626 Type<StoredMemberFunctionPointerCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
627 VoidStoredMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
628};
629template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
630class StoredConstMemberFunctionPointerCall2 : public RunFunctionTask<T>
631{
632public:
633 StoredConstMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2)
634 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
635
636 void runFunctor()
637 {
638 this->result = (object->*fn)(arg1, arg2);
639 }
640private:
641 T (Class::*fn)(Param1, Param2)const;
642 Class const *object;
643 Arg1 arg1; Arg2 arg2;
644};
645template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
646class VoidStoredConstMemberFunctionPointerCall2 : public RunFunctionTask<T>
647{
648public:
649 VoidStoredConstMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2)
650 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
651
652 void runFunctor()
653 {
654 (object->*fn)(arg1, arg2);
655 }
656private:
657 T (Class::*fn)(Param1, Param2)const;
658 Class const *object;
659 Arg1 arg1; Arg2 arg2;
660};
661template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
662struct SelectStoredConstMemberFunctionPointerCall2
663{
664 typedef typename SelectSpecialization<T>::template
665 Type<StoredConstMemberFunctionPointerCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
666 VoidStoredConstMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
667};
668template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
669struct StoredFunctorCall3: public RunFunctionTask<T>
670{
671 inline StoredFunctorCall3(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
672 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
673 void runFunctor() { this->result = function(arg1, arg2, arg3); }
674 FunctionPointer function;
675 Arg1 arg1; Arg2 arg2; Arg3 arg3;
676};
677
678template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
679struct StoredFunctorCall3<void, FunctionPointer, Arg1, Arg2, Arg3>: public RunFunctionTask<void>
680{
681 inline StoredFunctorCall3(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
682 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
683 void runFunctor() { function(arg1, arg2, arg3); }
684 FunctionPointer function;
685 Arg1 arg1; Arg2 arg2; Arg3 arg3;
686};
687
688template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
689struct StoredFunctorPointerCall3: public RunFunctionTask<T>
690{
691 inline StoredFunctorPointerCall3(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
692 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
693 void runFunctor() { this->result =(*function)(arg1, arg2, arg3); }
694 FunctionPointer * function;
695 Arg1 arg1; Arg2 arg2; Arg3 arg3;
696};
697
698template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
699struct VoidStoredFunctorPointerCall3: public RunFunctionTask<T>
700{
701 inline VoidStoredFunctorPointerCall3(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
702 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
703 void runFunctor() {(*function)(arg1, arg2, arg3); }
704 FunctionPointer * function;
705 Arg1 arg1; Arg2 arg2; Arg3 arg3;
706};
707
708template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
709struct SelectStoredFunctorPointerCall3
710{
711 typedef typename SelectSpecialization<T>::template
712 Type<StoredFunctorPointerCall3 <T, FunctionPointer, Arg1, Arg2, Arg3>,
713 VoidStoredFunctorPointerCall3<T, FunctionPointer, Arg1, Arg2, Arg3> >::type type;
714};
715template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
716class StoredMemberFunctionCall3 : public RunFunctionTask<T>
717{
718public:
719 StoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
720 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
721
722 void runFunctor()
723 {
724 this->result = (object.*fn)(arg1, arg2, arg3);
725 }
726private:
727 T (Class::*fn)(Param1, Param2, Param3);
728 Class object;
729 Arg1 arg1; Arg2 arg2; Arg3 arg3;
730};
731template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
732class VoidStoredMemberFunctionCall3 : public RunFunctionTask<T>
733{
734public:
735 VoidStoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
736 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
737
738 void runFunctor()
739 {
740 (object.*fn)(arg1, arg2, arg3);
741 }
742private:
743 T (Class::*fn)(Param1, Param2, Param3);
744 Class object;
745 Arg1 arg1; Arg2 arg2; Arg3 arg3;
746};
747template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
748struct SelectStoredMemberFunctionCall3
749{
750 typedef typename SelectSpecialization<T>::template
751 Type<StoredMemberFunctionCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
752 VoidStoredMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
753};
754template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
755class StoredConstMemberFunctionCall3 : public RunFunctionTask<T>
756{
757public:
758 StoredConstMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
759 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
760
761 void runFunctor()
762 {
763 this->result = (object.*fn)(arg1, arg2, arg3);
764 }
765private:
766 T (Class::*fn)(Param1, Param2, Param3)const;
767 const Class object;
768 Arg1 arg1; Arg2 arg2; Arg3 arg3;
769};
770template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
771class VoidStoredConstMemberFunctionCall3 : public RunFunctionTask<T>
772{
773public:
774 VoidStoredConstMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
775 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
776
777 void runFunctor()
778 {
779 (object.*fn)(arg1, arg2, arg3);
780 }
781private:
782 T (Class::*fn)(Param1, Param2, Param3)const;
783 const Class object;
784 Arg1 arg1; Arg2 arg2; Arg3 arg3;
785};
786template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
787struct SelectStoredConstMemberFunctionCall3
788{
789 typedef typename SelectSpecialization<T>::template
790 Type<StoredConstMemberFunctionCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
791 VoidStoredConstMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
792};
793template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
794class StoredMemberFunctionPointerCall3 : public RunFunctionTask<T>
795{
796public:
797 StoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
798 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
799
800 void runFunctor()
801 {
802 this->result = (object->*fn)(arg1, arg2, arg3);
803 }
804private:
805 T (Class::*fn)(Param1, Param2, Param3);
806 Class *object;
807 Arg1 arg1; Arg2 arg2; Arg3 arg3;
808};
809template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
810class VoidStoredMemberFunctionPointerCall3 : public RunFunctionTask<T>
811{
812public:
813 VoidStoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
814 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
815
816 void runFunctor()
817 {
818 (object->*fn)(arg1, arg2, arg3);
819 }
820private:
821 T (Class::*fn)(Param1, Param2, Param3);
822 Class *object;
823 Arg1 arg1; Arg2 arg2; Arg3 arg3;
824};
825template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
826struct SelectStoredMemberFunctionPointerCall3
827{
828 typedef typename SelectSpecialization<T>::template
829 Type<StoredMemberFunctionPointerCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
830 VoidStoredMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
831};
832template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
833class StoredConstMemberFunctionPointerCall3 : public RunFunctionTask<T>
834{
835public:
836 StoredConstMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
837 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
838
839 void runFunctor()
840 {
841 this->result = (object->*fn)(arg1, arg2, arg3);
842 }
843private:
844 T (Class::*fn)(Param1, Param2, Param3)const;
845 Class const *object;
846 Arg1 arg1; Arg2 arg2; Arg3 arg3;
847};
848template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
849class VoidStoredConstMemberFunctionPointerCall3 : public RunFunctionTask<T>
850{
851public:
852 VoidStoredConstMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
853 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
854
855 void runFunctor()
856 {
857 (object->*fn)(arg1, arg2, arg3);
858 }
859private:
860 T (Class::*fn)(Param1, Param2, Param3)const;
861 Class const *object;
862 Arg1 arg1; Arg2 arg2; Arg3 arg3;
863};
864template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
865struct SelectStoredConstMemberFunctionPointerCall3
866{
867 typedef typename SelectSpecialization<T>::template
868 Type<StoredConstMemberFunctionPointerCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
869 VoidStoredConstMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
870};
871template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
872struct StoredFunctorCall4: public RunFunctionTask<T>
873{
874 inline StoredFunctorCall4(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
875 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
876 void runFunctor() { this->result = function(arg1, arg2, arg3, arg4); }
877 FunctionPointer function;
878 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
879};
880
881template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
882struct StoredFunctorCall4<void, FunctionPointer, Arg1, Arg2, Arg3, Arg4>: public RunFunctionTask<void>
883{
884 inline StoredFunctorCall4(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
885 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
886 void runFunctor() { function(arg1, arg2, arg3, arg4); }
887 FunctionPointer function;
888 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
889};
890
891template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
892struct StoredFunctorPointerCall4: public RunFunctionTask<T>
893{
894 inline StoredFunctorPointerCall4(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
895 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
896 void runFunctor() { this->result =(*function)(arg1, arg2, arg3, arg4); }
897 FunctionPointer * function;
898 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
899};
900
901template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
902struct VoidStoredFunctorPointerCall4: public RunFunctionTask<T>
903{
904 inline VoidStoredFunctorPointerCall4(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
905 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
906 void runFunctor() {(*function)(arg1, arg2, arg3, arg4); }
907 FunctionPointer * function;
908 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
909};
910
911template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
912struct SelectStoredFunctorPointerCall4
913{
914 typedef typename SelectSpecialization<T>::template
915 Type<StoredFunctorPointerCall4 <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4>,
916 VoidStoredFunctorPointerCall4<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4> >::type type;
917};
918template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
919class StoredMemberFunctionCall4 : public RunFunctionTask<T>
920{
921public:
922 StoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
923 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
924
925 void runFunctor()
926 {
927 this->result = (object.*fn)(arg1, arg2, arg3, arg4);
928 }
929private:
930 T (Class::*fn)(Param1, Param2, Param3, Param4);
931 Class object;
932 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
933};
934template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
935class VoidStoredMemberFunctionCall4 : public RunFunctionTask<T>
936{
937public:
938 VoidStoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
939 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
940
941 void runFunctor()
942 {
943 (object.*fn)(arg1, arg2, arg3, arg4);
944 }
945private:
946 T (Class::*fn)(Param1, Param2, Param3, Param4);
947 Class object;
948 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
949};
950template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
951struct SelectStoredMemberFunctionCall4
952{
953 typedef typename SelectSpecialization<T>::template
954 Type<StoredMemberFunctionCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
955 VoidStoredMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
956};
957template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
958class StoredConstMemberFunctionCall4 : public RunFunctionTask<T>
959{
960public:
961 StoredConstMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
962 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
963
964 void runFunctor()
965 {
966 this->result = (object.*fn)(arg1, arg2, arg3, arg4);
967 }
968private:
969 T (Class::*fn)(Param1, Param2, Param3, Param4)const;
970 const Class object;
971 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
972};
973template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
974class VoidStoredConstMemberFunctionCall4 : public RunFunctionTask<T>
975{
976public:
977 VoidStoredConstMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
978 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
979
980 void runFunctor()
981 {
982 (object.*fn)(arg1, arg2, arg3, arg4);
983 }
984private:
985 T (Class::*fn)(Param1, Param2, Param3, Param4)const;
986 const Class object;
987 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
988};
989template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
990struct SelectStoredConstMemberFunctionCall4
991{
992 typedef typename SelectSpecialization<T>::template
993 Type<StoredConstMemberFunctionCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
994 VoidStoredConstMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
995};
996template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
997class StoredMemberFunctionPointerCall4 : public RunFunctionTask<T>
998{
999public:
1000 StoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1001 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1002
1003 void runFunctor()
1004 {
1005 this->result = (object->*fn)(arg1, arg2, arg3, arg4);
1006 }
1007private:
1008 T (Class::*fn)(Param1, Param2, Param3, Param4);
1009 Class *object;
1010 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1011};
1012template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1013class VoidStoredMemberFunctionPointerCall4 : public RunFunctionTask<T>
1014{
1015public:
1016 VoidStoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1017 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1018
1019 void runFunctor()
1020 {
1021 (object->*fn)(arg1, arg2, arg3, arg4);
1022 }
1023private:
1024 T (Class::*fn)(Param1, Param2, Param3, Param4);
1025 Class *object;
1026 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1027};
1028template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1029struct SelectStoredMemberFunctionPointerCall4
1030{
1031 typedef typename SelectSpecialization<T>::template
1032 Type<StoredMemberFunctionPointerCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
1033 VoidStoredMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
1034};
1035template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1036class StoredConstMemberFunctionPointerCall4 : public RunFunctionTask<T>
1037{
1038public:
1039 StoredConstMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1040 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1041
1042 void runFunctor()
1043 {
1044 this->result = (object->*fn)(arg1, arg2, arg3, arg4);
1045 }
1046private:
1047 T (Class::*fn)(Param1, Param2, Param3, Param4)const;
1048 Class const *object;
1049 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1050};
1051template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1052class VoidStoredConstMemberFunctionPointerCall4 : public RunFunctionTask<T>
1053{
1054public:
1055 VoidStoredConstMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1056 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1057
1058 void runFunctor()
1059 {
1060 (object->*fn)(arg1, arg2, arg3, arg4);
1061 }
1062private:
1063 T (Class::*fn)(Param1, Param2, Param3, Param4)const;
1064 Class const *object;
1065 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1066};
1067template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1068struct SelectStoredConstMemberFunctionPointerCall4
1069{
1070 typedef typename SelectSpecialization<T>::template
1071 Type<StoredConstMemberFunctionPointerCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
1072 VoidStoredConstMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
1073};
1074template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1075struct StoredFunctorCall5: public RunFunctionTask<T>
1076{
1077 inline StoredFunctorCall5(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1078 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
1079 void runFunctor() { this->result = function(arg1, arg2, arg3, arg4, arg5); }
1080 FunctionPointer function;
1081 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1082};
1083
1084template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1085struct StoredFunctorCall5<void, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5>: public RunFunctionTask<void>
1086{
1087 inline StoredFunctorCall5(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1088 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
1089 void runFunctor() { function(arg1, arg2, arg3, arg4, arg5); }
1090 FunctionPointer function;
1091 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1092};
1093
1094template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1095struct StoredFunctorPointerCall5: public RunFunctionTask<T>
1096{
1097 inline StoredFunctorPointerCall5(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1098 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
1099 void runFunctor() { this->result =(*function)(arg1, arg2, arg3, arg4, arg5); }
1100 FunctionPointer * function;
1101 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1102};
1103
1104template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1105struct VoidStoredFunctorPointerCall5: public RunFunctionTask<T>
1106{
1107 inline VoidStoredFunctorPointerCall5(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1108 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
1109 void runFunctor() {(*function)(arg1, arg2, arg3, arg4, arg5); }
1110 FunctionPointer * function;
1111 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1112};
1113
1114template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1115struct SelectStoredFunctorPointerCall5
1116{
1117 typedef typename SelectSpecialization<T>::template
1118 Type<StoredFunctorPointerCall5 <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5>,
1119 VoidStoredFunctorPointerCall5<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5> >::type type;
1120};
1121template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1122class StoredMemberFunctionCall5 : public RunFunctionTask<T>
1123{
1124public:
1125 StoredMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1126 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
1127
1128 void runFunctor()
1129 {
1130 this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
1131 }
1132private:
1133 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
1134 Class object;
1135 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1136};
1137template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1138class VoidStoredMemberFunctionCall5 : public RunFunctionTask<T>
1139{
1140public:
1141 VoidStoredMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1142 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
1143
1144 void runFunctor()
1145 {
1146 (object.*fn)(arg1, arg2, arg3, arg4, arg5);
1147 }
1148private:
1149 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
1150 Class object;
1151 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1152};
1153template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1154struct SelectStoredMemberFunctionCall5
1155{
1156 typedef typename SelectSpecialization<T>::template
1157 Type<StoredMemberFunctionCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
1158 VoidStoredMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
1159};
1160template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1161class StoredConstMemberFunctionCall5 : public RunFunctionTask<T>
1162{
1163public:
1164 StoredConstMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1165 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
1166
1167 void runFunctor()
1168 {
1169 this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
1170 }
1171private:
1172 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
1173 const Class object;
1174 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1175};
1176template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1177class VoidStoredConstMemberFunctionCall5 : public RunFunctionTask<T>
1178{
1179public:
1180 VoidStoredConstMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1181 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
1182
1183 void runFunctor()
1184 {
1185 (object.*fn)(arg1, arg2, arg3, arg4, arg5);
1186 }
1187private:
1188 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
1189 const Class object;
1190 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1191};
1192template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1193struct SelectStoredConstMemberFunctionCall5
1194{
1195 typedef typename SelectSpecialization<T>::template
1196 Type<StoredConstMemberFunctionCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
1197 VoidStoredConstMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
1198};
1199template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1200class StoredMemberFunctionPointerCall5 : public RunFunctionTask<T>
1201{
1202public:
1203 StoredMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1204 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
1205
1206 void runFunctor()
1207 {
1208 this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
1209 }
1210private:
1211 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
1212 Class *object;
1213 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1214};
1215template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1216class VoidStoredMemberFunctionPointerCall5 : public RunFunctionTask<T>
1217{
1218public:
1219 VoidStoredMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1220 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
1221
1222 void runFunctor()
1223 {
1224 (object->*fn)(arg1, arg2, arg3, arg4, arg5);
1225 }
1226private:
1227 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
1228 Class *object;
1229 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1230};
1231template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1232struct SelectStoredMemberFunctionPointerCall5
1233{
1234 typedef typename SelectSpecialization<T>::template
1235 Type<StoredMemberFunctionPointerCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
1236 VoidStoredMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
1237};
1238template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1239class StoredConstMemberFunctionPointerCall5 : public RunFunctionTask<T>
1240{
1241public:
1242 StoredConstMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1243 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
1244
1245 void runFunctor()
1246 {
1247 this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
1248 }
1249private:
1250 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
1251 Class const *object;
1252 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1253};
1254template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1255class VoidStoredConstMemberFunctionPointerCall5 : public RunFunctionTask<T>
1256{
1257public:
1258 VoidStoredConstMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1259 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
1260
1261 void runFunctor()
1262 {
1263 (object->*fn)(arg1, arg2, arg3, arg4, arg5);
1264 }
1265private:
1266 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
1267 Class const *object;
1268 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1269};
1270template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1271struct SelectStoredConstMemberFunctionPointerCall5
1272{
1273 typedef typename SelectSpecialization<T>::template
1274 Type<StoredConstMemberFunctionPointerCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
1275 VoidStoredConstMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
1276};
1277
1278template <typename T, typename Functor>
1279class StoredFunctorCall : public RunFunctionTask<T>
1280{
1281public:
1282 StoredFunctorCall(const Functor &f) : functor(f) { }
1283 void runFunctor()
1284 {
1285 this->result = functor();
1286 }
1287private:
1288 Functor functor;
1289};
1290template <typename Functor>
1291class StoredFunctorCall<void, Functor> : public RunFunctionTask<void>
1292{
1293public:
1294 StoredFunctorCall(const Functor &f) : functor(f) { }
1295 void runFunctor()
1296 {
1297 functor();
1298 }
1299private:
1300 Functor functor;
1301};
1302
1303
1304} //namespace QtConcurrent
1305
1306#endif // qdoc
1307
1308QT_END_NAMESPACE
1309QT_END_HEADER
1310
1311#endif // QT_NO_CONCURRENT
1312
1313#endif
1314