1/****************************************************************************
2**
3** Copyright (C) 2016 The Qt Company Ltd.
4** Contact: https://www.qt.io/licensing/
5**
6** This file is part of the QtConcurrent 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 The Qt Company. For licensing terms
14** and conditions see https://www.qt.io/terms-conditions. For further
15** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
20** Foundation and appearing in the file LICENSE.LGPL3 included in the
21** packaging of this file. Please review the following information to
22** ensure the GNU Lesser General Public License version 3 requirements
23** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
24**
25** GNU General Public License Usage
26** Alternatively, this file may be used under the terms of the GNU
27** General Public License version 2.0 or (at your option) the GNU General
28** Public license version 3 or any later version approved by the KDE Free
29** Qt Foundation. The licenses are as published by the Free Software
30** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
31** included in the packaging of this file. Please review the following
32** information to ensure the GNU General Public License requirements will
33** be met: https://www.gnu.org/licenses/gpl-2.0.html and
34** https://www.gnu.org/licenses/gpl-3.0.html.
35**
36** $QT_END_LICENSE$
37**
38****************************************************************************/
39
40// Generated code, do not edit! Use generator at tools/qtconcurrent/generaterun/
41#ifndef QTCONCURRENT_STOREDFUNCTIONCALL_H
42#define QTCONCURRENT_STOREDFUNCTIONCALL_H
43
44#include <QtConcurrent/qtconcurrent_global.h>
45
46#ifndef QT_NO_CONCURRENT
47#include <QtConcurrent/qtconcurrentrunbase.h>
48
49QT_BEGIN_NAMESPACE
50
51
52#ifndef Q_QDOC
53
54namespace QtConcurrent {
55template <typename T, typename FunctionPointer>
56struct StoredFunctorCall0: public RunFunctionTask<T>
57{
58 inline StoredFunctorCall0(FunctionPointer _function)
59 : function(_function) {}
60 void runFunctor() override { this->result = function(); }
61 FunctionPointer function;
62
63};
64
65template <typename FunctionPointer>
66struct StoredFunctorCall0<void, FunctionPointer>: public RunFunctionTask<void>
67{
68 inline StoredFunctorCall0(FunctionPointer _function)
69 : function(_function) {}
70 void runFunctor() override { function(); }
71 FunctionPointer function;
72
73};
74
75template <typename T, typename FunctionPointer>
76struct StoredFunctorPointerCall0: public RunFunctionTask<T>
77{
78 inline StoredFunctorPointerCall0(FunctionPointer * _function)
79 : function(_function) {}
80 void runFunctor() override { this->result =(*function)(); }
81 FunctionPointer * function;
82
83};
84
85template <typename T, typename FunctionPointer>
86struct VoidStoredFunctorPointerCall0: public RunFunctionTask<T>
87{
88 inline VoidStoredFunctorPointerCall0(FunctionPointer * _function)
89 : function(_function) {}
90 void runFunctor() override { (*function)(); }
91 FunctionPointer * function;
92
93};
94
95template <typename T, typename FunctionPointer>
96struct SelectStoredFunctorPointerCall0
97{
98 typedef typename SelectSpecialization<T>::template
99 Type<StoredFunctorPointerCall0 <T, FunctionPointer>,
100 VoidStoredFunctorPointerCall0<T, FunctionPointer> >::type type;
101};
102template <typename T, typename Class>
103class StoredMemberFunctionCall0 : public RunFunctionTask<T>
104{
105public:
106 StoredMemberFunctionCall0(T (Class::*_fn)(), const Class &_object)
107 : fn(_fn), object(_object){ }
108
109 void runFunctor() override
110 {
111 this->result = (object.*fn)();
112 }
113private:
114 T (Class::*fn)();
115 Class object;
116
117};
118template <typename T, typename Class>
119class VoidStoredMemberFunctionCall0 : public RunFunctionTask<T>
120{
121public:
122 VoidStoredMemberFunctionCall0(T (Class::*_fn)(), const Class &_object)
123 : fn(_fn), object(_object){ }
124
125 void runFunctor() override
126 {
127 (object.*fn)();
128 }
129private:
130 T (Class::*fn)();
131 Class object;
132
133};
134template <typename T, typename Class>
135struct SelectStoredMemberFunctionCall0
136{
137 typedef typename SelectSpecialization<T>::template
138 Type<StoredMemberFunctionCall0 <T, Class>,
139 VoidStoredMemberFunctionCall0<T, Class> >::type type;
140};
141template <typename T, typename Class>
142class StoredConstMemberFunctionCall0 : public RunFunctionTask<T>
143{
144public:
145 StoredConstMemberFunctionCall0(T (Class::*_fn)() const, const Class &_object)
146 : fn(_fn), object(_object){ }
147
148 void runFunctor() override
149 {
150 this->result = (object.*fn)();
151 }
152private:
153 T (Class::*fn)() const;
154 const Class object;
155
156};
157template <typename T, typename Class>
158class VoidStoredConstMemberFunctionCall0 : public RunFunctionTask<T>
159{
160public:
161 VoidStoredConstMemberFunctionCall0(T (Class::*_fn)() const, const Class &_object)
162 : fn(_fn), object(_object){ }
163
164 void runFunctor() override
165 {
166 (object.*fn)();
167 }
168private:
169 T (Class::*fn)() const;
170 const Class object;
171
172};
173template <typename T, typename Class>
174struct SelectStoredConstMemberFunctionCall0
175{
176 typedef typename SelectSpecialization<T>::template
177 Type<StoredConstMemberFunctionCall0 <T, Class>,
178 VoidStoredConstMemberFunctionCall0<T, Class> >::type type;
179};
180template <typename T, typename Class>
181class StoredMemberFunctionPointerCall0 : public RunFunctionTask<T>
182{
183public:
184 StoredMemberFunctionPointerCall0(T (Class::*_fn)(), Class *_object)
185 : fn(_fn), object(_object){ }
186
187 void runFunctor() override
188 {
189 this->result = (object->*fn)();
190 }
191private:
192 T (Class::*fn)();
193 Class *object;
194
195};
196template <typename T, typename Class>
197class VoidStoredMemberFunctionPointerCall0 : public RunFunctionTask<T>
198{
199public:
200 VoidStoredMemberFunctionPointerCall0(T (Class::*_fn)(), Class *_object)
201 : fn(_fn), object(_object){ }
202
203 void runFunctor() override
204 {
205 (object->*fn)();
206 }
207private:
208 T (Class::*fn)();
209 Class *object;
210
211};
212template <typename T, typename Class>
213struct SelectStoredMemberFunctionPointerCall0
214{
215 typedef typename SelectSpecialization<T>::template
216 Type<StoredMemberFunctionPointerCall0 <T, Class>,
217 VoidStoredMemberFunctionPointerCall0<T, Class> >::type type;
218};
219template <typename T, typename Class>
220class StoredConstMemberFunctionPointerCall0 : public RunFunctionTask<T>
221{
222public:
223 StoredConstMemberFunctionPointerCall0(T (Class::*_fn)() const, Class const *_object)
224 : fn(_fn), object(_object){ }
225
226 void runFunctor() override
227 {
228 this->result = (object->*fn)();
229 }
230private:
231 T (Class::*fn)() const;
232 Class const *object;
233
234};
235template <typename T, typename Class>
236class VoidStoredConstMemberFunctionPointerCall0 : public RunFunctionTask<T>
237{
238public:
239 VoidStoredConstMemberFunctionPointerCall0(T (Class::*_fn)() const, Class const *_object)
240 : fn(_fn), object(_object){ }
241
242 void runFunctor() override
243 {
244 (object->*fn)();
245 }
246private:
247 T (Class::*fn)() const;
248 Class const *object;
249
250};
251template <typename T, typename Class>
252struct SelectStoredConstMemberFunctionPointerCall0
253{
254 typedef typename SelectSpecialization<T>::template
255 Type<StoredConstMemberFunctionPointerCall0 <T, Class>,
256 VoidStoredConstMemberFunctionPointerCall0<T, Class> >::type type;
257};
258#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510
259template <typename T, typename Class>
260class StoredNoExceptMemberFunctionCall0 : public RunFunctionTask<T>
261{
262public:
263 StoredNoExceptMemberFunctionCall0(T (Class::*_fn)() noexcept, const Class &_object)
264 : fn(_fn), object(_object){ }
265
266 void runFunctor() override
267 {
268 this->result = (object.*fn)();
269 }
270private:
271 T (Class::*fn)() noexcept;
272 Class object;
273
274};
275template <typename T, typename Class>
276class VoidStoredNoExceptMemberFunctionCall0 : public RunFunctionTask<T>
277{
278public:
279 VoidStoredNoExceptMemberFunctionCall0(T (Class::*_fn)() noexcept, const Class &_object)
280 : fn(_fn), object(_object){ }
281
282 void runFunctor() override
283 {
284 (object.*fn)();
285 }
286private:
287 T (Class::*fn)() noexcept;
288 Class object;
289
290};
291template <typename T, typename Class>
292struct SelectStoredNoExceptMemberFunctionCall0
293{
294 typedef typename SelectSpecialization<T>::template
295 Type<StoredNoExceptMemberFunctionCall0 <T, Class>,
296 VoidStoredNoExceptMemberFunctionCall0<T, Class> >::type type;
297};
298template <typename T, typename Class>
299class StoredConstNoExceptMemberFunctionCall0 : public RunFunctionTask<T>
300{
301public:
302 StoredConstNoExceptMemberFunctionCall0(T (Class::*_fn)() const noexcept, const Class &_object)
303 : fn(_fn), object(_object){ }
304
305 void runFunctor() override
306 {
307 this->result = (object.*fn)();
308 }
309private:
310 T (Class::*fn)() const noexcept;
311 const Class object;
312
313};
314template <typename T, typename Class>
315class VoidStoredConstNoExceptMemberFunctionCall0 : public RunFunctionTask<T>
316{
317public:
318 VoidStoredConstNoExceptMemberFunctionCall0(T (Class::*_fn)() const noexcept, const Class &_object)
319 : fn(_fn), object(_object){ }
320
321 void runFunctor() override
322 {
323 (object.*fn)();
324 }
325private:
326 T (Class::*fn)() const noexcept;
327 const Class object;
328
329};
330template <typename T, typename Class>
331struct SelectStoredConstNoExceptMemberFunctionCall0
332{
333 typedef typename SelectSpecialization<T>::template
334 Type<StoredConstNoExceptMemberFunctionCall0 <T, Class>,
335 VoidStoredConstNoExceptMemberFunctionCall0<T, Class> >::type type;
336};
337template <typename T, typename Class>
338class StoredNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T>
339{
340public:
341 StoredNoExceptMemberFunctionPointerCall0(T (Class::*_fn)() noexcept, Class *_object)
342 : fn(_fn), object(_object){ }
343
344 void runFunctor() override
345 {
346 this->result = (object->*fn)();
347 }
348private:
349 T (Class::*fn)() noexcept;
350 Class *object;
351
352};
353template <typename T, typename Class>
354class VoidStoredNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T>
355{
356public:
357 VoidStoredNoExceptMemberFunctionPointerCall0(T (Class::*_fn)() noexcept, Class *_object)
358 : fn(_fn), object(_object){ }
359
360 void runFunctor() override
361 {
362 (object->*fn)();
363 }
364private:
365 T (Class::*fn)() noexcept;
366 Class *object;
367
368};
369template <typename T, typename Class>
370struct SelectStoredNoExceptMemberFunctionPointerCall0
371{
372 typedef typename SelectSpecialization<T>::template
373 Type<StoredNoExceptMemberFunctionPointerCall0 <T, Class>,
374 VoidStoredNoExceptMemberFunctionPointerCall0<T, Class> >::type type;
375};
376template <typename T, typename Class>
377class StoredConstNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T>
378{
379public:
380 StoredConstNoExceptMemberFunctionPointerCall0(T (Class::*_fn)() const noexcept, Class const *_object)
381 : fn(_fn), object(_object){ }
382
383 void runFunctor() override
384 {
385 this->result = (object->*fn)();
386 }
387private:
388 T (Class::*fn)() const noexcept;
389 Class const *object;
390
391};
392template <typename T, typename Class>
393class VoidStoredConstNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T>
394{
395public:
396 VoidStoredConstNoExceptMemberFunctionPointerCall0(T (Class::*_fn)() const noexcept, Class const *_object)
397 : fn(_fn), object(_object){ }
398
399 void runFunctor() override
400 {
401 (object->*fn)();
402 }
403private:
404 T (Class::*fn)() const noexcept;
405 Class const *object;
406
407};
408template <typename T, typename Class>
409struct SelectStoredConstNoExceptMemberFunctionPointerCall0
410{
411 typedef typename SelectSpecialization<T>::template
412 Type<StoredConstNoExceptMemberFunctionPointerCall0 <T, Class>,
413 VoidStoredConstNoExceptMemberFunctionPointerCall0<T, Class> >::type type;
414};
415#endif
416
417template <typename T, typename FunctionPointer, typename Arg1>
418struct StoredFunctorCall1: public RunFunctionTask<T>
419{
420 inline StoredFunctorCall1(FunctionPointer _function, const Arg1 &_arg1)
421 : function(_function), arg1(_arg1) {}
422 void runFunctor() override { this->result = function(arg1); }
423 FunctionPointer function;
424 Arg1 arg1;
425};
426
427template <typename FunctionPointer, typename Arg1>
428struct StoredFunctorCall1<void, FunctionPointer, Arg1>: public RunFunctionTask<void>
429{
430 inline StoredFunctorCall1(FunctionPointer _function, const Arg1 &_arg1)
431 : function(_function), arg1(_arg1) {}
432 void runFunctor() override { function(arg1); }
433 FunctionPointer function;
434 Arg1 arg1;
435};
436
437template <typename T, typename FunctionPointer, typename Arg1>
438struct StoredFunctorPointerCall1: public RunFunctionTask<T>
439{
440 inline StoredFunctorPointerCall1(FunctionPointer * _function, const Arg1 &_arg1)
441 : function(_function), arg1(_arg1) {}
442 void runFunctor() override { this->result =(*function)(arg1); }
443 FunctionPointer * function;
444 Arg1 arg1;
445};
446
447template <typename T, typename FunctionPointer, typename Arg1>
448struct VoidStoredFunctorPointerCall1: public RunFunctionTask<T>
449{
450 inline VoidStoredFunctorPointerCall1(FunctionPointer * _function, const Arg1 &_arg1)
451 : function(_function), arg1(_arg1) {}
452 void runFunctor() override { (*function)(arg1); }
453 FunctionPointer * function;
454 Arg1 arg1;
455};
456
457template <typename T, typename FunctionPointer, typename Arg1>
458struct SelectStoredFunctorPointerCall1
459{
460 typedef typename SelectSpecialization<T>::template
461 Type<StoredFunctorPointerCall1 <T, FunctionPointer, Arg1>,
462 VoidStoredFunctorPointerCall1<T, FunctionPointer, Arg1> >::type type;
463};
464template <typename T, typename Class, typename Param1, typename Arg1>
465class StoredMemberFunctionCall1 : public RunFunctionTask<T>
466{
467public:
468 StoredMemberFunctionCall1(T (Class::*_fn)(Param1), const Class &_object, const Arg1 &_arg1)
469 : fn(_fn), object(_object), arg1(_arg1){ }
470
471 void runFunctor() override
472 {
473 this->result = (object.*fn)(arg1);
474 }
475private:
476 T (Class::*fn)(Param1);
477 Class object;
478 Arg1 arg1;
479};
480template <typename T, typename Class, typename Param1, typename Arg1>
481class VoidStoredMemberFunctionCall1 : public RunFunctionTask<T>
482{
483public:
484 VoidStoredMemberFunctionCall1(T (Class::*_fn)(Param1), const Class &_object, const Arg1 &_arg1)
485 : fn(_fn), object(_object), arg1(_arg1){ }
486
487 void runFunctor() override
488 {
489 (object.*fn)(arg1);
490 }
491private:
492 T (Class::*fn)(Param1);
493 Class object;
494 Arg1 arg1;
495};
496template <typename T, typename Class, typename Param1, typename Arg1>
497struct SelectStoredMemberFunctionCall1
498{
499 typedef typename SelectSpecialization<T>::template
500 Type<StoredMemberFunctionCall1 <T, Class, Param1, Arg1>,
501 VoidStoredMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
502};
503template <typename T, typename Class, typename Param1, typename Arg1>
504class StoredConstMemberFunctionCall1 : public RunFunctionTask<T>
505{
506public:
507 StoredConstMemberFunctionCall1(T (Class::*_fn)(Param1) const, const Class &_object, const Arg1 &_arg1)
508 : fn(_fn), object(_object), arg1(_arg1){ }
509
510 void runFunctor() override
511 {
512 this->result = (object.*fn)(arg1);
513 }
514private:
515 T (Class::*fn)(Param1) const;
516 const Class object;
517 Arg1 arg1;
518};
519template <typename T, typename Class, typename Param1, typename Arg1>
520class VoidStoredConstMemberFunctionCall1 : public RunFunctionTask<T>
521{
522public:
523 VoidStoredConstMemberFunctionCall1(T (Class::*_fn)(Param1) const, const Class &_object, const Arg1 &_arg1)
524 : fn(_fn), object(_object), arg1(_arg1){ }
525
526 void runFunctor() override
527 {
528 (object.*fn)(arg1);
529 }
530private:
531 T (Class::*fn)(Param1) const;
532 const Class object;
533 Arg1 arg1;
534};
535template <typename T, typename Class, typename Param1, typename Arg1>
536struct SelectStoredConstMemberFunctionCall1
537{
538 typedef typename SelectSpecialization<T>::template
539 Type<StoredConstMemberFunctionCall1 <T, Class, Param1, Arg1>,
540 VoidStoredConstMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
541};
542template <typename T, typename Class, typename Param1, typename Arg1>
543class StoredMemberFunctionPointerCall1 : public RunFunctionTask<T>
544{
545public:
546 StoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1), Class *_object, const Arg1 &_arg1)
547 : fn(_fn), object(_object), arg1(_arg1){ }
548
549 void runFunctor() override
550 {
551 this->result = (object->*fn)(arg1);
552 }
553private:
554 T (Class::*fn)(Param1);
555 Class *object;
556 Arg1 arg1;
557};
558template <typename T, typename Class, typename Param1, typename Arg1>
559class VoidStoredMemberFunctionPointerCall1 : public RunFunctionTask<T>
560{
561public:
562 VoidStoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1), Class *_object, const Arg1 &_arg1)
563 : fn(_fn), object(_object), arg1(_arg1){ }
564
565 void runFunctor() override
566 {
567 (object->*fn)(arg1);
568 }
569private:
570 T (Class::*fn)(Param1);
571 Class *object;
572 Arg1 arg1;
573};
574template <typename T, typename Class, typename Param1, typename Arg1>
575struct SelectStoredMemberFunctionPointerCall1
576{
577 typedef typename SelectSpecialization<T>::template
578 Type<StoredMemberFunctionPointerCall1 <T, Class, Param1, Arg1>,
579 VoidStoredMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
580};
581template <typename T, typename Class, typename Param1, typename Arg1>
582class StoredConstMemberFunctionPointerCall1 : public RunFunctionTask<T>
583{
584public:
585 StoredConstMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const, Class const *_object, const Arg1 &_arg1)
586 : fn(_fn), object(_object), arg1(_arg1){ }
587
588 void runFunctor() override
589 {
590 this->result = (object->*fn)(arg1);
591 }
592private:
593 T (Class::*fn)(Param1) const;
594 Class const *object;
595 Arg1 arg1;
596};
597template <typename T, typename Class, typename Param1, typename Arg1>
598class VoidStoredConstMemberFunctionPointerCall1 : public RunFunctionTask<T>
599{
600public:
601 VoidStoredConstMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const, Class const *_object, const Arg1 &_arg1)
602 : fn(_fn), object(_object), arg1(_arg1){ }
603
604 void runFunctor() override
605 {
606 (object->*fn)(arg1);
607 }
608private:
609 T (Class::*fn)(Param1) const;
610 Class const *object;
611 Arg1 arg1;
612};
613template <typename T, typename Class, typename Param1, typename Arg1>
614struct SelectStoredConstMemberFunctionPointerCall1
615{
616 typedef typename SelectSpecialization<T>::template
617 Type<StoredConstMemberFunctionPointerCall1 <T, Class, Param1, Arg1>,
618 VoidStoredConstMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
619};
620#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510
621template <typename T, typename Class, typename Param1, typename Arg1>
622class StoredNoExceptMemberFunctionCall1 : public RunFunctionTask<T>
623{
624public:
625 StoredNoExceptMemberFunctionCall1(T (Class::*_fn)(Param1) noexcept, const Class &_object, const Arg1 &_arg1)
626 : fn(_fn), object(_object), arg1(_arg1){ }
627
628 void runFunctor() override
629 {
630 this->result = (object.*fn)(arg1);
631 }
632private:
633 T (Class::*fn)(Param1) noexcept;
634 Class object;
635 Arg1 arg1;
636};
637template <typename T, typename Class, typename Param1, typename Arg1>
638class VoidStoredNoExceptMemberFunctionCall1 : public RunFunctionTask<T>
639{
640public:
641 VoidStoredNoExceptMemberFunctionCall1(T (Class::*_fn)(Param1) noexcept, const Class &_object, const Arg1 &_arg1)
642 : fn(_fn), object(_object), arg1(_arg1){ }
643
644 void runFunctor() override
645 {
646 (object.*fn)(arg1);
647 }
648private:
649 T (Class::*fn)(Param1) noexcept;
650 Class object;
651 Arg1 arg1;
652};
653template <typename T, typename Class, typename Param1, typename Arg1>
654struct SelectStoredNoExceptMemberFunctionCall1
655{
656 typedef typename SelectSpecialization<T>::template
657 Type<StoredNoExceptMemberFunctionCall1 <T, Class, Param1, Arg1>,
658 VoidStoredNoExceptMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
659};
660template <typename T, typename Class, typename Param1, typename Arg1>
661class StoredConstNoExceptMemberFunctionCall1 : public RunFunctionTask<T>
662{
663public:
664 StoredConstNoExceptMemberFunctionCall1(T (Class::*_fn)(Param1) const noexcept, const Class &_object, const Arg1 &_arg1)
665 : fn(_fn), object(_object), arg1(_arg1){ }
666
667 void runFunctor() override
668 {
669 this->result = (object.*fn)(arg1);
670 }
671private:
672 T (Class::*fn)(Param1) const noexcept;
673 const Class object;
674 Arg1 arg1;
675};
676template <typename T, typename Class, typename Param1, typename Arg1>
677class VoidStoredConstNoExceptMemberFunctionCall1 : public RunFunctionTask<T>
678{
679public:
680 VoidStoredConstNoExceptMemberFunctionCall1(T (Class::*_fn)(Param1) const noexcept, const Class &_object, const Arg1 &_arg1)
681 : fn(_fn), object(_object), arg1(_arg1){ }
682
683 void runFunctor() override
684 {
685 (object.*fn)(arg1);
686 }
687private:
688 T (Class::*fn)(Param1) const noexcept;
689 const Class object;
690 Arg1 arg1;
691};
692template <typename T, typename Class, typename Param1, typename Arg1>
693struct SelectStoredConstNoExceptMemberFunctionCall1
694{
695 typedef typename SelectSpecialization<T>::template
696 Type<StoredConstNoExceptMemberFunctionCall1 <T, Class, Param1, Arg1>,
697 VoidStoredConstNoExceptMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
698};
699template <typename T, typename Class, typename Param1, typename Arg1>
700class StoredNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T>
701{
702public:
703 StoredNoExceptMemberFunctionPointerCall1(T (Class::*_fn)(Param1) noexcept, Class *_object, const Arg1 &_arg1)
704 : fn(_fn), object(_object), arg1(_arg1){ }
705
706 void runFunctor() override
707 {
708 this->result = (object->*fn)(arg1);
709 }
710private:
711 T (Class::*fn)(Param1) noexcept;
712 Class *object;
713 Arg1 arg1;
714};
715template <typename T, typename Class, typename Param1, typename Arg1>
716class VoidStoredNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T>
717{
718public:
719 VoidStoredNoExceptMemberFunctionPointerCall1(T (Class::*_fn)(Param1) noexcept, Class *_object, const Arg1 &_arg1)
720 : fn(_fn), object(_object), arg1(_arg1){ }
721
722 void runFunctor() override
723 {
724 (object->*fn)(arg1);
725 }
726private:
727 T (Class::*fn)(Param1) noexcept;
728 Class *object;
729 Arg1 arg1;
730};
731template <typename T, typename Class, typename Param1, typename Arg1>
732struct SelectStoredNoExceptMemberFunctionPointerCall1
733{
734 typedef typename SelectSpecialization<T>::template
735 Type<StoredNoExceptMemberFunctionPointerCall1 <T, Class, Param1, Arg1>,
736 VoidStoredNoExceptMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
737};
738template <typename T, typename Class, typename Param1, typename Arg1>
739class StoredConstNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T>
740{
741public:
742 StoredConstNoExceptMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const noexcept, Class const *_object, const Arg1 &_arg1)
743 : fn(_fn), object(_object), arg1(_arg1){ }
744
745 void runFunctor() override
746 {
747 this->result = (object->*fn)(arg1);
748 }
749private:
750 T (Class::*fn)(Param1) const noexcept;
751 Class const *object;
752 Arg1 arg1;
753};
754template <typename T, typename Class, typename Param1, typename Arg1>
755class VoidStoredConstNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T>
756{
757public:
758 VoidStoredConstNoExceptMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const noexcept, Class const *_object, const Arg1 &_arg1)
759 : fn(_fn), object(_object), arg1(_arg1){ }
760
761 void runFunctor() override
762 {
763 (object->*fn)(arg1);
764 }
765private:
766 T (Class::*fn)(Param1) const noexcept;
767 Class const *object;
768 Arg1 arg1;
769};
770template <typename T, typename Class, typename Param1, typename Arg1>
771struct SelectStoredConstNoExceptMemberFunctionPointerCall1
772{
773 typedef typename SelectSpecialization<T>::template
774 Type<StoredConstNoExceptMemberFunctionPointerCall1 <T, Class, Param1, Arg1>,
775 VoidStoredConstNoExceptMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
776};
777#endif
778
779template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
780struct StoredFunctorCall2: public RunFunctionTask<T>
781{
782 inline StoredFunctorCall2(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2)
783 : function(_function), arg1(_arg1), arg2(_arg2) {}
784 void runFunctor() override { this->result = function(arg1, arg2); }
785 FunctionPointer function;
786 Arg1 arg1; Arg2 arg2;
787};
788
789template <typename FunctionPointer, typename Arg1, typename Arg2>
790struct StoredFunctorCall2<void, FunctionPointer, Arg1, Arg2>: public RunFunctionTask<void>
791{
792 inline StoredFunctorCall2(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2)
793 : function(_function), arg1(_arg1), arg2(_arg2) {}
794 void runFunctor() override { function(arg1, arg2); }
795 FunctionPointer function;
796 Arg1 arg1; Arg2 arg2;
797};
798
799template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
800struct StoredFunctorPointerCall2: public RunFunctionTask<T>
801{
802 inline StoredFunctorPointerCall2(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2)
803 : function(_function), arg1(_arg1), arg2(_arg2) {}
804 void runFunctor() override { this->result =(*function)(arg1, arg2); }
805 FunctionPointer * function;
806 Arg1 arg1; Arg2 arg2;
807};
808
809template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
810struct VoidStoredFunctorPointerCall2: public RunFunctionTask<T>
811{
812 inline VoidStoredFunctorPointerCall2(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2)
813 : function(_function), arg1(_arg1), arg2(_arg2) {}
814 void runFunctor() override { (*function)(arg1, arg2); }
815 FunctionPointer * function;
816 Arg1 arg1; Arg2 arg2;
817};
818
819template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
820struct SelectStoredFunctorPointerCall2
821{
822 typedef typename SelectSpecialization<T>::template
823 Type<StoredFunctorPointerCall2 <T, FunctionPointer, Arg1, Arg2>,
824 VoidStoredFunctorPointerCall2<T, FunctionPointer, Arg1, Arg2> >::type type;
825};
826template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
827class StoredMemberFunctionCall2 : public RunFunctionTask<T>
828{
829public:
830 StoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
831 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
832
833 void runFunctor() override
834 {
835 this->result = (object.*fn)(arg1, arg2);
836 }
837private:
838 T (Class::*fn)(Param1, Param2);
839 Class object;
840 Arg1 arg1; Arg2 arg2;
841};
842template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
843class VoidStoredMemberFunctionCall2 : public RunFunctionTask<T>
844{
845public:
846 VoidStoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
847 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
848
849 void runFunctor() override
850 {
851 (object.*fn)(arg1, arg2);
852 }
853private:
854 T (Class::*fn)(Param1, Param2);
855 Class object;
856 Arg1 arg1; Arg2 arg2;
857};
858template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
859struct SelectStoredMemberFunctionCall2
860{
861 typedef typename SelectSpecialization<T>::template
862 Type<StoredMemberFunctionCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
863 VoidStoredMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
864};
865template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
866class StoredConstMemberFunctionCall2 : public RunFunctionTask<T>
867{
868public:
869 StoredConstMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
870 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
871
872 void runFunctor() override
873 {
874 this->result = (object.*fn)(arg1, arg2);
875 }
876private:
877 T (Class::*fn)(Param1, Param2) const;
878 const Class object;
879 Arg1 arg1; Arg2 arg2;
880};
881template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
882class VoidStoredConstMemberFunctionCall2 : public RunFunctionTask<T>
883{
884public:
885 VoidStoredConstMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
886 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
887
888 void runFunctor() override
889 {
890 (object.*fn)(arg1, arg2);
891 }
892private:
893 T (Class::*fn)(Param1, Param2) const;
894 const Class object;
895 Arg1 arg1; Arg2 arg2;
896};
897template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
898struct SelectStoredConstMemberFunctionCall2
899{
900 typedef typename SelectSpecialization<T>::template
901 Type<StoredConstMemberFunctionCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
902 VoidStoredConstMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
903};
904template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
905class StoredMemberFunctionPointerCall2 : public RunFunctionTask<T>
906{
907public:
908 StoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
909 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
910
911 void runFunctor() override
912 {
913 this->result = (object->*fn)(arg1, arg2);
914 }
915private:
916 T (Class::*fn)(Param1, Param2);
917 Class *object;
918 Arg1 arg1; Arg2 arg2;
919};
920template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
921class VoidStoredMemberFunctionPointerCall2 : public RunFunctionTask<T>
922{
923public:
924 VoidStoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
925 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
926
927 void runFunctor() override
928 {
929 (object->*fn)(arg1, arg2);
930 }
931private:
932 T (Class::*fn)(Param1, Param2);
933 Class *object;
934 Arg1 arg1; Arg2 arg2;
935};
936template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
937struct SelectStoredMemberFunctionPointerCall2
938{
939 typedef typename SelectSpecialization<T>::template
940 Type<StoredMemberFunctionPointerCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
941 VoidStoredMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
942};
943template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
944class StoredConstMemberFunctionPointerCall2 : public RunFunctionTask<T>
945{
946public:
947 StoredConstMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2)
948 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
949
950 void runFunctor() override
951 {
952 this->result = (object->*fn)(arg1, arg2);
953 }
954private:
955 T (Class::*fn)(Param1, Param2) const;
956 Class const *object;
957 Arg1 arg1; Arg2 arg2;
958};
959template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
960class VoidStoredConstMemberFunctionPointerCall2 : public RunFunctionTask<T>
961{
962public:
963 VoidStoredConstMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2)
964 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
965
966 void runFunctor() override
967 {
968 (object->*fn)(arg1, arg2);
969 }
970private:
971 T (Class::*fn)(Param1, Param2) const;
972 Class const *object;
973 Arg1 arg1; Arg2 arg2;
974};
975template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
976struct SelectStoredConstMemberFunctionPointerCall2
977{
978 typedef typename SelectSpecialization<T>::template
979 Type<StoredConstMemberFunctionPointerCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
980 VoidStoredConstMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
981};
982#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510
983template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
984class StoredNoExceptMemberFunctionCall2 : public RunFunctionTask<T>
985{
986public:
987 StoredNoExceptMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
988 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
989
990 void runFunctor() override
991 {
992 this->result = (object.*fn)(arg1, arg2);
993 }
994private:
995 T (Class::*fn)(Param1, Param2) noexcept;
996 Class object;
997 Arg1 arg1; Arg2 arg2;
998};
999template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1000class VoidStoredNoExceptMemberFunctionCall2 : public RunFunctionTask<T>
1001{
1002public:
1003 VoidStoredNoExceptMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
1004 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
1005
1006 void runFunctor() override
1007 {
1008 (object.*fn)(arg1, arg2);
1009 }
1010private:
1011 T (Class::*fn)(Param1, Param2) noexcept;
1012 Class object;
1013 Arg1 arg1; Arg2 arg2;
1014};
1015template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1016struct SelectStoredNoExceptMemberFunctionCall2
1017{
1018 typedef typename SelectSpecialization<T>::template
1019 Type<StoredNoExceptMemberFunctionCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
1020 VoidStoredNoExceptMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
1021};
1022template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1023class StoredConstNoExceptMemberFunctionCall2 : public RunFunctionTask<T>
1024{
1025public:
1026 StoredConstNoExceptMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
1027 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
1028
1029 void runFunctor() override
1030 {
1031 this->result = (object.*fn)(arg1, arg2);
1032 }
1033private:
1034 T (Class::*fn)(Param1, Param2) const noexcept;
1035 const Class object;
1036 Arg1 arg1; Arg2 arg2;
1037};
1038template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1039class VoidStoredConstNoExceptMemberFunctionCall2 : public RunFunctionTask<T>
1040{
1041public:
1042 VoidStoredConstNoExceptMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
1043 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
1044
1045 void runFunctor() override
1046 {
1047 (object.*fn)(arg1, arg2);
1048 }
1049private:
1050 T (Class::*fn)(Param1, Param2) const noexcept;
1051 const Class object;
1052 Arg1 arg1; Arg2 arg2;
1053};
1054template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1055struct SelectStoredConstNoExceptMemberFunctionCall2
1056{
1057 typedef typename SelectSpecialization<T>::template
1058 Type<StoredConstNoExceptMemberFunctionCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
1059 VoidStoredConstNoExceptMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
1060};
1061template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1062class StoredNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T>
1063{
1064public:
1065 StoredNoExceptMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
1066 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
1067
1068 void runFunctor() override
1069 {
1070 this->result = (object->*fn)(arg1, arg2);
1071 }
1072private:
1073 T (Class::*fn)(Param1, Param2) noexcept;
1074 Class *object;
1075 Arg1 arg1; Arg2 arg2;
1076};
1077template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1078class VoidStoredNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T>
1079{
1080public:
1081 VoidStoredNoExceptMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
1082 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
1083
1084 void runFunctor() override
1085 {
1086 (object->*fn)(arg1, arg2);
1087 }
1088private:
1089 T (Class::*fn)(Param1, Param2) noexcept;
1090 Class *object;
1091 Arg1 arg1; Arg2 arg2;
1092};
1093template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1094struct SelectStoredNoExceptMemberFunctionPointerCall2
1095{
1096 typedef typename SelectSpecialization<T>::template
1097 Type<StoredNoExceptMemberFunctionPointerCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
1098 VoidStoredNoExceptMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
1099};
1100template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1101class StoredConstNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T>
1102{
1103public:
1104 StoredConstNoExceptMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2)
1105 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
1106
1107 void runFunctor() override
1108 {
1109 this->result = (object->*fn)(arg1, arg2);
1110 }
1111private:
1112 T (Class::*fn)(Param1, Param2) const noexcept;
1113 Class const *object;
1114 Arg1 arg1; Arg2 arg2;
1115};
1116template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1117class VoidStoredConstNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T>
1118{
1119public:
1120 VoidStoredConstNoExceptMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2)
1121 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
1122
1123 void runFunctor() override
1124 {
1125 (object->*fn)(arg1, arg2);
1126 }
1127private:
1128 T (Class::*fn)(Param1, Param2) const noexcept;
1129 Class const *object;
1130 Arg1 arg1; Arg2 arg2;
1131};
1132template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1133struct SelectStoredConstNoExceptMemberFunctionPointerCall2
1134{
1135 typedef typename SelectSpecialization<T>::template
1136 Type<StoredConstNoExceptMemberFunctionPointerCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
1137 VoidStoredConstNoExceptMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
1138};
1139#endif
1140
1141template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
1142struct StoredFunctorCall3: public RunFunctionTask<T>
1143{
1144 inline StoredFunctorCall3(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1145 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
1146 void runFunctor() override { this->result = function(arg1, arg2, arg3); }
1147 FunctionPointer function;
1148 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1149};
1150
1151template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
1152struct StoredFunctorCall3<void, FunctionPointer, Arg1, Arg2, Arg3>: public RunFunctionTask<void>
1153{
1154 inline StoredFunctorCall3(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1155 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
1156 void runFunctor() override { function(arg1, arg2, arg3); }
1157 FunctionPointer function;
1158 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1159};
1160
1161template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
1162struct StoredFunctorPointerCall3: public RunFunctionTask<T>
1163{
1164 inline StoredFunctorPointerCall3(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1165 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
1166 void runFunctor() override { this->result =(*function)(arg1, arg2, arg3); }
1167 FunctionPointer * function;
1168 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1169};
1170
1171template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
1172struct VoidStoredFunctorPointerCall3: public RunFunctionTask<T>
1173{
1174 inline VoidStoredFunctorPointerCall3(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1175 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
1176 void runFunctor() override { (*function)(arg1, arg2, arg3); }
1177 FunctionPointer * function;
1178 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1179};
1180
1181template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
1182struct SelectStoredFunctorPointerCall3
1183{
1184 typedef typename SelectSpecialization<T>::template
1185 Type<StoredFunctorPointerCall3 <T, FunctionPointer, Arg1, Arg2, Arg3>,
1186 VoidStoredFunctorPointerCall3<T, FunctionPointer, Arg1, Arg2, Arg3> >::type type;
1187};
1188template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1189class StoredMemberFunctionCall3 : public RunFunctionTask<T>
1190{
1191public:
1192 StoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1193 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1194
1195 void runFunctor() override
1196 {
1197 this->result = (object.*fn)(arg1, arg2, arg3);
1198 }
1199private:
1200 T (Class::*fn)(Param1, Param2, Param3);
1201 Class object;
1202 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1203};
1204template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1205class VoidStoredMemberFunctionCall3 : public RunFunctionTask<T>
1206{
1207public:
1208 VoidStoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1209 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1210
1211 void runFunctor() override
1212 {
1213 (object.*fn)(arg1, arg2, arg3);
1214 }
1215private:
1216 T (Class::*fn)(Param1, Param2, Param3);
1217 Class object;
1218 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1219};
1220template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1221struct SelectStoredMemberFunctionCall3
1222{
1223 typedef typename SelectSpecialization<T>::template
1224 Type<StoredMemberFunctionCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
1225 VoidStoredMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
1226};
1227template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1228class StoredConstMemberFunctionCall3 : public RunFunctionTask<T>
1229{
1230public:
1231 StoredConstMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1232 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1233
1234 void runFunctor() override
1235 {
1236 this->result = (object.*fn)(arg1, arg2, arg3);
1237 }
1238private:
1239 T (Class::*fn)(Param1, Param2, Param3) const;
1240 const Class object;
1241 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1242};
1243template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1244class VoidStoredConstMemberFunctionCall3 : public RunFunctionTask<T>
1245{
1246public:
1247 VoidStoredConstMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1248 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1249
1250 void runFunctor() override
1251 {
1252 (object.*fn)(arg1, arg2, arg3);
1253 }
1254private:
1255 T (Class::*fn)(Param1, Param2, Param3) const;
1256 const Class object;
1257 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1258};
1259template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1260struct SelectStoredConstMemberFunctionCall3
1261{
1262 typedef typename SelectSpecialization<T>::template
1263 Type<StoredConstMemberFunctionCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
1264 VoidStoredConstMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
1265};
1266template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1267class StoredMemberFunctionPointerCall3 : public RunFunctionTask<T>
1268{
1269public:
1270 StoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1271 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1272
1273 void runFunctor() override
1274 {
1275 this->result = (object->*fn)(arg1, arg2, arg3);
1276 }
1277private:
1278 T (Class::*fn)(Param1, Param2, Param3);
1279 Class *object;
1280 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1281};
1282template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1283class VoidStoredMemberFunctionPointerCall3 : public RunFunctionTask<T>
1284{
1285public:
1286 VoidStoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1287 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1288
1289 void runFunctor() override
1290 {
1291 (object->*fn)(arg1, arg2, arg3);
1292 }
1293private:
1294 T (Class::*fn)(Param1, Param2, Param3);
1295 Class *object;
1296 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1297};
1298template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1299struct SelectStoredMemberFunctionPointerCall3
1300{
1301 typedef typename SelectSpecialization<T>::template
1302 Type<StoredMemberFunctionPointerCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
1303 VoidStoredMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
1304};
1305template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1306class StoredConstMemberFunctionPointerCall3 : public RunFunctionTask<T>
1307{
1308public:
1309 StoredConstMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1310 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1311
1312 void runFunctor() override
1313 {
1314 this->result = (object->*fn)(arg1, arg2, arg3);
1315 }
1316private:
1317 T (Class::*fn)(Param1, Param2, Param3) const;
1318 Class const *object;
1319 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1320};
1321template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1322class VoidStoredConstMemberFunctionPointerCall3 : public RunFunctionTask<T>
1323{
1324public:
1325 VoidStoredConstMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1326 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1327
1328 void runFunctor() override
1329 {
1330 (object->*fn)(arg1, arg2, arg3);
1331 }
1332private:
1333 T (Class::*fn)(Param1, Param2, Param3) const;
1334 Class const *object;
1335 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1336};
1337template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1338struct SelectStoredConstMemberFunctionPointerCall3
1339{
1340 typedef typename SelectSpecialization<T>::template
1341 Type<StoredConstMemberFunctionPointerCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
1342 VoidStoredConstMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
1343};
1344#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510
1345template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1346class StoredNoExceptMemberFunctionCall3 : public RunFunctionTask<T>
1347{
1348public:
1349 StoredNoExceptMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1350 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1351
1352 void runFunctor() override
1353 {
1354 this->result = (object.*fn)(arg1, arg2, arg3);
1355 }
1356private:
1357 T (Class::*fn)(Param1, Param2, Param3) noexcept;
1358 Class object;
1359 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1360};
1361template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1362class VoidStoredNoExceptMemberFunctionCall3 : public RunFunctionTask<T>
1363{
1364public:
1365 VoidStoredNoExceptMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1366 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1367
1368 void runFunctor() override
1369 {
1370 (object.*fn)(arg1, arg2, arg3);
1371 }
1372private:
1373 T (Class::*fn)(Param1, Param2, Param3) noexcept;
1374 Class object;
1375 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1376};
1377template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1378struct SelectStoredNoExceptMemberFunctionCall3
1379{
1380 typedef typename SelectSpecialization<T>::template
1381 Type<StoredNoExceptMemberFunctionCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
1382 VoidStoredNoExceptMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
1383};
1384template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1385class StoredConstNoExceptMemberFunctionCall3 : public RunFunctionTask<T>
1386{
1387public:
1388 StoredConstNoExceptMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1389 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1390
1391 void runFunctor() override
1392 {
1393 this->result = (object.*fn)(arg1, arg2, arg3);
1394 }
1395private:
1396 T (Class::*fn)(Param1, Param2, Param3) const noexcept;
1397 const Class object;
1398 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1399};
1400template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1401class VoidStoredConstNoExceptMemberFunctionCall3 : public RunFunctionTask<T>
1402{
1403public:
1404 VoidStoredConstNoExceptMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1405 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1406
1407 void runFunctor() override
1408 {
1409 (object.*fn)(arg1, arg2, arg3);
1410 }
1411private:
1412 T (Class::*fn)(Param1, Param2, Param3) const noexcept;
1413 const Class object;
1414 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1415};
1416template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1417struct SelectStoredConstNoExceptMemberFunctionCall3
1418{
1419 typedef typename SelectSpecialization<T>::template
1420 Type<StoredConstNoExceptMemberFunctionCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
1421 VoidStoredConstNoExceptMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
1422};
1423template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1424class StoredNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T>
1425{
1426public:
1427 StoredNoExceptMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1428 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1429
1430 void runFunctor() override
1431 {
1432 this->result = (object->*fn)(arg1, arg2, arg3);
1433 }
1434private:
1435 T (Class::*fn)(Param1, Param2, Param3) noexcept;
1436 Class *object;
1437 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1438};
1439template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1440class VoidStoredNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T>
1441{
1442public:
1443 VoidStoredNoExceptMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1444 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1445
1446 void runFunctor() override
1447 {
1448 (object->*fn)(arg1, arg2, arg3);
1449 }
1450private:
1451 T (Class::*fn)(Param1, Param2, Param3) noexcept;
1452 Class *object;
1453 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1454};
1455template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1456struct SelectStoredNoExceptMemberFunctionPointerCall3
1457{
1458 typedef typename SelectSpecialization<T>::template
1459 Type<StoredNoExceptMemberFunctionPointerCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
1460 VoidStoredNoExceptMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
1461};
1462template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1463class StoredConstNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T>
1464{
1465public:
1466 StoredConstNoExceptMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1467 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1468
1469 void runFunctor() override
1470 {
1471 this->result = (object->*fn)(arg1, arg2, arg3);
1472 }
1473private:
1474 T (Class::*fn)(Param1, Param2, Param3) const noexcept;
1475 Class const *object;
1476 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1477};
1478template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1479class VoidStoredConstNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T>
1480{
1481public:
1482 VoidStoredConstNoExceptMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
1483 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
1484
1485 void runFunctor() override
1486 {
1487 (object->*fn)(arg1, arg2, arg3);
1488 }
1489private:
1490 T (Class::*fn)(Param1, Param2, Param3) const noexcept;
1491 Class const *object;
1492 Arg1 arg1; Arg2 arg2; Arg3 arg3;
1493};
1494template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1495struct SelectStoredConstNoExceptMemberFunctionPointerCall3
1496{
1497 typedef typename SelectSpecialization<T>::template
1498 Type<StoredConstNoExceptMemberFunctionPointerCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
1499 VoidStoredConstNoExceptMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
1500};
1501#endif
1502
1503template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
1504struct StoredFunctorCall4: public RunFunctionTask<T>
1505{
1506 inline StoredFunctorCall4(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1507 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
1508 void runFunctor() override { this->result = function(arg1, arg2, arg3, arg4); }
1509 FunctionPointer function;
1510 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1511};
1512
1513template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
1514struct StoredFunctorCall4<void, FunctionPointer, Arg1, Arg2, Arg3, Arg4>: public RunFunctionTask<void>
1515{
1516 inline StoredFunctorCall4(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1517 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
1518 void runFunctor() override { function(arg1, arg2, arg3, arg4); }
1519 FunctionPointer function;
1520 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1521};
1522
1523template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
1524struct StoredFunctorPointerCall4: public RunFunctionTask<T>
1525{
1526 inline StoredFunctorPointerCall4(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1527 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
1528 void runFunctor() override { this->result =(*function)(arg1, arg2, arg3, arg4); }
1529 FunctionPointer * function;
1530 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1531};
1532
1533template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
1534struct VoidStoredFunctorPointerCall4: public RunFunctionTask<T>
1535{
1536 inline VoidStoredFunctorPointerCall4(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1537 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
1538 void runFunctor() override { (*function)(arg1, arg2, arg3, arg4); }
1539 FunctionPointer * function;
1540 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1541};
1542
1543template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
1544struct SelectStoredFunctorPointerCall4
1545{
1546 typedef typename SelectSpecialization<T>::template
1547 Type<StoredFunctorPointerCall4 <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4>,
1548 VoidStoredFunctorPointerCall4<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4> >::type type;
1549};
1550template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1551class StoredMemberFunctionCall4 : public RunFunctionTask<T>
1552{
1553public:
1554 StoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1555 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1556
1557 void runFunctor() override
1558 {
1559 this->result = (object.*fn)(arg1, arg2, arg3, arg4);
1560 }
1561private:
1562 T (Class::*fn)(Param1, Param2, Param3, Param4);
1563 Class object;
1564 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1565};
1566template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1567class VoidStoredMemberFunctionCall4 : public RunFunctionTask<T>
1568{
1569public:
1570 VoidStoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1571 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1572
1573 void runFunctor() override
1574 {
1575 (object.*fn)(arg1, arg2, arg3, arg4);
1576 }
1577private:
1578 T (Class::*fn)(Param1, Param2, Param3, Param4);
1579 Class object;
1580 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1581};
1582template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1583struct SelectStoredMemberFunctionCall4
1584{
1585 typedef typename SelectSpecialization<T>::template
1586 Type<StoredMemberFunctionCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
1587 VoidStoredMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
1588};
1589template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1590class StoredConstMemberFunctionCall4 : public RunFunctionTask<T>
1591{
1592public:
1593 StoredConstMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1594 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1595
1596 void runFunctor() override
1597 {
1598 this->result = (object.*fn)(arg1, arg2, arg3, arg4);
1599 }
1600private:
1601 T (Class::*fn)(Param1, Param2, Param3, Param4) const;
1602 const Class object;
1603 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1604};
1605template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1606class VoidStoredConstMemberFunctionCall4 : public RunFunctionTask<T>
1607{
1608public:
1609 VoidStoredConstMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1610 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1611
1612 void runFunctor() override
1613 {
1614 (object.*fn)(arg1, arg2, arg3, arg4);
1615 }
1616private:
1617 T (Class::*fn)(Param1, Param2, Param3, Param4) const;
1618 const Class object;
1619 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1620};
1621template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1622struct SelectStoredConstMemberFunctionCall4
1623{
1624 typedef typename SelectSpecialization<T>::template
1625 Type<StoredConstMemberFunctionCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
1626 VoidStoredConstMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
1627};
1628template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1629class StoredMemberFunctionPointerCall4 : public RunFunctionTask<T>
1630{
1631public:
1632 StoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1633 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1634
1635 void runFunctor() override
1636 {
1637 this->result = (object->*fn)(arg1, arg2, arg3, arg4);
1638 }
1639private:
1640 T (Class::*fn)(Param1, Param2, Param3, Param4);
1641 Class *object;
1642 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1643};
1644template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1645class VoidStoredMemberFunctionPointerCall4 : public RunFunctionTask<T>
1646{
1647public:
1648 VoidStoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1649 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1650
1651 void runFunctor() override
1652 {
1653 (object->*fn)(arg1, arg2, arg3, arg4);
1654 }
1655private:
1656 T (Class::*fn)(Param1, Param2, Param3, Param4);
1657 Class *object;
1658 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1659};
1660template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1661struct SelectStoredMemberFunctionPointerCall4
1662{
1663 typedef typename SelectSpecialization<T>::template
1664 Type<StoredMemberFunctionPointerCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
1665 VoidStoredMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
1666};
1667template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1668class StoredConstMemberFunctionPointerCall4 : public RunFunctionTask<T>
1669{
1670public:
1671 StoredConstMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1672 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1673
1674 void runFunctor() override
1675 {
1676 this->result = (object->*fn)(arg1, arg2, arg3, arg4);
1677 }
1678private:
1679 T (Class::*fn)(Param1, Param2, Param3, Param4) const;
1680 Class const *object;
1681 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1682};
1683template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1684class VoidStoredConstMemberFunctionPointerCall4 : public RunFunctionTask<T>
1685{
1686public:
1687 VoidStoredConstMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1688 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1689
1690 void runFunctor() override
1691 {
1692 (object->*fn)(arg1, arg2, arg3, arg4);
1693 }
1694private:
1695 T (Class::*fn)(Param1, Param2, Param3, Param4) const;
1696 Class const *object;
1697 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1698};
1699template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1700struct SelectStoredConstMemberFunctionPointerCall4
1701{
1702 typedef typename SelectSpecialization<T>::template
1703 Type<StoredConstMemberFunctionPointerCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
1704 VoidStoredConstMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
1705};
1706#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510
1707template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1708class StoredNoExceptMemberFunctionCall4 : public RunFunctionTask<T>
1709{
1710public:
1711 StoredNoExceptMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1712 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1713
1714 void runFunctor() override
1715 {
1716 this->result = (object.*fn)(arg1, arg2, arg3, arg4);
1717 }
1718private:
1719 T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept;
1720 Class object;
1721 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1722};
1723template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1724class VoidStoredNoExceptMemberFunctionCall4 : public RunFunctionTask<T>
1725{
1726public:
1727 VoidStoredNoExceptMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1728 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1729
1730 void runFunctor() override
1731 {
1732 (object.*fn)(arg1, arg2, arg3, arg4);
1733 }
1734private:
1735 T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept;
1736 Class object;
1737 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1738};
1739template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1740struct SelectStoredNoExceptMemberFunctionCall4
1741{
1742 typedef typename SelectSpecialization<T>::template
1743 Type<StoredNoExceptMemberFunctionCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
1744 VoidStoredNoExceptMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
1745};
1746template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1747class StoredConstNoExceptMemberFunctionCall4 : public RunFunctionTask<T>
1748{
1749public:
1750 StoredConstNoExceptMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1751 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1752
1753 void runFunctor() override
1754 {
1755 this->result = (object.*fn)(arg1, arg2, arg3, arg4);
1756 }
1757private:
1758 T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept;
1759 const Class object;
1760 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1761};
1762template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1763class VoidStoredConstNoExceptMemberFunctionCall4 : public RunFunctionTask<T>
1764{
1765public:
1766 VoidStoredConstNoExceptMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1767 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1768
1769 void runFunctor() override
1770 {
1771 (object.*fn)(arg1, arg2, arg3, arg4);
1772 }
1773private:
1774 T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept;
1775 const Class object;
1776 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1777};
1778template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1779struct SelectStoredConstNoExceptMemberFunctionCall4
1780{
1781 typedef typename SelectSpecialization<T>::template
1782 Type<StoredConstNoExceptMemberFunctionCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
1783 VoidStoredConstNoExceptMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
1784};
1785template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1786class StoredNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T>
1787{
1788public:
1789 StoredNoExceptMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1790 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1791
1792 void runFunctor() override
1793 {
1794 this->result = (object->*fn)(arg1, arg2, arg3, arg4);
1795 }
1796private:
1797 T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept;
1798 Class *object;
1799 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1800};
1801template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1802class VoidStoredNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T>
1803{
1804public:
1805 VoidStoredNoExceptMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1806 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1807
1808 void runFunctor() override
1809 {
1810 (object->*fn)(arg1, arg2, arg3, arg4);
1811 }
1812private:
1813 T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept;
1814 Class *object;
1815 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1816};
1817template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1818struct SelectStoredNoExceptMemberFunctionPointerCall4
1819{
1820 typedef typename SelectSpecialization<T>::template
1821 Type<StoredNoExceptMemberFunctionPointerCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
1822 VoidStoredNoExceptMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
1823};
1824template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1825class StoredConstNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T>
1826{
1827public:
1828 StoredConstNoExceptMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1829 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1830
1831 void runFunctor() override
1832 {
1833 this->result = (object->*fn)(arg1, arg2, arg3, arg4);
1834 }
1835private:
1836 T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept;
1837 Class const *object;
1838 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1839};
1840template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1841class VoidStoredConstNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T>
1842{
1843public:
1844 VoidStoredConstNoExceptMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
1845 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
1846
1847 void runFunctor() override
1848 {
1849 (object->*fn)(arg1, arg2, arg3, arg4);
1850 }
1851private:
1852 T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept;
1853 Class const *object;
1854 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1855};
1856template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1857struct SelectStoredConstNoExceptMemberFunctionPointerCall4
1858{
1859 typedef typename SelectSpecialization<T>::template
1860 Type<StoredConstNoExceptMemberFunctionPointerCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
1861 VoidStoredConstNoExceptMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
1862};
1863#endif
1864
1865template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1866struct StoredFunctorCall5: public RunFunctionTask<T>
1867{
1868 inline StoredFunctorCall5(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1869 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
1870 void runFunctor() override { this->result = function(arg1, arg2, arg3, arg4, arg5); }
1871 FunctionPointer function;
1872 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1873};
1874
1875template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1876struct StoredFunctorCall5<void, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5>: public RunFunctionTask<void>
1877{
1878 inline StoredFunctorCall5(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1879 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
1880 void runFunctor() override { function(arg1, arg2, arg3, arg4, arg5); }
1881 FunctionPointer function;
1882 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1883};
1884
1885template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1886struct StoredFunctorPointerCall5: public RunFunctionTask<T>
1887{
1888 inline StoredFunctorPointerCall5(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1889 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
1890 void runFunctor() override { this->result =(*function)(arg1, arg2, arg3, arg4, arg5); }
1891 FunctionPointer * function;
1892 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1893};
1894
1895template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1896struct VoidStoredFunctorPointerCall5: public RunFunctionTask<T>
1897{
1898 inline VoidStoredFunctorPointerCall5(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
1899 : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
1900 void runFunctor() override { (*function)(arg1, arg2, arg3, arg4, arg5); }
1901 FunctionPointer * function;
1902 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1903};
1904
1905template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1906struct SelectStoredFunctorPointerCall5
1907{
1908 typedef typename SelectSpecialization<T>::template
1909 Type<StoredFunctorPointerCall5 <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5>,
1910 VoidStoredFunctorPointerCall5<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5> >::type type;
1911};
1912template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1913class StoredMemberFunctionCall5 : public RunFunctionTask<T>
1914{
1915public:
1916 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)
1917 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
1918
1919 void runFunctor() override
1920 {
1921 this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
1922 }
1923private:
1924 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
1925 Class object;
1926 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1927};
1928template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1929class VoidStoredMemberFunctionCall5 : public RunFunctionTask<T>
1930{
1931public:
1932 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)
1933 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
1934
1935 void runFunctor() override
1936 {
1937 (object.*fn)(arg1, arg2, arg3, arg4, arg5);
1938 }
1939private:
1940 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
1941 Class object;
1942 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1943};
1944template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1945struct SelectStoredMemberFunctionCall5
1946{
1947 typedef typename SelectSpecialization<T>::template
1948 Type<StoredMemberFunctionCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
1949 VoidStoredMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
1950};
1951template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1952class StoredConstMemberFunctionCall5 : public RunFunctionTask<T>
1953{
1954public:
1955 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)
1956 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
1957
1958 void runFunctor() override
1959 {
1960 this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
1961 }
1962private:
1963 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const;
1964 const Class object;
1965 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1966};
1967template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1968class VoidStoredConstMemberFunctionCall5 : public RunFunctionTask<T>
1969{
1970public:
1971 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)
1972 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
1973
1974 void runFunctor() override
1975 {
1976 (object.*fn)(arg1, arg2, arg3, arg4, arg5);
1977 }
1978private:
1979 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const;
1980 const Class object;
1981 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1982};
1983template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1984struct SelectStoredConstMemberFunctionCall5
1985{
1986 typedef typename SelectSpecialization<T>::template
1987 Type<StoredConstMemberFunctionCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
1988 VoidStoredConstMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
1989};
1990template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1991class StoredMemberFunctionPointerCall5 : public RunFunctionTask<T>
1992{
1993public:
1994 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)
1995 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
1996
1997 void runFunctor() override
1998 {
1999 this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
2000 }
2001private:
2002 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
2003 Class *object;
2004 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
2005};
2006template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2007class VoidStoredMemberFunctionPointerCall5 : public RunFunctionTask<T>
2008{
2009public:
2010 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)
2011 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
2012
2013 void runFunctor() override
2014 {
2015 (object->*fn)(arg1, arg2, arg3, arg4, arg5);
2016 }
2017private:
2018 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
2019 Class *object;
2020 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
2021};
2022template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2023struct SelectStoredMemberFunctionPointerCall5
2024{
2025 typedef typename SelectSpecialization<T>::template
2026 Type<StoredMemberFunctionPointerCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
2027 VoidStoredMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
2028};
2029template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2030class StoredConstMemberFunctionPointerCall5 : public RunFunctionTask<T>
2031{
2032public:
2033 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)
2034 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
2035
2036 void runFunctor() override
2037 {
2038 this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
2039 }
2040private:
2041 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const;
2042 Class const *object;
2043 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
2044};
2045template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2046class VoidStoredConstMemberFunctionPointerCall5 : public RunFunctionTask<T>
2047{
2048public:
2049 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)
2050 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
2051
2052 void runFunctor() override
2053 {
2054 (object->*fn)(arg1, arg2, arg3, arg4, arg5);
2055 }
2056private:
2057 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const;
2058 Class const *object;
2059 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
2060};
2061template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2062struct SelectStoredConstMemberFunctionPointerCall5
2063{
2064 typedef typename SelectSpecialization<T>::template
2065 Type<StoredConstMemberFunctionPointerCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
2066 VoidStoredConstMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
2067};
2068#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510
2069template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2070class StoredNoExceptMemberFunctionCall5 : public RunFunctionTask<T>
2071{
2072public:
2073 StoredNoExceptMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
2074 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
2075
2076 void runFunctor() override
2077 {
2078 this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
2079 }
2080private:
2081 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept;
2082 Class object;
2083 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
2084};
2085template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2086class VoidStoredNoExceptMemberFunctionCall5 : public RunFunctionTask<T>
2087{
2088public:
2089 VoidStoredNoExceptMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
2090 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
2091
2092 void runFunctor() override
2093 {
2094 (object.*fn)(arg1, arg2, arg3, arg4, arg5);
2095 }
2096private:
2097 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept;
2098 Class object;
2099 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
2100};
2101template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2102struct SelectStoredNoExceptMemberFunctionCall5
2103{
2104 typedef typename SelectSpecialization<T>::template
2105 Type<StoredNoExceptMemberFunctionCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
2106 VoidStoredNoExceptMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
2107};
2108template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2109class StoredConstNoExceptMemberFunctionCall5 : public RunFunctionTask<T>
2110{
2111public:
2112 StoredConstNoExceptMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
2113 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
2114
2115 void runFunctor() override
2116 {
2117 this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
2118 }
2119private:
2120 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept;
2121 const Class object;
2122 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
2123};
2124template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2125class VoidStoredConstNoExceptMemberFunctionCall5 : public RunFunctionTask<T>
2126{
2127public:
2128 VoidStoredConstNoExceptMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
2129 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
2130
2131 void runFunctor() override
2132 {
2133 (object.*fn)(arg1, arg2, arg3, arg4, arg5);
2134 }
2135private:
2136 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept;
2137 const Class object;
2138 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
2139};
2140template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2141struct SelectStoredConstNoExceptMemberFunctionCall5
2142{
2143 typedef typename SelectSpecialization<T>::template
2144 Type<StoredConstNoExceptMemberFunctionCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
2145 VoidStoredConstNoExceptMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
2146};
2147template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2148class StoredNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T>
2149{
2150public:
2151 StoredNoExceptMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
2152 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
2153
2154 void runFunctor() override
2155 {
2156 this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
2157 }
2158private:
2159 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept;
2160 Class *object;
2161 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
2162};
2163template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2164class VoidStoredNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T>
2165{
2166public:
2167 VoidStoredNoExceptMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
2168 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
2169
2170 void runFunctor() override
2171 {
2172 (object->*fn)(arg1, arg2, arg3, arg4, arg5);
2173 }
2174private:
2175 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept;
2176 Class *object;
2177 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
2178};
2179template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2180struct SelectStoredNoExceptMemberFunctionPointerCall5
2181{
2182 typedef typename SelectSpecialization<T>::template
2183 Type<StoredNoExceptMemberFunctionPointerCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
2184 VoidStoredNoExceptMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
2185};
2186template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2187class StoredConstNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T>
2188{
2189public:
2190 StoredConstNoExceptMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
2191 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
2192
2193 void runFunctor() override
2194 {
2195 this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
2196 }
2197private:
2198 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept;
2199 Class const *object;
2200 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
2201};
2202template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2203class VoidStoredConstNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T>
2204{
2205public:
2206 VoidStoredConstNoExceptMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
2207 : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
2208
2209 void runFunctor() override
2210 {
2211 (object->*fn)(arg1, arg2, arg3, arg4, arg5);
2212 }
2213private:
2214 T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept;
2215 Class const *object;
2216 Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
2217};
2218template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2219struct SelectStoredConstNoExceptMemberFunctionPointerCall5
2220{
2221 typedef typename SelectSpecialization<T>::template
2222 Type<StoredConstNoExceptMemberFunctionPointerCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
2223 VoidStoredConstNoExceptMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
2224};
2225#endif
2226
2227template <typename T, typename Functor>
2228class StoredFunctorCall : public RunFunctionTask<T>
2229{
2230public:
2231 StoredFunctorCall(const Functor &f) : functor(f) { }
2232 void runFunctor() override
2233 {
2234 this->result = functor();
2235 }
2236private:
2237 Functor functor;
2238};
2239template <typename Functor>
2240class StoredFunctorCall<void, Functor> : public RunFunctionTask<void>
2241{
2242public:
2243 StoredFunctorCall(const Functor &f) : functor(f) { }
2244 void runFunctor() override
2245 {
2246 functor();
2247 }
2248private:
2249 Functor functor;
2250};
2251
2252
2253} //namespace QtConcurrent
2254
2255#endif // Q_QDOC
2256
2257QT_END_NAMESPACE
2258
2259#endif // QT_NO_CONCURRENT
2260
2261#endif
2262