⚝
One Hat Cyber Team
⚝
Your IP:
216.73.216.72
Server IP:
41.128.143.86
Server:
Linux host.raqmix.cloud 6.8.0-1025-azure #30~22.04.1-Ubuntu SMP Wed Mar 12 15:28:20 UTC 2025 x86_64
Server Software:
Apache
PHP Version:
8.3.23
Buat File
|
Buat Folder
Eksekusi
Dir :
~
/
usr
/
include
/
x86_64-linux-gnu
/
qt5
/
QtConcurrent
/
View File Name :
qtconcurrentstoredfunctioncall.h
/**************************************************************************** ** ** Copyright (C) 2016 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the QtConcurrent module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and The Qt Company. For licensing terms ** and conditions see https://www.qt.io/terms-conditions. For further ** information use the contact form at https://www.qt.io/contact-us. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 3 as published by the Free Software ** Foundation and appearing in the file LICENSE.LGPL3 included in the ** packaging of this file. Please review the following information to ** ensure the GNU Lesser General Public License version 3 requirements ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. ** ** GNU General Public License Usage ** Alternatively, this file may be used under the terms of the GNU ** General Public License version 2.0 or (at your option) the GNU General ** Public license version 3 or any later version approved by the KDE Free ** Qt Foundation. The licenses are as published by the Free Software ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 ** included in the packaging of this file. Please review the following ** information to ensure the GNU General Public License requirements will ** be met: https://www.gnu.org/licenses/gpl-2.0.html and ** https://www.gnu.org/licenses/gpl-3.0.html. ** ** $QT_END_LICENSE$ ** ****************************************************************************/ // Generated code, do not edit! Use generator at tools/qtconcurrent/generaterun/ #ifndef QTCONCURRENT_STOREDFUNCTIONCALL_H #define QTCONCURRENT_STOREDFUNCTIONCALL_H #include <QtConcurrent/qtconcurrent_global.h> #ifndef QT_NO_CONCURRENT #include <QtConcurrent/qtconcurrentrunbase.h> QT_BEGIN_NAMESPACE #ifndef Q_QDOC namespace QtConcurrent { template <typename T, typename FunctionPointer> struct StoredFunctorCall0: public RunFunctionTask<T> { inline StoredFunctorCall0(FunctionPointer _function) : function(_function) {} void runFunctor() override { this->result = function(); } FunctionPointer function; }; template <typename FunctionPointer> struct StoredFunctorCall0<void, FunctionPointer>: public RunFunctionTask<void> { inline StoredFunctorCall0(FunctionPointer _function) : function(_function) {} void runFunctor() override { function(); } FunctionPointer function; }; template <typename T, typename FunctionPointer> struct StoredFunctorPointerCall0: public RunFunctionTask<T> { inline StoredFunctorPointerCall0(FunctionPointer * _function) : function(_function) {} void runFunctor() override { this->result =(*function)(); } FunctionPointer * function; }; template <typename T, typename FunctionPointer> struct VoidStoredFunctorPointerCall0: public RunFunctionTask<T> { inline VoidStoredFunctorPointerCall0(FunctionPointer * _function) : function(_function) {} void runFunctor() override { (*function)(); } FunctionPointer * function; }; template <typename T, typename FunctionPointer> struct SelectStoredFunctorPointerCall0 { typedef typename SelectSpecialization<T>::template Type<StoredFunctorPointerCall0 <T, FunctionPointer>, VoidStoredFunctorPointerCall0<T, FunctionPointer> >::type type; }; template <typename T, typename Class> class StoredMemberFunctionCall0 : public RunFunctionTask<T> { public: StoredMemberFunctionCall0(T (Class::*_fn)(), const Class &_object) : fn(_fn), object(_object){ } void runFunctor() override { this->result = (object.*fn)(); } private: T (Class::*fn)(); Class object; }; template <typename T, typename Class> class VoidStoredMemberFunctionCall0 : public RunFunctionTask<T> { public: VoidStoredMemberFunctionCall0(T (Class::*_fn)(), const Class &_object) : fn(_fn), object(_object){ } void runFunctor() override { (object.*fn)(); } private: T (Class::*fn)(); Class object; }; template <typename T, typename Class> struct SelectStoredMemberFunctionCall0 { typedef typename SelectSpecialization<T>::template Type<StoredMemberFunctionCall0 <T, Class>, VoidStoredMemberFunctionCall0<T, Class> >::type type; }; template <typename T, typename Class> class StoredConstMemberFunctionCall0 : public RunFunctionTask<T> { public: StoredConstMemberFunctionCall0(T (Class::*_fn)() const, const Class &_object) : fn(_fn), object(_object){ } void runFunctor() override { this->result = (object.*fn)(); } private: T (Class::*fn)() const; const Class object; }; template <typename T, typename Class> class VoidStoredConstMemberFunctionCall0 : public RunFunctionTask<T> { public: VoidStoredConstMemberFunctionCall0(T (Class::*_fn)() const, const Class &_object) : fn(_fn), object(_object){ } void runFunctor() override { (object.*fn)(); } private: T (Class::*fn)() const; const Class object; }; template <typename T, typename Class> struct SelectStoredConstMemberFunctionCall0 { typedef typename SelectSpecialization<T>::template Type<StoredConstMemberFunctionCall0 <T, Class>, VoidStoredConstMemberFunctionCall0<T, Class> >::type type; }; template <typename T, typename Class> class StoredMemberFunctionPointerCall0 : public RunFunctionTask<T> { public: StoredMemberFunctionPointerCall0(T (Class::*_fn)(), Class *_object) : fn(_fn), object(_object){ } void runFunctor() override { this->result = (object->*fn)(); } private: T (Class::*fn)(); Class *object; }; template <typename T, typename Class> class VoidStoredMemberFunctionPointerCall0 : public RunFunctionTask<T> { public: VoidStoredMemberFunctionPointerCall0(T (Class::*_fn)(), Class *_object) : fn(_fn), object(_object){ } void runFunctor() override { (object->*fn)(); } private: T (Class::*fn)(); Class *object; }; template <typename T, typename Class> struct SelectStoredMemberFunctionPointerCall0 { typedef typename SelectSpecialization<T>::template Type<StoredMemberFunctionPointerCall0 <T, Class>, VoidStoredMemberFunctionPointerCall0<T, Class> >::type type; }; template <typename T, typename Class> class StoredConstMemberFunctionPointerCall0 : public RunFunctionTask<T> { public: StoredConstMemberFunctionPointerCall0(T (Class::*_fn)() const, Class const *_object) : fn(_fn), object(_object){ } void runFunctor() override { this->result = (object->*fn)(); } private: T (Class::*fn)() const; Class const *object; }; template <typename T, typename Class> class VoidStoredConstMemberFunctionPointerCall0 : public RunFunctionTask<T> { public: VoidStoredConstMemberFunctionPointerCall0(T (Class::*_fn)() const, Class const *_object) : fn(_fn), object(_object){ } void runFunctor() override { (object->*fn)(); } private: T (Class::*fn)() const; Class const *object; }; template <typename T, typename Class> struct SelectStoredConstMemberFunctionPointerCall0 { typedef typename SelectSpecialization<T>::template Type<StoredConstMemberFunctionPointerCall0 <T, Class>, VoidStoredConstMemberFunctionPointerCall0<T, Class> >::type type; }; #if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510 template <typename T, typename Class> class StoredNoExceptMemberFunctionCall0 : public RunFunctionTask<T> { public: StoredNoExceptMemberFunctionCall0(T (Class::*_fn)() noexcept, const Class &_object) : fn(_fn), object(_object){ } void runFunctor() override { this->result = (object.*fn)(); } private: T (Class::*fn)() noexcept; Class object; }; template <typename T, typename Class> class VoidStoredNoExceptMemberFunctionCall0 : public RunFunctionTask<T> { public: VoidStoredNoExceptMemberFunctionCall0(T (Class::*_fn)() noexcept, const Class &_object) : fn(_fn), object(_object){ } void runFunctor() override { (object.*fn)(); } private: T (Class::*fn)() noexcept; Class object; }; template <typename T, typename Class> struct SelectStoredNoExceptMemberFunctionCall0 { typedef typename SelectSpecialization<T>::template Type<StoredNoExceptMemberFunctionCall0 <T, Class>, VoidStoredNoExceptMemberFunctionCall0<T, Class> >::type type; }; template <typename T, typename Class> class StoredConstNoExceptMemberFunctionCall0 : public RunFunctionTask<T> { public: StoredConstNoExceptMemberFunctionCall0(T (Class::*_fn)() const noexcept, const Class &_object) : fn(_fn), object(_object){ } void runFunctor() override { this->result = (object.*fn)(); } private: T (Class::*fn)() const noexcept; const Class object; }; template <typename T, typename Class> class VoidStoredConstNoExceptMemberFunctionCall0 : public RunFunctionTask<T> { public: VoidStoredConstNoExceptMemberFunctionCall0(T (Class::*_fn)() const noexcept, const Class &_object) : fn(_fn), object(_object){ } void runFunctor() override { (object.*fn)(); } private: T (Class::*fn)() const noexcept; const Class object; }; template <typename T, typename Class> struct SelectStoredConstNoExceptMemberFunctionCall0 { typedef typename SelectSpecialization<T>::template Type<StoredConstNoExceptMemberFunctionCall0 <T, Class>, VoidStoredConstNoExceptMemberFunctionCall0<T, Class> >::type type; }; template <typename T, typename Class> class StoredNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T> { public: StoredNoExceptMemberFunctionPointerCall0(T (Class::*_fn)() noexcept, Class *_object) : fn(_fn), object(_object){ } void runFunctor() override { this->result = (object->*fn)(); } private: T (Class::*fn)() noexcept; Class *object; }; template <typename T, typename Class> class VoidStoredNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T> { public: VoidStoredNoExceptMemberFunctionPointerCall0(T (Class::*_fn)() noexcept, Class *_object) : fn(_fn), object(_object){ } void runFunctor() override { (object->*fn)(); } private: T (Class::*fn)() noexcept; Class *object; }; template <typename T, typename Class> struct SelectStoredNoExceptMemberFunctionPointerCall0 { typedef typename SelectSpecialization<T>::template Type<StoredNoExceptMemberFunctionPointerCall0 <T, Class>, VoidStoredNoExceptMemberFunctionPointerCall0<T, Class> >::type type; }; template <typename T, typename Class> class StoredConstNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T> { public: StoredConstNoExceptMemberFunctionPointerCall0(T (Class::*_fn)() const noexcept, Class const *_object) : fn(_fn), object(_object){ } void runFunctor() override { this->result = (object->*fn)(); } private: T (Class::*fn)() const noexcept; Class const *object; }; template <typename T, typename Class> class VoidStoredConstNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T> { public: VoidStoredConstNoExceptMemberFunctionPointerCall0(T (Class::*_fn)() const noexcept, Class const *_object) : fn(_fn), object(_object){ } void runFunctor() override { (object->*fn)(); } private: T (Class::*fn)() const noexcept; Class const *object; }; template <typename T, typename Class> struct SelectStoredConstNoExceptMemberFunctionPointerCall0 { typedef typename SelectSpecialization<T>::template Type<StoredConstNoExceptMemberFunctionPointerCall0 <T, Class>, VoidStoredConstNoExceptMemberFunctionPointerCall0<T, Class> >::type type; }; #endif template <typename T, typename FunctionPointer, typename Arg1> struct StoredFunctorCall1: public RunFunctionTask<T> { inline StoredFunctorCall1(FunctionPointer _function, const Arg1 &_arg1) : function(_function), arg1(_arg1) {} void runFunctor() override { this->result = function(arg1); } FunctionPointer function; Arg1 arg1; }; template <typename FunctionPointer, typename Arg1> struct StoredFunctorCall1<void, FunctionPointer, Arg1>: public RunFunctionTask<void> { inline StoredFunctorCall1(FunctionPointer _function, const Arg1 &_arg1) : function(_function), arg1(_arg1) {} void runFunctor() override { function(arg1); } FunctionPointer function; Arg1 arg1; }; template <typename T, typename FunctionPointer, typename Arg1> struct StoredFunctorPointerCall1: public RunFunctionTask<T> { inline StoredFunctorPointerCall1(FunctionPointer * _function, const Arg1 &_arg1) : function(_function), arg1(_arg1) {} void runFunctor() override { this->result =(*function)(arg1); } FunctionPointer * function; Arg1 arg1; }; template <typename T, typename FunctionPointer, typename Arg1> struct VoidStoredFunctorPointerCall1: public RunFunctionTask<T> { inline VoidStoredFunctorPointerCall1(FunctionPointer * _function, const Arg1 &_arg1) : function(_function), arg1(_arg1) {} void runFunctor() override { (*function)(arg1); } FunctionPointer * function; Arg1 arg1; }; template <typename T, typename FunctionPointer, typename Arg1> struct SelectStoredFunctorPointerCall1 { typedef typename SelectSpecialization<T>::template Type<StoredFunctorPointerCall1 <T, FunctionPointer, Arg1>, VoidStoredFunctorPointerCall1<T, FunctionPointer, Arg1> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1> class StoredMemberFunctionCall1 : public RunFunctionTask<T> { public: StoredMemberFunctionCall1(T (Class::*_fn)(Param1), const Class &_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { this->result = (object.*fn)(arg1); } private: T (Class::*fn)(Param1); Class object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> class VoidStoredMemberFunctionCall1 : public RunFunctionTask<T> { public: VoidStoredMemberFunctionCall1(T (Class::*_fn)(Param1), const Class &_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { (object.*fn)(arg1); } private: T (Class::*fn)(Param1); Class object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> struct SelectStoredMemberFunctionCall1 { typedef typename SelectSpecialization<T>::template Type<StoredMemberFunctionCall1 <T, Class, Param1, Arg1>, VoidStoredMemberFunctionCall1<T, Class, Param1, Arg1> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1> class StoredConstMemberFunctionCall1 : public RunFunctionTask<T> { public: StoredConstMemberFunctionCall1(T (Class::*_fn)(Param1) const, const Class &_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { this->result = (object.*fn)(arg1); } private: T (Class::*fn)(Param1) const; const Class object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> class VoidStoredConstMemberFunctionCall1 : public RunFunctionTask<T> { public: VoidStoredConstMemberFunctionCall1(T (Class::*_fn)(Param1) const, const Class &_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { (object.*fn)(arg1); } private: T (Class::*fn)(Param1) const; const Class object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> struct SelectStoredConstMemberFunctionCall1 { typedef typename SelectSpecialization<T>::template Type<StoredConstMemberFunctionCall1 <T, Class, Param1, Arg1>, VoidStoredConstMemberFunctionCall1<T, Class, Param1, Arg1> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1> class StoredMemberFunctionPointerCall1 : public RunFunctionTask<T> { public: StoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1), Class *_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { this->result = (object->*fn)(arg1); } private: T (Class::*fn)(Param1); Class *object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> class VoidStoredMemberFunctionPointerCall1 : public RunFunctionTask<T> { public: VoidStoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1), Class *_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { (object->*fn)(arg1); } private: T (Class::*fn)(Param1); Class *object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> struct SelectStoredMemberFunctionPointerCall1 { typedef typename SelectSpecialization<T>::template Type<StoredMemberFunctionPointerCall1 <T, Class, Param1, Arg1>, VoidStoredMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1> class StoredConstMemberFunctionPointerCall1 : public RunFunctionTask<T> { public: StoredConstMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const, Class const *_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { this->result = (object->*fn)(arg1); } private: T (Class::*fn)(Param1) const; Class const *object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> class VoidStoredConstMemberFunctionPointerCall1 : public RunFunctionTask<T> { public: VoidStoredConstMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const, Class const *_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { (object->*fn)(arg1); } private: T (Class::*fn)(Param1) const; Class const *object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> struct SelectStoredConstMemberFunctionPointerCall1 { typedef typename SelectSpecialization<T>::template Type<StoredConstMemberFunctionPointerCall1 <T, Class, Param1, Arg1>, VoidStoredConstMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type; }; #if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510 template <typename T, typename Class, typename Param1, typename Arg1> class StoredNoExceptMemberFunctionCall1 : public RunFunctionTask<T> { public: StoredNoExceptMemberFunctionCall1(T (Class::*_fn)(Param1) noexcept, const Class &_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { this->result = (object.*fn)(arg1); } private: T (Class::*fn)(Param1) noexcept; Class object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> class VoidStoredNoExceptMemberFunctionCall1 : public RunFunctionTask<T> { public: VoidStoredNoExceptMemberFunctionCall1(T (Class::*_fn)(Param1) noexcept, const Class &_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { (object.*fn)(arg1); } private: T (Class::*fn)(Param1) noexcept; Class object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> struct SelectStoredNoExceptMemberFunctionCall1 { typedef typename SelectSpecialization<T>::template Type<StoredNoExceptMemberFunctionCall1 <T, Class, Param1, Arg1>, VoidStoredNoExceptMemberFunctionCall1<T, Class, Param1, Arg1> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1> class StoredConstNoExceptMemberFunctionCall1 : public RunFunctionTask<T> { public: StoredConstNoExceptMemberFunctionCall1(T (Class::*_fn)(Param1) const noexcept, const Class &_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { this->result = (object.*fn)(arg1); } private: T (Class::*fn)(Param1) const noexcept; const Class object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> class VoidStoredConstNoExceptMemberFunctionCall1 : public RunFunctionTask<T> { public: VoidStoredConstNoExceptMemberFunctionCall1(T (Class::*_fn)(Param1) const noexcept, const Class &_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { (object.*fn)(arg1); } private: T (Class::*fn)(Param1) const noexcept; const Class object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> struct SelectStoredConstNoExceptMemberFunctionCall1 { typedef typename SelectSpecialization<T>::template Type<StoredConstNoExceptMemberFunctionCall1 <T, Class, Param1, Arg1>, VoidStoredConstNoExceptMemberFunctionCall1<T, Class, Param1, Arg1> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1> class StoredNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T> { public: StoredNoExceptMemberFunctionPointerCall1(T (Class::*_fn)(Param1) noexcept, Class *_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { this->result = (object->*fn)(arg1); } private: T (Class::*fn)(Param1) noexcept; Class *object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> class VoidStoredNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T> { public: VoidStoredNoExceptMemberFunctionPointerCall1(T (Class::*_fn)(Param1) noexcept, Class *_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { (object->*fn)(arg1); } private: T (Class::*fn)(Param1) noexcept; Class *object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> struct SelectStoredNoExceptMemberFunctionPointerCall1 { typedef typename SelectSpecialization<T>::template Type<StoredNoExceptMemberFunctionPointerCall1 <T, Class, Param1, Arg1>, VoidStoredNoExceptMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1> class StoredConstNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T> { public: StoredConstNoExceptMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const noexcept, Class const *_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { this->result = (object->*fn)(arg1); } private: T (Class::*fn)(Param1) const noexcept; Class const *object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> class VoidStoredConstNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T> { public: VoidStoredConstNoExceptMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const noexcept, Class const *_object, const Arg1 &_arg1) : fn(_fn), object(_object), arg1(_arg1){ } void runFunctor() override { (object->*fn)(arg1); } private: T (Class::*fn)(Param1) const noexcept; Class const *object; Arg1 arg1; }; template <typename T, typename Class, typename Param1, typename Arg1> struct SelectStoredConstNoExceptMemberFunctionPointerCall1 { typedef typename SelectSpecialization<T>::template Type<StoredConstNoExceptMemberFunctionPointerCall1 <T, Class, Param1, Arg1>, VoidStoredConstNoExceptMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type; }; #endif template <typename T, typename FunctionPointer, typename Arg1, typename Arg2> struct StoredFunctorCall2: public RunFunctionTask<T> { inline StoredFunctorCall2(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2) : function(_function), arg1(_arg1), arg2(_arg2) {} void runFunctor() override { this->result = function(arg1, arg2); } FunctionPointer function; Arg1 arg1; Arg2 arg2; }; template <typename FunctionPointer, typename Arg1, typename Arg2> struct StoredFunctorCall2<void, FunctionPointer, Arg1, Arg2>: public RunFunctionTask<void> { inline StoredFunctorCall2(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2) : function(_function), arg1(_arg1), arg2(_arg2) {} void runFunctor() override { function(arg1, arg2); } FunctionPointer function; Arg1 arg1; Arg2 arg2; }; template <typename T, typename FunctionPointer, typename Arg1, typename Arg2> struct StoredFunctorPointerCall2: public RunFunctionTask<T> { inline StoredFunctorPointerCall2(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2) : function(_function), arg1(_arg1), arg2(_arg2) {} void runFunctor() override { this->result =(*function)(arg1, arg2); } FunctionPointer * function; Arg1 arg1; Arg2 arg2; }; template <typename T, typename FunctionPointer, typename Arg1, typename Arg2> struct VoidStoredFunctorPointerCall2: public RunFunctionTask<T> { inline VoidStoredFunctorPointerCall2(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2) : function(_function), arg1(_arg1), arg2(_arg2) {} void runFunctor() override { (*function)(arg1, arg2); } FunctionPointer * function; Arg1 arg1; Arg2 arg2; }; template <typename T, typename FunctionPointer, typename Arg1, typename Arg2> struct SelectStoredFunctorPointerCall2 { typedef typename SelectSpecialization<T>::template Type<StoredFunctorPointerCall2 <T, FunctionPointer, Arg1, Arg2>, VoidStoredFunctorPointerCall2<T, FunctionPointer, Arg1, Arg2> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class StoredMemberFunctionCall2 : public RunFunctionTask<T> { public: StoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2); Class object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class VoidStoredMemberFunctionCall2 : public RunFunctionTask<T> { public: VoidStoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { (object.*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2); Class object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> struct SelectStoredMemberFunctionCall2 { typedef typename SelectSpecialization<T>::template Type<StoredMemberFunctionCall2 <T, Class, Param1, Arg1, Param2, Arg2>, VoidStoredMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class StoredConstMemberFunctionCall2 : public RunFunctionTask<T> { public: StoredConstMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2) const; const Class object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class VoidStoredConstMemberFunctionCall2 : public RunFunctionTask<T> { public: VoidStoredConstMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { (object.*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2) const; const Class object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> struct SelectStoredConstMemberFunctionCall2 { typedef typename SelectSpecialization<T>::template Type<StoredConstMemberFunctionCall2 <T, Class, Param1, Arg1, Param2, Arg2>, VoidStoredConstMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class StoredMemberFunctionPointerCall2 : public RunFunctionTask<T> { public: StoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2); Class *object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class VoidStoredMemberFunctionPointerCall2 : public RunFunctionTask<T> { public: VoidStoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { (object->*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2); Class *object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> struct SelectStoredMemberFunctionPointerCall2 { typedef typename SelectSpecialization<T>::template Type<StoredMemberFunctionPointerCall2 <T, Class, Param1, Arg1, Param2, Arg2>, VoidStoredMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class StoredConstMemberFunctionPointerCall2 : public RunFunctionTask<T> { public: StoredConstMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2) const; Class const *object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class VoidStoredConstMemberFunctionPointerCall2 : public RunFunctionTask<T> { public: VoidStoredConstMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { (object->*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2) const; Class const *object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> struct SelectStoredConstMemberFunctionPointerCall2 { typedef typename SelectSpecialization<T>::template Type<StoredConstMemberFunctionPointerCall2 <T, Class, Param1, Arg1, Param2, Arg2>, VoidStoredConstMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type; }; #if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class StoredNoExceptMemberFunctionCall2 : public RunFunctionTask<T> { public: StoredNoExceptMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2) noexcept; Class object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class VoidStoredNoExceptMemberFunctionCall2 : public RunFunctionTask<T> { public: VoidStoredNoExceptMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { (object.*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2) noexcept; Class object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> struct SelectStoredNoExceptMemberFunctionCall2 { typedef typename SelectSpecialization<T>::template Type<StoredNoExceptMemberFunctionCall2 <T, Class, Param1, Arg1, Param2, Arg2>, VoidStoredNoExceptMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class StoredConstNoExceptMemberFunctionCall2 : public RunFunctionTask<T> { public: StoredConstNoExceptMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2) const noexcept; const Class object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class VoidStoredConstNoExceptMemberFunctionCall2 : public RunFunctionTask<T> { public: VoidStoredConstNoExceptMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { (object.*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2) const noexcept; const Class object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> struct SelectStoredConstNoExceptMemberFunctionCall2 { typedef typename SelectSpecialization<T>::template Type<StoredConstNoExceptMemberFunctionCall2 <T, Class, Param1, Arg1, Param2, Arg2>, VoidStoredConstNoExceptMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class StoredNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T> { public: StoredNoExceptMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2) noexcept; Class *object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class VoidStoredNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T> { public: VoidStoredNoExceptMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { (object->*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2) noexcept; Class *object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> struct SelectStoredNoExceptMemberFunctionPointerCall2 { typedef typename SelectSpecialization<T>::template Type<StoredNoExceptMemberFunctionPointerCall2 <T, Class, Param1, Arg1, Param2, Arg2>, VoidStoredNoExceptMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class StoredConstNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T> { public: StoredConstNoExceptMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2) const noexcept; Class const *object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> class VoidStoredConstNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T> { public: VoidStoredConstNoExceptMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ } void runFunctor() override { (object->*fn)(arg1, arg2); } private: T (Class::*fn)(Param1, Param2) const noexcept; Class const *object; Arg1 arg1; Arg2 arg2; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2> struct SelectStoredConstNoExceptMemberFunctionPointerCall2 { typedef typename SelectSpecialization<T>::template Type<StoredConstNoExceptMemberFunctionPointerCall2 <T, Class, Param1, Arg1, Param2, Arg2>, VoidStoredConstNoExceptMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type; }; #endif template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3> struct StoredFunctorCall3: public RunFunctionTask<T> { inline StoredFunctorCall3(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {} void runFunctor() override { this->result = function(arg1, arg2, arg3); } FunctionPointer function; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3> struct StoredFunctorCall3<void, FunctionPointer, Arg1, Arg2, Arg3>: public RunFunctionTask<void> { inline StoredFunctorCall3(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {} void runFunctor() override { function(arg1, arg2, arg3); } FunctionPointer function; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3> struct StoredFunctorPointerCall3: public RunFunctionTask<T> { inline StoredFunctorPointerCall3(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {} void runFunctor() override { this->result =(*function)(arg1, arg2, arg3); } FunctionPointer * function; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3> struct VoidStoredFunctorPointerCall3: public RunFunctionTask<T> { inline VoidStoredFunctorPointerCall3(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {} void runFunctor() override { (*function)(arg1, arg2, arg3); } FunctionPointer * function; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3> struct SelectStoredFunctorPointerCall3 { typedef typename SelectSpecialization<T>::template Type<StoredFunctorPointerCall3 <T, FunctionPointer, Arg1, Arg2, Arg3>, VoidStoredFunctorPointerCall3<T, FunctionPointer, Arg1, Arg2, Arg3> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class StoredMemberFunctionCall3 : public RunFunctionTask<T> { public: StoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3); Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class VoidStoredMemberFunctionCall3 : public RunFunctionTask<T> { public: VoidStoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { (object.*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3); Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> struct SelectStoredMemberFunctionCall3 { typedef typename SelectSpecialization<T>::template Type<StoredMemberFunctionCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>, VoidStoredMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class StoredConstMemberFunctionCall3 : public RunFunctionTask<T> { public: StoredConstMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3) const; const Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class VoidStoredConstMemberFunctionCall3 : public RunFunctionTask<T> { public: VoidStoredConstMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { (object.*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3) const; const Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> struct SelectStoredConstMemberFunctionCall3 { typedef typename SelectSpecialization<T>::template Type<StoredConstMemberFunctionCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>, VoidStoredConstMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class StoredMemberFunctionPointerCall3 : public RunFunctionTask<T> { public: StoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3); Class *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class VoidStoredMemberFunctionPointerCall3 : public RunFunctionTask<T> { public: VoidStoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { (object->*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3); Class *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> struct SelectStoredMemberFunctionPointerCall3 { typedef typename SelectSpecialization<T>::template Type<StoredMemberFunctionPointerCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>, VoidStoredMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class StoredConstMemberFunctionPointerCall3 : public RunFunctionTask<T> { public: StoredConstMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3) const; Class const *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class VoidStoredConstMemberFunctionPointerCall3 : public RunFunctionTask<T> { public: VoidStoredConstMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { (object->*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3) const; Class const *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> struct SelectStoredConstMemberFunctionPointerCall3 { typedef typename SelectSpecialization<T>::template Type<StoredConstMemberFunctionPointerCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>, VoidStoredConstMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type; }; #if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class StoredNoExceptMemberFunctionCall3 : public RunFunctionTask<T> { public: StoredNoExceptMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3) noexcept; Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class VoidStoredNoExceptMemberFunctionCall3 : public RunFunctionTask<T> { public: VoidStoredNoExceptMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { (object.*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3) noexcept; Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> struct SelectStoredNoExceptMemberFunctionCall3 { typedef typename SelectSpecialization<T>::template Type<StoredNoExceptMemberFunctionCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>, VoidStoredNoExceptMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class StoredConstNoExceptMemberFunctionCall3 : public RunFunctionTask<T> { public: StoredConstNoExceptMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3) const noexcept; const Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class VoidStoredConstNoExceptMemberFunctionCall3 : public RunFunctionTask<T> { public: VoidStoredConstNoExceptMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { (object.*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3) const noexcept; const Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> struct SelectStoredConstNoExceptMemberFunctionCall3 { typedef typename SelectSpecialization<T>::template Type<StoredConstNoExceptMemberFunctionCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>, VoidStoredConstNoExceptMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class StoredNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T> { public: StoredNoExceptMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3) noexcept; Class *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class VoidStoredNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T> { public: VoidStoredNoExceptMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { (object->*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3) noexcept; Class *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> struct SelectStoredNoExceptMemberFunctionPointerCall3 { typedef typename SelectSpecialization<T>::template Type<StoredNoExceptMemberFunctionPointerCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>, VoidStoredNoExceptMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class StoredConstNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T> { public: StoredConstNoExceptMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3) const noexcept; Class const *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> class VoidStoredConstNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T> { public: VoidStoredConstNoExceptMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ } void runFunctor() override { (object->*fn)(arg1, arg2, arg3); } private: T (Class::*fn)(Param1, Param2, Param3) const noexcept; Class const *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3> struct SelectStoredConstNoExceptMemberFunctionPointerCall3 { typedef typename SelectSpecialization<T>::template Type<StoredConstNoExceptMemberFunctionPointerCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>, VoidStoredConstNoExceptMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type; }; #endif template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4> struct StoredFunctorCall4: public RunFunctionTask<T> { inline StoredFunctorCall4(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {} void runFunctor() override { this->result = function(arg1, arg2, arg3, arg4); } FunctionPointer function; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4> struct StoredFunctorCall4<void, FunctionPointer, Arg1, Arg2, Arg3, Arg4>: public RunFunctionTask<void> { inline StoredFunctorCall4(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {} void runFunctor() override { function(arg1, arg2, arg3, arg4); } FunctionPointer function; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4> struct StoredFunctorPointerCall4: public RunFunctionTask<T> { inline StoredFunctorPointerCall4(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {} void runFunctor() override { this->result =(*function)(arg1, arg2, arg3, arg4); } FunctionPointer * function; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4> struct VoidStoredFunctorPointerCall4: public RunFunctionTask<T> { inline VoidStoredFunctorPointerCall4(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {} void runFunctor() override { (*function)(arg1, arg2, arg3, arg4); } FunctionPointer * function; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4> struct SelectStoredFunctorPointerCall4 { typedef typename SelectSpecialization<T>::template Type<StoredFunctorPointerCall4 <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4>, VoidStoredFunctorPointerCall4<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class StoredMemberFunctionCall4 : public RunFunctionTask<T> { public: StoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4); Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class VoidStoredMemberFunctionCall4 : public RunFunctionTask<T> { public: VoidStoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { (object.*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4); Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> struct SelectStoredMemberFunctionCall4 { typedef typename SelectSpecialization<T>::template Type<StoredMemberFunctionCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>, VoidStoredMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class StoredConstMemberFunctionCall4 : public RunFunctionTask<T> { public: StoredConstMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4) const; const Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class VoidStoredConstMemberFunctionCall4 : public RunFunctionTask<T> { public: VoidStoredConstMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { (object.*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4) const; const Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> struct SelectStoredConstMemberFunctionCall4 { typedef typename SelectSpecialization<T>::template Type<StoredConstMemberFunctionCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>, VoidStoredConstMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class StoredMemberFunctionPointerCall4 : public RunFunctionTask<T> { public: StoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4); Class *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class VoidStoredMemberFunctionPointerCall4 : public RunFunctionTask<T> { public: VoidStoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { (object->*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4); Class *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> struct SelectStoredMemberFunctionPointerCall4 { typedef typename SelectSpecialization<T>::template Type<StoredMemberFunctionPointerCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>, VoidStoredMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class StoredConstMemberFunctionPointerCall4 : public RunFunctionTask<T> { public: StoredConstMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4) const; Class const *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class VoidStoredConstMemberFunctionPointerCall4 : public RunFunctionTask<T> { public: VoidStoredConstMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { (object->*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4) const; Class const *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> struct SelectStoredConstMemberFunctionPointerCall4 { typedef typename SelectSpecialization<T>::template Type<StoredConstMemberFunctionPointerCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>, VoidStoredConstMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type; }; #if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class StoredNoExceptMemberFunctionCall4 : public RunFunctionTask<T> { public: StoredNoExceptMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept; Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class VoidStoredNoExceptMemberFunctionCall4 : public RunFunctionTask<T> { public: VoidStoredNoExceptMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { (object.*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept; Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> struct SelectStoredNoExceptMemberFunctionCall4 { typedef typename SelectSpecialization<T>::template Type<StoredNoExceptMemberFunctionCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>, VoidStoredNoExceptMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class StoredConstNoExceptMemberFunctionCall4 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept; const Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class VoidStoredConstNoExceptMemberFunctionCall4 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { (object.*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept; const Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> struct SelectStoredConstNoExceptMemberFunctionCall4 { typedef typename SelectSpecialization<T>::template Type<StoredConstNoExceptMemberFunctionCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>, VoidStoredConstNoExceptMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class StoredNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T> { public: StoredNoExceptMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept; Class *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class VoidStoredNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T> { public: VoidStoredNoExceptMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { (object->*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept; Class *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> struct SelectStoredNoExceptMemberFunctionPointerCall4 { typedef typename SelectSpecialization<T>::template Type<StoredNoExceptMemberFunctionPointerCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>, VoidStoredNoExceptMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class StoredConstNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept; Class const *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> class VoidStoredConstNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ } void runFunctor() override { (object->*fn)(arg1, arg2, arg3, arg4); } private: T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept; Class const *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; }; template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4> struct SelectStoredConstNoExceptMemberFunctionPointerCall4 { typedef typename SelectSpecialization<T>::template Type<StoredConstNoExceptMemberFunctionPointerCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>, VoidStoredConstNoExceptMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type; }; #endif template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> struct StoredFunctorCall5: public RunFunctionTask<T> { inline StoredFunctorCall5(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5) : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {} void runFunctor() override { this->result = function(arg1, arg2, arg3, arg4, arg5); } FunctionPointer function; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> struct StoredFunctorCall5<void, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5>: public RunFunctionTask<void> { inline StoredFunctorCall5(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5) : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {} void runFunctor() override { function(arg1, arg2, arg3, arg4, arg5); } FunctionPointer function; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> struct StoredFunctorPointerCall5: public RunFunctionTask<T> { inline StoredFunctorPointerCall5(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5) : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {} void runFunctor() override { this->result =(*function)(arg1, arg2, arg3, arg4, arg5); } FunctionPointer * function; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> struct VoidStoredFunctorPointerCall5: public RunFunctionTask<T> { inline VoidStoredFunctorPointerCall5(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5) : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {} void runFunctor() override { (*function)(arg1, arg2, arg3, arg4, arg5); } FunctionPointer * function; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> struct SelectStoredFunctorPointerCall5 { typedef typename SelectSpecialization<T>::template Type<StoredFunctorPointerCall5 <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5>, VoidStoredFunctorPointerCall5<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5> >::type type; }; 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> class StoredMemberFunctionCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5); Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> class VoidStoredMemberFunctionCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { (object.*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5); Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> struct SelectStoredMemberFunctionCall5 { typedef typename SelectSpecialization<T>::template Type<StoredMemberFunctionCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>, VoidStoredMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type; }; 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> class StoredConstMemberFunctionCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const; const Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> class VoidStoredConstMemberFunctionCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { (object.*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const; const Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> struct SelectStoredConstMemberFunctionCall5 { typedef typename SelectSpecialization<T>::template Type<StoredConstMemberFunctionCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>, VoidStoredConstMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type; }; 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> class StoredMemberFunctionPointerCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5); Class *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> class VoidStoredMemberFunctionPointerCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { (object->*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5); Class *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> struct SelectStoredMemberFunctionPointerCall5 { typedef typename SelectSpecialization<T>::template Type<StoredMemberFunctionPointerCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>, VoidStoredMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type; }; 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> class StoredConstMemberFunctionPointerCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const; Class const *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> class VoidStoredConstMemberFunctionPointerCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { (object->*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const; Class const *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> struct SelectStoredConstMemberFunctionPointerCall5 { typedef typename SelectSpecialization<T>::template Type<StoredConstMemberFunctionPointerCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>, VoidStoredConstMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type; }; #if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510 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> class StoredNoExceptMemberFunctionCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept; Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> class VoidStoredNoExceptMemberFunctionCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { (object.*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept; Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> struct SelectStoredNoExceptMemberFunctionCall5 { typedef typename SelectSpecialization<T>::template Type<StoredNoExceptMemberFunctionCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>, VoidStoredNoExceptMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type; }; 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> class StoredConstNoExceptMemberFunctionCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept; const Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> class VoidStoredConstNoExceptMemberFunctionCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { (object.*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept; const Class object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> struct SelectStoredConstNoExceptMemberFunctionCall5 { typedef typename SelectSpecialization<T>::template Type<StoredConstNoExceptMemberFunctionCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>, VoidStoredConstNoExceptMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type; }; 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> class StoredNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept; Class *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> class VoidStoredNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { (object->*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept; Class *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> struct SelectStoredNoExceptMemberFunctionPointerCall5 { typedef typename SelectSpecialization<T>::template Type<StoredNoExceptMemberFunctionPointerCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>, VoidStoredNoExceptMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type; }; 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> class StoredConstNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept; Class const *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> class VoidStoredConstNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T> { public: 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) : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ } void runFunctor() override { (object->*fn)(arg1, arg2, arg3, arg4, arg5); } private: T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept; Class const *object; Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5; }; 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> struct SelectStoredConstNoExceptMemberFunctionPointerCall5 { typedef typename SelectSpecialization<T>::template Type<StoredConstNoExceptMemberFunctionPointerCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>, VoidStoredConstNoExceptMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type; }; #endif template <typename T, typename Functor> class StoredFunctorCall : public RunFunctionTask<T> { public: StoredFunctorCall(const Functor &f) : functor(f) { } void runFunctor() override { this->result = functor(); } private: Functor functor; }; template <typename Functor> class StoredFunctorCall<void, Functor> : public RunFunctionTask<void> { public: StoredFunctorCall(const Functor &f) : functor(f) { } void runFunctor() override { functor(); } private: Functor functor; }; } //namespace QtConcurrent #endif // Q_QDOC QT_END_NAMESPACE #endif // QT_NO_CONCURRENT #endif