Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/libraries/core/Functor.h @ 5829

Last change on this file since 5829 was 5738, checked in by landauf, 15 years ago

merged libraries2 back to trunk
  • Property svn:eol-style set to native
File size: 20.7 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 "CorePrereqs.h"
34
35#include "util/Debug.h"
36#include "util/MultiType.h"
37#include "util/StringUtils.h"
38
39namespace orxonox
40{
41    const unsigned int MAX_FUNCTOR_ARGUMENTS = 5;
42
43    namespace FunctionType
44    {
45        enum Value
46        {
47            Member,
48            ConstMember,
49            Static
50        };
51    }
52
53
54    template <class T>
55    inline std::string typeToString() { return "unknown"; }
56
57#define CreateTypeToStringTemplate(type) \
58    template <> \
59    inline std::string typeToString<type>() { return #type; } \
60    template <> \
61    inline std::string typeToString<type&>() { return #type; } \
62    template <> \
63    inline std::string typeToString<const type>() { return #type; } \
64    template <> \
65    inline std::string typeToString<const type&>() { return #type; }
66
67    CreateTypeToStringTemplate(int);
68    CreateTypeToStringTemplate(unsigned int);
69    CreateTypeToStringTemplate(char);
70    CreateTypeToStringTemplate(unsigned char);
71    CreateTypeToStringTemplate(short);
72    CreateTypeToStringTemplate(unsigned short);
73    CreateTypeToStringTemplate(long);
74    CreateTypeToStringTemplate(unsigned long);
75    CreateTypeToStringTemplate(long long);
76    CreateTypeToStringTemplate(unsigned long long);
77    CreateTypeToStringTemplate(float);
78    CreateTypeToStringTemplate(double);
79    CreateTypeToStringTemplate(long double);
80    CreateTypeToStringTemplate(bool);
81    CreateTypeToStringTemplate(Vector2);
82    CreateTypeToStringTemplate(Vector3);
83    CreateTypeToStringTemplate(Quaternion);
84    CreateTypeToStringTemplate(ColourValue);
85    CreateTypeToStringTemplate(Radian);
86    CreateTypeToStringTemplate(Degree);
87
88    template <>
89    inline std::string typeToString<std::string>() { return "string"; }
90    template <>
91    inline std::string typeToString<std::string&>() { return "string"; }
92    template <>
93    inline std::string typeToString<const std::string>() { return "string"; }
94    template <>
95    inline std::string typeToString<const std::string&>() { return "string"; }
96
97    class _CoreExport Functor
98    {
99        public:
100            Functor() {}
101            virtual ~Functor() {}
102
103            virtual void 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;
104
105            inline unsigned int getParamCount() const { return this->numParams_; }
106            inline bool hasReturnvalue() const { return this->hasReturnValue_; }
107            inline FunctionType::Value getType() const { return this->type_; }
108            inline const MultiType& getReturnvalue() const { return this->returnedValue_; }
109
110            const std::string& getTypenameParam(unsigned int param) const { return (param < 5) ? this->typeParam_[param] : BLANKSTRING; }
111            const std::string& getTypenameReturnvalue() const { return this->typeReturnvalue_; }
112
113            virtual void evaluateParam(unsigned int index, MultiType& param) const = 0;
114
115        protected:
116            unsigned int numParams_;
117            bool hasReturnValue_;
118            FunctionType::Value type_;
119            MultiType returnedValue_;
120
121            std::string typeReturnvalue_;
122            std::string typeParam_[MAX_FUNCTOR_ARGUMENTS];
123    };
124
125    class _CoreExport FunctorStatic : public Functor
126    {
127        public:
128            virtual ~FunctorStatic() {}
129            virtual void 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;
130    };
131
132    template <class T>
133    class FunctorMember : public Functor
134    {
135        public:
136            FunctorMember()
137            {
138                constObject_ = 0;
139                object_ = 0;
140                bConstObject_ = false;
141            }
142            virtual ~FunctorMember() {}
143
144            virtual void 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;
145            virtual void 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;
146
147            virtual void 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)
148            {
149                if (this->bConstObject_)
150                {
151                    if (this->constObject_)
152                        (*this)(this->constObject_, param1, param2, param3, param4, param5);
153                    else
154                    {
155                        COUT(1) << "An error occurred in Functor.h:" << std::endl;
156                        COUT(1) << "Error: No const object set." << std::endl;
157                    }
158                }
159                else
160                {
161                    if (this->object_)
162                        (*this)(this->object_, param1, param2, param3, param4, param5);
163                    else
164                    {
165                        COUT(1) << "An error occurred in Functor.h:" << std::endl;
166                        COUT(1) << "Error: No object set." << std::endl;
167                    }
168                }
169            }
170
171            FunctorMember<T>* setObject(T* object)
172            {
173                this->bConstObject_ = false;
174                this->object_ = object;
175                return this;
176            }
177
178            FunctorMember<T>* setObject(const T* object)
179            {
180                this->bConstObject_ = true;
181                this->constObject_ = object;
182                return this;
183            }
184
185        private:
186            const T* constObject_;
187            T* object_;
188            bool bConstObject_;
189    };
190
191
192
193#define FUNCTOR_TEMPLATE(ismember, returnvalue, numparams) FUNCTOR_TEMPLATE##ismember##returnvalue##numparams
194#define FUNCTOR_TEMPLATE000
195#define FUNCTOR_TEMPLATE001 template <class P1>
196#define FUNCTOR_TEMPLATE002 template <class P1, class P2>
197#define FUNCTOR_TEMPLATE003 template <class P1, class P2, class P3>
198#define FUNCTOR_TEMPLATE004 template <class P1, class P2, class P3, class P4>
199#define FUNCTOR_TEMPLATE005 template <class P1, class P2, class P3, class P4, class P5>
200#define FUNCTOR_TEMPLATE010 template <class R>
201#define FUNCTOR_TEMPLATE011 template <class R, class P1>
202#define FUNCTOR_TEMPLATE012 template <class R, class P1, class P2>
203#define FUNCTOR_TEMPLATE013 template <class R, class P1, class P2, class P3>
204#define FUNCTOR_TEMPLATE014 template <class R, class P1, class P2, class P3, class P4>
205#define FUNCTOR_TEMPLATE015 template <class R, class P1, class P2, class P3, class P4, class P5>
206#define FUNCTOR_TEMPLATE100 template <class T>
207#define FUNCTOR_TEMPLATE101 template <class T, class P1>
208#define FUNCTOR_TEMPLATE102 template <class T, class P1, class P2>
209#define FUNCTOR_TEMPLATE103 template <class T, class P1, class P2, class P3>
210#define FUNCTOR_TEMPLATE104 template <class T, class P1, class P2, class P3, class P4>
211#define FUNCTOR_TEMPLATE105 template <class T, class P1, class P2, class P3, class P4, class P5>
212#define FUNCTOR_TEMPLATE110 template <class T, class R>
213#define FUNCTOR_TEMPLATE111 template <class T, class R, class P1>
214#define FUNCTOR_TEMPLATE112 template <class T, class R, class P1, class P2>
215#define FUNCTOR_TEMPLATE113 template <class T, class R, class P1, class P2, class P3>
216#define FUNCTOR_TEMPLATE114 template <class T, class R, class P1, class P2, class P3, class P4>
217#define FUNCTOR_TEMPLATE115 template <class T, class R, class P1, class P2, class P3, class P4, class P5>
218
219
220
221#define FUNCTOR_TEMPLATE_CLASSES(ismember, returnvalue, numparams) FUNCTOR_TEMPLATE_CLASSES##ismember##returnvalue##numparams
222#define FUNCTOR_TEMPLATE_CLASSES000
223#define FUNCTOR_TEMPLATE_CLASSES001 <P1>
224#define FUNCTOR_TEMPLATE_CLASSES002 <P1, P2>
225#define FUNCTOR_TEMPLATE_CLASSES003 <P1, P2, P3>
226#define FUNCTOR_TEMPLATE_CLASSES004 <P1, P2, P3, P4>
227#define FUNCTOR_TEMPLATE_CLASSES005 <P1, P2, P3, P4, P5>
228#define FUNCTOR_TEMPLATE_CLASSES010 <R>
229#define FUNCTOR_TEMPLATE_CLASSES011 <R, P1>
230#define FUNCTOR_TEMPLATE_CLASSES012 <R, P1, P2>
231#define FUNCTOR_TEMPLATE_CLASSES013 <R, P1, P2, P3>
232#define FUNCTOR_TEMPLATE_CLASSES014 <R, P1, P2, P3, P4>
233#define FUNCTOR_TEMPLATE_CLASSES015 <R, P1, P2, P3, P4, P5>
234#define FUNCTOR_TEMPLATE_CLASSES100 <T>
235#define FUNCTOR_TEMPLATE_CLASSES101 <T, P1>
236#define FUNCTOR_TEMPLATE_CLASSES102 <T, P1, P2>
237#define FUNCTOR_TEMPLATE_CLASSES103 <T, P1, P2, P3>
238#define FUNCTOR_TEMPLATE_CLASSES104 <T, P1, P2, P3, P4>
239#define FUNCTOR_TEMPLATE_CLASSES105 <T, P1, P2, P3, P4, P5>
240#define FUNCTOR_TEMPLATE_CLASSES110 <T, R>
241#define FUNCTOR_TEMPLATE_CLASSES111 <T, R, P1>
242#define FUNCTOR_TEMPLATE_CLASSES112 <T, R, P1, P2>
243#define FUNCTOR_TEMPLATE_CLASSES113 <T, R, P1, P2, P3>
244#define FUNCTOR_TEMPLATE_CLASSES114 <T, R, P1, P2, P3, P4>
245#define FUNCTOR_TEMPLATE_CLASSES115 <T, R, P1, P2, P3, P4, P5>
246
247
248
249#define FUNCTOR_TYPENAME_PARAMS(numparams) FUNCTOR_TYPENAME_PARAMS##numparams
250#define FUNCTOR_TYPENAME_PARAMS0
251#define FUNCTOR_TYPENAME_PARAMS1 this->typeParam_[0] = typeToString<P1>();
252#define FUNCTOR_TYPENAME_PARAMS2 this->typeParam_[0] = typeToString<P1>(); this->typeParam_[1] = typeToString<P2>();
253#define FUNCTOR_TYPENAME_PARAMS3 this->typeParam_[0] = typeToString<P1>(); this->typeParam_[1] = typeToString<P2>(); this->typeParam_[2] = typeToString<P3>();
254#define FUNCTOR_TYPENAME_PARAMS4 this->typeParam_[0] = typeToString<P1>(); this->typeParam_[1] = typeToString<P2>(); this->typeParam_[2] = typeToString<P3>(); this->typeParam_[3] = typeToString<P4>();
255#define FUNCTOR_TYPENAME_PARAMS5 this->typeParam_[0] = typeToString<P1>(); this->typeParam_[1] = typeToString<P2>(); this->typeParam_[2] = typeToString<P3>(); this->typeParam_[3] = typeToString<P4>(); this->typeParam_[4] = typeToString<P5>();
256
257#define FUNCTOR_TYPENAME_RETURN(returnvalue) FUNCTOR_TYPENAME_RETURN##returnvalue
258#define FUNCTOR_TYPENAME_RETURN0
259#define FUNCTOR_TYPENAME_RETURN1 this->typeReturnvalue_ = typeToString<R>();
260
261
262
263#define FUNCTOR_FUNCTION_PARAMS(numparams) FUNCTOR_FUNCTION_PARAMS##numparams
264#define FUNCTOR_FUNCTION_PARAMS0
265#define FUNCTOR_FUNCTION_PARAMS1 P1 param1
266#define FUNCTOR_FUNCTION_PARAMS2 P1 param1, P2 param2
267#define FUNCTOR_FUNCTION_PARAMS3 P1 param1, P2 param2, P3 param3
268#define FUNCTOR_FUNCTION_PARAMS4 P1 param1, P2 param2, P3 param3, P4 param4
269#define FUNCTOR_FUNCTION_PARAMS5 P1 param1, P2 param2, P3 param3, P4 param4, P5 param5
270
271#define FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) FUNCTOR_FUNCTION_RETURNVALUE##returnvalue
272#define FUNCTOR_FUNCTION_RETURNVALUE0 void
273#define FUNCTOR_FUNCTION_RETURNVALUE1 R
274
275
276
277#define FUNCTOR_FUNCTION_CALL(numparams) FUNCTOR_FUNCTION_CALL##numparams
278#define FUNCTOR_FUNCTION_CALL0
279#define FUNCTOR_FUNCTION_CALL1 param1
280#define FUNCTOR_FUNCTION_CALL2 param1, param2
281#define FUNCTOR_FUNCTION_CALL3 param1, param2, param3
282#define FUNCTOR_FUNCTION_CALL4 param1, param2, param3, param4
283#define FUNCTOR_FUNCTION_CALL5 param1, param2, param3, param4, param5
284
285#define FUNCTOR_STORE_RETURNVALUE(returnvalue, functioncall) FUNCTOR_STORE_RETURNVALUE##returnvalue(functioncall)
286#define FUNCTOR_STORE_RETURNVALUE0(functioncall) functioncall
287#define FUNCTOR_STORE_RETURNVALUE1(functioncall) this->returnedValue_ = functioncall
288
289
290
291#define FUNCTOR_EVALUATE_PARAM(numparams) FUNCTOR_EVALUATE_PARAM##numparams
292#define FUNCTOR_EVALUATE_PARAM0
293#define FUNCTOR_EVALUATE_PARAM1 \
294    if (index == 0) { param.convert<P1>(); }
295#define FUNCTOR_EVALUATE_PARAM2 \
296    if (index == 0) { param.convert<P1>(); } \
297    else if (index == 1) { param.convert<P2>(); }
298#define FUNCTOR_EVALUATE_PARAM3 \
299    if (index == 0) { param.convert<P1>(); } \
300    else if (index == 1) { param.convert<P2>(); } \
301    else if (index == 2) { param.convert<P3>(); }
302#define FUNCTOR_EVALUATE_PARAM4 \
303    if (index == 0) { param.convert<P1>(); } \
304    else if (index == 1) { param.convert<P2>(); } \
305    else if (index == 2) { param.convert<P3>(); } \
306    else if (index == 3) { param.convert<P4>(); }
307#define FUNCTOR_EVALUATE_PARAM5 \
308    if (index == 0) { param.convert<P1>(); } \
309    else if (index == 1) { param.convert<P2>(); } \
310    else if (index == 2) { param.convert<P3>(); } \
311    else if (index == 3) { param.convert<P4>(); } \
312    else if (index == 4) { param.convert<P5>(); }
313
314
315
316
317
318#define CREATE_STATIC_FUNCTOR(returnvalue, numparams) \
319    FUNCTOR_TEMPLATE(0, returnvalue, numparams) \
320    class FunctorStatic##returnvalue##numparams : public FunctorStatic \
321    { \
322        public: \
323            FunctorStatic##returnvalue##numparams(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
324            { \
325                this->numParams_ = numparams; \
326                this->hasReturnValue_ = returnvalue; \
327                this->type_ = FunctionType::Static; \
328                this->functionPointer_ = functionPointer; \
329                \
330                FUNCTOR_TYPENAME_PARAMS(numparams); \
331                FUNCTOR_TYPENAME_RETURN(returnvalue); \
332            } \
333    \
334            void 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) \
335            { \
336                FUNCTOR_STORE_RETURNVALUE(returnvalue, (*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
337            } \
338    \
339            virtual void evaluateParam(unsigned int index, MultiType& param) const \
340            { \
341                FUNCTOR_EVALUATE_PARAM(numparams); \
342            } \
343    \
344        private: \
345            FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (*functionPointer_)(FUNCTOR_FUNCTION_PARAMS(numparams)); \
346    }; \
347    \
348    \
349    FUNCTOR_TEMPLATE(0, returnvalue, numparams) \
350    inline FunctorStatic##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(0, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
351    { \
352        return new FunctorStatic##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(0, returnvalue, numparams) (functionPointer); \
353    }
354
355
356
357
358
359#define CREATE_MEMBER_FUNCTOR(returnvalue, numparams) \
360    FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
361    class FunctorMember##returnvalue##numparams : public FunctorMember<T> \
362    { \
363        public: \
364            FunctorMember##returnvalue##numparams(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
365            { \
366                this->numParams_ = numparams; \
367                this->hasReturnValue_ = returnvalue; \
368                this->type_ = FunctionType::Member; \
369                this->functionPointer_ = functionPointer; \
370            } \
371    \
372            void 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) \
373            { \
374                FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
375            } \
376    \
377            void 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) \
378            { \
379                COUT(1) << "An error occurred in Functor.h:" << std::endl; \
380                COUT(1) << "Error: Function is not const." << std::endl; \
381            } \
382    \
383            virtual void evaluateParam(unsigned int index, MultiType& param) const \
384            { \
385                FUNCTOR_EVALUATE_PARAM(numparams); \
386            } \
387    \
388        private: \
389            FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer_)(FUNCTOR_FUNCTION_PARAMS(numparams)); \
390    }; \
391    \
392    \
393    FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
394    class FunctorConstMember##returnvalue##numparams : public FunctorMember<T> \
395    { \
396        public: \
397            FunctorConstMember##returnvalue##numparams(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams)) const) \
398            { \
399                this->numParams_ = numparams; \
400                this->hasReturnValue_ = returnvalue; \
401                this->type_ = FunctionType::ConstMember; \
402                this->functionPointer_ = functionPointer; \
403            } \
404    \
405            void 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) \
406            { \
407                FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
408            } \
409    \
410            void 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) \
411            { \
412                FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
413            } \
414    \
415            virtual void evaluateParam(unsigned int index, MultiType& param) const \
416            { \
417                FUNCTOR_EVALUATE_PARAM(numparams); \
418            } \
419    \
420        private: \
421            FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer_)(FUNCTOR_FUNCTION_PARAMS(numparams)) const; \
422    }; \
423    \
424    \
425    FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
426    inline FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
427    { \
428        return new FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams) (functionPointer); \
429    } \
430    \
431    \
432    FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
433    inline FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams)) const) \
434    { \
435        return new FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams) (functionPointer); \
436    }
437
438
439// disable annoying warning about forcing value to boolean
440#ifdef ORXONOX_COMPILER_MSVC
441#pragma warning(push)
442#pragma warning(disable:4100 4800)
443#endif
444
445#define CREATE_ALL_STATIC_FUNCTORS() \
446    CREATE_STATIC_FUNCTOR(0, 0); \
447    CREATE_STATIC_FUNCTOR(0, 1); \
448    CREATE_STATIC_FUNCTOR(0, 2); \
449    CREATE_STATIC_FUNCTOR(0, 3); \
450    CREATE_STATIC_FUNCTOR(0, 4); \
451    CREATE_STATIC_FUNCTOR(0, 5); \
452    CREATE_STATIC_FUNCTOR(1, 0); \
453    CREATE_STATIC_FUNCTOR(1, 1); \
454    CREATE_STATIC_FUNCTOR(1, 2); \
455    CREATE_STATIC_FUNCTOR(1, 3); \
456    CREATE_STATIC_FUNCTOR(1, 4); \
457    CREATE_STATIC_FUNCTOR(1, 5)
458
459
460#define CREATE_ALL_MEMBER_FUNCTORS() \
461    CREATE_MEMBER_FUNCTOR(0, 0); \
462    CREATE_MEMBER_FUNCTOR(0, 1); \
463    CREATE_MEMBER_FUNCTOR(0, 2); \
464    CREATE_MEMBER_FUNCTOR(0, 3); \
465    CREATE_MEMBER_FUNCTOR(0, 4); \
466    CREATE_MEMBER_FUNCTOR(0, 5); \
467    CREATE_MEMBER_FUNCTOR(1, 0); \
468    CREATE_MEMBER_FUNCTOR(1, 1); \
469    CREATE_MEMBER_FUNCTOR(1, 2); \
470    CREATE_MEMBER_FUNCTOR(1, 3); \
471    CREATE_MEMBER_FUNCTOR(1, 4); \
472    CREATE_MEMBER_FUNCTOR(1, 5)
473
474
475    CREATE_ALL_STATIC_FUNCTORS();
476    CREATE_ALL_MEMBER_FUNCTORS();
477}
478
479#ifdef ORXONOX_COMPILER_MSVC
480#pragma warning(pop)
481#endif
482
483#endif /* _Functor_H__ */
Note: See TracBrowser for help on using the repository browser.