You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1329 lines
55 KiB
1329 lines
55 KiB
/****************************************************************************
|
|
**
|
|
** 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
|