Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

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

Last change on this file since 7242 was 7242, checked in by landauf, 14 years ago
small changes regarding the return type of createFunctor() to compile with msvc
Property svn:eol-style set to `native`
File size: 34.6 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/Debug.h"
37	#include "util/MultiType.h"
38	#include "FunctorPtr.h"
39
40	namespace orxonox
41	{
42	const unsigned int MAX_FUNCTOR_ARGUMENTS = 5;
43
44	template <class T>
45	inline std::string _typeToString() { return "unknown"; }
46
47	template <> inline std::string _typeToString<void>() { return ""; }
48	template <> inline std::string _typeToString<int>() { return "int"; }
49	template <> inline std::string _typeToString<unsigned int>() { return "uint"; }
50	template <> inline std::string _typeToString<char>() { return "char"; }
51	template <> inline std::string _typeToString<unsigned char>() { return "uchar"; }
52	template <> inline std::string _typeToString<short>() { return "short"; }
53	template <> inline std::string _typeToString<unsigned short>() { return "ushort"; }
54	template <> inline std::string _typeToString<long>() { return "long"; }
55	template <> inline std::string _typeToString<unsigned long>() { return "ulong"; }
56	template <> inline std::string _typeToString<long long>() { return "longlong"; }
57	template <> inline std::string _typeToString<unsigned long long>() { return "ulonglong"; }
58	template <> inline std::string _typeToString<float>() { return "float"; }
59	template <> inline std::string _typeToString<double>() { return "double"; }
60	template <> inline std::string _typeToString<long double>() { return "longdouble"; }
61	template <> inline std::string _typeToString<bool>() { return "bool"; }
62	template <> inline std::string _typeToString<std::string>() { return "string"; }
63	template <> inline std::string _typeToString<Vector2>() { return "Vector2"; }
64	template <> inline std::string _typeToString<Vector3>() { return "Vector3"; }
65	template <> inline std::string _typeToString<Quaternion>() { return "Quaternion"; }
66	template <> inline std::string _typeToString<ColourValue>() { return "ColourValue"; }
67	template <> inline std::string _typeToString<Radian>() { return "Radian"; }
68	template <> inline std::string _typeToString<Degree>() { return "Degree"; }
69
70	template <class T>
71	inline std::string typeToString() { return _typeToString<typename Loki::TypeTraits<T>::UnqualifiedReferredType>(); }
72
73	class _CoreExport Functor
74	{
75	public:
76	struct Type
77	{
78	enum Enum
79	{
80	Static,
81	Member
82	};
83	};
84
85	public:
86	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;
87
88	virtual Type::Enum getType() const = 0;
89	virtual unsigned int getParamCount() const = 0;
90	virtual bool hasReturnvalue() const = 0;
91
92	virtual std::string getTypenameParam(unsigned int param) const = 0;
93	virtual std::string getTypenameReturnvalue() const = 0;
94
95	virtual void evaluateParam(unsigned int index, MultiType& param) const = 0;
96
97	virtual void setRawObjectPointer(void* object) {}
98	virtual void* getRawObjectPointer() const { return 0; }
99
100	template <class F>
101	inline bool setFunction(F* function)
102	{
103	if (this->getFullIdentifier() == typeid(F*))
104	{
105	modifyFunctor(this, function);
106	return true;
107	}
108	return false;
109	}
110
111	virtual const std::type_info& getFullIdentifier() const = 0;
112	virtual const std::type_info& getHeaderIdentifier() const = 0;
113	virtual const std::type_info& getHeaderIdentifier(unsigned int params) const = 0;
114	};
115
116	namespace detail
117	{
118	template <class O>
119	struct FunctorTypeStatic
120	{ enum { result = false }; };
121	template <>
122	struct FunctorTypeStatic<void>
123	{ enum { result = true }; };
124	}
125
126	template <class O>
127	class FunctorMember : public Functor
128	{
129	public:
130	FunctorMember(O* object = 0) : object_(object) {}
131
132	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;
133
134	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)
135	{
136	if (detail::FunctorTypeStatic<O>::result \|\| this->object_)
137	return (*this)(this->object_, param1, param2, param3, param4, param5);
138	else
139	{
140	COUT(1) << "Error: Can't execute FunctorMember, no object set." << std::endl;
141	return MT_Type::Null;
142	}
143	}
144
145	Functor::Type::Enum getType() const
146	{ return detail::FunctorTypeStatic<O>::result ? Functor::Type::Static : Functor::Type::Member; }
147
148	inline void setObject(O* object)
149	{ this->object_ = object;}
150	inline O* getObject() const
151	{ return this->object_; }
152
153	inline void setRawObjectPointer(void* object)
154	{ this->object_ = (O*)object; }
155	inline void* getRawObjectPointer() const
156	{ return this->object_; }
157
158	protected:
159	O* object_;
160	};
161
162	typedef FunctorMember<void> FunctorStatic;
163
164	template <class F, class O = void>
165	class FunctorPointer : public FunctorMember<O>
166	{
167	public:
168	FunctorPointer(F functionPointer, O* object = 0) : FunctorMember<O>(object), functionPointer_(functionPointer) {}
169
170	inline void setFunction(F functionPointer)
171	{ this->functionPointer_ = functionPointer; }
172	inline F getFunction() const
173	{ return this->functionPointer_; }
174
175	const std::type_info& getFullIdentifier() const
176	{ return typeid(F); }
177
178	protected:
179	F functionPointer_;
180	};
181
182	namespace detail
183	{
184	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); };
185	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); };
186	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); };
187	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); };
188	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); };
189	template <class R, class O, class P1> struct FunctionPointer<R, O, false, P1, void, void, void, void> { typedef R (O::*Type)(P1); };
190	template <class R, class O> struct FunctionPointer<R, O, false, void, void, void, void, void> { typedef R (O::*Type)(); };
191	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; };
192	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; };
193	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; };
194	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; };
195	template <class R, class O, class P1> struct FunctionPointer<R, O, true, P1, void, void, void, void> { typedef R (O::*Type)(P1) const; };
196	template <class R, class O> struct FunctionPointer<R, O, true, void, void, void, void, void> { typedef R (O::*Type)() const; };
197	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); };
198	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); };
199	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); };
200	template <class R, class P1, class P2> struct FunctionPointer<R, void, false, P1, P2, void, void, void> { typedef R (*Type)(P1, P2); };
201	template <class R, class P1> struct FunctionPointer<R, void, false, P1, void, void, void, void> { typedef R (*Type)(P1); };
202	template <class R> struct FunctionPointer<R, void, false, void, void, void, void, void> { typedef R (*Type)(); };
203
204	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); } };
205	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); } };
206	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); } };
207	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); } };
208	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); } };
209	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)(); } };
210	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; } };
211	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; } };
212	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; } };
213	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; } };
214	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; } };
215	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; } };
216	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); } };
217	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); } };
218	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); } };
219	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); } };
220	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); } };
221	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)(); } };
222	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; } };
223	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; } };
224	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; } };
225	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; } };
226	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; } };
227	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; } };
228
229	template <class R, class P1, class P2, class P3, class P4, class P5>
230	struct FunctorHeaderIdentifier
231	{};
232
233	template <class T>
234	struct FunctorHasReturnvalue
235	{ enum { result = true }; };
236	template <>
237	struct FunctorHasReturnvalue<void>
238	{ enum { result = false }; };
239
240	template <class P1, class P2, class P3, class P4, class P5>
241	struct FunctorParamCount
242	{ enum { result = 5 }; };
243	template <class P1, class P2, class P3, class P4>
244	struct FunctorParamCount<P1, P2, P3, P4, void>
245	{ enum { result = 4 }; };
246	template <class P1, class P2, class P3>
247	struct FunctorParamCount<P1, P2, P3, void, void>
248	{ enum { result = 3 }; };
249	template <class P1, class P2>
250	struct FunctorParamCount<P1, P2, void, void, void>
251	{ enum { result = 2 }; };
252	template <class P1>
253	struct FunctorParamCount<P1, void, void, void, void>
254	{ enum { result = 1 }; };
255	template <>
256	struct FunctorParamCount<void, void, void, void, void>
257	{ enum { result = 0 }; };
258	}
259
260	template <class R, class O, bool isconst, class P1, class P2, class P3, class P4, class P5>
261	class FunctorTemplate : public FunctorPointer<typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type, O>
262	{
263	public:
264	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) {}
265
266	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)
267	{
268	return detail::FunctorCaller<R, O, isconst, P1, P2, P3, P4, P5>::call(this->functionPointer_, object, param1, param2, param3, param4, param5);
269	}
270
271	void evaluateParam(unsigned int index, MultiType& param) const
272	{
273	switch (index)
274	{
275	case 0: param.convert<P1>(); break;
276	case 1: param.convert<P2>(); break;
277	case 2: param.convert<P3>(); break;
278	case 3: param.convert<P4>(); break;
279	case 4: param.convert<P5>(); break;
280	}
281	}
282
283	unsigned int getParamCount() const
284	{
285	return detail::FunctorParamCount<P1, P2, P3, P4, P5>::result;
286	}
287
288	bool hasReturnvalue() const
289	{
290	return detail::FunctorHasReturnvalue<R>::result;
291	}
292
293	std::string getTypenameParam(unsigned int param) const
294	{
295	switch (param)
296	{
297	case 0: return typeToString<P1>();
298	case 1: return typeToString<P2>();
299	case 2: return typeToString<P3>();
300	case 3: return typeToString<P4>();
301	case 4: return typeToString<P5>();
302	default: return "";
303	}
304	}
305
306	std::string getTypenameReturnvalue() const
307	{
308	return typeToString<R>();
309	}
310
311	const std::type_info& getHeaderIdentifier() const
312	{
313	return typeid(detail::FunctorHeaderIdentifier<R, P1, P2, P3, P4, P5>);
314	}
315
316	const std::type_info& getHeaderIdentifier(unsigned int params) const
317	{
318	switch (params)
319	{
320	case 0: return typeid(detail::FunctorHeaderIdentifier<R, void, void, void, void, void>);
321	case 1: return typeid(detail::FunctorHeaderIdentifier<R, P1, void, void, void, void>);
322	case 2: return typeid(detail::FunctorHeaderIdentifier<R, P1, P2, void, void, void>);
323	case 3: return typeid(detail::FunctorHeaderIdentifier<R, P1, P2, P3, void, void>);
324	case 4: return typeid(detail::FunctorHeaderIdentifier<R, P1, P2, P3, P4, void>);
325	default: return typeid(detail::FunctorHeaderIdentifier<R, P1, P2, P3, P4, P5>);
326	}
327	}
328	};
329
330	template <class R, class O, class OO, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<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); }
331	template <class R, class O, class OO, class P1, class P2, class P3, class P4> inline FunctorMemberPtr<O> createFunctor(R (O::functionPointer)(P1, P2, P3, P4), OO object) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, void>(functionPointer, object); }
332	template <class R, class O, class OO, class P1, class P2, class P3> inline FunctorMemberPtr<O> createFunctor(R (O::functionPointer)(P1, P2, P3), OO object) { return new FunctorTemplate<R, O, false, P1, P2, P3, void, void>(functionPointer, object); }
333	template <class R, class O, class OO, class P1, class P2> inline FunctorMemberPtr<O> createFunctor(R (O::functionPointer)(P1, P2), OO object) { return new FunctorTemplate<R, O, false, P1, P2, void, void, void>(functionPointer, object); }
334	template <class R, class O, class OO, class P1> inline FunctorMemberPtr<O> createFunctor(R (O::functionPointer)(P1), OO object) { return new FunctorTemplate<R, O, false, P1, void, void, void, void>(functionPointer, object); }
335	template <class R, class O, class OO> inline FunctorMemberPtr<O> createFunctor(R (O::functionPointer)(), OO object) { return new FunctorTemplate<R, O, false, void, void, void, void, void>(functionPointer, object); }
336	template <class R, class O, class OO, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<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); }
337	template <class R, class O, class OO, class P1, class P2, class P3, class P4> inline FunctorMemberPtr<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); }
338	template <class R, class O, class OO, class P1, class P2, class P3> inline FunctorMemberPtr<O> createFunctor(R (O::functionPointer)(P1, P2, P3) const, OO object) { return new FunctorTemplate<R, O, true, P1, P2, P3, void, void>(functionPointer, object); }
339	template <class R, class O, class OO, class P1, class P2> inline FunctorMemberPtr<O> createFunctor(R (O::functionPointer)(P1, P2) const, OO object) { return new FunctorTemplate<R, O, true, P1, P2, void, void, void>(functionPointer, object); }
340	template <class R, class O, class OO, class P1> inline FunctorMemberPtr<O> createFunctor(R (O::functionPointer)(P1) const, OO object) { return new FunctorTemplate<R, O, true, P1, void, void, void, void>(functionPointer, object); }
341	template <class R, class O, class OO> inline FunctorMemberPtr<O> createFunctor(R (O::functionPointer)() const, OO object) { return new FunctorTemplate<R, O, true, void, void, void, void, void>(functionPointer, object); }
342
343	template <class R, class O, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5)) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>(functionPointer); }
344	template <class R, class O, class P1, class P2, class P3, class P4> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4)) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, void>(functionPointer); }
345	template <class R, class O, class P1, class P2, class P3> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3)) { return new FunctorTemplate<R, O, false, P1, P2, P3, void, void>(functionPointer); }
346	template <class R, class O, class P1, class P2> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2)) { return new FunctorTemplate<R, O, false, P1, P2, void, void, void>(functionPointer); }
347	template <class R, class O, class P1> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1)) { return new FunctorTemplate<R, O, false, P1, void, void, void, void>(functionPointer); }
348	template <class R, class O> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)()) { return new FunctorTemplate<R, O, false, void, void, void, void, void>(functionPointer); }
349	template <class R, class O, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5) const) { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>(functionPointer); }
350	template <class R, class O, class P1, class P2, class P3, class P4> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4) const) { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, void>(functionPointer); }
351	template <class R, class O, class P1, class P2, class P3> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3) const) { return new FunctorTemplate<R, O, true, P1, P2, P3, void, void>(functionPointer); }
352	template <class R, class O, class P1, class P2> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2) const) { return new FunctorTemplate<R, O, true, P1, P2, void, void, void>(functionPointer); }
353	template <class R, class O, class P1> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1) const) { return new FunctorTemplate<R, O, true, P1, void, void, void, void>(functionPointer); }
354	template <class R, class O> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)() const) { return new FunctorTemplate<R, O, true, void, void, void, void, void>(functionPointer); }
355
356	template <class R, class P1, class P2, class P3, class P4, class P5> inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3, P4, P5)) { return new FunctorTemplate<R, void, false, P1, P2, P3, P4, P5>(functionPointer); }
357	template <class R, class P1, class P2, class P3, class P4> inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3, P4)) { return new FunctorTemplate<R, void, false, P1, P2, P3, P4, void>(functionPointer); }
358	template <class R, class P1, class P2, class P3> inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3)) { return new FunctorTemplate<R, void, false, P1, P2, P3, void, void>(functionPointer); }
359	template <class R, class P1, class P2> inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2)) { return new FunctorTemplate<R, void, false, P1, P2, void, void, void>(functionPointer); }
360	template <class R, class P1> inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1)) { return new FunctorTemplate<R, void, false, P1, void, void, void, void>(functionPointer); }
361	template <class R> inline FunctorStaticPtr createFunctor(R (*functionPointer)()) { return new FunctorTemplate<R, void, false, void, void, void, void, void>(functionPointer); }
362	}
363
364	#endif /* _Functor_H__ */

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

Download in other formats: