diff options
Diffstat (limited to 'qtinterface/qt4/Qt/qtconcurrentstoredfunctioncall.h')
| -rw-r--r-- | qtinterface/qt4/Qt/qtconcurrentstoredfunctioncall.h | 1328 |
1 files changed, 1328 insertions, 0 deletions
diff --git a/qtinterface/qt4/Qt/qtconcurrentstoredfunctioncall.h b/qtinterface/qt4/Qt/qtconcurrentstoredfunctioncall.h new file mode 100644 index 0000000..182f1ff --- /dev/null +++ b/qtinterface/qt4/Qt/qtconcurrentstoredfunctioncall.h @@ -0,0 +1,1328 @@ +/**************************************************************************** +** +** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial Usage +** Licensees holding valid Qt Commercial licenses may use this file in +** accordance with the Qt Commercial License Agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Nokia. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// Generated code, do not edit! Use generator at tools/qtconcurrent/generaterun/ +#ifndef QTCONCURRENT_STOREDFUNCTIONCALL_H +#define QTCONCURRENT_STOREDFUNCTIONCALL_H + +#include <QtCore/qglobal.h> + +#ifndef QT_NO_CONCURRENT +#include <QtCore/qtconcurrentrunbase.h> + +QT_BEGIN_HEADER +QT_BEGIN_NAMESPACE + +QT_MODULE(Core) + +#ifndef qdoc + +namespace QtConcurrent { +template <typename T, typename FunctionPointer> +struct StoredFunctorCall0: public RunFunctionTask<T> +{ + inline StoredFunctorCall0(FunctionPointer _function) + : function(_function) {} + void runFunctor() { this->result = function(); } + FunctionPointer function; + +}; + +template <typename T, typename FunctionPointer> +struct VoidStoredFunctorCall0: public RunFunctionTask<T> +{ + inline VoidStoredFunctorCall0(FunctionPointer _function) + : function(_function) {} + void runFunctor() { function(); } + FunctionPointer function; + +}; + +template <typename T, typename FunctionPointer> +struct SelectStoredFunctorCall0 +{ + typedef typename SelectSpecialization<T>::template + Type<StoredFunctorCall0 <T, FunctionPointer>, + VoidStoredFunctorCall0<T, FunctionPointer> >::type type; +}; +template <typename T, typename FunctionPointer> +struct StoredFunctorPointerCall0: public RunFunctionTask<T> +{ + inline StoredFunctorPointerCall0(FunctionPointer * _function) + : function(_function) {} + void runFunctor() { this->result =(*function)(); } + FunctionPointer * function; + +}; + +template <typename T, typename FunctionPointer> +struct VoidStoredFunctorPointerCall0: public RunFunctionTask<T> +{ + inline VoidStoredFunctorPointerCall0(FunctionPointer * _function) + : function(_function) {} + void runFunctor() {(*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() + { + 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() + { + (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() + { + 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() + { + (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() + { + 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() + { + (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() + { + 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() + { + (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; +}; +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() { this->result = function(arg1); } + FunctionPointer function; + Arg1 arg1; +}; + +template <typename T, typename FunctionPointer, typename Arg1> +struct VoidStoredFunctorCall1: public RunFunctionTask<T> +{ + inline VoidStoredFunctorCall1(FunctionPointer _function, const Arg1 &_arg1) + : function(_function), arg1(_arg1) {} + void runFunctor() { function(arg1); } + FunctionPointer function; + Arg1 arg1; +}; + +template <typename T, typename FunctionPointer, typename Arg1> +struct SelectStoredFunctorCall1 +{ + typedef typename SelectSpecialization<T>::template + Type<StoredFunctorCall1 <T, FunctionPointer, Arg1>, + VoidStoredFunctorCall1<T, FunctionPointer, Arg1> >::type type; +}; +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() { 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() {(*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() + { + 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() + { + (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() + { + 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() + { + (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() + { + 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() + { + (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() + { + 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() + { + (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; +}; +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() { this->result = function(arg1, arg2); } + FunctionPointer function; + Arg1 arg1; Arg2 arg2; +}; + +template <typename T, typename FunctionPointer, typename Arg1, typename Arg2> +struct VoidStoredFunctorCall2: public RunFunctionTask<T> +{ + inline VoidStoredFunctorCall2(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2) + : function(_function), arg1(_arg1), arg2(_arg2) {} + void runFunctor() { function(arg1, arg2); } + FunctionPointer function; + Arg1 arg1; Arg2 arg2; +}; + +template <typename T, typename FunctionPointer, typename Arg1, typename Arg2> +struct SelectStoredFunctorCall2 +{ + typedef typename SelectSpecialization<T>::template + Type<StoredFunctorCall2 <T, FunctionPointer, Arg1, Arg2>, + VoidStoredFunctorCall2<T, FunctionPointer, Arg1, Arg2> >::type type; +}; +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() { 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() {(*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() + { + 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() + { + (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() + { + 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() + { + (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() + { + 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() + { + (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() + { + 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() + { + (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; +}; +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() { 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 VoidStoredFunctorCall3: public RunFunctionTask<T> +{ + inline VoidStoredFunctorCall3(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3) + : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {} + void runFunctor() { function(arg1, arg2, arg3); } + FunctionPointer function; + Arg1 arg1; Arg2 arg2; Arg3 arg3; +}; + +template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3> +struct SelectStoredFunctorCall3 +{ + typedef typename SelectSpecialization<T>::template + Type<StoredFunctorCall3 <T, FunctionPointer, Arg1, Arg2, Arg3>, + VoidStoredFunctorCall3<T, FunctionPointer, Arg1, Arg2, Arg3> >::type type; +}; +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() { 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() {(*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() + { + 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() + { + (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() + { + 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() + { + (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() + { + 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() + { + (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() + { + 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() + { + (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; +}; +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() { 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 VoidStoredFunctorCall4: public RunFunctionTask<T> +{ + inline VoidStoredFunctorCall4(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() { 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 SelectStoredFunctorCall4 +{ + typedef typename SelectSpecialization<T>::template + Type<StoredFunctorCall4 <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4>, + VoidStoredFunctorCall4<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4> >::type type; +}; +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() { 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() {(*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() + { + 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() + { + (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() + { + 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() + { + (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() + { + 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() + { + (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() + { + 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() + { + (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; +}; +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() { 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 VoidStoredFunctorCall5: public RunFunctionTask<T> +{ + inline VoidStoredFunctorCall5(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() { 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 SelectStoredFunctorCall5 +{ + typedef typename SelectSpecialization<T>::template + Type<StoredFunctorCall5 <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5>, + VoidStoredFunctorCall5<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5> >::type type; +}; +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() { 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() {(*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() + { + 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() + { + (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() + { + 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() + { + (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() + { + 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() + { + (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() + { + 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() + { + (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; +}; +} //namespace QtConcurrent + +#endif // qdoc + +QT_END_NAMESPACE +QT_END_HEADER + +#endif // QT_NO_CONCURRENT + +#endif |