Changeset 7716 in orxonox.OLD for trunk/src/lib
- Timestamp:
- May 19, 2006, 2:43:22 AM (19 years ago)
- Location:
- trunk/src/lib
- Files:
-
- 1 edited
- 1 copied
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/lib/Makefile.am
r7661 r7716 41 41 util/helper_functions.h \ 42 42 util/executor/executor.h \ 43 util/executor/executor_functional.h \ 43 44 util/executor/executor_specials.h \ 44 45 util/executor/functor_list.h \ -
trunk/src/lib/util/executor/executor_functional.h
r7714 r7716 1 1 /*! 2 * @file executor .h2 * @file executor_functional.h 3 3 * Definition of an Executor 4 4 */ 5 5 6 #ifndef _EXECUTOR_H 7 #define _EXECUTOR_H 6 /* 7 orxonox - the future of 3D-vertical-scrollers 8 8 9 #include "base_object.h" 9 Copyright (C) 2004 orx 10 10 11 #include "helper_functions.h" 12 #include "multi_type.h" 13 #include "substring.h" 14 #include "functor_list.h" //< MUST BE INCLUDED HERE AT LEAST ONCE.11 This program is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 2, or (at your option) 14 any later version. 15 15 16 //! an enumerator for the definition of the Type. 17 typedef enum { 18 Executor_Objective = 1,19 Executor_Static = 2, 16 ### File Specific: 17 main-programmer: Benjamin Grauer 18 co-programmer: ... 19 */ 20 20 21 Executor_NoLoadString = 8,22 } Executor_Type;23 21 24 //////////////// 25 // BASE CLASS // 26 //////////////// 27 //! a BaseClass for all possible Executors 28 /** 29 * An Executor is an Object, that is able to call Objects of Any type (class) 30 * and execute a function with given parameters on it. 31 * 32 * The Executor is able to handle: 33 * Objects of any Class (Templated) 34 * Default Values 35 * Functions with up to 5 parameters (more seems useless) 36 * Functions with many types (@see functor_list.h) 37 */ 38 class Executor : public BaseObject 39 { 40 public: 41 virtual ~Executor(); 42 43 virtual Executor* clone () const = 0; 44 45 // SETTING up the EXECUTOR 46 Executor* defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL, 47 const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL, 48 const MultiType& value4 = MT_NULL); 49 /** @param i the i'th defaultValue, @returns reference to the MultiType */ 50 inline MultiType& getDefaultValue(unsigned int i) { return defaultValue[i]; }; 51 52 // EXECUTE 53 /** executes a Command @param object the object to apply this to @param parameters the parameters the command takes */ 54 virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const = 0; 55 /** executes a Command @param object the object to apply this to @param parameters the parameters the command takes @brief here for your convenience*/ 56 void execute (BaseObject* object, const std::string& parameters = "") const { (*this)(object, parameters); }; 57 58 // RETRIEVE INFORMATION 59 /** @returns the Type of this Function (either static or objective) */ 60 inline long getType() const { return this->functorType; }; 61 /** @returns the Count of Parameters this Executor takes */ 62 inline unsigned int getParamCount() const { return this->paramCount; }; 63 64 static void debug(); 65 66 protected: 67 Executor(const MultiType& param0 = MT_NULL, const MultiType& param1 = MT_NULL, 68 const MultiType& param2 = MT_NULL, const MultiType& param3 = MT_NULL, 69 const MultiType& param4 = MT_NULL); 70 71 void cloning(Executor* executor) const; 72 73 protected: 74 short functorType; //!< The type of Function we've got (either static or objective). 75 unsigned int paramCount; //!< the count of parameters. 76 MultiType defaultValue[5]; //!< Default Values. 77 }; 78 79 /////////////////////////////////////////////////// 80 /////////////////////////////////////////////////// 81 82 ////////////////////////// 83 // COMMAND REGISTRATION // 84 ////////////////////////// 85 // EXECUTOR can be redefined as Executor or ExecutorStatic 86 // EXECUTOREXECUTER can be redefined too. 87 // EXECUTORINCLASS 88 // EXECUTORTYPE 22 #ifndef __EXECUTOR_FUNCTIONAL_H_ 23 #define __EXECUTOR_FUNCTIONAL_H_ 89 24 90 25 91 26 92 /////////////////////// 93 // FUNCTION POINTERS // 94 /////////////////////// 95 #define ExecutorFunctionPoiter0() \ 96 void EXECUTORINCLASS(*functionPointer_0)(); 27 template<typename type> MT_Type ExecutorParamType() { return MT_EXT1; }; 28 template<> MT_Type ExecutorParamType<bool>() { return MT_EXT1; }; 29 template<> MT_Type ExecutorParamType<int>() { return MT_INT; }; 30 template<> MT_Type ExecutorParamType<unsigned int>() { return MT_UINT; }; 31 template<> MT_Type ExecutorParamType<float>() { return MT_FLOAT; }; 32 template<> MT_Type ExecutorParamType<char>() { return MT_CHAR; }; 33 template<> MT_Type ExecutorParamType<const std::string&>() { return MT_STRING; }; 97 34 98 #define ExecutorFunctionPoiter1(t1) \ 99 void EXECUTORINCLASS(*functionPointer_1_##t1)(t1##_TYPE); 35 template<typename type> type fromString(const std::string& input, type defaultValue) {return defaultValue; }; 36 template<> bool fromString<bool>(const std::string& input, bool defaultValue) { return isBool(input, defaultValue); }; 37 template<> int fromString<int>(const std::string& input, int defaultValue) { return isInt(input, defaultValue); }; 38 template<> unsigned int fromString<unsigned int>(const std::string& input, unsigned int defaultValue) { return isInt(input, defaultValue); }; 39 template<> float fromString<float>(const std::string& input, float defaultValue) { return isFloat(input, defaultValue); }; 40 template<> char fromString<char>(const std::string& input, char defaultValue) { return isInt(input, defaultValue); }; 41 template<> const std::string& fromString<const std::string&>(const std::string& input, const std::string& defaultValue) { return isString(input, defaultValue); }; 100 42 101 #define ExecutorFunctionPoiter2(t1, t2) \ 102 void EXECUTORINCLASS(*functionPointer_2_##t1##_##t2)(t1##_TYPE, t2##_TYPE); 43 template<typename type> type getDefault(const MultiType* const defaultValues, unsigned int i) { return (type)0; }; 44 template<> bool getDefault<bool>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getBool(); }; 45 template<> int getDefault<int>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getInt(); }; 46 template<> unsigned int getDefault<unsigned int>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getInt(); }; 47 template<> float getDefault<float>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getFloat(); }; 48 template<> char getDefault<char>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getChar(); }; 49 template<> std::string getDefault<std::string>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getString(); }; 50 51 #endif /* __EXECUTOR_FUNCTIONAL_H_ */ 103 52 104 53 105 #define ExecutorFunctionPoiter3(t1, t2, t3) \ 106 void EXECUTORINCLASS(*functionPointer_3_##t1##_##t2##_##t3)(t1##_TYPE, t2##_TYPE, t3##_TYPE); 54 #define __EXECUTOR_FUNCTIONAL_CONST 55 #define __EXECUTOR_FUNCTIONAL_NAME(ParamCount) Executor##ParamCount##Params 56 #define __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC dynamic_cast<T*>(object)->*(functionPointer) 57 #define __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER T::*functionPointer 107 58 108 #define ExecutorFunctionPoiter4(t1, t2, t3, t4) \ 109 void EXECUTORINCLASS(*functionPointer_4_##t1##_##t2##_##t3##_##t4)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE); 59 #ifdef EXECUTOR_FUNCTIONAL_USE_CONST 60 #undef __EXECUTOR_FUNCTIONAL_CONST 61 #define __EXECUTOR_FUNCTIONAL_CONST const 62 #undef __EXECUTOR_FUNCTIONAL_NAME 63 #define __EXECUTOR_FUNCTIONAL_NAME(ParamCount) Executor##ParamCount##Params_const 64 #undef EXECUTOR_FUNCTIONAL_USE_CONST 65 #endif 66 67 #ifdef EXECUTOR_FUNCTIONAL_USE_STATIC 68 #ifdef EXECUTOR_FUNCTIONAL_USE_CONST 69 #error you obviously do not know what you are doing !! ask the bensch 70 #endif /* EXECUTOR_FUNCTIONAL_USE_CONST */ 71 72 #undef __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC 73 #define __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC functionPointer 74 #undef __EXECUTOR_FUNCTIONAL_NAME 75 #define __EXECUTOR_FUNCTIONAL_NAME(ParamCount) Executor##ParamCount##Params_static 76 #undef __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER 77 #define __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER *functionPointer 78 79 #undef EXECUTOR_FUNCTIONAL_USE_STATIC 80 #endif /* EXECUTOR_FUNCTIONAL_USE_STATIC */ 81 82 template<class T> class __EXECUTOR_FUNCTIONAL_NAME(0) : public Executor 83 { 84 private: 85 void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)() __EXECUTOR_FUNCTIONAL_CONST; 86 87 public: 88 __EXECUTOR_FUNCTIONAL_NAME(0) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)() __EXECUTOR_FUNCTIONAL_CONST ) 89 : Executor() 90 { 91 this->functorType = Executor_Objective; 92 this->functionPointer = functionPointer; 93 } 94 virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const 95 { 96 (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(); 97 }; 98 99 Executor* clone() const { }; 100 }; 110 101 111 102 112 #define ExecutorFunctionPoiter5(t1, t2, t3, t4, t5) \ 113 void EXECUTORINCLASS(*functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE); 103 template<class T, typename type0> class __EXECUTOR_FUNCTIONAL_NAME(1) : public Executor 104 { 105 private: 106 void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0) __EXECUTOR_FUNCTIONAL_CONST; 114 107 108 public: 109 __EXECUTOR_FUNCTIONAL_NAME(1) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0) __EXECUTOR_FUNCTIONAL_CONST) 110 : Executor(ExecutorParamType<type0>()) 111 { 112 this->functorType = Executor_Objective; 113 this->functionPointer = functionPointer; 114 } 115 virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const 116 { 115 117 116 ////////////////// 117 // CONSTRUCTORS // 118 ///////////////// 119 //! creates a command that takes no parameters 120 #define ExecutorConstructor0() \ 121 EXECUTOR(void EXECUTORINCLASS(*function)()) \ 122 : Executor(0) \ 123 { \ 124 this->functorType = EXECUTORTYPE; \ 125 this->fp.functionPointer_0 = function; \ 118 /* // THE VERY COOL DEBUG 119 printf("SUB[0] : %s\n", sub[0].c_str()); 120 printf("getDefault<type0>(this->defaultValue, 0):::: %d\n", getDefault<type0>(this->defaultValue, 0)); 121 printf("VALUE: %d\n", fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0))); 122 */ 123 (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)( 124 fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)) ); 125 }; 126 127 virtual Executor* clone() const {}; 128 }; 129 130 /// DOUBLE PENETRATION 131 template<class T, typename type0, typename type1> class __EXECUTOR_FUNCTIONAL_NAME(2) : public Executor 132 { 133 private: 134 void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1) __EXECUTOR_FUNCTIONAL_CONST; 135 136 public: 137 __EXECUTOR_FUNCTIONAL_NAME(2) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1) __EXECUTOR_FUNCTIONAL_CONST) 138 : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>()) 139 { 140 this->functorType = Executor_Objective; 141 this->functionPointer = functionPointer; 126 142 } 143 virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const 144 { 145 (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)( 146 fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)), 147 fromString<type1>(sub[1], getDefault<type1>(this->defaultValue, 1))); 148 }; 127 149 128 //! creates a command that takes one parameter 129 #define ExecutorConstructor1(t1) \ 130 EXECUTOR(void EXECUTORINCLASS(*function)(t1##_TYPE)) \ 131 : Executor(t1##_PARAM) \ 132 { \ 133 this->functorType = EXECUTORTYPE; \ 134 this->fp.functionPointer_1_##t1 = function; \ 135 } 136 137 //! creates a command that takes two parameters 138 #define ExecutorConstructor2(t1,t2) \ 139 EXECUTOR(void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE)) \ 140 : Executor(t1##_PARAM, t2##_PARAM) \ 141 { \ 142 this->functorType = EXECUTORTYPE; \ 143 this->fp.functionPointer_2_##t1##_##t2 = function; \ 144 } 145 146 //! creates a command that takes three parameter 147 #define ExecutorConstructor3(t1,t2,t3) \ 148 EXECUTOR(void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE)) \ 149 : Executor(t1##_PARAM, t2##_PARAM, t3##_PARAM) \ 150 { \ 151 this->functorType = EXECUTORTYPE; \ 152 this->fp.functionPointer_3_##t1##_##t2##_##t3 = function; \ 153 } 154 155 //! creates a command that takes four parameter 156 #define ExecutorConstructor4(t1,t2,t3,t4) \ 157 EXECUTOR(void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE)) \ 158 : Executor(t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM) \ 159 { \ 160 this->functorType = EXECUTORTYPE; \ 161 this->fp.functionPointer_4_##t1##_##t2##_##t3##_##t4 = function; \ 162 } 163 164 //! creates a command that takes five parameter 165 #define ExecutorConstructor5(t1,t2,t3,t4,t5) \ 166 EXECUTOR(void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE)) \ 167 : Executor(t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM) \ 168 { \ 169 this->functorType = EXECUTORTYPE; \ 170 this->fp.functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5 = function; \ 171 } 172 173 /////////////// 174 // EXECUTION // 175 /////////////// 176 //! execute-macro for functions with no parameters 177 #define ExecutorExecute0() \ 178 if (this->paramCount == 0) \ 179 EXECUTOREXECUTER(_0)() 180 181 //! execute-macro for functions with one parameter 182 #define ExecutorExecute1(t1) \ 183 else if (this->paramCount == 1 && this->defaultValue[0] == t1##_PARAM) \ 184 EXECUTOREXECUTER(_1_##t1)(t1##_FUNC(sub[0], t1##_DEFGRAB(0))) 185 186 //! execute-macro for functions with two parameters 187 #define ExecutorExecute2(t1,t2) \ 188 else if (this->paramCount == 2 && this->defaultValue[0] == t1##_PARAM && this->defaultValue[1] == t2##_PARAM) \ 189 EXECUTOREXECUTER(_2_##t1##_##t2)(t1##_FUNC(sub[0], t1##_DEFGRAB(0)), t2##_FUNC(sub[1], t2##_DEFGRAB(1))) 190 191 //! execute-macro for functions with three parameters 192 #define ExecutorExecute3(t1,t2,t3) \ 193 else if (this->paramCount == 3 && this->defaultValue[0] == t1##_PARAM && this->defaultValue[1] == t2##_PARAM && this->defaultValue[2] == t3##_PARAM) \ 194 EXECUTOREXECUTER(_3_##t1##_##t2##_##t3)(t1##_FUNC(sub[0], t1##_DEFGRAB(0)), t2##_FUNC(sub[1], t2##_DEFGRAB(1)), t3##_FUNC(sub[2], t3##_DEFGRAB(2))) 195 196 //! execute-macro for functions with four parameters 197 #define ExecutorExecute4(t1,t2,t3,t4) \ 198 else if (this->paramCount == 4 && this->defaultValue[0] == t1##_PARAM && this->defaultValue[1] == t2##_PARAM && this->defaultValue[2] == t3##_PARAM && this->defaultValue[3] == t4##_PARAM) \ 199 EXECUTOREXECUTER(_4_##t1##_##t2##_##t3##_##t4)(t1##_FUNC(sub[0], t1##_DEFGRAB(0)), t2##_FUNC(sub[1], t2##_DEFGRAB(1)), t3##_FUNC(sub[2], t3##_DEFGRAB(2)), t4##_FUNC(sub[3], t4##_DEFGRAB(3))) \ 200 201 202 //! execute-macro for functions with five parameters 203 #define ExecutorExecute5(t1,t2,t3,t4,t5) \ 204 else if (this->paramCount == 5 && this->defaultValue[0] == t1##_PARAM && this->defaultValue[1] == t2##_PARAM && this->defaultValue[2] == t3##_PARAM && this->defaultValue[3] == t4##_PARAM && this->defaultValue[4] == t5##_PARAM) \ 205 EXECUTOREXECUTER(_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_FUNC(sub[0], t1##_DEFGRAB(0)), t2##_FUNC(sub[1], t2##_DEFGRAB(1)), t3##_FUNC(sub[2], t3##_DEFGRAB(2)), t4##_FUNC(sub[3], t4##_DEFGRAB(3)), t5##_FUNC(sub[4], t5##_DEFGRAB(4))) 150 virtual Executor* clone() const {}; 151 }; 206 152 207 153 208 154 155 /// HACK !! THESE WILL BE RESET AGAIN !! 209 156 210 ///////////////////// 211 // DYNAMIC FUNCTOR // 212 ///////////////////// 213 #ifdef FUNCTOR_LIST 214 #undef FUNCTOR_LIST 215 #endif 216 #ifdef EXECUTOR 217 #undef EXECUTOR 218 #endif 219 #define EXECUTOR ExecutorObjective 220 #ifdef EXECUTOREXECUTER 221 #undef EXECUTOREXECUTER 222 #endif 223 #define EXECUTOREXECUTER(nameExt) (dynamic_cast<T*>(object)->*(fp.functionPointer##nameExt)) 224 #ifdef EXECUTORINCLASS 225 #undef EXECUTORINCLASS 226 #endif 227 #define EXECUTORINCLASS(FUNCTION) (T::FUNCTION) 228 #ifdef EXECUTORTYPE 229 #undef EXECUTORTYPE 230 #endif 231 #define EXECUTORTYPE Executor_Objective 232 //! keeps information about a Executor 233 template<class T> class EXECUTOR : public Executor 157 template<class T> Executor* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)() __EXECUTOR_FUNCTIONAL_CONST) 234 158 { 235 public: 236 EXECUTOR() : Executor() { }; 237 // COPY constuctor (virtual version) 238 virtual Executor* clone () const 239 { 240 EXECUTOR<T>* executor = new EXECUTOR<T>(); 241 this->cloning(executor); 242 executor->fp = this->fp; 243 return executor; 244 } 245 246 //! FUNCTOR_LIST is the List of CommandConstructors 247 #define FUNCTOR_LIST(x) ExecutorConstructor ## x 248 #include "functor_list.h" 249 #undef FUNCTOR_LIST 250 251 private: 252 //! FUNCTOR_LIST is the List of FunctionPointers 253 union FunctionPointers { 254 #define FUNCTOR_LIST(x) ExecutorFunctionPoiter ## x 255 #include "functor_list.h" 256 #undef FUNCTOR_LIST 257 } fp; 258 259 virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const 260 { 261 //! FUNCTOR_LIST is the List of Executive Functions 262 #define FUNCTOR_LIST(x) ExecutorExecute ## x 263 #include "functor_list.h" 264 #undef FUNCTOR_LIST 265 266 } 267 }; 159 return new __EXECUTOR_FUNCTIONAL_NAME(0)<T>(functionPointer); 160 } 161 template<class T> Executor* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(bool) __EXECUTOR_FUNCTIONAL_CONST) 162 { 163 return new __EXECUTOR_FUNCTIONAL_NAME(1)<T, bool>(functionPointer); 164 } 165 template<class T> Executor* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(int) __EXECUTOR_FUNCTIONAL_CONST) 166 { 167 return new __EXECUTOR_FUNCTIONAL_NAME(1)<T, int>(functionPointer); 168 } 169 template<class T> Executor* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(bool, int) __EXECUTOR_FUNCTIONAL_CONST) 170 { 171 return new __EXECUTOR_FUNCTIONAL_NAME(2)<T, bool, int>(functionPointer); 172 } 268 173 269 174 270 //////////////////// 271 // STATIC FUNCTOR // 272 //////////////////// 273 #ifdef FUNCTOR_LIST 274 #undef FUNCTOR_LIST 275 #endif 276 #ifdef EXECUTOR 277 #undef EXECUTOR 278 #endif 279 #define EXECUTOR ExecutorStatic 280 #ifdef EXECUTOREXECUTER 281 #undef EXECUTOREXECUTER 282 #endif 283 #define EXECUTOREXECUTER(nameExt) fp.functionPointer##nameExt 284 #ifdef EXECUTORINCLASS 285 #undef EXECUTORINCLASS 286 #endif 287 #define EXECUTORINCLASS(FUNCTION) (FUNCTION) 288 #ifdef EXECUTORTYPE 289 #undef EXECUTORTYPE 290 #endif 291 #define EXECUTORTYPE Executor_Static 292 293 //! keeps information about a Executor, that points to a Static Function 294 template<class T> class ExecutorStatic : public Executor 295 { 296 public: 297 EXECUTOR() : Executor() { }; 298 // COPY constuctor 299 virtual Executor* clone () const 300 { 301 EXECUTOR<T>* executor = new EXECUTOR<T>(); 302 this->cloning(executor); 303 executor->fp = this->fp; 304 return executor; 305 } 306 307 //! FUNCTOR_LIST is the List of CommandConstructors 308 #define FUNCTOR_LIST(x) ExecutorConstructor ## x 309 #include "functor_list.h" 310 #undef FUNCTOR_LIST 311 312 private: 313 //! FUNCTOR_LIST is the List of FunctionPointers 314 union FunctionPointers { 315 #define FUNCTOR_LIST(x) ExecutorFunctionPoiter ## x 316 #include "functor_list.h" 317 #undef FUNCTOR_LIST 318 } fp; 319 320 321 virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const 322 { 323 //! FUNCTOR_LIST is the List of Executive Functions 324 #define FUNCTOR_LIST(x) ExecutorExecute ## x 325 #include "functor_list.h" 326 #undef FUNCTOR_LIST 327 328 } 329 }; 330 331 #endif /* _EXECUTOR_H */ 175 #undef __EXECUTOR_FUNCTIONAL_CONST 176 #undef __EXECUTOR_FUNCTIONAL_NAME 177 #undef __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC 178 #undef __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER
Note: See TracChangeset
for help on using the changeset viewer.