 | PixelLight 0.9.11-R1 Copyright (C) 2002-2012 by The PixelLight Team Last modified Thu Feb 23 2012 14:08:54 |  | The content of this PixelLight
document is published under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported |
|
PixelLightAPI
.
|
00001 /*********************************************************\ 00002 * File: FuncFunPtr.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_FUNPTR_H__ 00024 #define __PLCORE_FUNC_FUNPTR_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 function pointer 00046 * 00047 * @remarks 00048 * This is a functoid that calls a static 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 FuncFunPtr : 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<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::FuncType FUNC; 00071 00072 public: 00073 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00074 } 00075 00076 virtual ~FuncFunPtr() { 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 return m_pFunc ? (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15) : DefaultValue<R>::Default(); 00081 } 00082 00083 virtual DynFunc *Clone() const override { 00084 return new FuncFunPtr(m_pFunc); 00085 } 00086 00087 private: 00088 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00089 }; 00090 00091 /** 00092 * @brief 00093 * Static function pointer 00094 * 00095 * @remarks 00096 * Implementation for up to 16 parameters without a return value 00097 */ 00098 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> 00099 class FuncFunPtr<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> { 00100 public: 00101 typedef typename Type<T0> ::_Type _T0; 00102 typedef typename Type<T1> ::_Type _T1; 00103 typedef typename Type<T2> ::_Type _T2; 00104 typedef typename Type<T3> ::_Type _T3; 00105 typedef typename Type<T4> ::_Type _T4; 00106 typedef typename Type<T5> ::_Type _T5; 00107 typedef typename Type<T6> ::_Type _T6; 00108 typedef typename Type<T7> ::_Type _T7; 00109 typedef typename Type<T8> ::_Type _T8; 00110 typedef typename Type<T9> ::_Type _T9; 00111 typedef typename Type<T10>::_Type _T10; 00112 typedef typename Type<T11>::_Type _T11; 00113 typedef typename Type<T12>::_Type _T12; 00114 typedef typename Type<T13>::_Type _T13; 00115 typedef typename Type<T14>::_Type _T14; 00116 typedef typename Type<T15>::_Type _T15; 00117 typedef typename Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::FuncType FUNC; 00118 00119 public: 00120 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00121 } 00122 00123 virtual ~FuncFunPtr() { 00124 } 00125 00126 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 { 00127 if (m_pFunc) 00128 (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15); 00129 } 00130 00131 virtual DynFunc *Clone() const override { 00132 return new FuncFunPtr(m_pFunc); 00133 } 00134 00135 private: 00136 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00137 }; 00138 00139 /** 00140 * @brief 00141 * Static function pointer 00142 * 00143 * @remarks 00144 * Implementation for 15 parameters and a return value 00145 */ 00146 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> 00147 class FuncFunPtr<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> { 00148 public: 00149 typedef typename Type<R> ::_Type _R; 00150 typedef typename Type<T0> ::_Type _T0; 00151 typedef typename Type<T1> ::_Type _T1; 00152 typedef typename Type<T2> ::_Type _T2; 00153 typedef typename Type<T3> ::_Type _T3; 00154 typedef typename Type<T4> ::_Type _T4; 00155 typedef typename Type<T5> ::_Type _T5; 00156 typedef typename Type<T6> ::_Type _T6; 00157 typedef typename Type<T7> ::_Type _T7; 00158 typedef typename Type<T8> ::_Type _T8; 00159 typedef typename Type<T9> ::_Type _T9; 00160 typedef typename Type<T10>::_Type _T10; 00161 typedef typename Type<T11>::_Type _T11; 00162 typedef typename Type<T12>::_Type _T12; 00163 typedef typename Type<T13>::_Type _T13; 00164 typedef typename Type<T14>::_Type _T14; 00165 typedef typename Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::FuncType FUNC; 00166 00167 public: 00168 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00169 } 00170 00171 virtual ~FuncFunPtr() { 00172 } 00173 00174 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 { 00175 return m_pFunc ? (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14) : DefaultValue<R>::Default(); 00176 } 00177 00178 virtual DynFunc *Clone() const override { 00179 return new FuncFunPtr(m_pFunc); 00180 } 00181 00182 private: 00183 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00184 }; 00185 00186 /** 00187 * @brief 00188 * Static function pointer 00189 * 00190 * @remarks 00191 * Implementation for 15 parameters without a return value 00192 */ 00193 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> 00194 class FuncFunPtr<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> { 00195 public: 00196 typedef typename Type<T0> ::_Type _T0; 00197 typedef typename Type<T1> ::_Type _T1; 00198 typedef typename Type<T2> ::_Type _T2; 00199 typedef typename Type<T3> ::_Type _T3; 00200 typedef typename Type<T4> ::_Type _T4; 00201 typedef typename Type<T5> ::_Type _T5; 00202 typedef typename Type<T6> ::_Type _T6; 00203 typedef typename Type<T7> ::_Type _T7; 00204 typedef typename Type<T8> ::_Type _T8; 00205 typedef typename Type<T9> ::_Type _T9; 00206 typedef typename Type<T10>::_Type _T10; 00207 typedef typename Type<T11>::_Type _T11; 00208 typedef typename Type<T12>::_Type _T12; 00209 typedef typename Type<T13>::_Type _T13; 00210 typedef typename Type<T14>::_Type _T14; 00211 typedef typename Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::FuncType FUNC; 00212 00213 public: 00214 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00215 } 00216 00217 virtual ~FuncFunPtr() { 00218 } 00219 00220 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 { 00221 if (m_pFunc) 00222 (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14); 00223 } 00224 00225 virtual DynFunc *Clone() const override { 00226 return new FuncFunPtr(m_pFunc); 00227 } 00228 00229 private: 00230 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00231 }; 00232 00233 /** 00234 * @brief 00235 * Static function pointer 00236 * 00237 * @remarks 00238 * Implementation for 14 parameters and a return value 00239 */ 00240 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> 00241 class FuncFunPtr<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> { 00242 public: 00243 typedef typename Type<R> ::_Type _R; 00244 typedef typename Type<T0> ::_Type _T0; 00245 typedef typename Type<T1> ::_Type _T1; 00246 typedef typename Type<T2> ::_Type _T2; 00247 typedef typename Type<T3> ::_Type _T3; 00248 typedef typename Type<T4> ::_Type _T4; 00249 typedef typename Type<T5> ::_Type _T5; 00250 typedef typename Type<T6> ::_Type _T6; 00251 typedef typename Type<T7> ::_Type _T7; 00252 typedef typename Type<T8> ::_Type _T8; 00253 typedef typename Type<T9> ::_Type _T9; 00254 typedef typename Type<T10>::_Type _T10; 00255 typedef typename Type<T11>::_Type _T11; 00256 typedef typename Type<T12>::_Type _T12; 00257 typedef typename Type<T13>::_Type _T13; 00258 typedef typename Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::FuncType FUNC; 00259 00260 public: 00261 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00262 } 00263 00264 virtual ~FuncFunPtr() { 00265 } 00266 00267 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 { 00268 return m_pFunc ? (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13) : DefaultValue<R>::Default(); 00269 } 00270 00271 virtual DynFunc *Clone() const override { 00272 return new FuncFunPtr(m_pFunc); 00273 } 00274 00275 private: 00276 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00277 }; 00278 00279 /** 00280 * @brief 00281 * Static function pointer 00282 * 00283 * @remarks 00284 * Implementation for 14 parameters without a return value 00285 */ 00286 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> 00287 class FuncFunPtr<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> { 00288 public: 00289 typedef typename Type<T0> ::_Type _T0; 00290 typedef typename Type<T1> ::_Type _T1; 00291 typedef typename Type<T2> ::_Type _T2; 00292 typedef typename Type<T3> ::_Type _T3; 00293 typedef typename Type<T4> ::_Type _T4; 00294 typedef typename Type<T5> ::_Type _T5; 00295 typedef typename Type<T6> ::_Type _T6; 00296 typedef typename Type<T7> ::_Type _T7; 00297 typedef typename Type<T8> ::_Type _T8; 00298 typedef typename Type<T9> ::_Type _T9; 00299 typedef typename Type<T10>::_Type _T10; 00300 typedef typename Type<T11>::_Type _T11; 00301 typedef typename Type<T12>::_Type _T12; 00302 typedef typename Type<T13>::_Type _T13; 00303 typedef typename Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::FuncType FUNC; 00304 00305 public: 00306 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00307 } 00308 00309 virtual ~FuncFunPtr() { 00310 } 00311 00312 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 { 00313 if (m_pFunc) 00314 (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13); 00315 } 00316 00317 virtual DynFunc *Clone() const override { 00318 return new FuncFunPtr(m_pFunc); 00319 } 00320 00321 private: 00322 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00323 }; 00324 00325 /** 00326 * @brief 00327 * Static function pointer 00328 * 00329 * @remarks 00330 * Implementation for 13 parameters and a return value 00331 */ 00332 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> 00333 class FuncFunPtr<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> { 00334 public: 00335 typedef typename Type<R> ::_Type _R; 00336 typedef typename Type<T0> ::_Type _T0; 00337 typedef typename Type<T1> ::_Type _T1; 00338 typedef typename Type<T2> ::_Type _T2; 00339 typedef typename Type<T3> ::_Type _T3; 00340 typedef typename Type<T4> ::_Type _T4; 00341 typedef typename Type<T5> ::_Type _T5; 00342 typedef typename Type<T6> ::_Type _T6; 00343 typedef typename Type<T7> ::_Type _T7; 00344 typedef typename Type<T8> ::_Type _T8; 00345 typedef typename Type<T9> ::_Type _T9; 00346 typedef typename Type<T10>::_Type _T10; 00347 typedef typename Type<T11>::_Type _T11; 00348 typedef typename Type<T12>::_Type _T12; 00349 typedef typename Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::FuncType FUNC; 00350 00351 public: 00352 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00353 } 00354 00355 virtual ~FuncFunPtr() { 00356 } 00357 00358 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 { 00359 return m_pFunc ? (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12) : DefaultValue<R>::Default(); 00360 } 00361 00362 virtual DynFunc *Clone() const override { 00363 return new FuncFunPtr(m_pFunc); 00364 } 00365 00366 private: 00367 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00368 }; 00369 00370 /** 00371 * @brief 00372 * Static function pointer 00373 * 00374 * @remarks 00375 * Implementation for 13 parameters without a return value 00376 */ 00377 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> 00378 class FuncFunPtr<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> { 00379 public: 00380 typedef typename Type<T0> ::_Type _T0; 00381 typedef typename Type<T1> ::_Type _T1; 00382 typedef typename Type<T2> ::_Type _T2; 00383 typedef typename Type<T3> ::_Type _T3; 00384 typedef typename Type<T4> ::_Type _T4; 00385 typedef typename Type<T5> ::_Type _T5; 00386 typedef typename Type<T6> ::_Type _T6; 00387 typedef typename Type<T7> ::_Type _T7; 00388 typedef typename Type<T8> ::_Type _T8; 00389 typedef typename Type<T9> ::_Type _T9; 00390 typedef typename Type<T10>::_Type _T10; 00391 typedef typename Type<T11>::_Type _T11; 00392 typedef typename Type<T12>::_Type _T12; 00393 typedef typename Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::FuncType FUNC; 00394 00395 public: 00396 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00397 } 00398 00399 virtual ~FuncFunPtr() { 00400 } 00401 00402 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 { 00403 if (m_pFunc) 00404 (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12); 00405 } 00406 00407 virtual DynFunc *Clone() const override { 00408 return new FuncFunPtr(m_pFunc); 00409 } 00410 00411 private: 00412 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00413 }; 00414 00415 /** 00416 * @brief 00417 * Static function pointer 00418 * 00419 * @remarks 00420 * Implementation for 12 parameters and a return value 00421 */ 00422 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> 00423 class FuncFunPtr<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> { 00424 public: 00425 typedef typename Type<R> ::_Type _R; 00426 typedef typename Type<T0> ::_Type _T0; 00427 typedef typename Type<T1> ::_Type _T1; 00428 typedef typename Type<T2> ::_Type _T2; 00429 typedef typename Type<T3> ::_Type _T3; 00430 typedef typename Type<T4> ::_Type _T4; 00431 typedef typename Type<T5> ::_Type _T5; 00432 typedef typename Type<T6> ::_Type _T6; 00433 typedef typename Type<T7> ::_Type _T7; 00434 typedef typename Type<T8> ::_Type _T8; 00435 typedef typename Type<T9> ::_Type _T9; 00436 typedef typename Type<T10>::_Type _T10; 00437 typedef typename Type<T11>::_Type _T11; 00438 typedef typename Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::FuncType FUNC; 00439 00440 public: 00441 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00442 } 00443 00444 virtual ~FuncFunPtr() { 00445 } 00446 00447 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 { 00448 return m_pFunc ? (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11) : DefaultValue<R>::Default(); 00449 } 00450 00451 virtual DynFunc *Clone() const override { 00452 return new FuncFunPtr(m_pFunc); 00453 } 00454 00455 private: 00456 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00457 }; 00458 00459 /** 00460 * @brief 00461 * Static function pointer 00462 * 00463 * @remarks 00464 * Implementation for 12 parameters without a return value 00465 */ 00466 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> 00467 class FuncFunPtr<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> { 00468 public: 00469 typedef typename Type<T0> ::_Type _T0; 00470 typedef typename Type<T1> ::_Type _T1; 00471 typedef typename Type<T2> ::_Type _T2; 00472 typedef typename Type<T3> ::_Type _T3; 00473 typedef typename Type<T4> ::_Type _T4; 00474 typedef typename Type<T5> ::_Type _T5; 00475 typedef typename Type<T6> ::_Type _T6; 00476 typedef typename Type<T7> ::_Type _T7; 00477 typedef typename Type<T8> ::_Type _T8; 00478 typedef typename Type<T9> ::_Type _T9; 00479 typedef typename Type<T10>::_Type _T10; 00480 typedef typename Type<T11>::_Type _T11; 00481 typedef typename Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::FuncType FUNC; 00482 00483 public: 00484 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00485 } 00486 00487 virtual ~FuncFunPtr() { 00488 } 00489 00490 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 { 00491 if (m_pFunc) 00492 (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11); 00493 } 00494 00495 virtual DynFunc *Clone() const override { 00496 return new FuncFunPtr(m_pFunc); 00497 } 00498 00499 private: 00500 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00501 }; 00502 00503 /** 00504 * @brief 00505 * Static function pointer 00506 * 00507 * @remarks 00508 * Implementation for 11 parameters and a return value 00509 */ 00510 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> 00511 class FuncFunPtr<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> { 00512 public: 00513 typedef typename Type<R> ::_Type _R; 00514 typedef typename Type<T0> ::_Type _T0; 00515 typedef typename Type<T1> ::_Type _T1; 00516 typedef typename Type<T2> ::_Type _T2; 00517 typedef typename Type<T3> ::_Type _T3; 00518 typedef typename Type<T4> ::_Type _T4; 00519 typedef typename Type<T5> ::_Type _T5; 00520 typedef typename Type<T6> ::_Type _T6; 00521 typedef typename Type<T7> ::_Type _T7; 00522 typedef typename Type<T8> ::_Type _T8; 00523 typedef typename Type<T9> ::_Type _T9; 00524 typedef typename Type<T10>::_Type _T10; 00525 typedef typename Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::FuncType FUNC; 00526 00527 public: 00528 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00529 } 00530 00531 virtual ~FuncFunPtr() { 00532 } 00533 00534 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 { 00535 return m_pFunc ? (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) : DefaultValue<R>::Default(); 00536 } 00537 00538 virtual DynFunc *Clone() const override { 00539 return new FuncFunPtr(m_pFunc); 00540 } 00541 00542 private: 00543 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00544 }; 00545 00546 /** 00547 * @brief 00548 * Static function pointer 00549 * 00550 * @remarks 00551 * Implementation for 11 parameters without a return value 00552 */ 00553 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> 00554 class FuncFunPtr<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> { 00555 public: 00556 typedef typename Type<T0> ::_Type _T0; 00557 typedef typename Type<T1> ::_Type _T1; 00558 typedef typename Type<T2> ::_Type _T2; 00559 typedef typename Type<T3> ::_Type _T3; 00560 typedef typename Type<T4> ::_Type _T4; 00561 typedef typename Type<T5> ::_Type _T5; 00562 typedef typename Type<T6> ::_Type _T6; 00563 typedef typename Type<T7> ::_Type _T7; 00564 typedef typename Type<T8> ::_Type _T8; 00565 typedef typename Type<T9> ::_Type _T9; 00566 typedef typename Type<T10>::_Type _T10; 00567 typedef typename Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::FuncType FUNC; 00568 00569 public: 00570 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00571 } 00572 00573 virtual ~FuncFunPtr() { 00574 } 00575 00576 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 { 00577 if (m_pFunc) 00578 (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); 00579 } 00580 00581 virtual DynFunc *Clone() const override { 00582 return new FuncFunPtr(m_pFunc); 00583 } 00584 00585 private: 00586 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00587 }; 00588 00589 /** 00590 * @brief 00591 * Static function pointer 00592 * 00593 * @remarks 00594 * Implementation for 10 parameters and a return value 00595 */ 00596 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> 00597 class FuncFunPtr<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> : public Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> { 00598 public: 00599 typedef typename Type<R> ::_Type _R; 00600 typedef typename Type<T0> ::_Type _T0; 00601 typedef typename Type<T1> ::_Type _T1; 00602 typedef typename Type<T2> ::_Type _T2; 00603 typedef typename Type<T3> ::_Type _T3; 00604 typedef typename Type<T4> ::_Type _T4; 00605 typedef typename Type<T5> ::_Type _T5; 00606 typedef typename Type<T6> ::_Type _T6; 00607 typedef typename Type<T7> ::_Type _T7; 00608 typedef typename Type<T8> ::_Type _T8; 00609 typedef typename Type<T9> ::_Type _T9; 00610 typedef typename Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::FuncType FUNC; 00611 00612 public: 00613 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00614 } 00615 00616 virtual ~FuncFunPtr() { 00617 } 00618 00619 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9) override { 00620 return m_pFunc ? (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) : DefaultValue<R>::Default(); 00621 } 00622 00623 virtual DynFunc *Clone() const override { 00624 return new FuncFunPtr(m_pFunc); 00625 } 00626 00627 private: 00628 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00629 }; 00630 00631 /** 00632 * @brief 00633 * Static function pointer 00634 * 00635 * @remarks 00636 * Implementation for 10 parameters without a return value 00637 */ 00638 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> 00639 class FuncFunPtr<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> : public Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> { 00640 public: 00641 typedef typename Type<T0> ::_Type _T0; 00642 typedef typename Type<T1> ::_Type _T1; 00643 typedef typename Type<T2> ::_Type _T2; 00644 typedef typename Type<T3> ::_Type _T3; 00645 typedef typename Type<T4> ::_Type _T4; 00646 typedef typename Type<T5> ::_Type _T5; 00647 typedef typename Type<T6> ::_Type _T6; 00648 typedef typename Type<T7> ::_Type _T7; 00649 typedef typename Type<T8> ::_Type _T8; 00650 typedef typename Type<T9> ::_Type _T9; 00651 typedef typename Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::FuncType FUNC; 00652 00653 public: 00654 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00655 } 00656 00657 virtual ~FuncFunPtr() { 00658 } 00659 00660 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9) override { 00661 if (m_pFunc) 00662 (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9); 00663 } 00664 00665 virtual DynFunc *Clone() const override { 00666 return new FuncFunPtr(m_pFunc); 00667 } 00668 00669 private: 00670 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00671 }; 00672 00673 /** 00674 * @brief 00675 * Static function pointer 00676 * 00677 * @remarks 00678 * Implementation for 9 parameters and a return value 00679 */ 00680 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> 00681 class FuncFunPtr<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> : public Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> { 00682 public: 00683 typedef typename Type<R> ::_Type _R; 00684 typedef typename Type<T0> ::_Type _T0; 00685 typedef typename Type<T1> ::_Type _T1; 00686 typedef typename Type<T2> ::_Type _T2; 00687 typedef typename Type<T3> ::_Type _T3; 00688 typedef typename Type<T4> ::_Type _T4; 00689 typedef typename Type<T5> ::_Type _T5; 00690 typedef typename Type<T6> ::_Type _T6; 00691 typedef typename Type<T7> ::_Type _T7; 00692 typedef typename Type<T8> ::_Type _T8; 00693 typedef typename Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8>::FuncType FUNC; 00694 00695 public: 00696 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00697 } 00698 00699 virtual ~FuncFunPtr() { 00700 } 00701 00702 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8) override { 00703 return m_pFunc ? (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8) : DefaultValue<R>::Default(); 00704 } 00705 00706 virtual DynFunc *Clone() const override { 00707 return new FuncFunPtr(m_pFunc); 00708 } 00709 00710 private: 00711 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00712 }; 00713 00714 /** 00715 * @brief 00716 * Static function pointer 00717 * 00718 * @remarks 00719 * Implementation for 9 parameters without a return value 00720 */ 00721 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> 00722 class FuncFunPtr<void, T0, T1, T2, T3, T4, T5, T6, T7, T8> : public Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8> { 00723 public: 00724 typedef typename Type<T0> ::_Type _T0; 00725 typedef typename Type<T1> ::_Type _T1; 00726 typedef typename Type<T2> ::_Type _T2; 00727 typedef typename Type<T3> ::_Type _T3; 00728 typedef typename Type<T4> ::_Type _T4; 00729 typedef typename Type<T5> ::_Type _T5; 00730 typedef typename Type<T6> ::_Type _T6; 00731 typedef typename Type<T7> ::_Type _T7; 00732 typedef typename Type<T8> ::_Type _T8; 00733 typedef typename Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8>::FuncType FUNC; 00734 00735 public: 00736 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00737 } 00738 00739 virtual ~FuncFunPtr() { 00740 } 00741 00742 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8) override { 00743 if (m_pFunc) 00744 (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7, t8); 00745 } 00746 00747 virtual DynFunc *Clone() const override { 00748 return new FuncFunPtr(m_pFunc); 00749 } 00750 00751 private: 00752 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00753 }; 00754 00755 /** 00756 * @brief 00757 * Static function pointer 00758 * 00759 * @remarks 00760 * Implementation for 8 parameters and a return value 00761 */ 00762 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> 00763 class FuncFunPtr<R, T0, T1, T2, T3, T4, T5, T6, T7> : public Func<R, T0, T1, T2, T3, T4, T5, T6, T7> { 00764 public: 00765 typedef typename Type<R> ::_Type _R; 00766 typedef typename Type<T0> ::_Type _T0; 00767 typedef typename Type<T1> ::_Type _T1; 00768 typedef typename Type<T2> ::_Type _T2; 00769 typedef typename Type<T3> ::_Type _T3; 00770 typedef typename Type<T4> ::_Type _T4; 00771 typedef typename Type<T5> ::_Type _T5; 00772 typedef typename Type<T6> ::_Type _T6; 00773 typedef typename Type<T7> ::_Type _T7; 00774 typedef typename Signature<R, T0, T1, T2, T3, T4, T5, T6, T7>::FuncType FUNC; 00775 00776 public: 00777 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00778 } 00779 00780 virtual ~FuncFunPtr() { 00781 } 00782 00783 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7) override { 00784 return m_pFunc ? (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7) : DefaultValue<R>::Default(); 00785 } 00786 00787 virtual DynFunc *Clone() const override { 00788 return new FuncFunPtr(m_pFunc); 00789 } 00790 00791 private: 00792 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00793 }; 00794 00795 /** 00796 * @brief 00797 * Static function pointer 00798 * 00799 * @remarks 00800 * Implementation for 8 parameters without a return value 00801 */ 00802 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> 00803 class FuncFunPtr<void, T0, T1, T2, T3, T4, T5, T6, T7> : public Func<void, T0, T1, T2, T3, T4, T5, T6, T7> { 00804 public: 00805 typedef typename Type<T0> ::_Type _T0; 00806 typedef typename Type<T1> ::_Type _T1; 00807 typedef typename Type<T2> ::_Type _T2; 00808 typedef typename Type<T3> ::_Type _T3; 00809 typedef typename Type<T4> ::_Type _T4; 00810 typedef typename Type<T5> ::_Type _T5; 00811 typedef typename Type<T6> ::_Type _T6; 00812 typedef typename Type<T7> ::_Type _T7; 00813 typedef typename Signature<void, T0, T1, T2, T3, T4, T5, T6, T7>::FuncType FUNC; 00814 00815 public: 00816 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00817 } 00818 00819 virtual ~FuncFunPtr() { 00820 } 00821 00822 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7) override { 00823 if (m_pFunc) 00824 (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6, t7); 00825 } 00826 00827 virtual DynFunc *Clone() const override { 00828 return new FuncFunPtr(m_pFunc); 00829 } 00830 00831 private: 00832 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00833 }; 00834 00835 /** 00836 * @brief 00837 * Static function pointer 00838 * 00839 * @remarks 00840 * Implementation for 7 parameters and a return value 00841 */ 00842 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> 00843 class FuncFunPtr<R, T0, T1, T2, T3, T4, T5, T6> : public Func<R, T0, T1, T2, T3, T4, T5, T6> { 00844 public: 00845 typedef typename Type<R> ::_Type _R; 00846 typedef typename Type<T0> ::_Type _T0; 00847 typedef typename Type<T1> ::_Type _T1; 00848 typedef typename Type<T2> ::_Type _T2; 00849 typedef typename Type<T3> ::_Type _T3; 00850 typedef typename Type<T4> ::_Type _T4; 00851 typedef typename Type<T5> ::_Type _T5; 00852 typedef typename Type<T6> ::_Type _T6; 00853 typedef typename Signature<R, T0, T1, T2, T3, T4, T5, T6>::FuncType FUNC; 00854 00855 public: 00856 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00857 } 00858 00859 virtual ~FuncFunPtr() { 00860 } 00861 00862 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6) override { 00863 return m_pFunc ? (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6) : DefaultValue<R>::Default(); 00864 } 00865 00866 virtual DynFunc *Clone() const override { 00867 return new FuncFunPtr(m_pFunc); 00868 } 00869 00870 private: 00871 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00872 }; 00873 00874 /** 00875 * @brief 00876 * Static function pointer 00877 * 00878 * @remarks 00879 * Implementation for 7 parameters without a return value 00880 */ 00881 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> 00882 class FuncFunPtr<void, T0, T1, T2, T3, T4, T5, T6> : public Func<void, T0, T1, T2, T3, T4, T5, T6> { 00883 public: 00884 typedef typename Type<T0> ::_Type _T0; 00885 typedef typename Type<T1> ::_Type _T1; 00886 typedef typename Type<T2> ::_Type _T2; 00887 typedef typename Type<T3> ::_Type _T3; 00888 typedef typename Type<T4> ::_Type _T4; 00889 typedef typename Type<T5> ::_Type _T5; 00890 typedef typename Type<T6> ::_Type _T6; 00891 typedef typename Signature<void, T0, T1, T2, T3, T4, T5, T6>::FuncType FUNC; 00892 00893 public: 00894 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00895 } 00896 00897 virtual ~FuncFunPtr() { 00898 } 00899 00900 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6) override { 00901 if (m_pFunc) 00902 (*m_pFunc)(t0, t1, t2, t3, t4, t5, t6); 00903 } 00904 00905 virtual DynFunc *Clone() const override { 00906 return new FuncFunPtr(m_pFunc); 00907 } 00908 00909 private: 00910 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00911 }; 00912 00913 /** 00914 * @brief 00915 * Static function pointer 00916 * 00917 * @remarks 00918 * Implementation for 6 parameters and a return value 00919 */ 00920 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5> 00921 class FuncFunPtr<R, T0, T1, T2, T3, T4, T5> : public Func<R, T0, T1, T2, T3, T4, T5> { 00922 public: 00923 typedef typename Type<R> ::_Type _R; 00924 typedef typename Type<T0> ::_Type _T0; 00925 typedef typename Type<T1> ::_Type _T1; 00926 typedef typename Type<T2> ::_Type _T2; 00927 typedef typename Type<T3> ::_Type _T3; 00928 typedef typename Type<T4> ::_Type _T4; 00929 typedef typename Type<T5> ::_Type _T5; 00930 typedef typename Signature<R, T0, T1, T2, T3, T4, T5>::FuncType FUNC; 00931 00932 public: 00933 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00934 } 00935 00936 virtual ~FuncFunPtr() { 00937 } 00938 00939 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5) override { 00940 return m_pFunc ? (*m_pFunc)(t0, t1, t2, t3, t4, t5) : DefaultValue<R>::Default(); 00941 } 00942 00943 virtual DynFunc *Clone() const override { 00944 return new FuncFunPtr(m_pFunc); 00945 } 00946 00947 private: 00948 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00949 }; 00950 00951 /** 00952 * @brief 00953 * Static function pointer 00954 * 00955 * @remarks 00956 * Implementation for 6 parameters without a return value 00957 */ 00958 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5> 00959 class FuncFunPtr<void, T0, T1, T2, T3, T4, T5> : public Func<void, T0, T1, T2, T3, T4, T5> { 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 Signature<void, T0, T1, T2, T3, T4, T5>::FuncType FUNC; 00968 00969 public: 00970 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 00971 } 00972 00973 virtual ~FuncFunPtr() { 00974 } 00975 00976 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5) override { 00977 if (m_pFunc) 00978 (*m_pFunc)(t0, t1, t2, t3, t4, t5); 00979 } 00980 00981 virtual DynFunc *Clone() const override { 00982 return new FuncFunPtr(m_pFunc); 00983 } 00984 00985 private: 00986 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 00987 }; 00988 00989 /** 00990 * @brief 00991 * Static function pointer 00992 * 00993 * @remarks 00994 * Implementation for 5 parameters and a return value 00995 */ 00996 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4> 00997 class FuncFunPtr<R, T0, T1, T2, T3, T4> : public Func<R, T0, T1, T2, T3, T4> { 00998 public: 00999 typedef typename Type<R> ::_Type _R; 01000 typedef typename Type<T0> ::_Type _T0; 01001 typedef typename Type<T1> ::_Type _T1; 01002 typedef typename Type<T2> ::_Type _T2; 01003 typedef typename Type<T3> ::_Type _T3; 01004 typedef typename Type<T4> ::_Type _T4; 01005 typedef typename Signature<R, T0, T1, T2, T3, T4>::FuncType FUNC; 01006 01007 public: 01008 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 01009 } 01010 01011 virtual ~FuncFunPtr() { 01012 } 01013 01014 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4) override { 01015 return m_pFunc ? (*m_pFunc)(t0, t1, t2, t3, t4) : DefaultValue<R>::Default(); 01016 } 01017 01018 virtual DynFunc *Clone() const override { 01019 return new FuncFunPtr(m_pFunc); 01020 } 01021 01022 private: 01023 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 01024 }; 01025 01026 /** 01027 * @brief 01028 * Static function pointer 01029 * 01030 * @remarks 01031 * Implementation for 5 parameters without a return value 01032 */ 01033 template <typename T0, typename T1, typename T2, typename T3, typename T4> 01034 class FuncFunPtr<void, T0, T1, T2, T3, T4> : public Func<void, T0, T1, T2, T3, T4> { 01035 public: 01036 typedef typename Type<T0> ::_Type _T0; 01037 typedef typename Type<T1> ::_Type _T1; 01038 typedef typename Type<T2> ::_Type _T2; 01039 typedef typename Type<T3> ::_Type _T3; 01040 typedef typename Type<T4> ::_Type _T4; 01041 typedef typename Signature<void, T0, T1, T2, T3, T4>::FuncType FUNC; 01042 01043 public: 01044 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 01045 } 01046 01047 virtual ~FuncFunPtr() { 01048 } 01049 01050 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4) override { 01051 if (m_pFunc) 01052 (*m_pFunc)(t0, t1, t2, t3, t4); 01053 } 01054 01055 virtual DynFunc *Clone() const override { 01056 return new FuncFunPtr(m_pFunc); 01057 } 01058 01059 private: 01060 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 01061 }; 01062 01063 /** 01064 * @brief 01065 * Static function pointer 01066 * 01067 * @remarks 01068 * Implementation for 4 parameters and a return value 01069 */ 01070 template <typename R, typename T0, typename T1, typename T2, typename T3> 01071 class FuncFunPtr<R, T0, T1, T2, T3> : public Func<R, T0, T1, T2, T3> { 01072 public: 01073 typedef typename Type<R> ::_Type _R; 01074 typedef typename Type<T0> ::_Type _T0; 01075 typedef typename Type<T1> ::_Type _T1; 01076 typedef typename Type<T2> ::_Type _T2; 01077 typedef typename Type<T3> ::_Type _T3; 01078 typedef typename Signature<R, T0, T1, T2, T3>::FuncType FUNC; 01079 01080 public: 01081 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 01082 } 01083 01084 virtual ~FuncFunPtr() { 01085 } 01086 01087 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3) override { 01088 return m_pFunc ? (*m_pFunc)(t0, t1, t2, t3) : DefaultValue<R>::Default(); 01089 } 01090 01091 virtual DynFunc *Clone() const override { 01092 return new FuncFunPtr(m_pFunc); 01093 } 01094 01095 private: 01096 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 01097 }; 01098 01099 /** 01100 * @brief 01101 * Static function pointer 01102 * 01103 * @remarks 01104 * Implementation for 4 parameters without a return value 01105 */ 01106 template <typename T0, typename T1, typename T2, typename T3> 01107 class FuncFunPtr<void, T0, T1, T2, T3> : public Func<void, T0, T1, T2, T3> { 01108 public: 01109 typedef typename Type<T0> ::_Type _T0; 01110 typedef typename Type<T1> ::_Type _T1; 01111 typedef typename Type<T2> ::_Type _T2; 01112 typedef typename Type<T3> ::_Type _T3; 01113 typedef typename Signature<void, T0, T1, T2, T3>::FuncType FUNC; 01114 01115 public: 01116 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 01117 } 01118 01119 virtual ~FuncFunPtr() { 01120 } 01121 01122 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3) override { 01123 if (m_pFunc) 01124 (*m_pFunc)(t0, t1, t2, t3); 01125 } 01126 01127 virtual DynFunc *Clone() const override { 01128 return new FuncFunPtr(m_pFunc); 01129 } 01130 01131 private: 01132 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 01133 }; 01134 01135 /** 01136 * @brief 01137 * Static function pointer 01138 * 01139 * @remarks 01140 * Implementation for 3 parameters and a return value 01141 */ 01142 template <typename R, typename T0, typename T1, typename T2> 01143 class FuncFunPtr<R, T0, T1, T2> : public Func<R, T0, T1, T2> { 01144 public: 01145 typedef typename Type<R> ::_Type _R; 01146 typedef typename Type<T0> ::_Type _T0; 01147 typedef typename Type<T1> ::_Type _T1; 01148 typedef typename Type<T2> ::_Type _T2; 01149 typedef typename Signature<R, T0, T1, T2>::FuncType FUNC; 01150 01151 public: 01152 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 01153 } 01154 01155 virtual ~FuncFunPtr() { 01156 } 01157 01158 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2) override { 01159 return m_pFunc ? (*m_pFunc)(t0, t1, t2) : DefaultValue<R>::Default(); 01160 } 01161 01162 virtual DynFunc *Clone() const override { 01163 return new FuncFunPtr(m_pFunc); 01164 } 01165 01166 private: 01167 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 01168 }; 01169 01170 /** 01171 * @brief 01172 * Static function pointer 01173 * 01174 * @remarks 01175 * Implementation for 3 parameters without a return value 01176 */ 01177 template <typename T0, typename T1, typename T2> 01178 class FuncFunPtr<void, T0, T1, T2> : public Func<void, T0, T1, T2> { 01179 public: 01180 typedef typename Type<T0> ::_Type _T0; 01181 typedef typename Type<T1> ::_Type _T1; 01182 typedef typename Type<T2> ::_Type _T2; 01183 typedef typename Signature<void, T0, T1, T2>::FuncType FUNC; 01184 01185 public: 01186 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 01187 } 01188 01189 virtual ~FuncFunPtr() { 01190 } 01191 01192 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2) override { 01193 if (m_pFunc) 01194 (*m_pFunc)(t0, t1, t2); 01195 } 01196 01197 virtual DynFunc *Clone() const override { 01198 return new FuncFunPtr(m_pFunc); 01199 } 01200 01201 private: 01202 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 01203 }; 01204 01205 /** 01206 * @brief 01207 * Static function pointer 01208 * 01209 * @remarks 01210 * Implementation for 2 parameters and a return value 01211 */ 01212 template <typename R, typename T0, typename T1> 01213 class FuncFunPtr<R, T0, T1> : public Func<R, T0, T1> { 01214 public: 01215 typedef typename Type<R> ::_Type _R; 01216 typedef typename Type<T0> ::_Type _T0; 01217 typedef typename Type<T1> ::_Type _T1; 01218 typedef typename Signature<R, T0, T1>::FuncType FUNC; 01219 01220 public: 01221 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 01222 } 01223 01224 virtual ~FuncFunPtr() { 01225 } 01226 01227 virtual _R operator ()(_T0 t0, _T1 t1) override { 01228 return m_pFunc ? (*m_pFunc)(t0, t1) : DefaultValue<R>::Default(); 01229 } 01230 01231 virtual DynFunc *Clone() const override { 01232 return new FuncFunPtr(m_pFunc); 01233 } 01234 01235 private: 01236 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 01237 }; 01238 01239 /** 01240 * @brief 01241 * Static function pointer 01242 * 01243 * @remarks 01244 * Implementation for 2 parameters without a return value 01245 */ 01246 template <typename T0, typename T1> 01247 class FuncFunPtr<void, T0, T1> : public Func<void, T0, T1> { 01248 public: 01249 typedef typename Type<T0> ::_Type _T0; 01250 typedef typename Type<T1> ::_Type _T1; 01251 typedef typename Signature<void, T0, T1>::FuncType FUNC; 01252 01253 public: 01254 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 01255 } 01256 01257 virtual ~FuncFunPtr() { 01258 } 01259 01260 virtual void operator ()(_T0 t0, _T1 t1) override { 01261 if (m_pFunc) 01262 (*m_pFunc)(t0, t1); 01263 } 01264 01265 virtual DynFunc *Clone() const override { 01266 return new FuncFunPtr(m_pFunc); 01267 } 01268 01269 private: 01270 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 01271 }; 01272 01273 /** 01274 * @brief 01275 * Static function pointer 01276 * 01277 * @remarks 01278 * Implementation for 1 parameters and a return value 01279 */ 01280 template <typename R, typename T0> 01281 class FuncFunPtr<R, T0> : public Func<R, T0> { 01282 public: 01283 typedef typename Type<R> ::_Type _R; 01284 typedef typename Type<T0> ::_Type _T0; 01285 typedef typename Signature<R, T0>::FuncType FUNC; 01286 01287 public: 01288 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 01289 } 01290 01291 virtual ~FuncFunPtr() { 01292 } 01293 01294 virtual _R operator ()(_T0 t0) override { 01295 return m_pFunc ? (*m_pFunc)(t0) : DefaultValue<R>::Default(); 01296 } 01297 01298 virtual DynFunc *Clone() const override { 01299 return new FuncFunPtr(m_pFunc); 01300 } 01301 01302 private: 01303 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 01304 }; 01305 01306 /** 01307 * @brief 01308 * Static function pointer 01309 * 01310 * @remarks 01311 * Implementation for 1 parameters without a return value 01312 */ 01313 template <typename T0> 01314 class FuncFunPtr<void, T0> : public Func<void, T0> { 01315 public: 01316 typedef typename Type<T0> ::_Type _T0; 01317 typedef typename Signature<void, T0>::FuncType FUNC; 01318 01319 public: 01320 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 01321 } 01322 01323 virtual ~FuncFunPtr() { 01324 } 01325 01326 virtual void operator ()(_T0 t0) override { 01327 if (m_pFunc) 01328 (*m_pFunc)(t0); 01329 } 01330 01331 virtual DynFunc *Clone() const override { 01332 return new FuncFunPtr(m_pFunc); 01333 } 01334 01335 private: 01336 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 01337 }; 01338 01339 /** 01340 * @brief 01341 * Static function pointer 01342 * 01343 * @remarks 01344 * Implementation for 0 parameters and a return value 01345 */ 01346 template <typename R> 01347 class FuncFunPtr<R> : public Func<R> { 01348 public: 01349 typedef typename Type<R> ::_Type _R; 01350 typedef typename Signature<R>::FuncType FUNC; 01351 01352 public: 01353 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 01354 } 01355 01356 virtual ~FuncFunPtr() { 01357 } 01358 01359 virtual _R operator ()() override { 01360 return m_pFunc ? (*m_pFunc)() : DefaultValue<R>::Default(); 01361 } 01362 01363 virtual DynFunc *Clone() const override { 01364 return new FuncFunPtr(m_pFunc); 01365 } 01366 01367 private: 01368 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 01369 }; 01370 01371 /** 01372 * @brief 01373 * Static function pointer 01374 * 01375 * @remarks 01376 * Implementation for 0 parameters without a return value 01377 */ 01378 template <> 01379 class FuncFunPtr<void> : public Func<void> { 01380 public: 01381 typedef Signature<void>::FuncType FUNC; 01382 01383 public: 01384 FuncFunPtr(const FUNC &pFunc) : m_pFunc(pFunc) { 01385 } 01386 01387 virtual ~FuncFunPtr() { 01388 } 01389 01390 virtual void operator ()() override { 01391 if (m_pFunc) 01392 (*m_pFunc)(); 01393 } 01394 01395 virtual DynFunc *Clone() const override { 01396 return new FuncFunPtr(m_pFunc); 01397 } 01398 01399 private: 01400 FUNC m_pFunc; /**< Function pointer, can be a null pointer */ 01401 }; 01402 01403 01404 //[-------------------------------------------------------] 01405 //[ Namespace ] 01406 //[-------------------------------------------------------] 01407 } // PLCore 01408 01409 01410 #endif // __PLCORE_FUNC_H__
|