/**************************************************************************** | |
** | |
** Copyright (C) 2011 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$ | |
** GNU Lesser General Public License Usage | |
** 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. | |
** | |
** Other Usage | |
** Alternatively, this file may be used in accordance with the terms and | |
** conditions contained in a signed written agreement between you and Nokia. | |
** | |
** | |
** | |
** | |
** | |
** $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 |