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
49	QT_BEGIN_NAMESPACE
50
51
52	#ifndef Q_QDOC
53
54	namespace QtConcurrent {
55	template <typename T, typename FunctionPointer>
56	struct 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
65	template <typename FunctionPointer>
66	struct 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
75	template <typename T, typename FunctionPointer>
76	struct 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
85	template <typename T, typename FunctionPointer>
86	struct VoidStoredFunctorPointerCall0: public RunFunctionTask<T>
87	{
88	inline VoidStoredFunctorPointerCall0(FunctionPointer * _function)
89	: function(_function) {}
90	void runFunctor() override { (*function)(); }
91	FunctionPointer * function;
92
93	};
94
95	template <typename T, typename FunctionPointer>
96	struct SelectStoredFunctorPointerCall0
97	{
98	typedef typename SelectSpecialization<T>::template
99	Type<StoredFunctorPointerCall0 <T, FunctionPointer>,
100	VoidStoredFunctorPointerCall0<T, FunctionPointer> >::type type;
101	};
102	template <typename T, typename Class>
103	class StoredMemberFunctionCall0 : public RunFunctionTask<T>
104	{
105	public:
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	}
113	private:
114	T (Class::*fn)();
115	Class object;
116
117	};
118	template <typename T, typename Class>
119	class VoidStoredMemberFunctionCall0 : public RunFunctionTask<T>
120	{
121	public:
122	VoidStoredMemberFunctionCall0(T (Class::*_fn)(), const Class &_object)
123	: fn(_fn), object(_object){ }
124
125	void runFunctor() override
126	{
127	(object.*fn)();
128	}
129	private:
130	T (Class::*fn)();
131	Class object;
132
133	};
134	template <typename T, typename Class>
135	struct SelectStoredMemberFunctionCall0
136	{
137	typedef typename SelectSpecialization<T>::template
138	Type<StoredMemberFunctionCall0 <T, Class>,
139	VoidStoredMemberFunctionCall0<T, Class> >::type type;
140	};
141	template <typename T, typename Class>
142	class StoredConstMemberFunctionCall0 : public RunFunctionTask<T>
143	{
144	public:
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	}
152	private:
153	T (Class::*fn)() const;
154	const Class object;
155
156	};
157	template <typename T, typename Class>
158	class VoidStoredConstMemberFunctionCall0 : public RunFunctionTask<T>
159	{
160	public:
161	VoidStoredConstMemberFunctionCall0(T (Class::*_fn)() const, const Class &_object)
162	: fn(_fn), object(_object){ }
163
164	void runFunctor() override
165	{
166	(object.*fn)();
167	}
168	private:
169	T (Class::*fn)() const;
170	const Class object;
171
172	};
173	template <typename T, typename Class>
174	struct SelectStoredConstMemberFunctionCall0
175	{
176	typedef typename SelectSpecialization<T>::template
177	Type<StoredConstMemberFunctionCall0 <T, Class>,
178	VoidStoredConstMemberFunctionCall0<T, Class> >::type type;
179	};
180	template <typename T, typename Class>
181	class StoredMemberFunctionPointerCall0 : public RunFunctionTask<T>
182	{
183	public:
184	StoredMemberFunctionPointerCall0(T (Class::*_fn)(), Class *_object)
185	: fn(_fn), object(_object){ }
186
187	void runFunctor() override
188	{
189	this->result = (object->*fn)();
190	}
191	private:
192	T (Class::*fn)();
193	Class *object;
194
195	};
196	template <typename T, typename Class>
197	class VoidStoredMemberFunctionPointerCall0 : public RunFunctionTask<T>
198	{
199	public:
200	VoidStoredMemberFunctionPointerCall0(T (Class::*_fn)(), Class *_object)
201	: fn(_fn), object(_object){ }
202
203	void runFunctor() override
204	{
205	(object->*fn)();
206	}
207	private:
208	T (Class::*fn)();
209	Class *object;
210
211	};
212	template <typename T, typename Class>
213	struct SelectStoredMemberFunctionPointerCall0
214	{
215	typedef typename SelectSpecialization<T>::template
216	Type<StoredMemberFunctionPointerCall0 <T, Class>,
217	VoidStoredMemberFunctionPointerCall0<T, Class> >::type type;
218	};
219	template <typename T, typename Class>
220	class StoredConstMemberFunctionPointerCall0 : public RunFunctionTask<T>
221	{
222	public:
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	}
230	private:
231	T (Class::*fn)() const;
232	Class const *object;
233
234	};
235	template <typename T, typename Class>
236	class VoidStoredConstMemberFunctionPointerCall0 : public RunFunctionTask<T>
237	{
238	public:
239	VoidStoredConstMemberFunctionPointerCall0(T (Class::*_fn)() const, Class const *_object)
240	: fn(_fn), object(_object){ }
241
242	void runFunctor() override
243	{
244	(object->*fn)();
245	}
246	private:
247	T (Class::*fn)() const;
248	Class const *object;
249
250	};
251	template <typename T, typename Class>
252	struct 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
259	template <typename T, typename Class>
260	class StoredNoExceptMemberFunctionCall0 : public RunFunctionTask<T>
261	{
262	public:
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	}
270	private:
271	T (Class::*fn)() noexcept;
272	Class object;
273
274	};
275	template <typename T, typename Class>
276	class VoidStoredNoExceptMemberFunctionCall0 : public RunFunctionTask<T>
277	{
278	public:
279	VoidStoredNoExceptMemberFunctionCall0(T (Class::*_fn)() noexcept, const Class &_object)
280	: fn(_fn), object(_object){ }
281
282	void runFunctor() override
283	{
284	(object.*fn)();
285	}
286	private:
287	T (Class::*fn)() noexcept;
288	Class object;
289
290	};
291	template <typename T, typename Class>
292	struct SelectStoredNoExceptMemberFunctionCall0
293	{
294	typedef typename SelectSpecialization<T>::template
295	Type<StoredNoExceptMemberFunctionCall0 <T, Class>,
296	VoidStoredNoExceptMemberFunctionCall0<T, Class> >::type type;
297	};
298	template <typename T, typename Class>
299	class StoredConstNoExceptMemberFunctionCall0 : public RunFunctionTask<T>
300	{
301	public:
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	}
309	private:
310	T (Class::*fn)() const noexcept;
311	const Class object;
312
313	};
314	template <typename T, typename Class>
315	class VoidStoredConstNoExceptMemberFunctionCall0 : public RunFunctionTask<T>
316	{
317	public:
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	}
325	private:
326	T (Class::*fn)() const noexcept;
327	const Class object;
328
329	};
330	template <typename T, typename Class>
331	struct SelectStoredConstNoExceptMemberFunctionCall0
332	{
333	typedef typename SelectSpecialization<T>::template
334	Type<StoredConstNoExceptMemberFunctionCall0 <T, Class>,
335	VoidStoredConstNoExceptMemberFunctionCall0<T, Class> >::type type;
336	};
337	template <typename T, typename Class>
338	class StoredNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T>
339	{
340	public:
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	}
348	private:
349	T (Class::*fn)() noexcept;
350	Class *object;
351
352	};
353	template <typename T, typename Class>
354	class VoidStoredNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T>
355	{
356	public:
357	VoidStoredNoExceptMemberFunctionPointerCall0(T (Class::*_fn)() noexcept, Class *_object)
358	: fn(_fn), object(_object){ }
359
360	void runFunctor() override
361	{
362	(object->*fn)();
363	}
364	private:
365	T (Class::*fn)() noexcept;
366	Class *object;
367
368	};
369	template <typename T, typename Class>
370	struct SelectStoredNoExceptMemberFunctionPointerCall0
371	{
372	typedef typename SelectSpecialization<T>::template
373	Type<StoredNoExceptMemberFunctionPointerCall0 <T, Class>,
374	VoidStoredNoExceptMemberFunctionPointerCall0<T, Class> >::type type;
375	};
376	template <typename T, typename Class>
377	class StoredConstNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T>
378	{
379	public:
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	}
387	private:
388	T (Class::*fn)() const noexcept;
389	Class const *object;
390
391	};
392	template <typename T, typename Class>
393	class VoidStoredConstNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T>
394	{
395	public:
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	}
403	private:
404	T (Class::*fn)() const noexcept;
405	Class const *object;
406
407	};
408	template <typename T, typename Class>
409	struct SelectStoredConstNoExceptMemberFunctionPointerCall0
410	{
411	typedef typename SelectSpecialization<T>::template
412	Type<StoredConstNoExceptMemberFunctionPointerCall0 <T, Class>,
413	VoidStoredConstNoExceptMemberFunctionPointerCall0<T, Class> >::type type;
414	};
415	#endif
416
417	template <typename T, typename FunctionPointer, typename Arg1>
418	struct 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
427	template <typename FunctionPointer, typename Arg1>
428	struct 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
437	template <typename T, typename FunctionPointer, typename Arg1>
438	struct 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
447	template <typename T, typename FunctionPointer, typename Arg1>
448	struct 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
457	template <typename T, typename FunctionPointer, typename Arg1>
458	struct SelectStoredFunctorPointerCall1
459	{
460	typedef typename SelectSpecialization<T>::template
461	Type<StoredFunctorPointerCall1 <T, FunctionPointer, Arg1>,
462	VoidStoredFunctorPointerCall1<T, FunctionPointer, Arg1> >::type type;
463	};
464	template <typename T, typename Class, typename Param1, typename Arg1>
465	class StoredMemberFunctionCall1 : public RunFunctionTask<T>
466	{
467	public:
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	}
475	private:
476	T (Class::*fn)(Param1);
477	Class object;
478	Arg1 arg1;
479	};
480	template <typename T, typename Class, typename Param1, typename Arg1>
481	class VoidStoredMemberFunctionCall1 : public RunFunctionTask<T>
482	{
483	public:
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	}
491	private:
492	T (Class::*fn)(Param1);
493	Class object;
494	Arg1 arg1;
495	};
496	template <typename T, typename Class, typename Param1, typename Arg1>
497	struct SelectStoredMemberFunctionCall1
498	{
499	typedef typename SelectSpecialization<T>::template
500	Type<StoredMemberFunctionCall1 <T, Class, Param1, Arg1>,
501	VoidStoredMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
502	};
503	template <typename T, typename Class, typename Param1, typename Arg1>
504	class StoredConstMemberFunctionCall1 : public RunFunctionTask<T>
505	{
506	public:
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	}
514	private:
515	T (Class::*fn)(Param1) const;
516	const Class object;
517	Arg1 arg1;
518	};
519	template <typename T, typename Class, typename Param1, typename Arg1>
520	class VoidStoredConstMemberFunctionCall1 : public RunFunctionTask<T>
521	{
522	public:
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	}
530	private:
531	T (Class::*fn)(Param1) const;
532	const Class object;
533	Arg1 arg1;
534	};
535	template <typename T, typename Class, typename Param1, typename Arg1>
536	struct SelectStoredConstMemberFunctionCall1
537	{
538	typedef typename SelectSpecialization<T>::template
539	Type<StoredConstMemberFunctionCall1 <T, Class, Param1, Arg1>,
540	VoidStoredConstMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
541	};
542	template <typename T, typename Class, typename Param1, typename Arg1>
543	class StoredMemberFunctionPointerCall1 : public RunFunctionTask<T>
544	{
545	public:
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	}
553	private:
554	T (Class::*fn)(Param1);
555	Class *object;
556	Arg1 arg1;
557	};
558	template <typename T, typename Class, typename Param1, typename Arg1>
559	class VoidStoredMemberFunctionPointerCall1 : public RunFunctionTask<T>
560	{
561	public:
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	}
569	private:
570	T (Class::*fn)(Param1);
571	Class *object;
572	Arg1 arg1;
573	};
574	template <typename T, typename Class, typename Param1, typename Arg1>
575	struct SelectStoredMemberFunctionPointerCall1
576	{
577	typedef typename SelectSpecialization<T>::template
578	Type<StoredMemberFunctionPointerCall1 <T, Class, Param1, Arg1>,
579	VoidStoredMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
580	};
581	template <typename T, typename Class, typename Param1, typename Arg1>
582	class StoredConstMemberFunctionPointerCall1 : public RunFunctionTask<T>
583	{
584	public:
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	}
592	private:
593	T (Class::*fn)(Param1) const;
594	Class const *object;
595	Arg1 arg1;
596	};
597	template <typename T, typename Class, typename Param1, typename Arg1>
598	class VoidStoredConstMemberFunctionPointerCall1 : public RunFunctionTask<T>
599	{
600	public:
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	}
608	private:
609	T (Class::*fn)(Param1) const;
610	Class const *object;
611	Arg1 arg1;
612	};
613	template <typename T, typename Class, typename Param1, typename Arg1>
614	struct 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
621	template <typename T, typename Class, typename Param1, typename Arg1>
622	class StoredNoExceptMemberFunctionCall1 : public RunFunctionTask<T>
623	{
624	public:
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	}
632	private:
633	T (Class::*fn)(Param1) noexcept;
634	Class object;
635	Arg1 arg1;
636	};
637	template <typename T, typename Class, typename Param1, typename Arg1>
638	class VoidStoredNoExceptMemberFunctionCall1 : public RunFunctionTask<T>
639	{
640	public:
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	}
648	private:
649	T (Class::*fn)(Param1) noexcept;
650	Class object;
651	Arg1 arg1;
652	};
653	template <typename T, typename Class, typename Param1, typename Arg1>
654	struct SelectStoredNoExceptMemberFunctionCall1
655	{
656	typedef typename SelectSpecialization<T>::template
657	Type<StoredNoExceptMemberFunctionCall1 <T, Class, Param1, Arg1>,
658	VoidStoredNoExceptMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
659	};
660	template <typename T, typename Class, typename Param1, typename Arg1>
661	class StoredConstNoExceptMemberFunctionCall1 : public RunFunctionTask<T>
662	{
663	public:
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	}
671	private:
672	T (Class::*fn)(Param1) const noexcept;
673	const Class object;
674	Arg1 arg1;
675	};
676	template <typename T, typename Class, typename Param1, typename Arg1>
677	class VoidStoredConstNoExceptMemberFunctionCall1 : public RunFunctionTask<T>
678	{
679	public:
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	}
687	private:
688	T (Class::*fn)(Param1) const noexcept;
689	const Class object;
690	Arg1 arg1;
691	};
692	template <typename T, typename Class, typename Param1, typename Arg1>
693	struct SelectStoredConstNoExceptMemberFunctionCall1
694	{
695	typedef typename SelectSpecialization<T>::template
696	Type<StoredConstNoExceptMemberFunctionCall1 <T, Class, Param1, Arg1>,
697	VoidStoredConstNoExceptMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
698	};
699	template <typename T, typename Class, typename Param1, typename Arg1>
700	class StoredNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T>
701	{
702	public:
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	}
710	private:
711	T (Class::*fn)(Param1) noexcept;
712	Class *object;
713	Arg1 arg1;
714	};
715	template <typename T, typename Class, typename Param1, typename Arg1>
716	class VoidStoredNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T>
717	{
718	public:
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	}
726	private:
727	T (Class::*fn)(Param1) noexcept;
728	Class *object;
729	Arg1 arg1;
730	};
731	template <typename T, typename Class, typename Param1, typename Arg1>
732	struct SelectStoredNoExceptMemberFunctionPointerCall1
733	{
734	typedef typename SelectSpecialization<T>::template
735	Type<StoredNoExceptMemberFunctionPointerCall1 <T, Class, Param1, Arg1>,
736	VoidStoredNoExceptMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
737	};
738	template <typename T, typename Class, typename Param1, typename Arg1>
739	class StoredConstNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T>
740	{
741	public:
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	}
749	private:
750	T (Class::*fn)(Param1) const noexcept;
751	Class const *object;
752	Arg1 arg1;
753	};
754	template <typename T, typename Class, typename Param1, typename Arg1>
755	class VoidStoredConstNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T>
756	{
757	public:
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	}
765	private:
766	T (Class::*fn)(Param1) const noexcept;
767	Class const *object;
768	Arg1 arg1;
769	};
770	template <typename T, typename Class, typename Param1, typename Arg1>
771	struct 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
779	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
780	struct 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
789	template <typename FunctionPointer, typename Arg1, typename Arg2>
790	struct 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
799	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
800	struct 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
809	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
810	struct 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
819	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
820	struct SelectStoredFunctorPointerCall2
821	{
822	typedef typename SelectSpecialization<T>::template
823	Type<StoredFunctorPointerCall2 <T, FunctionPointer, Arg1, Arg2>,
824	VoidStoredFunctorPointerCall2<T, FunctionPointer, Arg1, Arg2> >::type type;
825	};
826	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
827	class StoredMemberFunctionCall2 : public RunFunctionTask<T>
828	{
829	public:
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	}
837	private:
838	T (Class::*fn)(Param1, Param2);
839	Class object;
840	Arg1 arg1; Arg2 arg2;
841	};
842	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
843	class VoidStoredMemberFunctionCall2 : public RunFunctionTask<T>
844	{
845	public:
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	}
853	private:
854	T (Class::*fn)(Param1, Param2);
855	Class object;
856	Arg1 arg1; Arg2 arg2;
857	};
858	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
859	struct 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	};
865	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
866	class StoredConstMemberFunctionCall2 : public RunFunctionTask<T>
867	{
868	public:
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	}
876	private:
877	T (Class::*fn)(Param1, Param2) const;
878	const Class object;
879	Arg1 arg1; Arg2 arg2;
880	};
881	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
882	class VoidStoredConstMemberFunctionCall2 : public RunFunctionTask<T>
883	{
884	public:
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	}
892	private:
893	T (Class::*fn)(Param1, Param2) const;
894	const Class object;
895	Arg1 arg1; Arg2 arg2;
896	};
897	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
898	struct 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	};
904	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
905	class StoredMemberFunctionPointerCall2 : public RunFunctionTask<T>
906	{
907	public:
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	}
915	private:
916	T (Class::*fn)(Param1, Param2);
917	Class *object;
918	Arg1 arg1; Arg2 arg2;
919	};
920	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
921	class VoidStoredMemberFunctionPointerCall2 : public RunFunctionTask<T>
922	{
923	public:
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	}
931	private:
932	T (Class::*fn)(Param1, Param2);
933	Class *object;
934	Arg1 arg1; Arg2 arg2;
935	};
936	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
937	struct 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	};
943	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
944	class StoredConstMemberFunctionPointerCall2 : public RunFunctionTask<T>
945	{
946	public:
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	}
954	private:
955	T (Class::*fn)(Param1, Param2) const;
956	Class const *object;
957	Arg1 arg1; Arg2 arg2;
958	};
959	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
960	class VoidStoredConstMemberFunctionPointerCall2 : public RunFunctionTask<T>
961	{
962	public:
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	}
970	private:
971	T (Class::*fn)(Param1, Param2) const;
972	Class const *object;
973	Arg1 arg1; Arg2 arg2;
974	};
975	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
976	struct 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
983	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
984	class StoredNoExceptMemberFunctionCall2 : public RunFunctionTask<T>
985	{
986	public:
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	}
994	private:
995	T (Class::*fn)(Param1, Param2) noexcept;
996	Class object;
997	Arg1 arg1; Arg2 arg2;
998	};
999	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1000	class VoidStoredNoExceptMemberFunctionCall2 : public RunFunctionTask<T>
1001	{
1002	public:
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	}
1010	private:
1011	T (Class::*fn)(Param1, Param2) noexcept;
1012	Class object;
1013	Arg1 arg1; Arg2 arg2;
1014	};
1015	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1016	struct 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	};
1022	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1023	class StoredConstNoExceptMemberFunctionCall2 : public RunFunctionTask<T>
1024	{
1025	public:
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	}
1033	private:
1034	T (Class::*fn)(Param1, Param2) const noexcept;
1035	const Class object;
1036	Arg1 arg1; Arg2 arg2;
1037	};
1038	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1039	class VoidStoredConstNoExceptMemberFunctionCall2 : public RunFunctionTask<T>
1040	{
1041	public:
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	}
1049	private:
1050	T (Class::*fn)(Param1, Param2) const noexcept;
1051	const Class object;
1052	Arg1 arg1; Arg2 arg2;
1053	};
1054	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1055	struct 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	};
1061	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1062	class StoredNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T>
1063	{
1064	public:
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	}
1072	private:
1073	T (Class::*fn)(Param1, Param2) noexcept;
1074	Class *object;
1075	Arg1 arg1; Arg2 arg2;
1076	};
1077	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1078	class VoidStoredNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T>
1079	{
1080	public:
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	}
1088	private:
1089	T (Class::*fn)(Param1, Param2) noexcept;
1090	Class *object;
1091	Arg1 arg1; Arg2 arg2;
1092	};
1093	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1094	struct 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	};
1100	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1101	class StoredConstNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T>
1102	{
1103	public:
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	}
1111	private:
1112	T (Class::*fn)(Param1, Param2) const noexcept;
1113	Class const *object;
1114	Arg1 arg1; Arg2 arg2;
1115	};
1116	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1117	class VoidStoredConstNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T>
1118	{
1119	public:
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	}
1127	private:
1128	T (Class::*fn)(Param1, Param2) const noexcept;
1129	Class const *object;
1130	Arg1 arg1; Arg2 arg2;
1131	};
1132	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
1133	struct 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
1141	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
1142	struct 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
1151	template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
1152	struct 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
1161	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
1162	struct 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
1171	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
1172	struct 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
1181	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
1182	struct 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	};
1188	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1189	class StoredMemberFunctionCall3 : public RunFunctionTask<T>
1190	{
1191	public:
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	}
1199	private:
1200	T (Class::*fn)(Param1, Param2, Param3);
1201	Class object;
1202	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1203	};
1204	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1205	class VoidStoredMemberFunctionCall3 : public RunFunctionTask<T>
1206	{
1207	public:
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	}
1215	private:
1216	T (Class::*fn)(Param1, Param2, Param3);
1217	Class object;
1218	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1219	};
1220	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1221	struct 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	};
1227	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1228	class StoredConstMemberFunctionCall3 : public RunFunctionTask<T>
1229	{
1230	public:
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	}
1238	private:
1239	T (Class::*fn)(Param1, Param2, Param3) const;
1240	const Class object;
1241	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1242	};
1243	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1244	class VoidStoredConstMemberFunctionCall3 : public RunFunctionTask<T>
1245	{
1246	public:
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	}
1254	private:
1255	T (Class::*fn)(Param1, Param2, Param3) const;
1256	const Class object;
1257	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1258	};
1259	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1260	struct 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	};
1266	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1267	class StoredMemberFunctionPointerCall3 : public RunFunctionTask<T>
1268	{
1269	public:
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	}
1277	private:
1278	T (Class::*fn)(Param1, Param2, Param3);
1279	Class *object;
1280	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1281	};
1282	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1283	class VoidStoredMemberFunctionPointerCall3 : public RunFunctionTask<T>
1284	{
1285	public:
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	}
1293	private:
1294	T (Class::*fn)(Param1, Param2, Param3);
1295	Class *object;
1296	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1297	};
1298	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1299	struct 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	};
1305	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1306	class StoredConstMemberFunctionPointerCall3 : public RunFunctionTask<T>
1307	{
1308	public:
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	}
1316	private:
1317	T (Class::*fn)(Param1, Param2, Param3) const;
1318	Class const *object;
1319	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1320	};
1321	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1322	class VoidStoredConstMemberFunctionPointerCall3 : public RunFunctionTask<T>
1323	{
1324	public:
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	}
1332	private:
1333	T (Class::*fn)(Param1, Param2, Param3) const;
1334	Class const *object;
1335	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1336	};
1337	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1338	struct 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
1345	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1346	class StoredNoExceptMemberFunctionCall3 : public RunFunctionTask<T>
1347	{
1348	public:
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	}
1356	private:
1357	T (Class::*fn)(Param1, Param2, Param3) noexcept;
1358	Class object;
1359	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1360	};
1361	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1362	class VoidStoredNoExceptMemberFunctionCall3 : public RunFunctionTask<T>
1363	{
1364	public:
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	}
1372	private:
1373	T (Class::*fn)(Param1, Param2, Param3) noexcept;
1374	Class object;
1375	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1376	};
1377	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1378	struct 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	};
1384	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1385	class StoredConstNoExceptMemberFunctionCall3 : public RunFunctionTask<T>
1386	{
1387	public:
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	}
1395	private:
1396	T (Class::*fn)(Param1, Param2, Param3) const noexcept;
1397	const Class object;
1398	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1399	};
1400	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1401	class VoidStoredConstNoExceptMemberFunctionCall3 : public RunFunctionTask<T>
1402	{
1403	public:
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	}
1411	private:
1412	T (Class::*fn)(Param1, Param2, Param3) const noexcept;
1413	const Class object;
1414	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1415	};
1416	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1417	struct 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	};
1423	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1424	class StoredNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T>
1425	{
1426	public:
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	}
1434	private:
1435	T (Class::*fn)(Param1, Param2, Param3) noexcept;
1436	Class *object;
1437	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1438	};
1439	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1440	class VoidStoredNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T>
1441	{
1442	public:
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	}
1450	private:
1451	T (Class::*fn)(Param1, Param2, Param3) noexcept;
1452	Class *object;
1453	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1454	};
1455	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1456	struct 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	};
1462	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1463	class StoredConstNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T>
1464	{
1465	public:
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	}
1473	private:
1474	T (Class::*fn)(Param1, Param2, Param3) const noexcept;
1475	Class const *object;
1476	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1477	};
1478	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1479	class VoidStoredConstNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T>
1480	{
1481	public:
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	}
1489	private:
1490	T (Class::*fn)(Param1, Param2, Param3) const noexcept;
1491	Class const *object;
1492	Arg1 arg1; Arg2 arg2; Arg3 arg3;
1493	};
1494	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
1495	struct 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
1503	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
1504	struct 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
1513	template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
1514	struct 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
1523	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
1524	struct 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
1533	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
1534	struct 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
1543	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
1544	struct 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	};
1550	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1551	class StoredMemberFunctionCall4 : public RunFunctionTask<T>
1552	{
1553	public:
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	}
1561	private:
1562	T (Class::*fn)(Param1, Param2, Param3, Param4);
1563	Class object;
1564	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1565	};
1566	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1567	class VoidStoredMemberFunctionCall4 : public RunFunctionTask<T>
1568	{
1569	public:
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	}
1577	private:
1578	T (Class::*fn)(Param1, Param2, Param3, Param4);
1579	Class object;
1580	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1581	};
1582	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1583	struct 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	};
1589	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1590	class StoredConstMemberFunctionCall4 : public RunFunctionTask<T>
1591	{
1592	public:
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	}
1600	private:
1601	T (Class::*fn)(Param1, Param2, Param3, Param4) const;
1602	const Class object;
1603	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1604	};
1605	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1606	class VoidStoredConstMemberFunctionCall4 : public RunFunctionTask<T>
1607	{
1608	public:
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	}
1616	private:
1617	T (Class::*fn)(Param1, Param2, Param3, Param4) const;
1618	const Class object;
1619	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1620	};
1621	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1622	struct 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	};
1628	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1629	class StoredMemberFunctionPointerCall4 : public RunFunctionTask<T>
1630	{
1631	public:
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	}
1639	private:
1640	T (Class::*fn)(Param1, Param2, Param3, Param4);
1641	Class *object;
1642	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1643	};
1644	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1645	class VoidStoredMemberFunctionPointerCall4 : public RunFunctionTask<T>
1646	{
1647	public:
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	}
1655	private:
1656	T (Class::*fn)(Param1, Param2, Param3, Param4);
1657	Class *object;
1658	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1659	};
1660	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1661	struct 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	};
1667	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1668	class StoredConstMemberFunctionPointerCall4 : public RunFunctionTask<T>
1669	{
1670	public:
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	}
1678	private:
1679	T (Class::*fn)(Param1, Param2, Param3, Param4) const;
1680	Class const *object;
1681	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1682	};
1683	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1684	class VoidStoredConstMemberFunctionPointerCall4 : public RunFunctionTask<T>
1685	{
1686	public:
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	}
1694	private:
1695	T (Class::*fn)(Param1, Param2, Param3, Param4) const;
1696	Class const *object;
1697	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1698	};
1699	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1700	struct 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
1707	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1708	class StoredNoExceptMemberFunctionCall4 : public RunFunctionTask<T>
1709	{
1710	public:
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	}
1718	private:
1719	T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept;
1720	Class object;
1721	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1722	};
1723	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1724	class VoidStoredNoExceptMemberFunctionCall4 : public RunFunctionTask<T>
1725	{
1726	public:
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	}
1734	private:
1735	T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept;
1736	Class object;
1737	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1738	};
1739	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1740	struct 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	};
1746	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1747	class StoredConstNoExceptMemberFunctionCall4 : public RunFunctionTask<T>
1748	{
1749	public:
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	}
1757	private:
1758	T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept;
1759	const Class object;
1760	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1761	};
1762	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1763	class VoidStoredConstNoExceptMemberFunctionCall4 : public RunFunctionTask<T>
1764	{
1765	public:
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	}
1773	private:
1774	T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept;
1775	const Class object;
1776	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1777	};
1778	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1779	struct 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	};
1785	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1786	class StoredNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T>
1787	{
1788	public:
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	}
1796	private:
1797	T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept;
1798	Class *object;
1799	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1800	};
1801	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1802	class VoidStoredNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T>
1803	{
1804	public:
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	}
1812	private:
1813	T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept;
1814	Class *object;
1815	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1816	};
1817	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1818	struct 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	};
1824	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1825	class StoredConstNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T>
1826	{
1827	public:
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	}
1835	private:
1836	T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept;
1837	Class const *object;
1838	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1839	};
1840	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1841	class VoidStoredConstNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T>
1842	{
1843	public:
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	}
1851	private:
1852	T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept;
1853	Class const *object;
1854	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
1855	};
1856	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
1857	struct 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
1865	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1866	struct 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
1875	template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1876	struct 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
1885	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1886	struct 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
1895	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1896	struct 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
1905	template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
1906	struct 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	};
1912	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1913	class StoredMemberFunctionCall5 : public RunFunctionTask<T>
1914	{
1915	public:
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	}
1923	private:
1924	T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
1925	Class object;
1926	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1927	};
1928	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1929	class VoidStoredMemberFunctionCall5 : public RunFunctionTask<T>
1930	{
1931	public:
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	}
1939	private:
1940	T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
1941	Class object;
1942	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
1943	};
1944	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1945	struct 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	};
1951	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1952	class StoredConstMemberFunctionCall5 : public RunFunctionTask<T>
1953	{
1954	public:
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	}
1962	private:
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	};
1967	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1968	class VoidStoredConstMemberFunctionCall5 : public RunFunctionTask<T>
1969	{
1970	public:
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	}
1978	private:
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	};
1983	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1984	struct 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	};
1990	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
1991	class StoredMemberFunctionPointerCall5 : public RunFunctionTask<T>
1992	{
1993	public:
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	}
2001	private:
2002	T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
2003	Class *object;
2004	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
2005	};
2006	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2007	class VoidStoredMemberFunctionPointerCall5 : public RunFunctionTask<T>
2008	{
2009	public:
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	}
2017	private:
2018	T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
2019	Class *object;
2020	Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
2021	};
2022	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2023	struct 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	};
2029	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2030	class StoredConstMemberFunctionPointerCall5 : public RunFunctionTask<T>
2031	{
2032	public:
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	}
2040	private:
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	};
2045	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2046	class VoidStoredConstMemberFunctionPointerCall5 : public RunFunctionTask<T>
2047	{
2048	public:
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	}
2056	private:
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	};
2061	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2062	struct 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
2069	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2070	class StoredNoExceptMemberFunctionCall5 : public RunFunctionTask<T>
2071	{
2072	public:
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	}
2080	private:
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	};
2085	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2086	class VoidStoredNoExceptMemberFunctionCall5 : public RunFunctionTask<T>
2087	{
2088	public:
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	}
2096	private:
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	};
2101	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2102	struct 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	};
2108	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2109	class StoredConstNoExceptMemberFunctionCall5 : public RunFunctionTask<T>
2110	{
2111	public:
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	}
2119	private:
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	};
2124	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2125	class VoidStoredConstNoExceptMemberFunctionCall5 : public RunFunctionTask<T>
2126	{
2127	public:
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	}
2135	private:
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	};
2140	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2141	struct 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	};
2147	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2148	class StoredNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T>
2149	{
2150	public:
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	}
2158	private:
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	};
2163	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2164	class VoidStoredNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T>
2165	{
2166	public:
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	}
2174	private:
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	};
2179	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2180	struct 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	};
2186	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2187	class StoredConstNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T>
2188	{
2189	public:
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	}
2197	private:
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	};
2202	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2203	class VoidStoredConstNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T>
2204	{
2205	public:
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	}
2213	private:
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	};
2218	template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
2219	struct 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
2227	template <typename T, typename Functor>
2228	class StoredFunctorCall : public RunFunctionTask<T>
2229	{
2230	public:
2231	StoredFunctorCall(const Functor &f) : functor(f) { }
2232	void runFunctor() override
2233	{
2234	this->result = functor();
2235	}
2236	private:
2237	Functor functor;
2238	};
2239	template <typename Functor>
2240	class StoredFunctorCall<void, Functor> : public RunFunctionTask<void>
2241	{
2242	public:
2243	StoredFunctorCall(const Functor &f) : functor(f) { }
2244	void runFunctor() override
2245	{
2246	functor();
2247	}
2248	private:
2249	Functor functor;
2250	};
2251
2252
2253	} //namespace QtConcurrent
2254
2255	#endif // Q_QDOC
2256
2257	QT_END_NAMESPACE
2258
2259	#endif // QT_NO_CONCURRENT
2260
2261	#endif
2262