Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 7198 was 7198, checked in by landauf, 14 years ago

createFunctor() now returns a SharedPtr instead of a pointer. Adapted code that uses createFunctor() accordingly.
  • Property svn:eol-style set to native
File size: 27.2 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 *   Inspiration: Functor by Benjamin Grauer
28 */
29
30#ifndef _Functor_H__
31#define _Functor_H__
32
33#include <typeinfo>
34
35#include "CorePrereqs.h"
36
37#include "util/Convert.h"
38#include "util/Debug.h"
39#include "util/MultiType.h"
40#include "FunctorPtr.h"
41
42namespace orxonox
43{
44    const unsigned int MAX_FUNCTOR_ARGUMENTS = 5;
45
46    template <class T>
47    inline std::string typeToString() { return "unknown"; }
48
49#define CreateTypeToStringTemplate(type) \
50    template <> \
51    inline std::string typeToString<type>() { return #type; } \
52    template <> \
53    inline std::string typeToString<type&>() { return #type; } \
54    template <> \
55    inline std::string typeToString<const type>() { return #type; } \
56    template <> \
57    inline std::string typeToString<const type&>() { return #type; }
58
59    CreateTypeToStringTemplate(int);
60    CreateTypeToStringTemplate(unsigned int);
61    CreateTypeToStringTemplate(char);
62    CreateTypeToStringTemplate(unsigned char);
63    CreateTypeToStringTemplate(short);
64    CreateTypeToStringTemplate(unsigned short);
65    CreateTypeToStringTemplate(long);
66    CreateTypeToStringTemplate(unsigned long);
67    CreateTypeToStringTemplate(long long);
68    CreateTypeToStringTemplate(unsigned long long);
69    CreateTypeToStringTemplate(float);
70    CreateTypeToStringTemplate(double);
71    CreateTypeToStringTemplate(long double);
72    CreateTypeToStringTemplate(bool);
73    CreateTypeToStringTemplate(Vector2);
74    CreateTypeToStringTemplate(Vector3);
75    CreateTypeToStringTemplate(Quaternion);
76    CreateTypeToStringTemplate(ColourValue);
77    CreateTypeToStringTemplate(Radian);
78    CreateTypeToStringTemplate(Degree);
79
80    template <>
81    inline std::string typeToString<std::string>() { return "string"; }
82    template <>
83    inline std::string typeToString<std::string&>() { return "string"; }
84    template <>
85    inline std::string typeToString<const std::string>() { return "string"; }
86    template <>
87    inline std::string typeToString<const std::string&>() { return "string"; }
88
89    class _CoreExport Functor
90    {
91        public:
92            struct Type
93            {
94                enum Enum
95                {
96                    Member,
97                    ConstMember,
98                    Static,
99                    Lua
100                };
101            };
102
103        public:
104            Functor() { ++instances_s; COUT(0) << "functor ++: " << instances_s << std::endl; }
105            virtual ~Functor() { --instances_s; COUT(0) << "functor --: " << instances_s << std::endl; }
106
107            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;
108
109            virtual Type::Enum getType() const = 0;
110            virtual unsigned int getParamCount() const = 0;
111            virtual bool hasReturnvalue() const = 0;
112
113            virtual std::string getTypenameParam(unsigned int param) const = 0;
114            virtual std::string getTypenameReturnvalue() const = 0;
115
116            virtual void evaluateParam(unsigned int index, MultiType& param) const = 0;
117
118            virtual void setRawObjectPointer(void* object) {}
119            virtual void* getRawObjectPointer() const { return 0; }
120
121            virtual const std::type_info& getHeaderIdentifier() const = 0;
122
123        private:
124            static int instances_s;
125    };
126
127    class _CoreExport FunctorStatic : public Functor
128    {
129        public:
130            virtual ~FunctorStatic() {}
131            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;
132    };
133
134    template <class T>
135    class FunctorMember : public Functor
136    {
137        public:
138            FunctorMember()
139            {
140                this->object_ = 0;
141                this->constObject_ = 0;
142            }
143            virtual ~FunctorMember() {}
144
145            virtual MultiType operator()(T* 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;
146            virtual MultiType operator()(const T* 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;
147
148            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)
149            {
150                if (this->object_)
151                    return (*this)(this->object_, param1, param2, param3, param4, param5);
152                else if (this->constObject_)
153                    return (*this)(this->constObject_, param1, param2, param3, param4, param5);
154                else
155                {
156                    COUT(1) << "An error occurred in Functor.h:" << std::endl;
157                    COUT(1) << "Error: No object set." << std::endl;
158                    return MT_Type::Null;
159                }
160            }
161
162            inline FunctorMember<T>* setObject(T* object)
163            {
164                this->object_ = object;
165                this->constObject_ = 0;
166                return this;
167            }
168
169            inline FunctorMember<T>* setObject(const T* object)
170            {
171                this->object_ = 0;
172                this->constObject_ = object;
173                return this;
174            }
175
176            void setRawObjectPointer(void* object)
177            {
178                this->object_ = (T*)object;
179                this->constObject_ = 0;
180            }
181
182            void* getRawObjectPointer() const
183            {
184                if (this->object_)
185                    return (void*)this->object_;
186                else
187                    return (void*)this->constObject_;
188            }
189
190            typedef std::pair<T*, const T*> Objects;
191
192            inline Objects getObjects() const
193            {
194                return Objects(this->object_, this->constObject_);
195            }
196
197            inline void setObjects(const Objects& objects)
198            {
199                this->object_ = objects.first;
200                this->constObject_ = objects.second;
201            }
202
203        private:
204            T* object_;
205            const T* constObject_;
206    };
207
208
209
210    template <class R, class P1, class P2, class P3, class P4, class P5>
211    struct FunctorHeaderIdentifier {};
212
213
214
215    inline const FunctorPtr& createFunctor(const FunctorPtr& functor)
216    {
217        return functor;
218    }
219
220
221
222#define FUNCTOR_TEMPLATE(ismember, returnvalue, numparams, additionalobject) FUNCTOR_TEMPLATE##ismember##returnvalue##numparams(additionalobject)
223#define FUNCTOR_TEMPLATE000(additionalobject)
224#define FUNCTOR_TEMPLATE001(additionalobject) template <class P1>
225#define FUNCTOR_TEMPLATE002(additionalobject) template <class P1, class P2>
226#define FUNCTOR_TEMPLATE003(additionalobject) template <class P1, class P2, class P3>
227#define FUNCTOR_TEMPLATE004(additionalobject) template <class P1, class P2, class P3, class P4>
228#define FUNCTOR_TEMPLATE005(additionalobject) template <class P1, class P2, class P3, class P4, class P5>
229#define FUNCTOR_TEMPLATE010(additionalobject) template <class R>
230#define FUNCTOR_TEMPLATE011(additionalobject) template <class R, class P1>
231#define FUNCTOR_TEMPLATE012(additionalobject) template <class R, class P1, class P2>
232#define FUNCTOR_TEMPLATE013(additionalobject) template <class R, class P1, class P2, class P3>
233#define FUNCTOR_TEMPLATE014(additionalobject) template <class R, class P1, class P2, class P3, class P4>
234#define FUNCTOR_TEMPLATE015(additionalobject) template <class R, class P1, class P2, class P3, class P4, class P5>
235#define FUNCTOR_TEMPLATE100(additionalobject) template <class T FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
236#define FUNCTOR_TEMPLATE101(additionalobject) template <class T, class P1 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
237#define FUNCTOR_TEMPLATE102(additionalobject) template <class T, class P1, class P2 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
238#define FUNCTOR_TEMPLATE103(additionalobject) template <class T, class P1, class P2, class P3 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
239#define FUNCTOR_TEMPLATE104(additionalobject) template <class T, class P1, class P2, class P3, class P4 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
240#define FUNCTOR_TEMPLATE105(additionalobject) template <class T, class P1, class P2, class P3, class P4, class P5 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
241#define FUNCTOR_TEMPLATE110(additionalobject) template <class T, class R FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
242#define FUNCTOR_TEMPLATE111(additionalobject) template <class T, class R, class P1 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
243#define FUNCTOR_TEMPLATE112(additionalobject) template <class T, class R, class P1, class P2 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
244#define FUNCTOR_TEMPLATE113(additionalobject) template <class T, class R, class P1, class P2, class P3 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
245#define FUNCTOR_TEMPLATE114(additionalobject) template <class T, class R, class P1, class P2, class P3, class P4 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
246#define FUNCTOR_TEMPLATE115(additionalobject) template <class T, class R, class P1, class P2, class P3, class P4, class P5 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
247
248
249
250#define FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT##additionalobject
251#define FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT0
252#define FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT1 , class O
253
254
255
256#define FUNCTOR_TEMPLATE_CLASSES(ismember, returnvalue, numparams) FUNCTOR_TEMPLATE_CLASSES##ismember##returnvalue##numparams
257#define FUNCTOR_TEMPLATE_CLASSES000
258#define FUNCTOR_TEMPLATE_CLASSES001 <P1>
259#define FUNCTOR_TEMPLATE_CLASSES002 <P1, P2>
260#define FUNCTOR_TEMPLATE_CLASSES003 <P1, P2, P3>
261#define FUNCTOR_TEMPLATE_CLASSES004 <P1, P2, P3, P4>
262#define FUNCTOR_TEMPLATE_CLASSES005 <P1, P2, P3, P4, P5>
263#define FUNCTOR_TEMPLATE_CLASSES010 <R>
264#define FUNCTOR_TEMPLATE_CLASSES011 <R, P1>
265#define FUNCTOR_TEMPLATE_CLASSES012 <R, P1, P2>
266#define FUNCTOR_TEMPLATE_CLASSES013 <R, P1, P2, P3>
267#define FUNCTOR_TEMPLATE_CLASSES014 <R, P1, P2, P3, P4>
268#define FUNCTOR_TEMPLATE_CLASSES015 <R, P1, P2, P3, P4, P5>
269#define FUNCTOR_TEMPLATE_CLASSES100 <T>
270#define FUNCTOR_TEMPLATE_CLASSES101 <T, P1>
271#define FUNCTOR_TEMPLATE_CLASSES102 <T, P1, P2>
272#define FUNCTOR_TEMPLATE_CLASSES103 <T, P1, P2, P3>
273#define FUNCTOR_TEMPLATE_CLASSES104 <T, P1, P2, P3, P4>
274#define FUNCTOR_TEMPLATE_CLASSES105 <T, P1, P2, P3, P4, P5>
275#define FUNCTOR_TEMPLATE_CLASSES110 <T, R>
276#define FUNCTOR_TEMPLATE_CLASSES111 <T, R, P1>
277#define FUNCTOR_TEMPLATE_CLASSES112 <T, R, P1, P2>
278#define FUNCTOR_TEMPLATE_CLASSES113 <T, R, P1, P2, P3>
279#define FUNCTOR_TEMPLATE_CLASSES114 <T, R, P1, P2, P3, P4>
280#define FUNCTOR_TEMPLATE_CLASSES115 <T, R, P1, P2, P3, P4, P5>
281
282
283
284#define FUNCTOR_TYPENAME_PARAM(numparams) FUNCTOR_TYPENAME_PARAM##numparams
285#define FUNCTOR_TYPENAME_PARAM0 \
286    return BLANKSTRING
287#define FUNCTOR_TYPENAME_PARAM1 \
288    if (param == 0) { return typeToString<P1>(); } \
289    else { return BLANKSTRING; }
290#define FUNCTOR_TYPENAME_PARAM2 \
291    if (param == 0) { return typeToString<P1>(); } \
292    else if (param == 1) { return typeToString<P2>(); } \
293    else { return BLANKSTRING; }
294#define FUNCTOR_TYPENAME_PARAM3 \
295    if (param == 0) { return typeToString<P1>(); } \
296    else if (param == 1) { return typeToString<P2>(); } \
297    else if (param == 2) { return typeToString<P3>(); } \
298    else { return BLANKSTRING; }
299#define FUNCTOR_TYPENAME_PARAM4 \
300    if (param == 0) { return typeToString<P1>(); } \
301    else if (param == 1) { return typeToString<P2>(); } \
302    else if (param == 2) { return typeToString<P3>(); } \
303    else if (param == 3) { return typeToString<P4>(); } \
304    else { return BLANKSTRING; }
305#define FUNCTOR_TYPENAME_PARAM5 \
306    if (param == 0) { return typeToString<P1>(); } \
307    else if (param == 1) { return typeToString<P2>(); } \
308    else if (param == 2) { return typeToString<P3>(); } \
309    else if (param == 3) { return typeToString<P4>(); } \
310    else if (param == 4) { return typeToString<P5>(); } \
311    else { return BLANKSTRING; }
312
313#define FUNCTOR_TYPENAME_RETURN(returnvalue) FUNCTOR_TYPENAME_RETURN##returnvalue
314#define FUNCTOR_TYPENAME_RETURN0 BLANKSTRING
315#define FUNCTOR_TYPENAME_RETURN1 typeToString<R>()
316
317
318
319#define FUNCTOR_FUNCTION_PARAMS(numparams) FUNCTOR_FUNCTION_PARAMS##numparams
320#define FUNCTOR_FUNCTION_PARAMS0
321#define FUNCTOR_FUNCTION_PARAMS1 P1 param1
322#define FUNCTOR_FUNCTION_PARAMS2 P1 param1, P2 param2
323#define FUNCTOR_FUNCTION_PARAMS3 P1 param1, P2 param2, P3 param3
324#define FUNCTOR_FUNCTION_PARAMS4 P1 param1, P2 param2, P3 param3, P4 param4
325#define FUNCTOR_FUNCTION_PARAMS5 P1 param1, P2 param2, P3 param3, P4 param4, P5 param5
326
327#define FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) FUNCTOR_FUNCTION_RETURNVALUE##returnvalue
328#define FUNCTOR_FUNCTION_RETURNVALUE0 void
329#define FUNCTOR_FUNCTION_RETURNVALUE1 R
330
331
332
333#define FUNCTOR_FUNCTION_CALL(numparams) FUNCTOR_FUNCTION_CALL##numparams
334#define FUNCTOR_FUNCTION_CALL0
335#define FUNCTOR_FUNCTION_CALL1 param1
336#define FUNCTOR_FUNCTION_CALL2 param1, param2
337#define FUNCTOR_FUNCTION_CALL3 param1, param2, param3
338#define FUNCTOR_FUNCTION_CALL4 param1, param2, param3, param4
339#define FUNCTOR_FUNCTION_CALL5 param1, param2, param3, param4, param5
340
341#define FUNCTOR_STORE_RETURNVALUE(returnvalue, functioncall) FUNCTOR_STORE_RETURNVALUE##returnvalue(functioncall)
342#define FUNCTOR_STORE_RETURNVALUE0(functioncall) functioncall; return MT_Type::Null
343#define FUNCTOR_STORE_RETURNVALUE1(functioncall) return functioncall
344
345
346
347#define FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES(returnvalue, numparams) FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES##numparams(returnvalue)
348#define FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES0(returnvalue) <FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES_RETURNVALUE(returnvalue), void, void, void, void, void>
349#define FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES1(returnvalue) <FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES_RETURNVALUE(returnvalue), P1, void, void, void, void>
350#define FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES2(returnvalue) <FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES_RETURNVALUE(returnvalue), P1, P2, void, void, void>
351#define FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES3(returnvalue) <FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES_RETURNVALUE(returnvalue), P1, P2, P3, void, void>
352#define FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES4(returnvalue) <FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES_RETURNVALUE(returnvalue), P1, P2, P3, P4, void>
353#define FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES5(returnvalue) <FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES_RETURNVALUE(returnvalue), P1, P2, P3, P4, P5>
354
355#define FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES_RETURNVALUE(returnvalue) FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES_RETURNVALUE##returnvalue
356#define FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES_RETURNVALUE0 void
357#define FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES_RETURNVALUE1 R
358
359
360
361#define FUNCTOR_EVALUATE_PARAM(numparams) FUNCTOR_EVALUATE_PARAM##numparams
362#define FUNCTOR_EVALUATE_PARAM0
363#define FUNCTOR_EVALUATE_PARAM1 \
364    if (index == 0) { param.convert<P1>(); }
365#define FUNCTOR_EVALUATE_PARAM2 \
366    if (index == 0) { param.convert<P1>(); } \
367    else if (index == 1) { param.convert<P2>(); }
368#define FUNCTOR_EVALUATE_PARAM3 \
369    if (index == 0) { param.convert<P1>(); } \
370    else if (index == 1) { param.convert<P2>(); } \
371    else if (index == 2) { param.convert<P3>(); }
372#define FUNCTOR_EVALUATE_PARAM4 \
373    if (index == 0) { param.convert<P1>(); } \
374    else if (index == 1) { param.convert<P2>(); } \
375    else if (index == 2) { param.convert<P3>(); } \
376    else if (index == 3) { param.convert<P4>(); }
377#define FUNCTOR_EVALUATE_PARAM5 \
378    if (index == 0) { param.convert<P1>(); } \
379    else if (index == 1) { param.convert<P2>(); } \
380    else if (index == 2) { param.convert<P3>(); } \
381    else if (index == 3) { param.convert<P4>(); } \
382    else if (index == 4) { param.convert<P5>(); }
383
384
385
386
387#define CREATE_STATIC_FUNCTOR(returnvalue, numparams) \
388    FUNCTOR_TEMPLATE(0, returnvalue, numparams, 0) \
389    class FunctorStatic##returnvalue##numparams : public FunctorStatic \
390    { \
391        public: \
392            FunctorStatic##returnvalue##numparams(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
393            { \
394                this->functionPointer_ = functionPointer; \
395            } \
396    \
397            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) \
398            { \
399                FUNCTOR_STORE_RETURNVALUE(returnvalue, (*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
400            } \
401    \
402            void evaluateParam(unsigned int index, MultiType& param) const \
403            { \
404                FUNCTOR_EVALUATE_PARAM(numparams); \
405            } \
406    \
407            Functor::Type::Enum getType() const { return Functor::Type::Static; } \
408            unsigned int getParamCount() const { return numparams; } \
409            bool hasReturnvalue() const { return returnvalue; } \
410            std::string getTypenameParam(unsigned int param) const { FUNCTOR_TYPENAME_PARAM(numparams); } \
411            std::string getTypenameReturnvalue() const { return FUNCTOR_TYPENAME_RETURN(returnvalue); } \
412    \
413            const std::type_info& getHeaderIdentifier() const \
414            { \
415                return typeid(FunctorHeaderIdentifier FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES(returnvalue, numparams)); \
416            } \
417    \
418        private: \
419            FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (*functionPointer_)(FUNCTOR_FUNCTION_PARAMS(numparams)); \
420    }; \
421    \
422    \
423    FUNCTOR_TEMPLATE(0, returnvalue, numparams, 0) \
424    inline SharedChildPtr<FunctorStatic##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(0, returnvalue, numparams), FunctorStaticPtr> createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
425    { \
426        return new FunctorStatic##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(0, returnvalue, numparams) (functionPointer); \
427    }
428
429
430
431
432
433#define CREATE_MEMBER_FUNCTOR(returnvalue, numparams) \
434    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 0) \
435    class FunctorMember##returnvalue##numparams : public FunctorMember<T> \
436    { \
437        public: \
438            FunctorMember##returnvalue##numparams(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
439            { \
440                this->functionPointer_ = functionPointer; \
441            } \
442    \
443            MultiType operator()(T* 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) \
444            { \
445                FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
446            } \
447    \
448            MultiType operator()(const T* 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) \
449            { \
450                COUT(1) << "An error occurred in Functor.h:" << std::endl; \
451                COUT(1) << "Error: Function is not const." << std::endl; \
452                return MT_Type::Null; \
453            } \
454    \
455            void evaluateParam(unsigned int index, MultiType& param) const \
456            { \
457                FUNCTOR_EVALUATE_PARAM(numparams); \
458            } \
459    \
460            Functor::Type::Enum getType() const { return Functor::Type::Member; } \
461            unsigned int getParamCount() const { return numparams; } \
462            bool hasReturnvalue() const { return returnvalue; } \
463            std::string getTypenameParam(unsigned int param) const { FUNCTOR_TYPENAME_PARAM(numparams); } \
464            std::string getTypenameReturnvalue() const { return FUNCTOR_TYPENAME_RETURN(returnvalue); } \
465    \
466            const std::type_info& getHeaderIdentifier() const \
467            { \
468                return typeid(FunctorHeaderIdentifier FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES(returnvalue, numparams)); \
469            } \
470    \
471        private: \
472            FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer_)(FUNCTOR_FUNCTION_PARAMS(numparams)); \
473    }; \
474    \
475    \
476    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 0) \
477    class FunctorConstMember##returnvalue##numparams : public FunctorMember<T> \
478    { \
479        public: \
480            FunctorConstMember##returnvalue##numparams(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams)) const) \
481            { \
482                this->functionPointer_ = functionPointer; \
483            } \
484    \
485            MultiType operator()(T* 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) \
486            { \
487                FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
488            } \
489    \
490            MultiType operator()(const T* 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) \
491            { \
492                FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
493            } \
494    \
495            void evaluateParam(unsigned int index, MultiType& param) const \
496            { \
497                FUNCTOR_EVALUATE_PARAM(numparams); \
498            } \
499    \
500            Functor::Type::Enum getType() const { return Functor::Type::ConstMember; } \
501            unsigned int getParamCount() const { return numparams; } \
502            bool hasReturnvalue() const { return returnvalue; } \
503            std::string getTypenameParam(unsigned int param) const { FUNCTOR_TYPENAME_PARAM(numparams); } \
504            std::string getTypenameReturnvalue() const { return FUNCTOR_TYPENAME_RETURN(returnvalue); } \
505    \
506            const std::type_info& getHeaderIdentifier() const \
507            { \
508                return typeid(FunctorHeaderIdentifier FUNCTOR_HEADER_IDENTIFIER_TEMPLATE_CLASSES(returnvalue, numparams)); \
509            } \
510    \
511        private: \
512            FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer_)(FUNCTOR_FUNCTION_PARAMS(numparams)) const; \
513    }; \
514    \
515    \
516    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 0) \
517    inline SharedChildPtr<FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams), FunctorMemberPtr<T> > createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
518    { \
519        return new FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams) (functionPointer); \
520    } \
521    \
522    \
523    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 0) \
524    inline SharedChildPtr<FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams), FunctorMemberPtr<T> > createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams)) const) \
525    { \
526        return new FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams) (functionPointer); \
527    } \
528    \
529    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 1) \
530    inline SharedChildPtr<FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams), FunctorMemberPtr<T> > createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams)), O* object) \
531    { \
532        FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* functor = new FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams) (functionPointer); \
533        functor->setObject(object); \
534        return functor; \
535    } \
536    \
537    \
538    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 1) \
539    inline SharedChildPtr<FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams), FunctorMemberPtr<T> > createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams)) const, O* object) \
540    { \
541        FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* functor = new FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams) (functionPointer); \
542        functor->setObject(object); \
543        return functor; \
544    }
545
546
547
548// disable annoying warning about forcing value to boolean
549#ifdef ORXONOX_COMPILER_MSVC
550#pragma warning(push)
551#pragma warning(disable:4100 4800)
552#endif
553
554#define CREATE_ALL_STATIC_FUNCTORS() \
555    CREATE_STATIC_FUNCTOR(0, 0); \
556    CREATE_STATIC_FUNCTOR(0, 1); \
557    CREATE_STATIC_FUNCTOR(0, 2); \
558    CREATE_STATIC_FUNCTOR(0, 3); \
559    CREATE_STATIC_FUNCTOR(0, 4); \
560    CREATE_STATIC_FUNCTOR(0, 5); \
561    CREATE_STATIC_FUNCTOR(1, 0); \
562    CREATE_STATIC_FUNCTOR(1, 1); \
563    CREATE_STATIC_FUNCTOR(1, 2); \
564    CREATE_STATIC_FUNCTOR(1, 3); \
565    CREATE_STATIC_FUNCTOR(1, 4); \
566    CREATE_STATIC_FUNCTOR(1, 5)
567
568
569#define CREATE_ALL_MEMBER_FUNCTORS() \
570    CREATE_MEMBER_FUNCTOR(0, 0); \
571    CREATE_MEMBER_FUNCTOR(0, 1); \
572    CREATE_MEMBER_FUNCTOR(0, 2); \
573    CREATE_MEMBER_FUNCTOR(0, 3); \
574    CREATE_MEMBER_FUNCTOR(0, 4); \
575    CREATE_MEMBER_FUNCTOR(0, 5); \
576    CREATE_MEMBER_FUNCTOR(1, 0); \
577    CREATE_MEMBER_FUNCTOR(1, 1); \
578    CREATE_MEMBER_FUNCTOR(1, 2); \
579    CREATE_MEMBER_FUNCTOR(1, 3); \
580    CREATE_MEMBER_FUNCTOR(1, 4); \
581    CREATE_MEMBER_FUNCTOR(1, 5)
582
583
584    CREATE_ALL_STATIC_FUNCTORS();
585    CREATE_ALL_MEMBER_FUNCTORS();
586}
587
588#ifdef ORXONOX_COMPILER_MSVC
589#pragma warning(pop)
590#endif
591
592#endif /* _Functor_H__ */
Note: See TracBrowser for help on using the repository browser.