 | PixelLight 0.9.11-R1 Copyright (C) 2002-2012 by The PixelLight Team Last modified Thu Feb 23 2012 14:08:55 |  | The content of this PixelLight
document is published under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported |
|
PixelLightAPI
.
|
00001 /*********************************************************\ 00002 * File: FuncGenMemPtr.h * 00003 * 00004 * Copyright (C) 2002-2012 The PixelLight Team (http://www.pixellight.org/) 00005 * 00006 * This file is part of PixelLight. 00007 * 00008 * PixelLight is free software: you can redistribute it and/or modify 00009 * it under the terms of the GNU Lesser General Public License as published by 00010 * the Free Software Foundation, either version 3 of the License, or 00011 * (at your option) any later version. 00012 * 00013 * PixelLight is distributed in the hope that it will be useful, 00014 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00016 * GNU Lesser General Public License for more details. 00017 * 00018 * You should have received a copy of the GNU Lesser General Public License 00019 * along with PixelLight. If not, see <http://www.gnu.org/licenses/>. 00020 \*********************************************************/ 00021 00022 00023 #ifndef __PLCORE_FUNC_GENMEMPTR_H__ 00024 #define __PLCORE_FUNC_GENMEMPTR_H__ 00025 #pragma once 00026 00027 00028 //[-------------------------------------------------------] 00029 //[ Includes ] 00030 //[-------------------------------------------------------] 00031 #include "PLCore/Base/Func/Func.h" 00032 00033 00034 //[-------------------------------------------------------] 00035 //[ Namespace ] 00036 //[-------------------------------------------------------] 00037 namespace PLCore { 00038 00039 00040 //[-------------------------------------------------------] 00041 //[ Classes ] 00042 //[-------------------------------------------------------] 00043 /** 00044 * @brief 00045 * Member generic function pointer 00046 * 00047 * @remarks 00048 * This is a functoid that calls a member function of a object 00049 */ 00050 template <typename CLASS, typename R, typename T0 = NullType, typename T1 = NullType, typename T2 = NullType, typename T3 = NullType, typename T4 = NullType, typename T5 = NullType, typename T6 = NullType, typename T7 = NullType, typename T8 = NullType, typename T9 = NullType, typename T10 = NullType, typename T11 = NullType, typename T12 = NullType, typename T13 = NullType, typename T14 = NullType, typename T15 = NullType> 00051 class FuncGenMemPtr : public Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> { 00052 public: 00053 typedef typename Type<R> ::_Type _R; 00054 typedef typename Type<T0> ::_Type _T0; 00055 typedef typename Type<T1> ::_Type _T1; 00056 typedef typename Type<T2> ::_Type _T2; 00057 typedef typename Type<T3> ::_Type _T3; 00058 typedef typename Type<T4> ::_Type _T4; 00059 typedef typename Type<T5> ::_Type _T5; 00060 typedef typename Type<T6> ::_Type _T6; 00061 typedef typename Type<T7> ::_Type _T7; 00062 typedef typename Type<T8> ::_Type _T8; 00063 typedef typename Type<T9> ::_Type _T9; 00064 typedef typename Type<T10>::_Type _T10; 00065 typedef typename Type<T11>::_Type _T11; 00066 typedef typename Type<T12>::_Type _T12; 00067 typedef typename Type<T13>::_Type _T13; 00068 typedef typename Type<T14>::_Type _T14; 00069 typedef typename Type<T15>::_Type _T15; 00070 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00071 00072 public: 00073 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00074 } 00075 00076 virtual ~FuncGenMemPtr() { 00077 } 00078 00079 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9, _T10 t10, _T11 t11, _T12 t12, _T13 t13, _T14 t14, _T15 t15) override { 00080 if (m_pMemFunc && m_pObject) { 00081 // Get typed params 00082 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15); 00083 00084 // Make the generic method call 00085 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00086 00087 // Done, return the result 00088 return cParams.Return; 00089 } else { 00090 return DefaultValue<R>::Default(); 00091 } 00092 } 00093 00094 virtual DynFunc *Clone() const override { 00095 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00096 } 00097 00098 private: 00099 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00100 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00101 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00102 }; 00103 00104 /** 00105 * @brief 00106 * Member generic function pointer 00107 * 00108 * @remarks 00109 * Implementation for up to 16 parameters without a return value 00110 */ 00111 template <typename CLASS, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15> 00112 class FuncGenMemPtr<CLASS, void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> : public Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> { 00113 public: 00114 typedef typename Type<T0> ::_Type _T0; 00115 typedef typename Type<T1> ::_Type _T1; 00116 typedef typename Type<T2> ::_Type _T2; 00117 typedef typename Type<T3> ::_Type _T3; 00118 typedef typename Type<T4> ::_Type _T4; 00119 typedef typename Type<T5> ::_Type _T5; 00120 typedef typename Type<T6> ::_Type _T6; 00121 typedef typename Type<T7> ::_Type _T7; 00122 typedef typename Type<T8> ::_Type _T8; 00123 typedef typename Type<T9> ::_Type _T9; 00124 typedef typename Type<T10>::_Type _T10; 00125 typedef typename Type<T11>::_Type _T11; 00126 typedef typename Type<T12>::_Type _T12; 00127 typedef typename Type<T13>::_Type _T13; 00128 typedef typename Type<T14>::_Type _T14; 00129 typedef typename Type<T15>::_Type _T15; 00130 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00131 00132 public: 00133 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00134 } 00135 00136 virtual ~FuncGenMemPtr() { 00137 } 00138 00139 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9, _T10 t10, _T11 t11, _T12 t12, _T13 t13, _T14 t14, _T15 t15) override { 00140 if (m_pMemFunc && m_pObject) { 00141 // Get typed params 00142 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15); 00143 00144 // Make the generic method call 00145 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00146 } 00147 } 00148 00149 virtual DynFunc *Clone() const override { 00150 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00151 } 00152 00153 private: 00154 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00155 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00156 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00157 }; 00158 00159 /** 00160 * @brief 00161 * Member generic function pointer 00162 * 00163 * @remarks 00164 * Implementation for 15 parameters and a return value 00165 */ 00166 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14> 00167 class FuncGenMemPtr<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> : public Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> { 00168 public: 00169 typedef typename Type<R> ::_Type _R; 00170 typedef typename Type<T0> ::_Type _T0; 00171 typedef typename Type<T1> ::_Type _T1; 00172 typedef typename Type<T2> ::_Type _T2; 00173 typedef typename Type<T3> ::_Type _T3; 00174 typedef typename Type<T4> ::_Type _T4; 00175 typedef typename Type<T5> ::_Type _T5; 00176 typedef typename Type<T6> ::_Type _T6; 00177 typedef typename Type<T7> ::_Type _T7; 00178 typedef typename Type<T8> ::_Type _T8; 00179 typedef typename Type<T9> ::_Type _T9; 00180 typedef typename Type<T10>::_Type _T10; 00181 typedef typename Type<T11>::_Type _T11; 00182 typedef typename Type<T12>::_Type _T12; 00183 typedef typename Type<T13>::_Type _T13; 00184 typedef typename Type<T14>::_Type _T14; 00185 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00186 00187 public: 00188 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00189 } 00190 00191 virtual ~FuncGenMemPtr() { 00192 } 00193 00194 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9, _T10 t10, _T11 t11, _T12 t12, _T13 t13, _T14 t14) override { 00195 if (m_pMemFunc && m_pObject) { 00196 // Get typed params 00197 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14); 00198 00199 // Make the generic method call 00200 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00201 00202 // Done, return the result 00203 return cParams.Return; 00204 } else { 00205 return DefaultValue<R>::Default(); 00206 } 00207 } 00208 00209 virtual DynFunc *Clone() const override { 00210 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00211 } 00212 00213 private: 00214 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00215 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00216 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00217 }; 00218 00219 /** 00220 * @brief 00221 * Member generic function pointer 00222 * 00223 * @remarks 00224 * Implementation for 15 parameters without a return value 00225 */ 00226 template <typename CLASS, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14> 00227 class FuncGenMemPtr<CLASS, void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> : public Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> { 00228 public: 00229 typedef typename Type<T0> ::_Type _T0; 00230 typedef typename Type<T1> ::_Type _T1; 00231 typedef typename Type<T2> ::_Type _T2; 00232 typedef typename Type<T3> ::_Type _T3; 00233 typedef typename Type<T4> ::_Type _T4; 00234 typedef typename Type<T5> ::_Type _T5; 00235 typedef typename Type<T6> ::_Type _T6; 00236 typedef typename Type<T7> ::_Type _T7; 00237 typedef typename Type<T8> ::_Type _T8; 00238 typedef typename Type<T9> ::_Type _T9; 00239 typedef typename Type<T10>::_Type _T10; 00240 typedef typename Type<T11>::_Type _T11; 00241 typedef typename Type<T12>::_Type _T12; 00242 typedef typename Type<T13>::_Type _T13; 00243 typedef typename Type<T14>::_Type _T14; 00244 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00245 00246 public: 00247 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00248 } 00249 00250 virtual ~FuncGenMemPtr() { 00251 } 00252 00253 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9, _T10 t10, _T11 t11, _T12 t12, _T13 t13, _T14 t14) override { 00254 if (m_pMemFunc && m_pObject) { 00255 // Get typed params 00256 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14); 00257 00258 // Make the generic method call 00259 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00260 } 00261 } 00262 00263 virtual DynFunc *Clone() const override { 00264 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00265 } 00266 00267 private: 00268 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00269 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00270 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00271 }; 00272 00273 /** 00274 * @brief 00275 * Member generic function pointer 00276 * 00277 * @remarks 00278 * Implementation for 14 parameters and a return value 00279 */ 00280 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13> 00281 class FuncGenMemPtr<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> : public Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> { 00282 public: 00283 typedef typename Type<R> ::_Type _R; 00284 typedef typename Type<T0> ::_Type _T0; 00285 typedef typename Type<T1> ::_Type _T1; 00286 typedef typename Type<T2> ::_Type _T2; 00287 typedef typename Type<T3> ::_Type _T3; 00288 typedef typename Type<T4> ::_Type _T4; 00289 typedef typename Type<T5> ::_Type _T5; 00290 typedef typename Type<T6> ::_Type _T6; 00291 typedef typename Type<T7> ::_Type _T7; 00292 typedef typename Type<T8> ::_Type _T8; 00293 typedef typename Type<T9> ::_Type _T9; 00294 typedef typename Type<T10>::_Type _T10; 00295 typedef typename Type<T11>::_Type _T11; 00296 typedef typename Type<T12>::_Type _T12; 00297 typedef typename Type<T13>::_Type _T13; 00298 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00299 00300 public: 00301 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00302 } 00303 00304 virtual ~FuncGenMemPtr() { 00305 } 00306 00307 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9, _T10 t10, _T11 t11, _T12 t12, _T13 t13) override { 00308 if (m_pMemFunc && m_pObject) { 00309 // Get typed params 00310 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13); 00311 00312 // Make the generic method call 00313 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00314 00315 // Done, return the result 00316 return cParams.Return; 00317 } else { 00318 return DefaultValue<R>::Default(); 00319 } 00320 } 00321 00322 virtual DynFunc *Clone() const override { 00323 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00324 } 00325 00326 private: 00327 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00328 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00329 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00330 }; 00331 00332 /** 00333 * @brief 00334 * Member generic function pointer 00335 * 00336 * @remarks 00337 * Implementation for 14 parameters without a return value 00338 */ 00339 template <typename CLASS, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13> 00340 class FuncGenMemPtr<CLASS, void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> : public Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> { 00341 public: 00342 typedef typename Type<T0> ::_Type _T0; 00343 typedef typename Type<T1> ::_Type _T1; 00344 typedef typename Type<T2> ::_Type _T2; 00345 typedef typename Type<T3> ::_Type _T3; 00346 typedef typename Type<T4> ::_Type _T4; 00347 typedef typename Type<T5> ::_Type _T5; 00348 typedef typename Type<T6> ::_Type _T6; 00349 typedef typename Type<T7> ::_Type _T7; 00350 typedef typename Type<T8> ::_Type _T8; 00351 typedef typename Type<T9> ::_Type _T9; 00352 typedef typename Type<T10>::_Type _T10; 00353 typedef typename Type<T11>::_Type _T11; 00354 typedef typename Type<T12>::_Type _T12; 00355 typedef typename Type<T13>::_Type _T13; 00356 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00357 00358 public: 00359 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00360 } 00361 00362 virtual ~FuncGenMemPtr() { 00363 } 00364 00365 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9, _T10 t10, _T11 t11, _T12 t12, _T13 t13) override { 00366 if (m_pMemFunc && m_pObject) { 00367 // Get typed params 00368 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13); 00369 00370 // Make the generic method call 00371 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00372 } 00373 } 00374 00375 virtual DynFunc *Clone() const override { 00376 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00377 } 00378 00379 private: 00380 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00381 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00382 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00383 }; 00384 00385 /** 00386 * @brief 00387 * Member generic function pointer 00388 * 00389 * @remarks 00390 * Implementation for 13 parameters and a return value 00391 */ 00392 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12> 00393 class FuncGenMemPtr<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : public Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> { 00394 public: 00395 typedef typename Type<R> ::_Type _R; 00396 typedef typename Type<T0> ::_Type _T0; 00397 typedef typename Type<T1> ::_Type _T1; 00398 typedef typename Type<T2> ::_Type _T2; 00399 typedef typename Type<T3> ::_Type _T3; 00400 typedef typename Type<T4> ::_Type _T4; 00401 typedef typename Type<T5> ::_Type _T5; 00402 typedef typename Type<T6> ::_Type _T6; 00403 typedef typename Type<T7> ::_Type _T7; 00404 typedef typename Type<T8> ::_Type _T8; 00405 typedef typename Type<T9> ::_Type _T9; 00406 typedef typename Type<T10>::_Type _T10; 00407 typedef typename Type<T11>::_Type _T11; 00408 typedef typename Type<T12>::_Type _T12; 00409 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00410 00411 public: 00412 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00413 } 00414 00415 virtual ~FuncGenMemPtr() { 00416 } 00417 00418 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9, _T10 t10, _T11 t11, _T12 t12) override { 00419 if (m_pMemFunc && m_pObject) { 00420 // Get typed params 00421 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12); 00422 00423 // Make the generic method call 00424 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00425 00426 // Done, return the result 00427 return cParams.Return; 00428 } else { 00429 return DefaultValue<R>::Default(); 00430 } 00431 } 00432 00433 virtual DynFunc *Clone() const override { 00434 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00435 } 00436 00437 private: 00438 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00439 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00440 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00441 }; 00442 00443 /** 00444 * @brief 00445 * Member generic function pointer 00446 * 00447 * @remarks 00448 * Implementation for 13 parameters without a return value 00449 */ 00450 template <typename CLASS, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12> 00451 class FuncGenMemPtr<CLASS, void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : public Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> { 00452 public: 00453 typedef typename Type<T0> ::_Type _T0; 00454 typedef typename Type<T1> ::_Type _T1; 00455 typedef typename Type<T2> ::_Type _T2; 00456 typedef typename Type<T3> ::_Type _T3; 00457 typedef typename Type<T4> ::_Type _T4; 00458 typedef typename Type<T5> ::_Type _T5; 00459 typedef typename Type<T6> ::_Type _T6; 00460 typedef typename Type<T7> ::_Type _T7; 00461 typedef typename Type<T8> ::_Type _T8; 00462 typedef typename Type<T9> ::_Type _T9; 00463 typedef typename Type<T10>::_Type _T10; 00464 typedef typename Type<T11>::_Type _T11; 00465 typedef typename Type<T12>::_Type _T12; 00466 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00467 00468 public: 00469 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00470 } 00471 00472 virtual ~FuncGenMemPtr() { 00473 } 00474 00475 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9, _T10 t10, _T11 t11, _T12 t12) override { 00476 if (m_pMemFunc && m_pObject) { 00477 // Get typed params 00478 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12); 00479 00480 // Make the generic method call 00481 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00482 } 00483 } 00484 00485 virtual DynFunc *Clone() const override { 00486 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00487 } 00488 00489 private: 00490 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00491 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00492 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00493 }; 00494 00495 /** 00496 * @brief 00497 * Member generic function pointer 00498 * 00499 * @remarks 00500 * Implementation for 12 parameters and a return value 00501 */ 00502 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11> 00503 class FuncGenMemPtr<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : public Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> { 00504 public: 00505 typedef typename Type<R> ::_Type _R; 00506 typedef typename Type<T0> ::_Type _T0; 00507 typedef typename Type<T1> ::_Type _T1; 00508 typedef typename Type<T2> ::_Type _T2; 00509 typedef typename Type<T3> ::_Type _T3; 00510 typedef typename Type<T4> ::_Type _T4; 00511 typedef typename Type<T5> ::_Type _T5; 00512 typedef typename Type<T6> ::_Type _T6; 00513 typedef typename Type<T7> ::_Type _T7; 00514 typedef typename Type<T8> ::_Type _T8; 00515 typedef typename Type<T9> ::_Type _T9; 00516 typedef typename Type<T10>::_Type _T10; 00517 typedef typename Type<T11>::_Type _T11; 00518 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00519 00520 public: 00521 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00522 } 00523 00524 virtual ~FuncGenMemPtr() { 00525 } 00526 00527 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9, _T10 t10, _T11 t11) override { 00528 if (m_pMemFunc && m_pObject) { 00529 // Get typed params 00530 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11); 00531 00532 // Make the generic method call 00533 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00534 00535 // Done, return the result 00536 return cParams.Return; 00537 } else { 00538 return DefaultValue<R>::Default(); 00539 } 00540 } 00541 00542 virtual DynFunc *Clone() const override { 00543 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00544 } 00545 00546 private: 00547 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00548 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00549 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00550 }; 00551 00552 /** 00553 * @brief 00554 * Member generic function pointer 00555 * 00556 * @remarks 00557 * Implementation for 12 parameters without a return value 00558 */ 00559 template <typename CLASS, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11> 00560 class FuncGenMemPtr<CLASS, void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : public Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> { 00561 public: 00562 typedef typename Type<T0> ::_Type _T0; 00563 typedef typename Type<T1> ::_Type _T1; 00564 typedef typename Type<T2> ::_Type _T2; 00565 typedef typename Type<T3> ::_Type _T3; 00566 typedef typename Type<T4> ::_Type _T4; 00567 typedef typename Type<T5> ::_Type _T5; 00568 typedef typename Type<T6> ::_Type _T6; 00569 typedef typename Type<T7> ::_Type _T7; 00570 typedef typename Type<T8> ::_Type _T8; 00571 typedef typename Type<T9> ::_Type _T9; 00572 typedef typename Type<T10>::_Type _T10; 00573 typedef typename Type<T11>::_Type _T11; 00574 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00575 00576 public: 00577 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00578 } 00579 00580 virtual ~FuncGenMemPtr() { 00581 } 00582 00583 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9, _T10 t10, _T11 t11) override { 00584 if (m_pMemFunc && m_pObject) { 00585 // Get typed params 00586 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11); 00587 00588 // Make the generic method call 00589 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00590 } 00591 } 00592 00593 virtual DynFunc *Clone() const override { 00594 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00595 } 00596 00597 private: 00598 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00599 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00600 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00601 }; 00602 00603 /** 00604 * @brief 00605 * Member generic function pointer 00606 * 00607 * @remarks 00608 * Implementation for 11 parameters and a return value 00609 */ 00610 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> 00611 class FuncGenMemPtr<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : public Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> { 00612 public: 00613 typedef typename Type<R> ::_Type _R; 00614 typedef typename Type<T0> ::_Type _T0; 00615 typedef typename Type<T1> ::_Type _T1; 00616 typedef typename Type<T2> ::_Type _T2; 00617 typedef typename Type<T3> ::_Type _T3; 00618 typedef typename Type<T4> ::_Type _T4; 00619 typedef typename Type<T5> ::_Type _T5; 00620 typedef typename Type<T6> ::_Type _T6; 00621 typedef typename Type<T7> ::_Type _T7; 00622 typedef typename Type<T8> ::_Type _T8; 00623 typedef typename Type<T9> ::_Type _T9; 00624 typedef typename Type<T10>::_Type _T10; 00625 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00626 00627 public: 00628 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00629 } 00630 00631 virtual ~FuncGenMemPtr() { 00632 } 00633 00634 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9, _T10 t10) override { 00635 if (m_pMemFunc && m_pObject) { 00636 // Get typed params 00637 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); 00638 00639 // Make the generic method call 00640 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00641 00642 // Done, return the result 00643 return cParams.Return; 00644 } else { 00645 return DefaultValue<R>::Default(); 00646 } 00647 } 00648 00649 virtual DynFunc *Clone() const override { 00650 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00651 } 00652 00653 private: 00654 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00655 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00656 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00657 }; 00658 00659 /** 00660 * @brief 00661 * Member generic function pointer 00662 * 00663 * @remarks 00664 * Implementation for 11 parameters without a return value 00665 */ 00666 template <typename CLASS, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> 00667 class FuncGenMemPtr<CLASS, void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : public Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> { 00668 public: 00669 typedef typename Type<T0> ::_Type _T0; 00670 typedef typename Type<T1> ::_Type _T1; 00671 typedef typename Type<T2> ::_Type _T2; 00672 typedef typename Type<T3> ::_Type _T3; 00673 typedef typename Type<T4> ::_Type _T4; 00674 typedef typename Type<T5> ::_Type _T5; 00675 typedef typename Type<T6> ::_Type _T6; 00676 typedef typename Type<T7> ::_Type _T7; 00677 typedef typename Type<T8> ::_Type _T8; 00678 typedef typename Type<T9> ::_Type _T9; 00679 typedef typename Type<T10>::_Type _T10; 00680 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00681 00682 public: 00683 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00684 } 00685 00686 virtual ~FuncGenMemPtr() { 00687 } 00688 00689 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9, _T10 t10) override { 00690 if (m_pMemFunc && m_pObject) { 00691 // Get typed params 00692 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); 00693 00694 // Make the generic method call 00695 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00696 } 00697 } 00698 00699 virtual DynFunc *Clone() const override { 00700 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00701 } 00702 00703 private: 00704 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00705 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00706 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00707 }; 00708 00709 /** 00710 * @brief 00711 * Member generic function pointer 00712 * 00713 * @remarks 00714 * Implementation for 10 parameters and a return value 00715 */ 00716 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> 00717 class FuncGenMemPtr<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> : public Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> { 00718 public: 00719 typedef typename Type<R> ::_Type _R; 00720 typedef typename Type<T0> ::_Type _T0; 00721 typedef typename Type<T1> ::_Type _T1; 00722 typedef typename Type<T2> ::_Type _T2; 00723 typedef typename Type<T3> ::_Type _T3; 00724 typedef typename Type<T4> ::_Type _T4; 00725 typedef typename Type<T5> ::_Type _T5; 00726 typedef typename Type<T6> ::_Type _T6; 00727 typedef typename Type<T7> ::_Type _T7; 00728 typedef typename Type<T8> ::_Type _T8; 00729 typedef typename Type<T9> ::_Type _T9; 00730 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00731 00732 public: 00733 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00734 } 00735 00736 virtual ~FuncGenMemPtr() { 00737 } 00738 00739 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9) override { 00740 if (m_pMemFunc && m_pObject) { 00741 // Get typed params 00742 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9); 00743 00744 // Make the generic method call 00745 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00746 00747 // Done, return the result 00748 return cParams.Return; 00749 } else { 00750 return DefaultValue<R>::Default(); 00751 } 00752 } 00753 00754 virtual DynFunc *Clone() const override { 00755 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00756 } 00757 00758 private: 00759 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00760 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00761 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00762 }; 00763 00764 /** 00765 * @brief 00766 * Member generic function pointer 00767 * 00768 * @remarks 00769 * Implementation for 10 parameters without a return value 00770 */ 00771 template <typename CLASS, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> 00772 class FuncGenMemPtr<CLASS, void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> : public Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> { 00773 public: 00774 typedef typename Type<T0> ::_Type _T0; 00775 typedef typename Type<T1> ::_Type _T1; 00776 typedef typename Type<T2> ::_Type _T2; 00777 typedef typename Type<T3> ::_Type _T3; 00778 typedef typename Type<T4> ::_Type _T4; 00779 typedef typename Type<T5> ::_Type _T5; 00780 typedef typename Type<T6> ::_Type _T6; 00781 typedef typename Type<T7> ::_Type _T7; 00782 typedef typename Type<T8> ::_Type _T8; 00783 typedef typename Type<T9> ::_Type _T9; 00784 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00785 00786 public: 00787 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00788 } 00789 00790 virtual ~FuncGenMemPtr() { 00791 } 00792 00793 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9) override { 00794 if (m_pMemFunc && m_pObject) { 00795 // Get typed params 00796 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9); 00797 00798 // Make the generic method call 00799 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00800 } 00801 } 00802 00803 virtual DynFunc *Clone() const override { 00804 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00805 } 00806 00807 private: 00808 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00809 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00810 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00811 }; 00812 00813 /** 00814 * @brief 00815 * Member generic function pointer 00816 * 00817 * @remarks 00818 * Implementation for 9 parameters and a return value 00819 */ 00820 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> 00821 class FuncGenMemPtr<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7, T8> : public Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> { 00822 public: 00823 typedef typename Type<R> ::_Type _R; 00824 typedef typename Type<T0> ::_Type _T0; 00825 typedef typename Type<T1> ::_Type _T1; 00826 typedef typename Type<T2> ::_Type _T2; 00827 typedef typename Type<T3> ::_Type _T3; 00828 typedef typename Type<T4> ::_Type _T4; 00829 typedef typename Type<T5> ::_Type _T5; 00830 typedef typename Type<T6> ::_Type _T6; 00831 typedef typename Type<T7> ::_Type _T7; 00832 typedef typename Type<T8> ::_Type _T8; 00833 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00834 00835 public: 00836 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00837 } 00838 00839 virtual ~FuncGenMemPtr() { 00840 } 00841 00842 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8) override { 00843 if (m_pMemFunc && m_pObject) { 00844 // Get typed params 00845 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8); 00846 00847 // Make the generic method call 00848 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00849 00850 // Done, return the result 00851 return cParams.Return; 00852 } else { 00853 return DefaultValue<R>::Default(); 00854 } 00855 } 00856 00857 virtual DynFunc *Clone() const override { 00858 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00859 } 00860 00861 private: 00862 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00863 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00864 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00865 }; 00866 00867 /** 00868 * @brief 00869 * Member generic function pointer 00870 * 00871 * @remarks 00872 * Implementation for 9 parameters without a return value 00873 */ 00874 template <typename CLASS, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> 00875 class FuncGenMemPtr<CLASS, void, T0, T1, T2, T3, T4, T5, T6, T7, T8> : public Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8> { 00876 public: 00877 typedef typename Type<T0> ::_Type _T0; 00878 typedef typename Type<T1> ::_Type _T1; 00879 typedef typename Type<T2> ::_Type _T2; 00880 typedef typename Type<T3> ::_Type _T3; 00881 typedef typename Type<T4> ::_Type _T4; 00882 typedef typename Type<T5> ::_Type _T5; 00883 typedef typename Type<T6> ::_Type _T6; 00884 typedef typename Type<T7> ::_Type _T7; 00885 typedef typename Type<T8> ::_Type _T8; 00886 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00887 00888 public: 00889 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00890 } 00891 00892 virtual ~FuncGenMemPtr() { 00893 } 00894 00895 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8) override { 00896 if (m_pMemFunc && m_pObject) { 00897 // Get typed params 00898 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8> cParams(t0, t1, t2, t3, t4, t5, t6, t7, t8); 00899 00900 // Make the generic method call 00901 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00902 } 00903 } 00904 00905 virtual DynFunc *Clone() const override { 00906 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00907 } 00908 00909 private: 00910 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00911 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00912 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00913 }; 00914 00915 /** 00916 * @brief 00917 * Member generic function pointer 00918 * 00919 * @remarks 00920 * Implementation for 8 parameters and a return value 00921 */ 00922 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> 00923 class FuncGenMemPtr<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7> : public Func<R, T0, T1, T2, T3, T4, T5, T6, T7> { 00924 public: 00925 typedef typename Type<R> ::_Type _R; 00926 typedef typename Type<T0> ::_Type _T0; 00927 typedef typename Type<T1> ::_Type _T1; 00928 typedef typename Type<T2> ::_Type _T2; 00929 typedef typename Type<T3> ::_Type _T3; 00930 typedef typename Type<T4> ::_Type _T4; 00931 typedef typename Type<T5> ::_Type _T5; 00932 typedef typename Type<T6> ::_Type _T6; 00933 typedef typename Type<T7> ::_Type _T7; 00934 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00935 00936 public: 00937 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00938 } 00939 00940 virtual ~FuncGenMemPtr() { 00941 } 00942 00943 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7) override { 00944 if (m_pMemFunc && m_pObject) { 00945 // Get typed params 00946 Params<R, T0, T1, T2, T3, T4, T5, T6, T7> cParams(t0, t1, t2, t3, t4, t5, t6, t7); 00947 00948 // Make the generic method call 00949 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 00950 00951 // Done, return the result 00952 return cParams.Return; 00953 } else { 00954 return DefaultValue<R>::Default(); 00955 } 00956 } 00957 00958 virtual DynFunc *Clone() const override { 00959 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 00960 } 00961 00962 private: 00963 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 00964 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 00965 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 00966 }; 00967 00968 /** 00969 * @brief 00970 * Member generic function pointer 00971 * 00972 * @remarks 00973 * Implementation for 8 parameters without a return value 00974 */ 00975 template <typename CLASS, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> 00976 class FuncGenMemPtr<CLASS, void, T0, T1, T2, T3, T4, T5, T6, T7> : public Func<void, T0, T1, T2, T3, T4, T5, T6, T7> { 00977 public: 00978 typedef typename Type<T0> ::_Type _T0; 00979 typedef typename Type<T1> ::_Type _T1; 00980 typedef typename Type<T2> ::_Type _T2; 00981 typedef typename Type<T3> ::_Type _T3; 00982 typedef typename Type<T4> ::_Type _T4; 00983 typedef typename Type<T5> ::_Type _T5; 00984 typedef typename Type<T6> ::_Type _T6; 00985 typedef typename Type<T7> ::_Type _T7; 00986 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 00987 00988 public: 00989 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 00990 } 00991 00992 virtual ~FuncGenMemPtr() { 00993 } 00994 00995 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7) override { 00996 if (m_pMemFunc && m_pObject) { 00997 // Get typed params 00998 Params<void, T0, T1, T2, T3, T4, T5, T6, T7> cParams(t0, t1, t2, t3, t4, t5, t6, t7); 00999 01000 // Make the generic method call 01001 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01002 } 01003 } 01004 01005 virtual DynFunc *Clone() const override { 01006 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01007 } 01008 01009 private: 01010 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01011 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01012 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01013 }; 01014 01015 /** 01016 * @brief 01017 * Member generic function pointer 01018 * 01019 * @remarks 01020 * Implementation for 7 parameters and a return value 01021 */ 01022 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> 01023 class FuncGenMemPtr<CLASS, R, T0, T1, T2, T3, T4, T5, T6> : public Func<R, T0, T1, T2, T3, T4, T5, T6> { 01024 public: 01025 typedef typename Type<R> ::_Type _R; 01026 typedef typename Type<T0> ::_Type _T0; 01027 typedef typename Type<T1> ::_Type _T1; 01028 typedef typename Type<T2> ::_Type _T2; 01029 typedef typename Type<T3> ::_Type _T3; 01030 typedef typename Type<T4> ::_Type _T4; 01031 typedef typename Type<T5> ::_Type _T5; 01032 typedef typename Type<T6> ::_Type _T6; 01033 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01034 01035 public: 01036 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01037 } 01038 01039 virtual ~FuncGenMemPtr() { 01040 } 01041 01042 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6) override { 01043 if (m_pMemFunc && m_pObject) { 01044 // Get typed params 01045 Params<R, T0, T1, T2, T3, T4, T5, T6> cParams(t0, t1, t2, t3, t4, t5, t6); 01046 01047 // Make the generic method call 01048 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01049 01050 // Done, return the result 01051 return cParams.Return; 01052 } else { 01053 return DefaultValue<R>::Default(); 01054 } 01055 } 01056 01057 virtual DynFunc *Clone() const override { 01058 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01059 } 01060 01061 private: 01062 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01063 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01064 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01065 }; 01066 01067 /** 01068 * @brief 01069 * Member generic function pointer 01070 * 01071 * @remarks 01072 * Implementation for 7 parameters without a return value 01073 */ 01074 template <typename CLASS, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> 01075 class FuncGenMemPtr<CLASS, void, T0, T1, T2, T3, T4, T5, T6> : public Func<void, T0, T1, T2, T3, T4, T5, T6> { 01076 public: 01077 typedef typename Type<T0> ::_Type _T0; 01078 typedef typename Type<T1> ::_Type _T1; 01079 typedef typename Type<T2> ::_Type _T2; 01080 typedef typename Type<T3> ::_Type _T3; 01081 typedef typename Type<T4> ::_Type _T4; 01082 typedef typename Type<T5> ::_Type _T5; 01083 typedef typename Type<T6> ::_Type _T6; 01084 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01085 01086 public: 01087 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01088 } 01089 01090 virtual ~FuncGenMemPtr() { 01091 } 01092 01093 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6) override { 01094 if (m_pMemFunc && m_pObject) { 01095 // Get typed params 01096 Params<void, T0, T1, T2, T3, T4, T5, T6> cParams(t0, t1, t2, t3, t4, t5, t6); 01097 01098 // Make the generic method call 01099 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01100 } 01101 } 01102 01103 virtual DynFunc *Clone() const override { 01104 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01105 } 01106 01107 private: 01108 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01109 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01110 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01111 }; 01112 01113 /** 01114 * @brief 01115 * Member generic function pointer 01116 * 01117 * @remarks 01118 * Implementation for 6 parameters and a return value 01119 */ 01120 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5> 01121 class FuncGenMemPtr<CLASS, R, T0, T1, T2, T3, T4, T5> : public Func<R, T0, T1, T2, T3, T4, T5> { 01122 public: 01123 typedef typename Type<R> ::_Type _R; 01124 typedef typename Type<T0> ::_Type _T0; 01125 typedef typename Type<T1> ::_Type _T1; 01126 typedef typename Type<T2> ::_Type _T2; 01127 typedef typename Type<T3> ::_Type _T3; 01128 typedef typename Type<T4> ::_Type _T4; 01129 typedef typename Type<T5> ::_Type _T5; 01130 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01131 01132 public: 01133 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01134 } 01135 01136 virtual ~FuncGenMemPtr() { 01137 } 01138 01139 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5) override { 01140 if (m_pMemFunc && m_pObject) { 01141 // Get typed params 01142 Params<R, T0, T1, T2, T3, T4, T5> cParams(t0, t1, t2, t3, t4, t5); 01143 01144 // Make the generic method call 01145 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01146 01147 // Done, return the result 01148 return cParams.Return; 01149 } else { 01150 return DefaultValue<R>::Default(); 01151 } 01152 } 01153 01154 virtual DynFunc *Clone() const override { 01155 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01156 } 01157 01158 private: 01159 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01160 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01161 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01162 }; 01163 01164 /** 01165 * @brief 01166 * Member generic function pointer 01167 * 01168 * @remarks 01169 * Implementation for 6 parameters without a return value 01170 */ 01171 template <typename CLASS, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5> 01172 class FuncGenMemPtr<CLASS, void, T0, T1, T2, T3, T4, T5> : public Func<void, T0, T1, T2, T3, T4, T5> { 01173 public: 01174 typedef typename Type<T0> ::_Type _T0; 01175 typedef typename Type<T1> ::_Type _T1; 01176 typedef typename Type<T2> ::_Type _T2; 01177 typedef typename Type<T3> ::_Type _T3; 01178 typedef typename Type<T4> ::_Type _T4; 01179 typedef typename Type<T5> ::_Type _T5; 01180 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01181 01182 public: 01183 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01184 } 01185 01186 virtual ~FuncGenMemPtr() { 01187 } 01188 01189 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5) override { 01190 if (m_pMemFunc && m_pObject) { 01191 // Get typed params 01192 Params<void, T0, T1, T2, T3, T4, T5> cParams(t0, t1, t2, t3, t4, t5); 01193 01194 // Make the generic method call 01195 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01196 } 01197 } 01198 01199 virtual DynFunc *Clone() const override { 01200 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01201 } 01202 01203 private: 01204 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01205 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01206 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01207 }; 01208 01209 /** 01210 * @brief 01211 * Member generic function pointer 01212 * 01213 * @remarks 01214 * Implementation for 5 parameters and a return value 01215 */ 01216 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4> 01217 class FuncGenMemPtr<CLASS, R, T0, T1, T2, T3, T4> : public Func<R, T0, T1, T2, T3, T4> { 01218 public: 01219 typedef typename Type<R> ::_Type _R; 01220 typedef typename Type<T0> ::_Type _T0; 01221 typedef typename Type<T1> ::_Type _T1; 01222 typedef typename Type<T2> ::_Type _T2; 01223 typedef typename Type<T3> ::_Type _T3; 01224 typedef typename Type<T4> ::_Type _T4; 01225 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01226 01227 public: 01228 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01229 } 01230 01231 virtual ~FuncGenMemPtr() { 01232 } 01233 01234 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4) override { 01235 if (m_pMemFunc && m_pObject) { 01236 // Get typed params 01237 Params<R, T0, T1, T2, T3, T4> cParams(t0, t1, t2, t3, t4); 01238 01239 // Make the generic method call 01240 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01241 01242 // Done, return the result 01243 return cParams.Return; 01244 } else { 01245 return DefaultValue<R>::Default(); 01246 } 01247 } 01248 01249 virtual DynFunc *Clone() const override { 01250 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01251 } 01252 01253 private: 01254 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01255 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01256 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01257 }; 01258 01259 /** 01260 * @brief 01261 * Member generic function pointer 01262 * 01263 * @remarks 01264 * Implementation for 5 parameters without a return value 01265 */ 01266 template <typename CLASS, typename T0, typename T1, typename T2, typename T3, typename T4> 01267 class FuncGenMemPtr<CLASS, void, T0, T1, T2, T3, T4> : public Func<void, T0, T1, T2, T3, T4> { 01268 public: 01269 typedef typename Type<T0> ::_Type _T0; 01270 typedef typename Type<T1> ::_Type _T1; 01271 typedef typename Type<T2> ::_Type _T2; 01272 typedef typename Type<T3> ::_Type _T3; 01273 typedef typename Type<T4> ::_Type _T4; 01274 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01275 01276 public: 01277 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01278 } 01279 01280 virtual ~FuncGenMemPtr() { 01281 } 01282 01283 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4) override { 01284 if (m_pMemFunc && m_pObject) { 01285 // Get typed params 01286 Params<void, T0, T1, T2, T3, T4> cParams(t0, t1, t2, t3, t4); 01287 01288 // Make the generic method call 01289 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01290 } 01291 } 01292 01293 virtual DynFunc *Clone() const override { 01294 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01295 } 01296 01297 private: 01298 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01299 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01300 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01301 }; 01302 01303 /** 01304 * @brief 01305 * Member generic function pointer 01306 * 01307 * @remarks 01308 * Implementation for 4 parameters and a return value 01309 */ 01310 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3> 01311 class FuncGenMemPtr<CLASS, R, T0, T1, T2, T3> : public Func<R, T0, T1, T2, T3> { 01312 public: 01313 typedef typename Type<R> ::_Type _R; 01314 typedef typename Type<T0> ::_Type _T0; 01315 typedef typename Type<T1> ::_Type _T1; 01316 typedef typename Type<T2> ::_Type _T2; 01317 typedef typename Type<T3> ::_Type _T3; 01318 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01319 01320 public: 01321 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01322 } 01323 01324 virtual ~FuncGenMemPtr() { 01325 } 01326 01327 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3) override { 01328 if (m_pMemFunc && m_pObject) { 01329 // Get typed params 01330 Params<R, T0, T1, T2, T3> cParams(t0, t1, t2, t3); 01331 01332 // Make the generic method call 01333 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01334 01335 // Done, return the result 01336 return cParams.Return; 01337 } else { 01338 return DefaultValue<R>::Default(); 01339 } 01340 } 01341 01342 virtual DynFunc *Clone() const override { 01343 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01344 } 01345 01346 private: 01347 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01348 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01349 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01350 }; 01351 01352 /** 01353 * @brief 01354 * Member generic function pointer 01355 * 01356 * @remarks 01357 * Implementation for 4 parameters without a return value 01358 */ 01359 template <typename CLASS, typename T0, typename T1, typename T2, typename T3> 01360 class FuncGenMemPtr<CLASS, void, T0, T1, T2, T3> : public Func<void, T0, T1, T2, T3> { 01361 public: 01362 typedef typename Type<T0> ::_Type _T0; 01363 typedef typename Type<T1> ::_Type _T1; 01364 typedef typename Type<T2> ::_Type _T2; 01365 typedef typename Type<T3> ::_Type _T3; 01366 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01367 01368 public: 01369 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01370 } 01371 01372 virtual ~FuncGenMemPtr() { 01373 } 01374 01375 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3) override { 01376 if (m_pMemFunc && m_pObject) { 01377 // Get typed params 01378 Params<void, T0, T1, T2, T3> cParams(t0, t1, t2, t3); 01379 01380 // Make the generic method call 01381 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01382 } 01383 } 01384 01385 virtual DynFunc *Clone() const override { 01386 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01387 } 01388 01389 private: 01390 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01391 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01392 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01393 }; 01394 01395 /** 01396 * @brief 01397 * Member generic function pointer 01398 * 01399 * @remarks 01400 * Implementation for 3 parameters and a return value 01401 */ 01402 template <typename CLASS, typename R, typename T0, typename T1, typename T2> 01403 class FuncGenMemPtr<CLASS, R, T0, T1, T2> : public Func<R, T0, T1, T2> { 01404 public: 01405 typedef typename Type<R> ::_Type _R; 01406 typedef typename Type<T0> ::_Type _T0; 01407 typedef typename Type<T1> ::_Type _T1; 01408 typedef typename Type<T2> ::_Type _T2; 01409 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01410 01411 public: 01412 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01413 } 01414 01415 virtual ~FuncGenMemPtr() { 01416 } 01417 01418 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2) override { 01419 if (m_pMemFunc && m_pObject) { 01420 // Get typed params 01421 Params<R, T0, T1, T2> cParams(t0, t1, t2); 01422 01423 // Make the generic method call 01424 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01425 01426 // Done, return the result 01427 return cParams.Return; 01428 } else { 01429 return DefaultValue<R>::Default(); 01430 } 01431 } 01432 01433 virtual DynFunc *Clone() const override { 01434 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01435 } 01436 01437 private: 01438 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01439 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01440 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01441 }; 01442 01443 /** 01444 * @brief 01445 * Member generic function pointer 01446 * 01447 * @remarks 01448 * Implementation for 3 parameters without a return value 01449 */ 01450 template <typename CLASS, typename T0, typename T1, typename T2> 01451 class FuncGenMemPtr<CLASS, void, T0, T1, T2> : public Func<void, T0, T1, T2> { 01452 public: 01453 typedef typename Type<T0> ::_Type _T0; 01454 typedef typename Type<T1> ::_Type _T1; 01455 typedef typename Type<T2> ::_Type _T2; 01456 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01457 01458 public: 01459 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01460 } 01461 01462 virtual ~FuncGenMemPtr() { 01463 } 01464 01465 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2) override { 01466 if (m_pMemFunc && m_pObject) { 01467 // Get typed params 01468 Params<void, T0, T1, T2> cParams(t0, t1, t2); 01469 01470 // Make the generic method call 01471 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01472 } 01473 } 01474 01475 virtual DynFunc *Clone() const override { 01476 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01477 } 01478 01479 private: 01480 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01481 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01482 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01483 }; 01484 01485 /** 01486 * @brief 01487 * Member generic function pointer 01488 * 01489 * @remarks 01490 * Implementation for 2 parameters and a return value 01491 */ 01492 template <typename CLASS, typename R, typename T0, typename T1> 01493 class FuncGenMemPtr<CLASS, R, T0, T1> : public Func<R, T0, T1> { 01494 public: 01495 typedef typename Type<R> ::_Type _R; 01496 typedef typename Type<T0> ::_Type _T0; 01497 typedef typename Type<T1> ::_Type _T1; 01498 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01499 01500 public: 01501 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01502 } 01503 01504 virtual ~FuncGenMemPtr() { 01505 } 01506 01507 virtual _R operator ()(_T0 t0, _T1 t1) override { 01508 if (m_pMemFunc && m_pObject) { 01509 // Get typed params 01510 Params<R, T0, T1> cParams(t0, t1); 01511 01512 // Make the generic method call 01513 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01514 01515 // Done, return the result 01516 return cParams.Return; 01517 } else { 01518 return DefaultValue<R>::Default(); 01519 } 01520 } 01521 01522 virtual DynFunc *Clone() const override { 01523 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01524 } 01525 01526 private: 01527 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01528 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01529 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01530 }; 01531 01532 /** 01533 * @brief 01534 * Member generic function pointer 01535 * 01536 * @remarks 01537 * Implementation for 2 parameters without a return value 01538 */ 01539 template <typename CLASS, typename T0, typename T1> 01540 class FuncGenMemPtr<CLASS, void, T0, T1> : public Func<void, T0, T1> { 01541 public: 01542 typedef typename Type<T0> ::_Type _T0; 01543 typedef typename Type<T1> ::_Type _T1; 01544 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01545 01546 public: 01547 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01548 } 01549 01550 virtual ~FuncGenMemPtr() { 01551 } 01552 01553 virtual void operator ()(_T0 t0, _T1 t1) override { 01554 if (m_pMemFunc && m_pObject) { 01555 // Get typed params 01556 Params<void, T0, T1> cParams(t0, t1); 01557 01558 // Make the generic method call 01559 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01560 } 01561 } 01562 01563 virtual DynFunc *Clone() const override { 01564 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01565 } 01566 01567 private: 01568 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01569 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01570 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01571 }; 01572 01573 /** 01574 * @brief 01575 * Member generic function pointer 01576 * 01577 * @remarks 01578 * Implementation for 1 parameters and a return value 01579 */ 01580 template <typename CLASS, typename R, typename T0> 01581 class FuncGenMemPtr<CLASS, R, T0> : public Func<R, T0> { 01582 public: 01583 typedef typename Type<R> ::_Type _R; 01584 typedef typename Type<T0> ::_Type _T0; 01585 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01586 01587 public: 01588 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01589 } 01590 01591 virtual ~FuncGenMemPtr() { 01592 } 01593 01594 virtual _R operator ()(_T0 t0) override { 01595 if (m_pMemFunc && m_pObject) { 01596 // Get typed params 01597 Params<R, T0> cParams(t0); 01598 01599 // Make the generic method call 01600 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01601 01602 // Done, return the result 01603 return cParams.Return; 01604 } else { 01605 return DefaultValue<R>::Default(); 01606 } 01607 } 01608 01609 virtual DynFunc *Clone() const override { 01610 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01611 } 01612 01613 private: 01614 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01615 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01616 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01617 }; 01618 01619 /** 01620 * @brief 01621 * Member generic function pointer 01622 * 01623 * @remarks 01624 * Implementation for 1 parameters without a return value 01625 */ 01626 template <typename CLASS, typename T0> 01627 class FuncGenMemPtr<CLASS, void, T0> : public Func<void, T0> { 01628 public: 01629 typedef typename Type<T0> ::_Type _T0; 01630 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01631 01632 public: 01633 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01634 } 01635 01636 virtual ~FuncGenMemPtr() { 01637 } 01638 01639 virtual void operator ()(_T0 t0) override { 01640 if (m_pMemFunc && m_pObject) { 01641 // Get typed params 01642 Params<void, T0> cParams(t0); 01643 01644 // Make the generic method call 01645 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01646 } 01647 } 01648 01649 virtual DynFunc *Clone() const override { 01650 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01651 } 01652 01653 private: 01654 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01655 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01656 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01657 }; 01658 01659 /** 01660 * @brief 01661 * Member generic function pointer 01662 * 01663 * @remarks 01664 * Implementation for 0 parameters and a return value 01665 */ 01666 template <typename CLASS, typename R> 01667 class FuncGenMemPtr<CLASS, R> : public Func<R> { 01668 public: 01669 typedef typename Type<R> ::_Type _R; 01670 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01671 01672 public: 01673 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01674 } 01675 01676 virtual ~FuncGenMemPtr() { 01677 } 01678 01679 virtual _R operator ()() override { 01680 if (m_pMemFunc && m_pObject) { 01681 // Get typed params 01682 Params<R> cParams(); 01683 01684 // Make the generic method call 01685 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01686 01687 // Done, return the result 01688 return cParams.Return; 01689 } else { 01690 return DefaultValue<R>::Default(); 01691 } 01692 } 01693 01694 virtual DynFunc *Clone() const override { 01695 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01696 } 01697 01698 private: 01699 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01700 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01701 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01702 }; 01703 01704 /** 01705 * @brief 01706 * Member generic function pointer 01707 * 01708 * @remarks 01709 * Implementation for 0 parameters without a return value 01710 */ 01711 template <typename CLASS> 01712 class FuncGenMemPtr<CLASS, void> : public Func<void> { 01713 public: 01714 typedef typename MethodSignature<CLASS, void, DynParams&, void*>::MemFuncType MEMFUNC; 01715 01716 public: 01717 FuncGenMemPtr(const MEMFUNC &pMemFunc, CLASS *pObject, void *pUserData = nullptr) : m_pMemFunc(pMemFunc), m_pObject(pObject), m_pUserData(pUserData) { 01718 } 01719 01720 virtual ~FuncGenMemPtr() { 01721 } 01722 01723 virtual void operator ()() override { 01724 if (m_pMemFunc && m_pObject) { 01725 // Get typed params 01726 Params<void> cParams; 01727 01728 // Make the generic method call 01729 ((*m_pObject).*m_pMemFunc)(cParams, m_pUserData); 01730 } 01731 } 01732 01733 virtual DynFunc *Clone() const override { 01734 return new FuncGenMemPtr(m_pMemFunc, m_pObject, m_pUserData); 01735 } 01736 01737 private: 01738 MEMFUNC m_pMemFunc; /**< Member function of a class, can be a null pointer */ 01739 CLASS *m_pObject; /**< Pointer to object, can be a null pointer */ 01740 void *m_pUserData; /**< Pointer to user data, can be a null pointer */ 01741 }; 01742 01743 01744 //[-------------------------------------------------------] 01745 //[ Namespace ] 01746 //[-------------------------------------------------------] 01747 } // PLCore 01748 01749 01750 #endif // __PLCORE_FUNC_GENMEMPTR_H__
|