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