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