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