Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/branches/consolecommands3/src/libraries/core/command/Functor.h @ 7212

Last change on this file since 7212 was 7212, checked in by landauf, 14 years ago
re-implemented Functor - without macros!
Property svn:eol-style set to `native`
File size: 38.8 KB

Line
1	/*
2	* ORXONOX - the hottest 3D action shooter ever to exist
3	* > www.orxonox.net <
4	*
5	*
6	* License notice:
7	*
8	* This program is free software; you can redistribute it and/or
9	* modify it under the terms of the GNU General Public License
10	* as published by the Free Software Foundation; either version 2
11	* of the License, or (at your option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21	*
22	* Author:
23	* Fabian 'x3n' Landau
24	* Co-authors:
25	* ...
26	*
27	*/
28
29	#ifndef _Functor_H__
30	#define _Functor_H__
31
32	#include <typeinfo>
33
34	#include "core/CorePrereqs.h"
35
36	#include "util/Convert.h"
37	#include "util/Debug.h"
38	#include "util/MultiType.h"
39	#include "FunctorPtr.h"
40
41	namespace orxonox
42	{
43	const unsigned int MAX_FUNCTOR_ARGUMENTS = 5;
44
45	template <class T>
46	inline std::string _typeToString() { return "unknown"; }
47
48	template <> inline std::string _typeToString<void>() { return ""; }
49	template <> inline std::string _typeToString<int>() { return "int"; }
50	template <> inline std::string _typeToString<unsigned int>() { return "uint"; }
51	template <> inline std::string _typeToString<char>() { return "char"; }
52	template <> inline std::string _typeToString<unsigned char>() { return "uchar"; }
53	template <> inline std::string _typeToString<short>() { return "short"; }
54	template <> inline std::string _typeToString<unsigned short>() { return "ushort"; }
55	template <> inline std::string _typeToString<long>() { return "long"; }
56	template <> inline std::string _typeToString<unsigned long>() { return "ulong"; }
57	template <> inline std::string _typeToString<long long>() { return "longlong"; }
58	template <> inline std::string _typeToString<unsigned long long>() { return "ulonglong"; }
59	template <> inline std::string _typeToString<float>() { return "float"; }
60	template <> inline std::string _typeToString<double>() { return "double"; }
61	template <> inline std::string _typeToString<long double>() { return "longdouble"; }
62	template <> inline std::string _typeToString<bool>() { return "bool"; }
63	template <> inline std::string _typeToString<std::string>() { return "string"; }
64	template <> inline std::string _typeToString<Vector2>() { return "Vector2"; }
65	template <> inline std::string _typeToString<Vector3>() { return "Vector3"; }
66	template <> inline std::string _typeToString<Quaternion>() { return "Quaternion"; }
67	template <> inline std::string _typeToString<ColourValue>() { return "ColourValue"; }
68	template <> inline std::string _typeToString<Radian>() { return "Radian"; }
69	template <> inline std::string _typeToString<Degree>() { return "Degree"; }
70
71	template <class T>
72	inline std::string typeToString() { return _typeToString<typename Loki::TypeTraits<T>::UnqualifiedReferredType>(); }
73
74	class _CoreExport Functor
75	{
76	public:
77	struct Type
78	{
79	enum Enum
80	{
81	Static,
82	Member
83	};
84	};
85
86	public:
87	virtual MultiType operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
88
89	virtual Type::Enum getType() const = 0;
90	virtual unsigned int getParamCount() const = 0;
91	virtual bool hasReturnvalue() const = 0;
92
93	virtual std::string getTypenameParam(unsigned int param) const = 0;
94	virtual std::string getTypenameReturnvalue() const = 0;
95
96	virtual void evaluateParam(unsigned int index, MultiType& param) const = 0;
97
98	virtual void setRawObjectPointer(void* object) {}
99	virtual void* getRawObjectPointer() const { return 0; }
100
101	template <class F>
102	inline bool setFunction(F* function)
103	{
104	if (this->getFullIdentifier() == typeid(F*))
105	{
106	modifyFunctor(this, function);
107	return true;
108	}
109	return false;
110	}
111
112	virtual const std::type_info& getFullIdentifier() const = 0;
113	virtual const std::type_info& getHeaderIdentifier() const = 0;
114	};
115
116	template <class O>
117	class FunctorMember : public Functor
118	{
119	public:
120	FunctorMember(O* object = 0) : object_(object) {}
121
122	virtual MultiType operator()(O* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
123
124	MultiType operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null)
125	{
126	if (this->object_)
127	return (*this)(this->object_, param1, param2, param3, param4, param5);
128	else
129	{
130	COUT(1) << "Error: Can't execute FunctorMember, no object set." << std::endl;
131	return MT_Type::Null;
132	}
133	}
134
135	Functor::Type::Enum getType() const
136	{ return Functor::Type::Member; }
137
138	inline void setObject(O* object)
139	{ this->object_ = object;}
140	inline O* getObject() const
141	{ return this->object_; }
142
143	inline void setRawObjectPointer(void* object)
144	{ this->object_ = (O*)object; }
145	inline void* getRawObjectPointer() const
146	{ return this->object_; }
147
148	protected:
149	O* object_;
150	};
151
152	template <>
153	class _CoreExport FunctorMember<void> : public Functor
154	{
155	public:
156	FunctorMember(void* = 0) {}
157
158	virtual MultiType operator()(void* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
159
160	MultiType operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null)
161	{
162	return (*this)(0, param1, param2, param3, param4, param5);
163	}
164
165	Functor::Type::Enum getType() const
166	{ return Functor::Type::Static; }
167	};
168
169	typedef FunctorMember<void> FunctorStatic;
170
171	template <class F, class O>
172	class FunctorPointer : public FunctorMember<O>
173	{
174	public:
175	FunctorPointer(F functionPointer, O* object = 0) : FunctorMember<O>(object), functionPointer_(functionPointer) {}
176
177	inline void setFunction(F functionPointer)
178	{ this->functionPointer_ = functionPointer; }
179	inline F getFunction() const
180	{ return this->functionPointer_; }
181
182	const std::type_info& getFullIdentifier() const
183	{ return typeid(F); }
184
185	protected:
186	F functionPointer_;
187	};
188
189	namespace detail
190	{
191	template <class R, class O, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctionPointer { typedef R (O::*Type)(P1, P2, P3, P4, P5); };
192	template <class R, class O, class P1, class P2, class P3, class P4, class P5> struct FunctionPointer<R, O, false, P1, P2, P3, P4, P5> { typedef R (O::*Type)(P1, P2, P3, P4, P5); };
193	template <class R, class O, class P1, class P2, class P3, class P4> struct FunctionPointer<R, O, false, P1, P2, P3, P4, void> { typedef R (O::*Type)(P1, P2, P3, P4); };
194	template <class R, class O, class P1, class P2, class P3> struct FunctionPointer<R, O, false, P1, P2, P3, void, void> { typedef R (O::*Type)(P1, P2, P3); };
195	template <class R, class O, class P1, class P2> struct FunctionPointer<R, O, false, P1, P2, void, void, void> { typedef R (O::*Type)(P1, P2); };
196	template <class R, class O, class P1> struct FunctionPointer<R, O, false, P1, void, void, void, void> { typedef R (O::*Type)(P1); };
197	template <class R, class O> struct FunctionPointer<R, O, false, void, void, void, void, void> { typedef R (O::*Type)(); };
198	template <class R, class O, class P1, class P2, class P3, class P4, class P5> struct FunctionPointer<R, O, true, P1, P2, P3, P4, P5> { typedef R (O::*Type)(P1, P2, P3, P4, P5) const; };
199	template <class R, class O, class P1, class P2, class P3, class P4> struct FunctionPointer<R, O, true, P1, P2, P3, P4, void> { typedef R (O::*Type)(P1, P2, P3, P4) const; };
200	template <class R, class O, class P1, class P2, class P3> struct FunctionPointer<R, O, true, P1, P2, P3, void, void> { typedef R (O::*Type)(P1, P2, P3) const; };
201	template <class R, class O, class P1, class P2> struct FunctionPointer<R, O, true, P1, P2, void, void, void> { typedef R (O::*Type)(P1, P2) const; };
202	template <class R, class O, class P1> struct FunctionPointer<R, O, true, P1, void, void, void, void> { typedef R (O::*Type)(P1) const; };
203	template <class R, class O> struct FunctionPointer<R, O, true, void, void, void, void, void> { typedef R (O::*Type)() const; };
204	template <class R, class P1, class P2, class P3, class P4, class P5> struct FunctionPointer<R, void, false, P1, P2, P3, P4, P5> { typedef R (*Type)(P1, P2, P3, P4, P5); };
205	template <class R, class P1, class P2, class P3, class P4> struct FunctionPointer<R, void, false, P1, P2, P3, P4, void> { typedef R (*Type)(P1, P2, P3, P4); };
206	template <class R, class P1, class P2, class P3> struct FunctionPointer<R, void, false, P1, P2, P3, void, void> { typedef R (*Type)(P1, P2, P3); };
207	template <class R, class P1, class P2> struct FunctionPointer<R, void, false, P1, P2, void, void, void> { typedef R (*Type)(P1, P2); };
208	template <class R, class P1> struct FunctionPointer<R, void, false, P1, void, void, void, void> { typedef R (*Type)(P1); };
209	template <class R> struct FunctionPointer<R, void, false, void, void, void, void, void> { typedef R (*Type)(); };
210
211	template <class R, class O, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(param1, param2, param3, param4, param5); } };
212	template <class R, class O, bool isconst, class P1, class P2, class P3, class P4> struct FunctorCaller<R, O, isconst, P1, P2, P3, P4, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(param1, param2, param3, param4); } };
213	template <class R, class O, bool isconst, class P1, class P2, class P3> struct FunctorCaller<R, O, isconst, P1, P2, P3, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(param1, param2, param3); } };
214	template <class R, class O, bool isconst, class P1, class P2> struct FunctorCaller<R, O, isconst, P1, P2, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(param1, param2); } };
215	template <class R, class O, bool isconst, class P1> struct FunctorCaller<R, O, isconst, P1, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(param1); } };
216	template <class R, class O, bool isconst> struct FunctorCaller<R, O, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, void, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(); } };
217	template <class O, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, P5> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1, param2, param3, param4, param5); return MT_Type::Null; } };
218	template <class O, bool isconst, class P1, class P2, class P3, class P4> struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1, param2, param3, param4); return MT_Type::Null; } };
219	template <class O, bool isconst, class P1, class P2, class P3> struct FunctorCaller<void, O, isconst, P1, P2, P3, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1, param2, param3); return MT_Type::Null; } };
220	template <class O, bool isconst, class P1, class P2> struct FunctorCaller<void, O, isconst, P1, P2, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1, param2); return MT_Type::Null; } };
221	template <class O, bool isconst, class P1> struct FunctorCaller<void, O, isconst, P1, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1); return MT_Type::Null; } };
222	template <class O, bool isconst> struct FunctorCaller<void, O, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, void, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(); return MT_Type::Null; } };
223	template <class R, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<R, void, isconst, P1, P2, P3, P4, P5> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, P4, P5>::Type functionPointer, void, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (functionPointer)(param1, param2, param3, param4, param5); } };
224	template <class R, bool isconst, class P1, class P2, class P3, class P4> struct FunctorCaller<R, void, isconst, P1, P2, P3, P4, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, P4, void>::Type functionPointer, void, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (functionPointer)(param1, param2, param3, param4); } };
225	template <class R, bool isconst, class P1, class P2, class P3> struct FunctorCaller<R, void, isconst, P1, P2, P3, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, void, void>::Type functionPointer, void, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (functionPointer)(param1, param2, param3); } };
226	template <class R, bool isconst, class P1, class P2> struct FunctorCaller<R, void, isconst, P1, P2, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, void, void, void>::Type functionPointer, void, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (functionPointer)(param1, param2); } };
227	template <class R, bool isconst, class P1> struct FunctorCaller<R, void, isconst, P1, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, void, void, void, void>::Type functionPointer, void, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (functionPointer)(param1); } };
228	template <class R, bool isconst> struct FunctorCaller<R, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, void, void, void, void, void>::Type functionPointer, void, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (functionPointer)(); } };
229	template <bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, P5> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, P5>::Type functionPointer, void, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (functionPointer)(param1, param2, param3, param4, param5); return MT_Type::Null; } };
230	template <bool isconst, class P1, class P2, class P3, class P4> struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, void>::Type functionPointer, void, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (functionPointer)(param1, param2, param3, param4); return MT_Type::Null; } };
231	template <bool isconst, class P1, class P2, class P3> struct FunctorCaller<void, void, isconst, P1, P2, P3, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, void, void>::Type functionPointer, void, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (functionPointer)(param1, param2, param3); return MT_Type::Null; } };
232	template <bool isconst, class P1, class P2> struct FunctorCaller<void, void, isconst, P1, P2, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, void, void, void>::Type functionPointer, void, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (functionPointer)(param1, param2); return MT_Type::Null; } };
233	template <bool isconst, class P1> struct FunctorCaller<void, void, isconst, P1, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, void, void, void, void>::Type functionPointer, void, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (functionPointer)(param1); return MT_Type::Null; } };
234	template <bool isconst> struct FunctorCaller<void, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, void, void, void, void, void>::Type functionPointer, void, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (functionPointer)(); return MT_Type::Null; } };
235
236	template <class R, class P1, class P2, class P3, class P4, class P5>
237	struct FunctorHeaderIdentifier
238	{};
239
240	template <typename T>
241	struct FunctorHasReturnvalue
242	{ enum { result = true }; };
243	template <>
244	struct FunctorHasReturnvalue<void>
245	{ enum { result = false }; };
246
247	template <class P1, class P2, class P3, class P4, class P5>
248	struct FunctorParamCount
249	{ enum { result = 5 }; };
250	template <class P1, class P2, class P3, class P4>
251	struct FunctorParamCount<P1, P2, P3, P4, void>
252	{ enum { result = 4 }; };
253	template <class P1, class P2, class P3>
254	struct FunctorParamCount<P1, P2, P3, void, void>
255	{ enum { result = 3 }; };
256	template <class P1, class P2>
257	struct FunctorParamCount<P1, P2, void, void, void>
258	{ enum { result = 2 }; };
259	template <class P1>
260	struct FunctorParamCount<P1, void, void, void, void>
261	{ enum { result = 1 }; };
262	template <>
263	struct FunctorParamCount<void, void, void, void, void>
264	{ enum { result = 0 }; };
265	}
266
267	template <class R, class O, bool isconst, class P1, class P2, class P3, class P4, class P5>
268	class FunctorTemplate : public FunctorPointer<typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type, O>
269	{
270	public:
271	FunctorTemplate(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object = 0) : FunctorPointer<typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type, O>(functionPointer, object) {}
272
273	MultiType operator()(O* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null)
274	{
275	return detail::FunctorCaller<R, O, isconst, P1, P2, P3, P4, P5>::call(this->functionPointer_, object, param1, param2, param3, param4, param5);
276	}
277
278	void evaluateParam(unsigned int index, MultiType& param) const
279	{
280	switch (index)
281	{
282	case 0: param.convert<P1>(); break;
283	case 1: param.convert<P2>(); break;
284	case 2: param.convert<P3>(); break;
285	case 3: param.convert<P4>(); break;
286	case 4: param.convert<P5>(); break;
287	}
288	}
289
290	unsigned int getParamCount() const
291	{
292	return detail::FunctorParamCount<P1, P2, P3, P4, P5>::result;
293	}
294
295	bool hasReturnvalue() const
296	{
297	return detail::FunctorHasReturnvalue<R>::result;
298	}
299
300	std::string getTypenameParam(unsigned int param) const
301	{
302	switch (param)
303	{
304	case 0: return typeToString<P1>();
305	case 1: return typeToString<P2>();
306	case 2: return typeToString<P3>();
307	case 3: return typeToString<P4>();
308	case 4: return typeToString<P5>();
309	default: return "";
310	}
311	}
312
313	std::string getTypenameReturnvalue() const
314	{
315	return typeToString<R>();
316	}
317
318	const std::type_info& getHeaderIdentifier() const
319	{
320	return typeid(detail::FunctorHeaderIdentifier<R, P1, P2, P3, P4, P5>);
321	}
322	};
323
324	template <class R, class O, class OO, class P1, class P2, class P3, class P4, class P5> SharedChildPtr<FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, false, P1, P2, P3, P4, P5>::Type, O> > createFunctor(R (O::functionPointer)(P1, P2, P3, P4, P5), OO object) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>(functionPointer, object); }
325	template <class R, class O, class OO, class P1, class P2, class P3, class P4> SharedChildPtr<FunctorTemplate<R, O, false, P1, P2, P3, P4, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, false, P1, P2, P3, P4, void>::Type, O> > createFunctor(R (O::functionPointer)(P1, P2, P3, P4), OO object) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, void>(functionPointer, object); }
326	template <class R, class O, class OO, class P1, class P2, class P3> SharedChildPtr<FunctorTemplate<R, O, false, P1, P2, P3, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, false, P1, P2, P3, void, void>::Type, O> > createFunctor(R (O::functionPointer)(P1, P2, P3), OO object) { return new FunctorTemplate<R, O, false, P1, P2, P3, void, void>(functionPointer, object); }
327	template <class R, class O, class OO, class P1, class P2> SharedChildPtr<FunctorTemplate<R, O, false, P1, P2, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, false, P1, P2, void, void, void>::Type, O> > createFunctor(R (O::functionPointer)(P1, P2), OO object) { return new FunctorTemplate<R, O, false, P1, P2, void, void, void>(functionPointer, object); }
328	template <class R, class O, class OO, class P1> SharedChildPtr<FunctorTemplate<R, O, false, P1, void, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, false, P1, void, void, void, void>::Type, O> > createFunctor(R (O::functionPointer)(P1), OO object) { return new FunctorTemplate<R, O, false, P1, void, void, void, void>(functionPointer, object); }
329	template <class R, class O, class OO> SharedChildPtr<FunctorTemplate<R, O, false, void, void, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, false, void, void, void, void, void>::Type, O> > createFunctor(R (O::functionPointer)(), OO object) { return new FunctorTemplate<R, O, false, void, void, void, void, void>(functionPointer, object); }
330	template <class R, class O, class OO, class P1, class P2, class P3, class P4, class P5> SharedChildPtr<FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, true, P1, P2, P3, P4, P5>::Type, O> > createFunctor(R (O::functionPointer)(P1, P2, P3, P4, P5) const, OO object) { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>(functionPointer, object); }
331	template <class R, class O, class OO, class P1, class P2, class P3, class P4> SharedChildPtr<FunctorTemplate<R, O, true, P1, P2, P3, P4, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, true, P1, P2, P3, P4, void>::Type, O> > createFunctor(R (O::functionPointer)(P1, P2, P3, P4) const, OO object) { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, void>(functionPointer, object); }
332	template <class R, class O, class OO, class P1, class P2, class P3> SharedChildPtr<FunctorTemplate<R, O, true, P1, P2, P3, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, true, P1, P2, P3, void, void>::Type, O> > createFunctor(R (O::functionPointer)(P1, P2, P3) const, OO object) { return new FunctorTemplate<R, O, true, P1, P2, P3, void, void>(functionPointer, object); }
333	template <class R, class O, class OO, class P1, class P2> SharedChildPtr<FunctorTemplate<R, O, true, P1, P2, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, true, P1, P2, void, void, void>::Type, O> > createFunctor(R (O::functionPointer)(P1, P2) const, OO object) { return new FunctorTemplate<R, O, true, P1, P2, void, void, void>(functionPointer, object); }
334	template <class R, class O, class OO, class P1> SharedChildPtr<FunctorTemplate<R, O, true, P1, void, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, true, P1, void, void, void, void>::Type, O> > createFunctor(R (O::functionPointer)(P1) const, OO object) { return new FunctorTemplate<R, O, true, P1, void, void, void, void>(functionPointer, object); }
335	template <class R, class O, class OO> SharedChildPtr<FunctorTemplate<R, O, true, void, void, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, true, void, void, void, void, void>::Type, O> > createFunctor(R (O::functionPointer)() const, OO object) { return new FunctorTemplate<R, O, true, void, void, void, void, void>(functionPointer, object); }
336
337	template <class R, class O, class P1, class P2, class P3, class P4, class P5> SharedChildPtr<FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, false, P1, P2, P3, P4, P5>::Type, O> > createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5)) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>(functionPointer); }
338	template <class R, class O, class P1, class P2, class P3, class P4> SharedChildPtr<FunctorTemplate<R, O, false, P1, P2, P3, P4, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, false, P1, P2, P3, P4, void>::Type, O> > createFunctor(R (O::*functionPointer)(P1, P2, P3, P4)) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, void>(functionPointer); }
339	template <class R, class O, class P1, class P2, class P3> SharedChildPtr<FunctorTemplate<R, O, false, P1, P2, P3, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, false, P1, P2, P3, void, void>::Type, O> > createFunctor(R (O::*functionPointer)(P1, P2, P3)) { return new FunctorTemplate<R, O, false, P1, P2, P3, void, void>(functionPointer); }
340	template <class R, class O, class P1, class P2> SharedChildPtr<FunctorTemplate<R, O, false, P1, P2, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, false, P1, P2, void, void, void>::Type, O> > createFunctor(R (O::*functionPointer)(P1, P2)) { return new FunctorTemplate<R, O, false, P1, P2, void, void, void>(functionPointer); }
341	template <class R, class O, class P1> SharedChildPtr<FunctorTemplate<R, O, false, P1, void, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, false, P1, void, void, void, void>::Type, O> > createFunctor(R (O::*functionPointer)(P1)) { return new FunctorTemplate<R, O, false, P1, void, void, void, void>(functionPointer); }
342	template <class R, class O> SharedChildPtr<FunctorTemplate<R, O, false, void, void, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, false, void, void, void, void, void>::Type, O> > createFunctor(R (O::*functionPointer)()) { return new FunctorTemplate<R, O, false, void, void, void, void, void>(functionPointer); }
343	template <class R, class O, class P1, class P2, class P3, class P4, class P5> SharedChildPtr<FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, true, P1, P2, P3, P4, P5>::Type, O> > createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5) const) { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>(functionPointer); }
344	template <class R, class O, class P1, class P2, class P3, class P4> SharedChildPtr<FunctorTemplate<R, O, true, P1, P2, P3, P4, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, true, P1, P2, P3, P4, void>::Type, O> > createFunctor(R (O::*functionPointer)(P1, P2, P3, P4) const) { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, void>(functionPointer); }
345	template <class R, class O, class P1, class P2, class P3> SharedChildPtr<FunctorTemplate<R, O, true, P1, P2, P3, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, true, P1, P2, P3, void, void>::Type, O> > createFunctor(R (O::*functionPointer)(P1, P2, P3) const) { return new FunctorTemplate<R, O, true, P1, P2, P3, void, void>(functionPointer); }
346	template <class R, class O, class P1, class P2> SharedChildPtr<FunctorTemplate<R, O, true, P1, P2, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, true, P1, P2, void, void, void>::Type, O> > createFunctor(R (O::*functionPointer)(P1, P2) const) { return new FunctorTemplate<R, O, true, P1, P2, void, void, void>(functionPointer); }
347	template <class R, class O, class P1> SharedChildPtr<FunctorTemplate<R, O, true, P1, void, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, true, P1, void, void, void, void>::Type, O> > createFunctor(R (O::*functionPointer)(P1) const) { return new FunctorTemplate<R, O, true, P1, void, void, void, void>(functionPointer); }
348	template <class R, class O> SharedChildPtr<FunctorTemplate<R, O, true, void, void, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, O, true, void, void, void, void, void>::Type, O> > createFunctor(R (O::*functionPointer)() const) { return new FunctorTemplate<R, O, true, void, void, void, void, void>(functionPointer); }
349
350	template <class R, class P1, class P2, class P3, class P4, class P5> SharedChildPtr<FunctorTemplate<R, void, false, P1, P2, P3, P4, P5>, FunctorPointerPtr<typename detail::FunctionPointer<R, void, false, P1, P2, P3, P4, P5>::Type, void> > createFunctor(R (*functionPointer)(P1, P2, P3, P4, P5)) { return new FunctorTemplate<R, void, false, P1, P2, P3, P4, P5>(functionPointer); }
351	template <class R, class P1, class P2, class P3, class P4> SharedChildPtr<FunctorTemplate<R, void, false, P1, P2, P3, P4, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, void, false, P1, P2, P3, P4, void>::Type, void> > createFunctor(R (*functionPointer)(P1, P2, P3, P4)) { return new FunctorTemplate<R, void, false, P1, P2, P3, P4, void>(functionPointer); }
352	template <class R, class P1, class P2, class P3> SharedChildPtr<FunctorTemplate<R, void, false, P1, P2, P3, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, void, false, P1, P2, P3, void, void>::Type, void> > createFunctor(R (*functionPointer)(P1, P2, P3)) { return new FunctorTemplate<R, void, false, P1, P2, P3, void, void>(functionPointer); }
353	template <class R, class P1, class P2> SharedChildPtr<FunctorTemplate<R, void, false, P1, P2, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, void, false, P1, P2, void, void, void>::Type, void> > createFunctor(R (*functionPointer)(P1, P2)) { return new FunctorTemplate<R, void, false, P1, P2, void, void, void>(functionPointer); }
354	template <class R, class P1> SharedChildPtr<FunctorTemplate<R, void, false, P1, void, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, void, false, P1, void, void, void, void>::Type, void> > createFunctor(R (*functionPointer)(P1)) { return new FunctorTemplate<R, void, false, P1, void, void, void, void>(functionPointer); }
355	template <class R> SharedChildPtr<FunctorTemplate<R, void, false, void, void, void, void, void>, FunctorPointerPtr<typename detail::FunctionPointer<R, void, false, void, void, void, void, void>::Type, void> > createFunctor(R (*functionPointer)()) { return new FunctorTemplate<R, void, false, void, void, void, void, void>(functionPointer); }
356	}
357
358	#endif /* _Functor_H__ */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: