 | 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: Func.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_H__ 00024 #define __PLCORE_FUNC_H__ 00025 #pragma once 00026 00027 00028 //[-------------------------------------------------------] 00029 //[ Includes ] 00030 //[-------------------------------------------------------] 00031 #include "PLCore/Base/Type/DefaultValue.h" 00032 #include "PLCore/Base/Func/Signature.h" 00033 #include "PLCore/Base/Func/Params.h" 00034 #include "PLCore/Base/Func/DynFunc.h" 00035 00036 00037 //[-------------------------------------------------------] 00038 //[ Namespace ] 00039 //[-------------------------------------------------------] 00040 namespace PLCore { 00041 00042 00043 //[-------------------------------------------------------] 00044 //[ Classes ] 00045 //[-------------------------------------------------------] 00046 /** 00047 * @brief 00048 * Function object (object that can be 'called' like a function / functoid) 00049 * 00050 * @remarks 00051 * Implementation for up to 16 parameters and a return value 00052 */ 00053 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> 00054 class Func : public DynFunc { 00055 public: 00056 typedef typename Type<R> ::_Type _R; 00057 typedef typename Type<T0> ::_Type _T0; 00058 typedef typename Type<T1> ::_Type _T1; 00059 typedef typename Type<T2> ::_Type _T2; 00060 typedef typename Type<T3> ::_Type _T3; 00061 typedef typename Type<T4> ::_Type _T4; 00062 typedef typename Type<T5> ::_Type _T5; 00063 typedef typename Type<T6> ::_Type _T6; 00064 typedef typename Type<T7> ::_Type _T7; 00065 typedef typename Type<T8> ::_Type _T8; 00066 typedef typename Type<T9> ::_Type _T9; 00067 typedef typename Type<T10>::_Type _T10; 00068 typedef typename Type<T11>::_Type _T11; 00069 typedef typename Type<T12>::_Type _T12; 00070 typedef typename Type<T13>::_Type _T13; 00071 typedef typename Type<T14>::_Type _T14; 00072 typedef typename Type<T15>::_Type _T15; 00073 00074 Func() 00075 { 00076 } 00077 00078 virtual ~Func() 00079 { 00080 } 00081 00082 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) 00083 { 00084 return DefaultValue<R>::Default(); 00085 } 00086 00087 virtual String GetSignature() const override 00088 { 00089 return Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::GetSignatureID(); 00090 } 00091 00092 virtual int GetReturnTypeID() const override 00093 { 00094 return Type<R>::TypeID; 00095 } 00096 00097 virtual uint32 GetNumOfParameters() const override 00098 { 00099 return 16; 00100 } 00101 00102 virtual int GetParameterTypeID(uint32 nIndex) const override 00103 { 00104 switch (nIndex) { 00105 case 0: return Type<T0> ::TypeID; 00106 case 1: return Type<T1> ::TypeID; 00107 case 2: return Type<T2> ::TypeID; 00108 case 3: return Type<T3> ::TypeID; 00109 case 4: return Type<T4> ::TypeID; 00110 case 5: return Type<T5> ::TypeID; 00111 case 6: return Type<T6> ::TypeID; 00112 case 7: return Type<T7> ::TypeID; 00113 case 8: return Type<T8> ::TypeID; 00114 case 9: return Type<T9> ::TypeID; 00115 case 10: return Type<T10>::TypeID; 00116 case 11: return Type<T11>::TypeID; 00117 case 12: return Type<T12>::TypeID; 00118 case 13: return Type<T13>::TypeID; 00119 case 14: return Type<T14>::TypeID; 00120 case 15: return Type<T15>::TypeID; 00121 default: return TypeInvalid; 00122 } 00123 } 00124 00125 virtual void Call(DynParams &cParams) override 00126 { 00127 // Check signature 00128 if (cParams.GetSignature() == GetSignature()) { 00129 // Get typed params 00130 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> &cP = 00131 static_cast<Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>&>(cParams); 00132 00133 // Call function 00134 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 00135 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 00136 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 00137 Type<T12>::ConvertStorageToReal(cP.Param12), Type<T13>::ConvertStorageToReal(cP.Param13), Type<T14>::ConvertStorageToReal(cP.Param14), Type<T15>::ConvertStorageToReal(cP.Param15))); 00138 } 00139 } 00140 00141 virtual void Call(const DynParams &cParams) override 00142 { 00143 // Check signature 00144 if (cParams.GetSignature() == GetSignature()) { 00145 // Get typed params 00146 const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> &cP = 00147 static_cast<const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>&>(cParams); 00148 00149 // Call function 00150 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 00151 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 00152 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 00153 Type<T12>::ConvertStorageToReal(cP.Param12), Type<T13>::ConvertStorageToReal(cP.Param13), Type<T14>::ConvertStorageToReal(cP.Param14), Type<T15>::ConvertStorageToReal(cP.Param15)); 00154 } 00155 } 00156 00157 virtual void Call(const String &sParams) override 00158 { 00159 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::FromString(sParams); 00160 Call(cParams); 00161 } 00162 00163 virtual void Call(const XmlElement &cElement) override 00164 { 00165 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::FromXml(cElement); 00166 Call(cParams); 00167 } 00168 00169 virtual String CallWithReturn(const String &sParams) override 00170 { 00171 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::FromString(sParams); 00172 Call(cParams); 00173 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 00174 } 00175 00176 virtual String CallWithReturn(const XmlElement &cElement) override 00177 { 00178 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::FromXml(cElement); 00179 Call(cParams); 00180 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 00181 } 00182 }; 00183 00184 /** 00185 * @brief 00186 * Function object (object that can be 'called' like a function / functoid) 00187 * 00188 * @remarks 00189 * Implementation for up to 16 parameters without a return value 00190 */ 00191 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> 00192 class Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> : public DynFunc { 00193 public: 00194 typedef typename Type<T0> ::_Type _T0; 00195 typedef typename Type<T1> ::_Type _T1; 00196 typedef typename Type<T2> ::_Type _T2; 00197 typedef typename Type<T3> ::_Type _T3; 00198 typedef typename Type<T4> ::_Type _T4; 00199 typedef typename Type<T5> ::_Type _T5; 00200 typedef typename Type<T6> ::_Type _T6; 00201 typedef typename Type<T7> ::_Type _T7; 00202 typedef typename Type<T8> ::_Type _T8; 00203 typedef typename Type<T9> ::_Type _T9; 00204 typedef typename Type<T10>::_Type _T10; 00205 typedef typename Type<T11>::_Type _T11; 00206 typedef typename Type<T12>::_Type _T12; 00207 typedef typename Type<T13>::_Type _T13; 00208 typedef typename Type<T14>::_Type _T14; 00209 typedef typename Type<T15>::_Type _T15; 00210 00211 Func() 00212 { 00213 } 00214 00215 virtual ~Func() 00216 { 00217 } 00218 00219 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) 00220 { 00221 } 00222 00223 virtual String GetSignature() const override 00224 { 00225 return Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::GetSignatureID(); 00226 } 00227 00228 virtual uint32 GetNumOfParameters() const override 00229 { 00230 return 16; 00231 } 00232 00233 virtual int GetParameterTypeID(uint32 nIndex) const override 00234 { 00235 switch (nIndex) { 00236 case 0: return Type<T0> ::TypeID; 00237 case 1: return Type<T1> ::TypeID; 00238 case 2: return Type<T2> ::TypeID; 00239 case 3: return Type<T3> ::TypeID; 00240 case 4: return Type<T4> ::TypeID; 00241 case 5: return Type<T5> ::TypeID; 00242 case 6: return Type<T6> ::TypeID; 00243 case 7: return Type<T7> ::TypeID; 00244 case 8: return Type<T8> ::TypeID; 00245 case 9: return Type<T9> ::TypeID; 00246 case 10: return Type<T10>::TypeID; 00247 case 11: return Type<T11>::TypeID; 00248 case 12: return Type<T12>::TypeID; 00249 case 13: return Type<T13>::TypeID; 00250 case 14: return Type<T14>::TypeID; 00251 case 15: return Type<T15>::TypeID; 00252 default: return TypeInvalid; 00253 } 00254 } 00255 00256 virtual void Call(DynParams &cParams) override 00257 { 00258 // Check signature 00259 if (cParams.GetSignature() == GetSignature()) { 00260 // Get typed params 00261 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> &cP = 00262 static_cast<Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>&>(cParams); 00263 00264 // Call function 00265 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 00266 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 00267 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 00268 Type<T12>::ConvertStorageToReal(cP.Param12), Type<T13>::ConvertStorageToReal(cP.Param13), Type<T14>::ConvertStorageToReal(cP.Param14), Type<T15>::ConvertStorageToReal(cP.Param15)); 00269 } 00270 } 00271 00272 virtual void Call(const DynParams &cParams) override 00273 { 00274 // Check signature 00275 if (cParams.GetSignature() == GetSignature()) { 00276 // Get typed params 00277 const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> &cP = 00278 static_cast<const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>&>(cParams); 00279 00280 // Call function 00281 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 00282 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 00283 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 00284 Type<T12>::ConvertStorageToReal(cP.Param12), Type<T13>::ConvertStorageToReal(cP.Param13), Type<T14>::ConvertStorageToReal(cP.Param14), Type<T15>::ConvertStorageToReal(cP.Param15)); 00285 } 00286 } 00287 00288 virtual void Call(const String &sParams) override 00289 { 00290 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::FromString(sParams); 00291 Call(cParams); 00292 } 00293 00294 virtual void Call(const XmlElement &cElement) override 00295 { 00296 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::FromXml(cElement); 00297 Call(cParams); 00298 } 00299 00300 virtual String CallWithReturn(const String &sParams) override 00301 { 00302 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::FromString(sParams); 00303 Call(cParams); 00304 return ""; 00305 } 00306 00307 virtual String CallWithReturn(const XmlElement &cElement) override 00308 { 00309 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::FromXml(cElement); 00310 Call(cParams); 00311 return ""; 00312 } 00313 }; 00314 00315 /** 00316 * @brief 00317 * Function object (object that can be 'called' like a function / functoid) 00318 * 00319 * @remarks 00320 * Implementation for 15 parameters and a return value 00321 */ 00322 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> 00323 class Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> : public DynFunc { 00324 public: 00325 typedef typename Type<R> ::_Type _R; 00326 typedef typename Type<T0> ::_Type _T0; 00327 typedef typename Type<T1> ::_Type _T1; 00328 typedef typename Type<T2> ::_Type _T2; 00329 typedef typename Type<T3> ::_Type _T3; 00330 typedef typename Type<T4> ::_Type _T4; 00331 typedef typename Type<T5> ::_Type _T5; 00332 typedef typename Type<T6> ::_Type _T6; 00333 typedef typename Type<T7> ::_Type _T7; 00334 typedef typename Type<T8> ::_Type _T8; 00335 typedef typename Type<T9> ::_Type _T9; 00336 typedef typename Type<T10>::_Type _T10; 00337 typedef typename Type<T11>::_Type _T11; 00338 typedef typename Type<T12>::_Type _T12; 00339 typedef typename Type<T13>::_Type _T13; 00340 typedef typename Type<T14>::_Type _T14; 00341 00342 Func() 00343 { 00344 } 00345 00346 virtual ~Func() 00347 { 00348 } 00349 00350 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) 00351 { 00352 return DefaultValue<R>::Default(); 00353 } 00354 00355 virtual String GetSignature() const override 00356 { 00357 return Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::GetSignatureID(); 00358 } 00359 00360 virtual int GetReturnTypeID() const override 00361 { 00362 return Type<R>::TypeID; 00363 } 00364 00365 virtual uint32 GetNumOfParameters() const override 00366 { 00367 return 15; 00368 } 00369 00370 virtual int GetParameterTypeID(uint32 nIndex) const override 00371 { 00372 switch (nIndex) { 00373 case 0: return Type<T0> ::TypeID; 00374 case 1: return Type<T1> ::TypeID; 00375 case 2: return Type<T2> ::TypeID; 00376 case 3: return Type<T3> ::TypeID; 00377 case 4: return Type<T4> ::TypeID; 00378 case 5: return Type<T5> ::TypeID; 00379 case 6: return Type<T6> ::TypeID; 00380 case 7: return Type<T7> ::TypeID; 00381 case 8: return Type<T8> ::TypeID; 00382 case 9: return Type<T9> ::TypeID; 00383 case 10: return Type<T10>::TypeID; 00384 case 11: return Type<T11>::TypeID; 00385 case 12: return Type<T12>::TypeID; 00386 case 13: return Type<T13>::TypeID; 00387 case 14: return Type<T14>::TypeID; 00388 default: return TypeInvalid; 00389 } 00390 } 00391 00392 virtual void Call(DynParams &cParams) override 00393 { 00394 // Check signature 00395 if (cParams.GetSignature() == GetSignature()) { 00396 // Get typed params 00397 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> &cP = 00398 static_cast<Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>&>(cParams); 00399 00400 // Call function 00401 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 00402 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 00403 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 00404 Type<T12>::ConvertStorageToReal(cP.Param12), Type<T13>::ConvertStorageToReal(cP.Param13), Type<T14>::ConvertStorageToReal(cP.Param14))); 00405 } 00406 } 00407 00408 virtual void Call(const DynParams &cParams) override 00409 { 00410 // Check signature 00411 if (cParams.GetSignature() == GetSignature()) { 00412 // Get typed params 00413 const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> &cP = 00414 static_cast<const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>&>(cParams); 00415 00416 // Call function 00417 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 00418 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 00419 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 00420 Type<T12>::ConvertStorageToReal(cP.Param12), Type<T13>::ConvertStorageToReal(cP.Param13), Type<T14>::ConvertStorageToReal(cP.Param14)); 00421 } 00422 } 00423 00424 virtual void Call(const String &sParams) override 00425 { 00426 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::FromString(sParams); 00427 Call(cParams); 00428 } 00429 00430 virtual void Call(const XmlElement &cElement) override 00431 { 00432 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::FromXml(cElement); 00433 Call(cParams); 00434 } 00435 00436 virtual String CallWithReturn(const String &sParams) override 00437 { 00438 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::FromString(sParams); 00439 Call(cParams); 00440 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 00441 } 00442 00443 virtual String CallWithReturn(const XmlElement &cElement) override 00444 { 00445 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::FromXml(cElement); 00446 Call(cParams); 00447 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 00448 } 00449 }; 00450 00451 /** 00452 * @brief 00453 * Function object (object that can be 'called' like a function / functoid) 00454 * 00455 * @remarks 00456 * Implementation for 15 parameters without a return value 00457 */ 00458 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> 00459 class Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> : public DynFunc { 00460 public: 00461 typedef typename Type<T0> ::_Type _T0; 00462 typedef typename Type<T1> ::_Type _T1; 00463 typedef typename Type<T2> ::_Type _T2; 00464 typedef typename Type<T3> ::_Type _T3; 00465 typedef typename Type<T4> ::_Type _T4; 00466 typedef typename Type<T5> ::_Type _T5; 00467 typedef typename Type<T6> ::_Type _T6; 00468 typedef typename Type<T7> ::_Type _T7; 00469 typedef typename Type<T8> ::_Type _T8; 00470 typedef typename Type<T9> ::_Type _T9; 00471 typedef typename Type<T10>::_Type _T10; 00472 typedef typename Type<T11>::_Type _T11; 00473 typedef typename Type<T12>::_Type _T12; 00474 typedef typename Type<T13>::_Type _T13; 00475 typedef typename Type<T14>::_Type _T14; 00476 00477 Func() 00478 { 00479 } 00480 00481 virtual ~Func() 00482 { 00483 } 00484 00485 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) 00486 { 00487 } 00488 00489 virtual String GetSignature() const override 00490 { 00491 return Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::GetSignatureID(); 00492 } 00493 00494 virtual uint32 GetNumOfParameters() const override 00495 { 00496 return 15; 00497 } 00498 00499 virtual int GetParameterTypeID(uint32 nIndex) const override 00500 { 00501 switch (nIndex) { 00502 case 0: return Type<T0> ::TypeID; 00503 case 1: return Type<T1> ::TypeID; 00504 case 2: return Type<T2> ::TypeID; 00505 case 3: return Type<T3> ::TypeID; 00506 case 4: return Type<T4> ::TypeID; 00507 case 5: return Type<T5> ::TypeID; 00508 case 6: return Type<T6> ::TypeID; 00509 case 7: return Type<T7> ::TypeID; 00510 case 8: return Type<T8> ::TypeID; 00511 case 9: return Type<T9> ::TypeID; 00512 case 10: return Type<T10>::TypeID; 00513 case 11: return Type<T11>::TypeID; 00514 case 12: return Type<T12>::TypeID; 00515 case 13: return Type<T13>::TypeID; 00516 case 14: return Type<T14>::TypeID; 00517 default: return TypeInvalid; 00518 } 00519 } 00520 00521 virtual void Call(DynParams &cParams) override 00522 { 00523 // Check signature 00524 if (cParams.GetSignature() == GetSignature()) { 00525 // Get typed params 00526 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> &cP = 00527 static_cast<Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>&>(cParams); 00528 00529 // Call function 00530 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 00531 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 00532 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 00533 Type<T12>::ConvertStorageToReal(cP.Param12), Type<T13>::ConvertStorageToReal(cP.Param13), Type<T14>::ConvertStorageToReal(cP.Param14)); 00534 } 00535 } 00536 00537 virtual void Call(const DynParams &cParams) override 00538 { 00539 // Check signature 00540 if (cParams.GetSignature() == GetSignature()) { 00541 // Get typed params 00542 const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> &cP = 00543 static_cast<const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>&>(cParams); 00544 00545 // Call function 00546 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 00547 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 00548 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 00549 Type<T12>::ConvertStorageToReal(cP.Param12), Type<T13>::ConvertStorageToReal(cP.Param13), Type<T14>::ConvertStorageToReal(cP.Param14)); 00550 } 00551 } 00552 00553 virtual void Call(const String &sParams) override 00554 { 00555 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::FromString(sParams); 00556 Call(cParams); 00557 } 00558 00559 virtual void Call(const XmlElement &cElement) override 00560 { 00561 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::FromXml(cElement); 00562 Call(cParams); 00563 } 00564 00565 virtual String CallWithReturn(const String &sParams) override 00566 { 00567 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::FromString(sParams); 00568 Call(cParams); 00569 return ""; 00570 } 00571 00572 virtual String CallWithReturn(const XmlElement &cElement) override 00573 { 00574 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::FromXml(cElement); 00575 Call(cParams); 00576 return ""; 00577 } 00578 }; 00579 00580 00581 /** 00582 * @brief 00583 * Function object (object that can be 'called' like a function / functoid) 00584 * 00585 * @remarks 00586 * Implementation for 14 parameters and a return value 00587 */ 00588 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> 00589 class Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> : public DynFunc { 00590 public: 00591 typedef typename Type<R> ::_Type _R; 00592 typedef typename Type<T0> ::_Type _T0; 00593 typedef typename Type<T1> ::_Type _T1; 00594 typedef typename Type<T2> ::_Type _T2; 00595 typedef typename Type<T3> ::_Type _T3; 00596 typedef typename Type<T4> ::_Type _T4; 00597 typedef typename Type<T5> ::_Type _T5; 00598 typedef typename Type<T6> ::_Type _T6; 00599 typedef typename Type<T7> ::_Type _T7; 00600 typedef typename Type<T8> ::_Type _T8; 00601 typedef typename Type<T9> ::_Type _T9; 00602 typedef typename Type<T10>::_Type _T10; 00603 typedef typename Type<T11>::_Type _T11; 00604 typedef typename Type<T12>::_Type _T12; 00605 typedef typename Type<T13>::_Type _T13; 00606 00607 Func() 00608 { 00609 } 00610 00611 virtual ~Func() 00612 { 00613 } 00614 00615 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) 00616 { 00617 return DefaultValue<R>::Default(); 00618 } 00619 00620 virtual String GetSignature() const override 00621 { 00622 return Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::GetSignatureID(); 00623 } 00624 00625 virtual int GetReturnTypeID() const override 00626 { 00627 return Type<R>::TypeID; 00628 } 00629 00630 virtual uint32 GetNumOfParameters() const override 00631 { 00632 return 14; 00633 } 00634 00635 virtual int GetParameterTypeID(uint32 nIndex) const override 00636 { 00637 switch (nIndex) { 00638 case 0: return Type<T0> ::TypeID; 00639 case 1: return Type<T1> ::TypeID; 00640 case 2: return Type<T2> ::TypeID; 00641 case 3: return Type<T3> ::TypeID; 00642 case 4: return Type<T4> ::TypeID; 00643 case 5: return Type<T5> ::TypeID; 00644 case 6: return Type<T6> ::TypeID; 00645 case 7: return Type<T7> ::TypeID; 00646 case 8: return Type<T8> ::TypeID; 00647 case 9: return Type<T9> ::TypeID; 00648 case 10: return Type<T10>::TypeID; 00649 case 11: return Type<T11>::TypeID; 00650 case 12: return Type<T12>::TypeID; 00651 case 13: return Type<T13>::TypeID; 00652 default: return TypeInvalid; 00653 } 00654 } 00655 00656 virtual void Call(DynParams &cParams) override 00657 { 00658 // Check signature 00659 if (cParams.GetSignature() == GetSignature()) { 00660 // Get typed params 00661 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> &cP = 00662 static_cast<Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>&>(cParams); 00663 00664 // Call function 00665 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 00666 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 00667 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 00668 Type<T12>::ConvertStorageToReal(cP.Param12), Type<T13>::ConvertStorageToReal(cP.Param13))); 00669 } 00670 } 00671 00672 virtual void Call(const DynParams &cParams) override 00673 { 00674 // Check signature 00675 if (cParams.GetSignature() == GetSignature()) { 00676 // Get typed params 00677 const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> &cP = 00678 static_cast<const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>&>(cParams); 00679 00680 // Call function 00681 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 00682 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 00683 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 00684 Type<T12>::ConvertStorageToReal(cP.Param12), Type<T13>::ConvertStorageToReal(cP.Param13)); 00685 } 00686 } 00687 00688 virtual void Call(const String &sParams) override 00689 { 00690 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::FromString(sParams); 00691 Call(cParams); 00692 } 00693 00694 virtual void Call(const XmlElement &cElement) override 00695 { 00696 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::FromXml(cElement); 00697 Call(cParams); 00698 } 00699 00700 virtual String CallWithReturn(const String &sParams) override 00701 { 00702 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::FromString(sParams); 00703 Call(cParams); 00704 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 00705 } 00706 00707 virtual String CallWithReturn(const XmlElement &cElement) override 00708 { 00709 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::FromXml(cElement); 00710 Call(cParams); 00711 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 00712 } 00713 }; 00714 00715 /** 00716 * @brief 00717 * Function object (object that can be 'called' like a function / functoid) 00718 * 00719 * @remarks 00720 * Implementation for 14 parameters without a return value 00721 */ 00722 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> 00723 class Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> : public DynFunc { 00724 public: 00725 typedef typename Type<T0> ::_Type _T0; 00726 typedef typename Type<T1> ::_Type _T1; 00727 typedef typename Type<T2> ::_Type _T2; 00728 typedef typename Type<T3> ::_Type _T3; 00729 typedef typename Type<T4> ::_Type _T4; 00730 typedef typename Type<T5> ::_Type _T5; 00731 typedef typename Type<T6> ::_Type _T6; 00732 typedef typename Type<T7> ::_Type _T7; 00733 typedef typename Type<T8> ::_Type _T8; 00734 typedef typename Type<T9> ::_Type _T9; 00735 typedef typename Type<T10>::_Type _T10; 00736 typedef typename Type<T11>::_Type _T11; 00737 typedef typename Type<T12>::_Type _T12; 00738 typedef typename Type<T13>::_Type _T13; 00739 00740 Func() 00741 { 00742 } 00743 00744 virtual ~Func() 00745 { 00746 } 00747 00748 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) 00749 { 00750 } 00751 00752 virtual String GetSignature() const override 00753 { 00754 return Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::GetSignatureID(); 00755 } 00756 00757 virtual uint32 GetNumOfParameters() const override 00758 { 00759 return 14; 00760 } 00761 00762 virtual int GetParameterTypeID(uint32 nIndex) const override 00763 { 00764 switch (nIndex) { 00765 case 0: return Type<T0> ::TypeID; 00766 case 1: return Type<T1> ::TypeID; 00767 case 2: return Type<T2> ::TypeID; 00768 case 3: return Type<T3> ::TypeID; 00769 case 4: return Type<T4> ::TypeID; 00770 case 5: return Type<T5> ::TypeID; 00771 case 6: return Type<T6> ::TypeID; 00772 case 7: return Type<T7> ::TypeID; 00773 case 8: return Type<T8> ::TypeID; 00774 case 9: return Type<T9> ::TypeID; 00775 case 10: return Type<T10>::TypeID; 00776 case 11: return Type<T11>::TypeID; 00777 case 12: return Type<T12>::TypeID; 00778 case 13: return Type<T13>::TypeID; 00779 default: return TypeInvalid; 00780 } 00781 } 00782 00783 virtual void Call(DynParams &cParams) override 00784 { 00785 // Check signature 00786 if (cParams.GetSignature() == GetSignature()) { 00787 // Get typed params 00788 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> &cP = 00789 static_cast<Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>&>(cParams); 00790 00791 // Call function 00792 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 00793 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 00794 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 00795 Type<T12>::ConvertStorageToReal(cP.Param12), Type<T13>::ConvertStorageToReal(cP.Param13)); 00796 } 00797 } 00798 00799 virtual void Call(const DynParams &cParams) override 00800 { 00801 // Check signature 00802 if (cParams.GetSignature() == GetSignature()) { 00803 // Get typed params 00804 const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> &cP = 00805 static_cast<const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>&>(cParams); 00806 00807 // Call function 00808 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 00809 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 00810 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 00811 Type<T12>::ConvertStorageToReal(cP.Param12), Type<T13>::ConvertStorageToReal(cP.Param13)); 00812 } 00813 } 00814 00815 virtual void Call(const String &sParams) override 00816 { 00817 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::FromString(sParams); 00818 Call(cParams); 00819 } 00820 00821 virtual void Call(const XmlElement &cElement) override 00822 { 00823 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::FromXml(cElement); 00824 Call(cParams); 00825 } 00826 00827 virtual String CallWithReturn(const String &sParams) override 00828 { 00829 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::FromString(sParams); 00830 Call(cParams); 00831 return ""; 00832 } 00833 00834 virtual String CallWithReturn(const XmlElement &cElement) override 00835 { 00836 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::FromXml(cElement); 00837 Call(cParams); 00838 return ""; 00839 } 00840 }; 00841 00842 /** 00843 * @brief 00844 * Function object (object that can be 'called' like a function / functoid) 00845 * 00846 * @remarks 00847 * Implementation for 13 parameters and a return value 00848 */ 00849 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> 00850 class Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : public DynFunc { 00851 public: 00852 typedef typename Type<R> ::_Type _R; 00853 typedef typename Type<T0> ::_Type _T0; 00854 typedef typename Type<T1> ::_Type _T1; 00855 typedef typename Type<T2> ::_Type _T2; 00856 typedef typename Type<T3> ::_Type _T3; 00857 typedef typename Type<T4> ::_Type _T4; 00858 typedef typename Type<T5> ::_Type _T5; 00859 typedef typename Type<T6> ::_Type _T6; 00860 typedef typename Type<T7> ::_Type _T7; 00861 typedef typename Type<T8> ::_Type _T8; 00862 typedef typename Type<T9> ::_Type _T9; 00863 typedef typename Type<T10>::_Type _T10; 00864 typedef typename Type<T11>::_Type _T11; 00865 typedef typename Type<T12>::_Type _T12; 00866 00867 Func() 00868 { 00869 } 00870 00871 virtual ~Func() 00872 { 00873 } 00874 00875 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) 00876 { 00877 return DefaultValue<R>::Default(); 00878 } 00879 00880 virtual String GetSignature() const override 00881 { 00882 return Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::GetSignatureID(); 00883 } 00884 00885 virtual int GetReturnTypeID() const override 00886 { 00887 return Type<R>::TypeID; 00888 } 00889 00890 virtual uint32 GetNumOfParameters() const override 00891 { 00892 return 13; 00893 } 00894 00895 virtual int GetParameterTypeID(uint32 nIndex) const override 00896 { 00897 switch (nIndex) { 00898 case 0: return Type<T0> ::TypeID; 00899 case 1: return Type<T1> ::TypeID; 00900 case 2: return Type<T2> ::TypeID; 00901 case 3: return Type<T3> ::TypeID; 00902 case 4: return Type<T4> ::TypeID; 00903 case 5: return Type<T5> ::TypeID; 00904 case 6: return Type<T6> ::TypeID; 00905 case 7: return Type<T7> ::TypeID; 00906 case 8: return Type<T8> ::TypeID; 00907 case 9: return Type<T9> ::TypeID; 00908 case 10: return Type<T10>::TypeID; 00909 case 11: return Type<T11>::TypeID; 00910 case 12: return Type<T12>::TypeID; 00911 default: return TypeInvalid; 00912 } 00913 } 00914 00915 virtual void Call(DynParams &cParams) override 00916 { 00917 // Check signature 00918 if (cParams.GetSignature() == GetSignature()) { 00919 // Get typed params 00920 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> &cP = 00921 static_cast<Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>&>(cParams); 00922 00923 // Call function 00924 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 00925 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 00926 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 00927 Type<T12>::ConvertStorageToReal(cP.Param12))); 00928 } 00929 } 00930 00931 virtual void Call(const DynParams &cParams) override 00932 { 00933 // Check signature 00934 if (cParams.GetSignature() == GetSignature()) { 00935 // Get typed params 00936 const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> &cP = 00937 static_cast<const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>&>(cParams); 00938 00939 // Call function 00940 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 00941 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 00942 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 00943 Type<T12>::ConvertStorageToReal(cP.Param12)); 00944 } 00945 } 00946 00947 virtual void Call(const String &sParams) override 00948 { 00949 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::FromString(sParams); 00950 Call(cParams); 00951 } 00952 00953 virtual void Call(const XmlElement &cElement) override 00954 { 00955 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::FromXml(cElement); 00956 Call(cParams); 00957 } 00958 00959 virtual String CallWithReturn(const String &sParams) override 00960 { 00961 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::FromString(sParams); 00962 Call(cParams); 00963 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 00964 } 00965 00966 virtual String CallWithReturn(const XmlElement &cElement) override 00967 { 00968 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::FromXml(cElement); 00969 Call(cParams); 00970 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 00971 } 00972 }; 00973 00974 /** 00975 * @brief 00976 * Function object (object that can be 'called' like a function / functoid) 00977 * 00978 * @remarks 00979 * Implementation for 13 parameters without a return value 00980 */ 00981 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> 00982 class Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : public DynFunc { 00983 public: 00984 typedef typename Type<T0> ::_Type _T0; 00985 typedef typename Type<T1> ::_Type _T1; 00986 typedef typename Type<T2> ::_Type _T2; 00987 typedef typename Type<T3> ::_Type _T3; 00988 typedef typename Type<T4> ::_Type _T4; 00989 typedef typename Type<T5> ::_Type _T5; 00990 typedef typename Type<T6> ::_Type _T6; 00991 typedef typename Type<T7> ::_Type _T7; 00992 typedef typename Type<T8> ::_Type _T8; 00993 typedef typename Type<T9> ::_Type _T9; 00994 typedef typename Type<T10>::_Type _T10; 00995 typedef typename Type<T11>::_Type _T11; 00996 typedef typename Type<T12>::_Type _T12; 00997 00998 Func() 00999 { 01000 } 01001 01002 virtual ~Func() 01003 { 01004 } 01005 01006 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) 01007 { 01008 } 01009 01010 virtual String GetSignature() const override 01011 { 01012 return Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::GetSignatureID(); 01013 } 01014 01015 virtual uint32 GetNumOfParameters() const override 01016 { 01017 return 13; 01018 } 01019 01020 virtual int GetParameterTypeID(uint32 nIndex) const override 01021 { 01022 switch (nIndex) { 01023 case 0: return Type<T0> ::TypeID; 01024 case 1: return Type<T1> ::TypeID; 01025 case 2: return Type<T2> ::TypeID; 01026 case 3: return Type<T3> ::TypeID; 01027 case 4: return Type<T4> ::TypeID; 01028 case 5: return Type<T5> ::TypeID; 01029 case 6: return Type<T6> ::TypeID; 01030 case 7: return Type<T7> ::TypeID; 01031 case 8: return Type<T8> ::TypeID; 01032 case 9: return Type<T9> ::TypeID; 01033 case 10: return Type<T10>::TypeID; 01034 case 11: return Type<T11>::TypeID; 01035 case 12: return Type<T12>::TypeID; 01036 default: return TypeInvalid; 01037 } 01038 } 01039 01040 virtual void Call(DynParams &cParams) override 01041 { 01042 // Check signature 01043 if (cParams.GetSignature() == GetSignature()) { 01044 // Get typed params 01045 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> &cP = 01046 static_cast<Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>&>(cParams); 01047 01048 // Call function 01049 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01050 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01051 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 01052 Type<T12>::ConvertStorageToReal(cP.Param12)); 01053 } 01054 } 01055 01056 virtual void Call(const DynParams &cParams) override 01057 { 01058 // Check signature 01059 if (cParams.GetSignature() == GetSignature()) { 01060 // Get typed params 01061 const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> &cP = 01062 static_cast<const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>&>(cParams); 01063 01064 // Call function 01065 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01066 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01067 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11), 01068 Type<T12>::ConvertStorageToReal(cP.Param12)); 01069 } 01070 } 01071 01072 virtual void Call(const String &sParams) override 01073 { 01074 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::FromString(sParams); 01075 Call(cParams); 01076 } 01077 01078 virtual void Call(const XmlElement &cElement) override 01079 { 01080 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::FromXml(cElement); 01081 Call(cParams); 01082 } 01083 01084 virtual String CallWithReturn(const String &sParams) override 01085 { 01086 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::FromString(sParams); 01087 Call(cParams); 01088 return ""; 01089 } 01090 01091 virtual String CallWithReturn(const XmlElement &cElement) override 01092 { 01093 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::FromXml(cElement); 01094 Call(cParams); 01095 return ""; 01096 } 01097 }; 01098 01099 /** 01100 * @brief 01101 * Function object (object that can be 'called' like a function / functoid) 01102 * 01103 * @remarks 01104 * Implementation for 12 parameters and a return value 01105 */ 01106 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> 01107 class Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : public DynFunc { 01108 public: 01109 typedef typename Type<R> ::_Type _R; 01110 typedef typename Type<T0> ::_Type _T0; 01111 typedef typename Type<T1> ::_Type _T1; 01112 typedef typename Type<T2> ::_Type _T2; 01113 typedef typename Type<T3> ::_Type _T3; 01114 typedef typename Type<T4> ::_Type _T4; 01115 typedef typename Type<T5> ::_Type _T5; 01116 typedef typename Type<T6> ::_Type _T6; 01117 typedef typename Type<T7> ::_Type _T7; 01118 typedef typename Type<T8> ::_Type _T8; 01119 typedef typename Type<T9> ::_Type _T9; 01120 typedef typename Type<T10>::_Type _T10; 01121 typedef typename Type<T11>::_Type _T11; 01122 01123 Func() 01124 { 01125 } 01126 01127 virtual ~Func() 01128 { 01129 } 01130 01131 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) 01132 { 01133 return DefaultValue<R>::Default(); 01134 } 01135 01136 virtual String GetSignature() const override 01137 { 01138 return Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::GetSignatureID(); 01139 } 01140 01141 virtual int GetReturnTypeID() const override 01142 { 01143 return Type<R>::TypeID; 01144 } 01145 01146 virtual uint32 GetNumOfParameters() const override 01147 { 01148 return 12; 01149 } 01150 01151 virtual int GetParameterTypeID(uint32 nIndex) const override 01152 { 01153 switch (nIndex) { 01154 case 0: return Type<T0> ::TypeID; 01155 case 1: return Type<T1> ::TypeID; 01156 case 2: return Type<T2> ::TypeID; 01157 case 3: return Type<T3> ::TypeID; 01158 case 4: return Type<T4> ::TypeID; 01159 case 5: return Type<T5> ::TypeID; 01160 case 6: return Type<T6> ::TypeID; 01161 case 7: return Type<T7> ::TypeID; 01162 case 8: return Type<T8> ::TypeID; 01163 case 9: return Type<T9> ::TypeID; 01164 case 10: return Type<T10>::TypeID; 01165 case 11: return Type<T11>::TypeID; 01166 default: return TypeInvalid; 01167 } 01168 } 01169 01170 virtual void Call(DynParams &cParams) override 01171 { 01172 // Check signature 01173 if (cParams.GetSignature() == GetSignature()) { 01174 // Get typed params 01175 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> &cP = 01176 static_cast<Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>&>(cParams); 01177 01178 // Call function 01179 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01180 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01181 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11))); 01182 } 01183 } 01184 01185 virtual void Call(const DynParams &cParams) override 01186 { 01187 // Check signature 01188 if (cParams.GetSignature() == GetSignature()) { 01189 // Get typed params 01190 const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> &cP = 01191 static_cast<const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>&>(cParams); 01192 01193 // Call function 01194 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01195 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01196 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11)); 01197 } 01198 } 01199 01200 virtual void Call(const String &sParams) override 01201 { 01202 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::FromString(sParams); 01203 Call(cParams); 01204 } 01205 01206 virtual void Call(const XmlElement &cElement) override 01207 { 01208 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::FromXml(cElement); 01209 Call(cParams); 01210 } 01211 01212 virtual String CallWithReturn(const String &sParams) override 01213 { 01214 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::FromString(sParams); 01215 Call(cParams); 01216 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 01217 } 01218 01219 virtual String CallWithReturn(const XmlElement &cElement) override 01220 { 01221 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::FromXml(cElement); 01222 Call(cParams); 01223 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 01224 } 01225 }; 01226 01227 /** 01228 * @brief 01229 * Function object (object that can be 'called' like a function / functoid) 01230 * 01231 * @remarks 01232 * Implementation for 12 parameters without a return value 01233 */ 01234 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> 01235 class Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : public DynFunc { 01236 public: 01237 typedef typename Type<T0> ::_Type _T0; 01238 typedef typename Type<T1> ::_Type _T1; 01239 typedef typename Type<T2> ::_Type _T2; 01240 typedef typename Type<T3> ::_Type _T3; 01241 typedef typename Type<T4> ::_Type _T4; 01242 typedef typename Type<T5> ::_Type _T5; 01243 typedef typename Type<T6> ::_Type _T6; 01244 typedef typename Type<T7> ::_Type _T7; 01245 typedef typename Type<T8> ::_Type _T8; 01246 typedef typename Type<T9> ::_Type _T9; 01247 typedef typename Type<T10>::_Type _T10; 01248 typedef typename Type<T11>::_Type _T11; 01249 01250 Func() 01251 { 01252 } 01253 01254 virtual ~Func() 01255 { 01256 } 01257 01258 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) 01259 { 01260 } 01261 01262 virtual String GetSignature() const override 01263 { 01264 return Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::GetSignatureID(); 01265 } 01266 01267 virtual uint32 GetNumOfParameters() const override 01268 { 01269 return 12; 01270 } 01271 01272 virtual int GetParameterTypeID(uint32 nIndex) const override 01273 { 01274 switch (nIndex) { 01275 case 0: return Type<T0> ::TypeID; 01276 case 1: return Type<T1> ::TypeID; 01277 case 2: return Type<T2> ::TypeID; 01278 case 3: return Type<T3> ::TypeID; 01279 case 4: return Type<T4> ::TypeID; 01280 case 5: return Type<T5> ::TypeID; 01281 case 6: return Type<T6> ::TypeID; 01282 case 7: return Type<T7> ::TypeID; 01283 case 8: return Type<T8> ::TypeID; 01284 case 9: return Type<T9> ::TypeID; 01285 case 10: return Type<T10>::TypeID; 01286 case 11: return Type<T11>::TypeID; 01287 default: return TypeInvalid; 01288 } 01289 } 01290 01291 virtual void Call(DynParams &cParams) override 01292 { 01293 // Check signature 01294 if (cParams.GetSignature() == GetSignature()) { 01295 // Get typed params 01296 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> &cP = 01297 static_cast<Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>&>(cParams); 01298 01299 // Call function 01300 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01301 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01302 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11)); 01303 } 01304 } 01305 01306 virtual void Call(const DynParams &cParams) override 01307 { 01308 // Check signature 01309 if (cParams.GetSignature() == GetSignature()) { 01310 // Get typed params 01311 const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> &cP = 01312 static_cast<const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>&>(cParams); 01313 01314 // Call function 01315 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01316 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01317 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10), Type<T11>::ConvertStorageToReal(cP.Param11)); 01318 } 01319 } 01320 01321 virtual void Call(const String &sParams) override 01322 { 01323 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::FromString(sParams); 01324 Call(cParams); 01325 } 01326 01327 virtual void Call(const XmlElement &cElement) override 01328 { 01329 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::FromXml(cElement); 01330 Call(cParams); 01331 } 01332 01333 virtual String CallWithReturn(const String &sParams) override 01334 { 01335 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::FromString(sParams); 01336 Call(cParams); 01337 return ""; 01338 } 01339 01340 virtual String CallWithReturn(const XmlElement &cElement) override 01341 { 01342 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::FromXml(cElement); 01343 Call(cParams); 01344 return ""; 01345 } 01346 }; 01347 01348 /** 01349 * @brief 01350 * Function object (object that can be 'called' like a function / functoid) 01351 * 01352 * @remarks 01353 * Implementation for 11 parameters and a return value 01354 */ 01355 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> 01356 class Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : public DynFunc { 01357 public: 01358 typedef typename Type<R> ::_Type _R; 01359 typedef typename Type<T0> ::_Type _T0; 01360 typedef typename Type<T1> ::_Type _T1; 01361 typedef typename Type<T2> ::_Type _T2; 01362 typedef typename Type<T3> ::_Type _T3; 01363 typedef typename Type<T4> ::_Type _T4; 01364 typedef typename Type<T5> ::_Type _T5; 01365 typedef typename Type<T6> ::_Type _T6; 01366 typedef typename Type<T7> ::_Type _T7; 01367 typedef typename Type<T8> ::_Type _T8; 01368 typedef typename Type<T9> ::_Type _T9; 01369 typedef typename Type<T10>::_Type _T10; 01370 01371 Func() 01372 { 01373 } 01374 01375 virtual ~Func() 01376 { 01377 } 01378 01379 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) 01380 { 01381 return DefaultValue<R>::Default(); 01382 } 01383 01384 virtual String GetSignature() const override 01385 { 01386 return Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::GetSignatureID(); 01387 } 01388 01389 virtual int GetReturnTypeID() const override 01390 { 01391 return Type<R>::TypeID; 01392 } 01393 01394 virtual uint32 GetNumOfParameters() const override 01395 { 01396 return 11; 01397 } 01398 01399 virtual int GetParameterTypeID(uint32 nIndex) const override 01400 { 01401 switch (nIndex) { 01402 case 0: return Type<T0> ::TypeID; 01403 case 1: return Type<T1> ::TypeID; 01404 case 2: return Type<T2> ::TypeID; 01405 case 3: return Type<T3> ::TypeID; 01406 case 4: return Type<T4> ::TypeID; 01407 case 5: return Type<T5> ::TypeID; 01408 case 6: return Type<T6> ::TypeID; 01409 case 7: return Type<T7> ::TypeID; 01410 case 8: return Type<T8> ::TypeID; 01411 case 9: return Type<T9> ::TypeID; 01412 case 10: return Type<T10>::TypeID; 01413 default: return TypeInvalid; 01414 } 01415 } 01416 01417 virtual void Call(DynParams &cParams) override 01418 { 01419 // Check signature 01420 if (cParams.GetSignature() == GetSignature()) { 01421 // Get typed params 01422 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> &cP = 01423 static_cast<Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>&>(cParams); 01424 01425 // Call function 01426 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01427 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01428 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10))); 01429 } 01430 } 01431 01432 virtual void Call(const DynParams &cParams) override 01433 { 01434 // Check signature 01435 if (cParams.GetSignature() == GetSignature()) { 01436 // Get typed params 01437 const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> &cP = 01438 static_cast<const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>&>(cParams); 01439 01440 // Call function 01441 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01442 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01443 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10)); 01444 } 01445 } 01446 01447 virtual void Call(const String &sParams) override 01448 { 01449 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::FromString(sParams); 01450 Call(cParams); 01451 } 01452 01453 virtual void Call(const XmlElement &cElement) override 01454 { 01455 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::FromXml(cElement); 01456 Call(cParams); 01457 } 01458 01459 virtual String CallWithReturn(const String &sParams) override 01460 { 01461 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::FromString(sParams); 01462 Call(cParams); 01463 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 01464 } 01465 01466 virtual String CallWithReturn(const XmlElement &cElement) override 01467 { 01468 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::FromXml(cElement); 01469 Call(cParams); 01470 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 01471 } 01472 }; 01473 01474 /** 01475 * @brief 01476 * Function object (object that can be 'called' like a function / functoid) 01477 * 01478 * @remarks 01479 * Implementation for 11 parameters without a return value 01480 */ 01481 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> 01482 class Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : public DynFunc { 01483 public: 01484 typedef typename Type<T0> ::_Type _T0; 01485 typedef typename Type<T1> ::_Type _T1; 01486 typedef typename Type<T2> ::_Type _T2; 01487 typedef typename Type<T3> ::_Type _T3; 01488 typedef typename Type<T4> ::_Type _T4; 01489 typedef typename Type<T5> ::_Type _T5; 01490 typedef typename Type<T6> ::_Type _T6; 01491 typedef typename Type<T7> ::_Type _T7; 01492 typedef typename Type<T8> ::_Type _T8; 01493 typedef typename Type<T9> ::_Type _T9; 01494 typedef typename Type<T10>::_Type _T10; 01495 01496 Func() 01497 { 01498 } 01499 01500 virtual ~Func() 01501 { 01502 } 01503 01504 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) 01505 { 01506 } 01507 01508 virtual String GetSignature() const override 01509 { 01510 return Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::GetSignatureID(); 01511 } 01512 01513 virtual uint32 GetNumOfParameters() const override 01514 { 01515 return 11; 01516 } 01517 01518 virtual int GetParameterTypeID(uint32 nIndex) const override 01519 { 01520 switch (nIndex) { 01521 case 0: return Type<T0> ::TypeID; 01522 case 1: return Type<T1> ::TypeID; 01523 case 2: return Type<T2> ::TypeID; 01524 case 3: return Type<T3> ::TypeID; 01525 case 4: return Type<T4> ::TypeID; 01526 case 5: return Type<T5> ::TypeID; 01527 case 6: return Type<T6> ::TypeID; 01528 case 7: return Type<T7> ::TypeID; 01529 case 8: return Type<T8> ::TypeID; 01530 case 9: return Type<T9> ::TypeID; 01531 case 10: return Type<T10>::TypeID; 01532 default: return TypeInvalid; 01533 } 01534 } 01535 01536 virtual void Call(DynParams &cParams) override 01537 { 01538 // Check signature 01539 if (cParams.GetSignature() == GetSignature()) { 01540 // Get typed params 01541 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> &cP = 01542 static_cast<Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>&>(cParams); 01543 01544 // Call function 01545 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01546 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01547 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10)); 01548 } 01549 } 01550 01551 virtual void Call(const DynParams &cParams) override 01552 { 01553 // Check signature 01554 if (cParams.GetSignature() == GetSignature()) { 01555 // Get typed params 01556 const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> &cP = 01557 static_cast<const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>&>(cParams); 01558 01559 // Call function 01560 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01561 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01562 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9), Type<T10>::ConvertStorageToReal(cP.Param10)); 01563 } 01564 } 01565 01566 virtual void Call(const String &sParams) override 01567 { 01568 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::FromString(sParams); 01569 Call(cParams); 01570 } 01571 01572 virtual void Call(const XmlElement &cElement) override 01573 { 01574 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::FromXml(cElement); 01575 Call(cParams); 01576 } 01577 01578 virtual String CallWithReturn(const String &sParams) override 01579 { 01580 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::FromString(sParams); 01581 Call(cParams); 01582 return ""; 01583 } 01584 01585 virtual String CallWithReturn(const XmlElement &cElement) override 01586 { 01587 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::FromXml(cElement); 01588 Call(cParams); 01589 return ""; 01590 } 01591 }; 01592 01593 /** 01594 * @brief 01595 * Function object (object that can be 'called' like a function / functoid) 01596 * 01597 * @remarks 01598 * Implementation for 10 parameters and a return value 01599 */ 01600 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> 01601 class Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> : public DynFunc { 01602 public: 01603 typedef typename Type<R> ::_Type _R; 01604 typedef typename Type<T0> ::_Type _T0; 01605 typedef typename Type<T1> ::_Type _T1; 01606 typedef typename Type<T2> ::_Type _T2; 01607 typedef typename Type<T3> ::_Type _T3; 01608 typedef typename Type<T4> ::_Type _T4; 01609 typedef typename Type<T5> ::_Type _T5; 01610 typedef typename Type<T6> ::_Type _T6; 01611 typedef typename Type<T7> ::_Type _T7; 01612 typedef typename Type<T8> ::_Type _T8; 01613 typedef typename Type<T9> ::_Type _T9; 01614 01615 Func() 01616 { 01617 } 01618 01619 virtual ~Func() 01620 { 01621 } 01622 01623 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9) 01624 { 01625 return DefaultValue<R>::Default(); 01626 } 01627 01628 virtual String GetSignature() const override 01629 { 01630 return Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::GetSignatureID(); 01631 } 01632 01633 virtual int GetReturnTypeID() const override 01634 { 01635 return Type<R>::TypeID; 01636 } 01637 01638 virtual uint32 GetNumOfParameters() const override 01639 { 01640 return 10; 01641 } 01642 01643 virtual int GetParameterTypeID(uint32 nIndex) const override 01644 { 01645 switch (nIndex) { 01646 case 0: return Type<T0>::TypeID; 01647 case 1: return Type<T1>::TypeID; 01648 case 2: return Type<T2>::TypeID; 01649 case 3: return Type<T3>::TypeID; 01650 case 4: return Type<T4>::TypeID; 01651 case 5: return Type<T5>::TypeID; 01652 case 6: return Type<T6>::TypeID; 01653 case 7: return Type<T7>::TypeID; 01654 case 8: return Type<T8>::TypeID; 01655 case 9: return Type<T9>::TypeID; 01656 default: return TypeInvalid; 01657 } 01658 } 01659 01660 virtual void Call(DynParams &cParams) override 01661 { 01662 // Check signature 01663 if (cParams.GetSignature() == GetSignature()) { 01664 // Get typed params 01665 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> &cP = 01666 static_cast<Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>&>(cParams); 01667 01668 // Call function 01669 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01670 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01671 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9))); 01672 } 01673 } 01674 01675 virtual void Call(const DynParams &cParams) override 01676 { 01677 // Check signature 01678 if (cParams.GetSignature() == GetSignature()) { 01679 // Get typed params 01680 const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> &cP = 01681 static_cast<const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>&>(cParams); 01682 01683 // Call function 01684 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01685 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01686 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9)); 01687 } 01688 } 01689 01690 virtual void Call(const String &sParams) override 01691 { 01692 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::FromString(sParams); 01693 Call(cParams); 01694 } 01695 01696 virtual void Call(const XmlElement &cElement) override 01697 { 01698 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::FromXml(cElement); 01699 Call(cParams); 01700 } 01701 01702 virtual String CallWithReturn(const String &sParams) override 01703 { 01704 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::FromString(sParams); 01705 Call(cParams); 01706 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 01707 } 01708 01709 virtual String CallWithReturn(const XmlElement &cElement) override 01710 { 01711 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::FromXml(cElement); 01712 Call(cParams); 01713 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 01714 } 01715 }; 01716 01717 /** 01718 * @brief 01719 * Function object (object that can be 'called' like a function / functoid) 01720 * 01721 * @remarks 01722 * Implementation for 10 parameters without a return value 01723 */ 01724 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> 01725 class Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> : public DynFunc { 01726 public: 01727 typedef typename Type<T0> ::_Type _T0; 01728 typedef typename Type<T1> ::_Type _T1; 01729 typedef typename Type<T2> ::_Type _T2; 01730 typedef typename Type<T3> ::_Type _T3; 01731 typedef typename Type<T4> ::_Type _T4; 01732 typedef typename Type<T5> ::_Type _T5; 01733 typedef typename Type<T6> ::_Type _T6; 01734 typedef typename Type<T7> ::_Type _T7; 01735 typedef typename Type<T8> ::_Type _T8; 01736 typedef typename Type<T9> ::_Type _T9; 01737 01738 Func() 01739 { 01740 } 01741 01742 virtual ~Func() 01743 { 01744 } 01745 01746 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8, _T9 t9) 01747 { 01748 } 01749 01750 virtual String GetSignature() const override 01751 { 01752 return Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::GetSignatureID(); 01753 } 01754 01755 virtual uint32 GetNumOfParameters() const override 01756 { 01757 return 10; 01758 } 01759 01760 virtual int GetParameterTypeID(uint32 nIndex) const override 01761 { 01762 switch (nIndex) { 01763 case 0: return Type<T0>::TypeID; 01764 case 1: return Type<T1>::TypeID; 01765 case 2: return Type<T2>::TypeID; 01766 case 3: return Type<T3>::TypeID; 01767 case 4: return Type<T4>::TypeID; 01768 case 5: return Type<T5>::TypeID; 01769 case 6: return Type<T6>::TypeID; 01770 case 7: return Type<T7>::TypeID; 01771 case 8: return Type<T8>::TypeID; 01772 case 9: return Type<T9>::TypeID; 01773 default: return TypeInvalid; 01774 } 01775 } 01776 01777 virtual void Call(DynParams &cParams) override 01778 { 01779 // Check signature 01780 if (cParams.GetSignature() == GetSignature()) { 01781 // Get typed params 01782 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> &cP = 01783 static_cast<Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>&>(cParams); 01784 01785 // Call function 01786 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01787 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01788 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9)); 01789 } 01790 } 01791 01792 virtual void Call(const DynParams &cParams) override 01793 { 01794 // Check signature 01795 if (cParams.GetSignature() == GetSignature()) { 01796 // Get typed params 01797 const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> &cP = 01798 static_cast<const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>&>(cParams); 01799 01800 // Call function 01801 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01802 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01803 Type<T8> ::ConvertStorageToReal(cP.Param8), Type<T9> ::ConvertStorageToReal(cP.Param9)); 01804 } 01805 } 01806 01807 virtual void Call(const String &sParams) override 01808 { 01809 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::FromString(sParams); 01810 Call(cParams); 01811 } 01812 01813 virtual void Call(const XmlElement &cElement) override 01814 { 01815 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::FromXml(cElement); 01816 Call(cParams); 01817 } 01818 01819 virtual String CallWithReturn(const String &sParams) override 01820 { 01821 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::FromString(sParams); 01822 Call(cParams); 01823 return ""; 01824 } 01825 01826 virtual String CallWithReturn(const XmlElement &cElement) override 01827 { 01828 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::FromXml(cElement); 01829 Call(cParams); 01830 return ""; 01831 } 01832 }; 01833 01834 /** 01835 * @brief 01836 * Function object (object that can be 'called' like a function / functoid) 01837 * 01838 * @remarks 01839 * Implementation for 9 parameters and a return value 01840 */ 01841 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> 01842 class Func<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> : public DynFunc { 01843 public: 01844 typedef typename Type<R> ::_Type _R; 01845 typedef typename Type<T0> ::_Type _T0; 01846 typedef typename Type<T1> ::_Type _T1; 01847 typedef typename Type<T2> ::_Type _T2; 01848 typedef typename Type<T3> ::_Type _T3; 01849 typedef typename Type<T4> ::_Type _T4; 01850 typedef typename Type<T5> ::_Type _T5; 01851 typedef typename Type<T6> ::_Type _T6; 01852 typedef typename Type<T7> ::_Type _T7; 01853 typedef typename Type<T8> ::_Type _T8; 01854 01855 Func() 01856 { 01857 } 01858 01859 virtual ~Func() 01860 { 01861 } 01862 01863 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8) 01864 { 01865 return DefaultValue<R>::Default(); 01866 } 01867 01868 virtual String GetSignature() const override 01869 { 01870 return Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8>::GetSignatureID(); 01871 } 01872 01873 virtual int GetReturnTypeID() const override 01874 { 01875 return Type<R>::TypeID; 01876 } 01877 01878 virtual uint32 GetNumOfParameters() const override 01879 { 01880 return 9; 01881 } 01882 01883 virtual int GetParameterTypeID(uint32 nIndex) const override 01884 { 01885 switch (nIndex) { 01886 case 0: return Type<T0>::TypeID; 01887 case 1: return Type<T1>::TypeID; 01888 case 2: return Type<T2>::TypeID; 01889 case 3: return Type<T3>::TypeID; 01890 case 4: return Type<T4>::TypeID; 01891 case 5: return Type<T5>::TypeID; 01892 case 6: return Type<T6>::TypeID; 01893 case 7: return Type<T7>::TypeID; 01894 case 8: return Type<T8>::TypeID; 01895 default: return TypeInvalid; 01896 } 01897 } 01898 01899 virtual void Call(DynParams &cParams) override 01900 { 01901 // Check signature 01902 if (cParams.GetSignature() == GetSignature()) { 01903 // Get typed params 01904 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> &cP = 01905 static_cast<Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8>&>(cParams); 01906 01907 // Call function 01908 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01909 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01910 Type<T8> ::ConvertStorageToReal(cP.Param8))); 01911 } 01912 } 01913 01914 virtual void Call(const DynParams &cParams) override 01915 { 01916 // Check signature 01917 if (cParams.GetSignature() == GetSignature()) { 01918 // Get typed params 01919 const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> &cP = 01920 static_cast<const Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8>&>(cParams); 01921 01922 // Call function 01923 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 01924 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 01925 Type<T8> ::ConvertStorageToReal(cP.Param8)); 01926 } 01927 } 01928 01929 virtual void Call(const String &sParams) override 01930 { 01931 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8>::FromString(sParams); 01932 Call(cParams); 01933 } 01934 01935 virtual void Call(const XmlElement &cElement) override 01936 { 01937 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8>::FromXml(cElement); 01938 Call(cParams); 01939 } 01940 01941 virtual String CallWithReturn(const String &sParams) override 01942 { 01943 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8>::FromString(sParams); 01944 Call(cParams); 01945 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 01946 } 01947 01948 virtual String CallWithReturn(const XmlElement &cElement) override 01949 { 01950 Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7, T8>::FromXml(cElement); 01951 Call(cParams); 01952 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 01953 } 01954 }; 01955 01956 /** 01957 * @brief 01958 * Function object (object that can be 'called' like a function / functoid) 01959 * 01960 * @remarks 01961 * Implementation for 9 parameters without a return value 01962 */ 01963 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> 01964 class Func<void, T0, T1, T2, T3, T4, T5, T6, T7, T8> : public DynFunc { 01965 public: 01966 typedef typename Type<T0> ::_Type _T0; 01967 typedef typename Type<T1> ::_Type _T1; 01968 typedef typename Type<T2> ::_Type _T2; 01969 typedef typename Type<T3> ::_Type _T3; 01970 typedef typename Type<T4> ::_Type _T4; 01971 typedef typename Type<T5> ::_Type _T5; 01972 typedef typename Type<T6> ::_Type _T6; 01973 typedef typename Type<T7> ::_Type _T7; 01974 typedef typename Type<T8> ::_Type _T8; 01975 01976 Func() 01977 { 01978 } 01979 01980 virtual ~Func() 01981 { 01982 } 01983 01984 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7, _T8 t8) 01985 { 01986 } 01987 01988 virtual String GetSignature() const override 01989 { 01990 return Signature<void, T0, T1, T2, T3, T4, T5, T6, T7, T8>::GetSignatureID(); 01991 } 01992 01993 virtual uint32 GetNumOfParameters() const override 01994 { 01995 return 9; 01996 } 01997 01998 virtual int GetParameterTypeID(uint32 nIndex) const override 01999 { 02000 switch (nIndex) { 02001 case 0: return Type<T0>::TypeID; 02002 case 1: return Type<T1>::TypeID; 02003 case 2: return Type<T2>::TypeID; 02004 case 3: return Type<T3>::TypeID; 02005 case 4: return Type<T4>::TypeID; 02006 case 5: return Type<T5>::TypeID; 02007 case 6: return Type<T6>::TypeID; 02008 case 7: return Type<T7>::TypeID; 02009 case 8: return Type<T8>::TypeID; 02010 default: return TypeInvalid; 02011 } 02012 } 02013 02014 virtual void Call(DynParams &cParams) override 02015 { 02016 // Check signature 02017 if (cParams.GetSignature() == GetSignature()) { 02018 // Get typed params 02019 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8> &cP = 02020 static_cast<Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8>&>(cParams); 02021 02022 // Call function 02023 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02024 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 02025 Type<T8> ::ConvertStorageToReal(cP.Param8)); 02026 } 02027 } 02028 02029 virtual void Call(const DynParams &cParams) override 02030 { 02031 // Check signature 02032 if (cParams.GetSignature() == GetSignature()) { 02033 // Get typed params 02034 const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8> &cP = 02035 static_cast<const Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8>&>(cParams); 02036 02037 // Call function 02038 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02039 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7), 02040 Type<T8> ::ConvertStorageToReal(cP.Param8)); 02041 } 02042 } 02043 02044 virtual void Call(const String &sParams) override 02045 { 02046 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8>::FromString(sParams); 02047 Call(cParams); 02048 } 02049 02050 virtual void Call(const XmlElement &cElement) override 02051 { 02052 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8>::FromXml(cElement); 02053 Call(cParams); 02054 } 02055 02056 virtual String CallWithReturn(const String &sParams) override 02057 { 02058 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8>::FromString(sParams); 02059 Call(cParams); 02060 return ""; 02061 } 02062 02063 virtual String CallWithReturn(const XmlElement &cElement) override 02064 { 02065 Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7, T8>::FromXml(cElement); 02066 Call(cParams); 02067 return ""; 02068 } 02069 }; 02070 02071 /** 02072 * @brief 02073 * Function object (object that can be 'called' like a function / functoid) 02074 * 02075 * @remarks 02076 * Implementation for 8 parameters and a return value 02077 */ 02078 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> 02079 class Func<R, T0, T1, T2, T3, T4, T5, T6, T7> : public DynFunc { 02080 public: 02081 typedef typename Type<R> ::_Type _R; 02082 typedef typename Type<T0> ::_Type _T0; 02083 typedef typename Type<T1> ::_Type _T1; 02084 typedef typename Type<T2> ::_Type _T2; 02085 typedef typename Type<T3> ::_Type _T3; 02086 typedef typename Type<T4> ::_Type _T4; 02087 typedef typename Type<T5> ::_Type _T5; 02088 typedef typename Type<T6> ::_Type _T6; 02089 typedef typename Type<T7> ::_Type _T7; 02090 02091 Func() 02092 { 02093 } 02094 02095 virtual ~Func() 02096 { 02097 } 02098 02099 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7) 02100 { 02101 return DefaultValue<R>::Default(); 02102 } 02103 02104 virtual String GetSignature() const override 02105 { 02106 return Signature<R, T0, T1, T2, T3, T4, T5, T6, T7>::GetSignatureID(); 02107 } 02108 02109 virtual int GetReturnTypeID() const override 02110 { 02111 return Type<R>::TypeID; 02112 } 02113 02114 virtual uint32 GetNumOfParameters() const override 02115 { 02116 return 8; 02117 } 02118 02119 virtual int GetParameterTypeID(uint32 nIndex) const override 02120 { 02121 switch (nIndex) { 02122 case 0: return Type<T0>::TypeID; 02123 case 1: return Type<T1>::TypeID; 02124 case 2: return Type<T2>::TypeID; 02125 case 3: return Type<T3>::TypeID; 02126 case 4: return Type<T4>::TypeID; 02127 case 5: return Type<T5>::TypeID; 02128 case 6: return Type<T6>::TypeID; 02129 case 7: return Type<T7>::TypeID; 02130 default: return TypeInvalid; 02131 } 02132 } 02133 02134 virtual void Call(DynParams &cParams) override 02135 { 02136 // Check signature 02137 if (cParams.GetSignature() == GetSignature()) { 02138 // Get typed params 02139 Params<R, T0, T1, T2, T3, T4, T5, T6, T7> &cP = 02140 static_cast<Params<R, T0, T1, T2, T3, T4, T5, T6, T7>&>(cParams); 02141 02142 // Call function 02143 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02144 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7))); 02145 } 02146 } 02147 02148 virtual void Call(const DynParams &cParams) override 02149 { 02150 // Check signature 02151 if (cParams.GetSignature() == GetSignature()) { 02152 // Get typed params 02153 const Params<R, T0, T1, T2, T3, T4, T5, T6, T7> &cP = 02154 static_cast<const Params<R, T0, T1, T2, T3, T4, T5, T6, T7>&>(cParams); 02155 02156 // Call function 02157 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02158 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7)); 02159 } 02160 } 02161 02162 virtual void Call(const String &sParams) override 02163 { 02164 Params<R, T0, T1, T2, T3, T4, T5, T6, T7> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7>::FromString(sParams); 02165 Call(cParams); 02166 } 02167 02168 virtual void Call(const XmlElement &cElement) override 02169 { 02170 Params<R, T0, T1, T2, T3, T4, T5, T6, T7> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7>::FromXml(cElement); 02171 Call(cParams); 02172 } 02173 02174 virtual String CallWithReturn(const String &sParams) override 02175 { 02176 Params<R, T0, T1, T2, T3, T4, T5, T6, T7> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7>::FromString(sParams); 02177 Call(cParams); 02178 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 02179 } 02180 02181 virtual String CallWithReturn(const XmlElement &cElement) override 02182 { 02183 Params<R, T0, T1, T2, T3, T4, T5, T6, T7> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6, T7>::FromXml(cElement); 02184 Call(cParams); 02185 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 02186 } 02187 }; 02188 02189 /** 02190 * @brief 02191 * Function object (object that can be 'called' like a function / functoid) 02192 * 02193 * @remarks 02194 * Implementation for 8 parameters without a return value 02195 */ 02196 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> 02197 class Func<void, T0, T1, T2, T3, T4, T5, T6, T7> : public DynFunc { 02198 public: 02199 typedef typename Type<T0> ::_Type _T0; 02200 typedef typename Type<T1> ::_Type _T1; 02201 typedef typename Type<T2> ::_Type _T2; 02202 typedef typename Type<T3> ::_Type _T3; 02203 typedef typename Type<T4> ::_Type _T4; 02204 typedef typename Type<T5> ::_Type _T5; 02205 typedef typename Type<T6> ::_Type _T6; 02206 typedef typename Type<T7> ::_Type _T7; 02207 02208 Func() 02209 { 02210 } 02211 02212 virtual ~Func() 02213 { 02214 } 02215 02216 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6, _T7 t7) 02217 { 02218 } 02219 02220 virtual String GetSignature() const override 02221 { 02222 return Signature<void, T0, T1, T2, T3, T4, T5, T6, T7>::GetSignatureID(); 02223 } 02224 02225 virtual uint32 GetNumOfParameters() const override 02226 { 02227 return 8; 02228 } 02229 02230 virtual int GetParameterTypeID(uint32 nIndex) const override 02231 { 02232 switch (nIndex) { 02233 case 0: return Type<T0>::TypeID; 02234 case 1: return Type<T1>::TypeID; 02235 case 2: return Type<T2>::TypeID; 02236 case 3: return Type<T3>::TypeID; 02237 case 4: return Type<T4>::TypeID; 02238 case 5: return Type<T5>::TypeID; 02239 case 6: return Type<T6>::TypeID; 02240 case 7: return Type<T7>::TypeID; 02241 default: return TypeInvalid; 02242 } 02243 } 02244 02245 virtual void Call(DynParams &cParams) override 02246 { 02247 // Check signature 02248 if (cParams.GetSignature() == GetSignature()) { 02249 // Get typed params 02250 Params<void, T0, T1, T2, T3, T4, T5, T6, T7> &cP = 02251 static_cast<Params<void, T0, T1, T2, T3, T4, T5, T6, T7>&>(cParams); 02252 02253 // Call function 02254 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02255 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7)); 02256 } 02257 } 02258 02259 virtual void Call(const DynParams &cParams) override 02260 { 02261 // Check signature 02262 if (cParams.GetSignature() == GetSignature()) { 02263 // Get typed params 02264 const Params<void, T0, T1, T2, T3, T4, T5, T6, T7> &cP = 02265 static_cast<const Params<void, T0, T1, T2, T3, T4, T5, T6, T7>&>(cParams); 02266 02267 // Call function 02268 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02269 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6), Type<T7> ::ConvertStorageToReal(cP.Param7)); 02270 } 02271 } 02272 02273 virtual void Call(const String &sParams) override 02274 { 02275 Params<void, T0, T1, T2, T3, T4, T5, T6, T7> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7>::FromString(sParams); 02276 Call(cParams); 02277 } 02278 02279 virtual void Call(const XmlElement &cElement) override 02280 { 02281 Params<void, T0, T1, T2, T3, T4, T5, T6, T7> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7>::FromXml(cElement); 02282 Call(cParams); 02283 } 02284 02285 virtual String CallWithReturn(const String &sParams) override 02286 { 02287 Params<void, T0, T1, T2, T3, T4, T5, T6, T7> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7>::FromString(sParams); 02288 Call(cParams); 02289 return ""; 02290 } 02291 02292 virtual String CallWithReturn(const XmlElement &cElement) override 02293 { 02294 Params<void, T0, T1, T2, T3, T4, T5, T6, T7> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6, T7>::FromXml(cElement); 02295 Call(cParams); 02296 return ""; 02297 } 02298 }; 02299 02300 /** 02301 * @brief 02302 * Function object (object that can be 'called' like a function / functoid) 02303 * 02304 * @remarks 02305 * Implementation for 7 parameters and a return value 02306 */ 02307 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> 02308 class Func<R, T0, T1, T2, T3, T4, T5, T6> : public DynFunc { 02309 public: 02310 typedef typename Type<R> ::_Type _R; 02311 typedef typename Type<T0> ::_Type _T0; 02312 typedef typename Type<T1> ::_Type _T1; 02313 typedef typename Type<T2> ::_Type _T2; 02314 typedef typename Type<T3> ::_Type _T3; 02315 typedef typename Type<T4> ::_Type _T4; 02316 typedef typename Type<T5> ::_Type _T5; 02317 typedef typename Type<T6> ::_Type _T6; 02318 02319 Func() 02320 { 02321 } 02322 02323 virtual ~Func() 02324 { 02325 } 02326 02327 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6) 02328 { 02329 return DefaultValue<R>::Default(); 02330 } 02331 02332 virtual String GetSignature() const override 02333 { 02334 return Signature<R, T0, T1, T2, T3, T4, T5, T6>::GetSignatureID(); 02335 } 02336 02337 virtual int GetReturnTypeID() const override 02338 { 02339 return Type<R>::TypeID; 02340 } 02341 02342 virtual uint32 GetNumOfParameters() const override 02343 { 02344 return 7; 02345 } 02346 02347 virtual int GetParameterTypeID(uint32 nIndex) const override 02348 { 02349 switch (nIndex) { 02350 case 0: return Type<T0>::TypeID; 02351 case 1: return Type<T1>::TypeID; 02352 case 2: return Type<T2>::TypeID; 02353 case 3: return Type<T3>::TypeID; 02354 case 4: return Type<T4>::TypeID; 02355 case 5: return Type<T5>::TypeID; 02356 case 6: return Type<T6>::TypeID; 02357 default: return TypeInvalid; 02358 } 02359 } 02360 02361 virtual void Call(DynParams &cParams) override 02362 { 02363 // Check signature 02364 if (cParams.GetSignature() == GetSignature()) { 02365 // Get typed params 02366 Params<R, T0, T1, T2, T3, T4, T5, T6> &cP = 02367 static_cast<Params<R, T0, T1, T2, T3, T4, T5, T6>&>(cParams); 02368 02369 // Call function 02370 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02371 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6))); 02372 } 02373 } 02374 02375 virtual void Call(const DynParams &cParams) override 02376 { 02377 // Check signature 02378 if (cParams.GetSignature() == GetSignature()) { 02379 // Get typed params 02380 const Params<R, T0, T1, T2, T3, T4, T5, T6> &cP = 02381 static_cast<const Params<R, T0, T1, T2, T3, T4, T5, T6>&>(cParams); 02382 02383 // Call function 02384 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02385 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6)); 02386 } 02387 } 02388 02389 virtual void Call(const String &sParams) override 02390 { 02391 Params<R, T0, T1, T2, T3, T4, T5, T6> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6>::FromString(sParams); 02392 Call(cParams); 02393 } 02394 02395 virtual void Call(const XmlElement &cElement) override 02396 { 02397 Params<R, T0, T1, T2, T3, T4, T5, T6> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6>::FromXml(cElement); 02398 Call(cParams); 02399 } 02400 02401 virtual String CallWithReturn(const String &sParams) override 02402 { 02403 Params<R, T0, T1, T2, T3, T4, T5, T6> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6>::FromString(sParams); 02404 Call(cParams); 02405 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 02406 } 02407 02408 virtual String CallWithReturn(const XmlElement &cElement) override 02409 { 02410 Params<R, T0, T1, T2, T3, T4, T5, T6> cParams = Params<R, T0, T1, T2, T3, T4, T5, T6>::FromXml(cElement); 02411 Call(cParams); 02412 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 02413 } 02414 }; 02415 02416 /** 02417 * @brief 02418 * Function object (object that can be 'called' like a function / functoid) 02419 * 02420 * @remarks 02421 * Implementation for 7 parameters without a return value 02422 */ 02423 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> 02424 class Func<void, T0, T1, T2, T3, T4, T5, T6> : public DynFunc { 02425 public: 02426 typedef typename Type<T0> ::_Type _T0; 02427 typedef typename Type<T1> ::_Type _T1; 02428 typedef typename Type<T2> ::_Type _T2; 02429 typedef typename Type<T3> ::_Type _T3; 02430 typedef typename Type<T4> ::_Type _T4; 02431 typedef typename Type<T5> ::_Type _T5; 02432 typedef typename Type<T6> ::_Type _T6; 02433 02434 Func() 02435 { 02436 } 02437 02438 virtual ~Func() 02439 { 02440 } 02441 02442 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5, _T6 t6) 02443 { 02444 } 02445 02446 virtual String GetSignature() const override 02447 { 02448 return Signature<void, T0, T1, T2, T3, T4, T5, T6>::GetSignatureID(); 02449 } 02450 02451 virtual uint32 GetNumOfParameters() const override 02452 { 02453 return 7; 02454 } 02455 02456 virtual int GetParameterTypeID(uint32 nIndex) const override 02457 { 02458 switch (nIndex) { 02459 case 0: return Type<T0>::TypeID; 02460 case 1: return Type<T1>::TypeID; 02461 case 2: return Type<T2>::TypeID; 02462 case 3: return Type<T3>::TypeID; 02463 case 4: return Type<T4>::TypeID; 02464 case 5: return Type<T5>::TypeID; 02465 case 6: return Type<T6>::TypeID; 02466 default: return TypeInvalid; 02467 } 02468 } 02469 02470 virtual void Call(DynParams &cParams) override 02471 { 02472 // Check signature 02473 if (cParams.GetSignature() == GetSignature()) { 02474 // Get typed params 02475 Params<void, T0, T1, T2, T3, T4, T5, T6> &cP = 02476 static_cast<Params<void, T0, T1, T2, T3, T4, T5, T6>&>(cParams); 02477 02478 // Call function 02479 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02480 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6)); 02481 } 02482 } 02483 02484 virtual void Call(const DynParams &cParams) override 02485 { 02486 // Check signature 02487 if (cParams.GetSignature() == GetSignature()) { 02488 // Get typed params 02489 const Params<void, T0, T1, T2, T3, T4, T5, T6> &cP = 02490 static_cast<const Params<void, T0, T1, T2, T3, T4, T5, T6>&>(cParams); 02491 02492 // Call function 02493 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02494 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5), Type<T6> ::ConvertStorageToReal(cP.Param6)); 02495 } 02496 } 02497 02498 virtual void Call(const String &sParams) override 02499 { 02500 Params<void, T0, T1, T2, T3, T4, T5, T6> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6>::FromString(sParams); 02501 Call(cParams); 02502 } 02503 02504 virtual void Call(const XmlElement &cElement) override 02505 { 02506 Params<void, T0, T1, T2, T3, T4, T5, T6> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6>::FromXml(cElement); 02507 Call(cParams); 02508 } 02509 02510 virtual String CallWithReturn(const String &sParams) override 02511 { 02512 Params<void, T0, T1, T2, T3, T4, T5, T6> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6>::FromString(sParams); 02513 Call(cParams); 02514 return ""; 02515 } 02516 02517 virtual String CallWithReturn(const XmlElement &cElement) override 02518 { 02519 Params<void, T0, T1, T2, T3, T4, T5, T6> cParams = Params<void, T0, T1, T2, T3, T4, T5, T6>::FromXml(cElement); 02520 Call(cParams); 02521 return ""; 02522 } 02523 }; 02524 02525 /** 02526 * @brief 02527 * Function object (object that can be 'called' like a function / functoid) 02528 * 02529 * @remarks 02530 * Implementation for 6 parameters and a return value 02531 */ 02532 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5> 02533 class Func<R, T0, T1, T2, T3, T4, T5> : public DynFunc { 02534 public: 02535 typedef typename Type<R> ::_Type _R; 02536 typedef typename Type<T0> ::_Type _T0; 02537 typedef typename Type<T1> ::_Type _T1; 02538 typedef typename Type<T2> ::_Type _T2; 02539 typedef typename Type<T3> ::_Type _T3; 02540 typedef typename Type<T4> ::_Type _T4; 02541 typedef typename Type<T5> ::_Type _T5; 02542 02543 Func() 02544 { 02545 } 02546 02547 virtual ~Func() 02548 { 02549 } 02550 02551 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5) 02552 { 02553 return DefaultValue<R>::Default(); 02554 } 02555 02556 virtual String GetSignature() const override 02557 { 02558 return Signature<R, T0, T1, T2, T3, T4, T5>::GetSignatureID(); 02559 } 02560 02561 virtual int GetReturnTypeID() const override 02562 { 02563 return Type<R>::TypeID; 02564 } 02565 02566 virtual uint32 GetNumOfParameters() const override 02567 { 02568 return 6; 02569 } 02570 02571 virtual int GetParameterTypeID(uint32 nIndex) const override 02572 { 02573 switch (nIndex) { 02574 case 0: return Type<T0>::TypeID; 02575 case 1: return Type<T1>::TypeID; 02576 case 2: return Type<T2>::TypeID; 02577 case 3: return Type<T3>::TypeID; 02578 case 4: return Type<T4>::TypeID; 02579 case 5: return Type<T5>::TypeID; 02580 default: return TypeInvalid; 02581 } 02582 } 02583 02584 virtual void Call(DynParams &cParams) override 02585 { 02586 // Check signature 02587 if (cParams.GetSignature() == GetSignature()) { 02588 // Get typed params 02589 Params<R, T0, T1, T2, T3, T4, T5> &cP = 02590 static_cast<Params<R, T0, T1, T2, T3, T4, T5>&>(cParams); 02591 02592 // Call function 02593 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02594 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5))); 02595 } 02596 } 02597 02598 virtual void Call(const DynParams &cParams) override 02599 { 02600 // Check signature 02601 if (cParams.GetSignature() == GetSignature()) { 02602 // Get typed params 02603 const Params<R, T0, T1, T2, T3, T4, T5> &cP = 02604 static_cast<const Params<R, T0, T1, T2, T3, T4, T5>&>(cParams); 02605 02606 // Call function 02607 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02608 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5)); 02609 } 02610 } 02611 02612 virtual void Call(const String &sParams) override 02613 { 02614 Params<R, T0, T1, T2, T3, T4, T5> cParams = Params<R, T0, T1, T2, T3, T4, T5>::FromString(sParams); 02615 Call(cParams); 02616 } 02617 02618 virtual void Call(const XmlElement &cElement) override 02619 { 02620 Params<R, T0, T1, T2, T3, T4, T5> cParams = Params<R, T0, T1, T2, T3, T4, T5>::FromXml(cElement); 02621 Call(cParams); 02622 } 02623 02624 virtual String CallWithReturn(const String &sParams) override 02625 { 02626 Params<R, T0, T1, T2, T3, T4, T5> cParams = Params<R, T0, T1, T2, T3, T4, T5>::FromString(sParams); 02627 Call(cParams); 02628 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 02629 } 02630 02631 virtual String CallWithReturn(const XmlElement &cElement) override 02632 { 02633 Params<R, T0, T1, T2, T3, T4, T5> cParams = Params<R, T0, T1, T2, T3, T4, T5>::FromXml(cElement); 02634 Call(cParams); 02635 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 02636 } 02637 }; 02638 02639 /** 02640 * @brief 02641 * Function object (object that can be 'called' like a function / functoid) 02642 * 02643 * @remarks 02644 * Implementation for 6 parameters without a return value 02645 */ 02646 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5> 02647 class Func<void, T0, T1, T2, T3, T4, T5> : public DynFunc { 02648 public: 02649 typedef typename Type<T0> ::_Type _T0; 02650 typedef typename Type<T1> ::_Type _T1; 02651 typedef typename Type<T2> ::_Type _T2; 02652 typedef typename Type<T3> ::_Type _T3; 02653 typedef typename Type<T4> ::_Type _T4; 02654 typedef typename Type<T5> ::_Type _T5; 02655 02656 Func() 02657 { 02658 } 02659 02660 virtual ~Func() 02661 { 02662 } 02663 02664 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4, _T5 t5) 02665 { 02666 } 02667 02668 virtual String GetSignature() const override 02669 { 02670 return Signature<void, T0, T1, T2, T3, T4, T5>::GetSignatureID(); 02671 } 02672 02673 virtual uint32 GetNumOfParameters() const override 02674 { 02675 return 6; 02676 } 02677 02678 virtual int GetParameterTypeID(uint32 nIndex) const override 02679 { 02680 switch (nIndex) { 02681 case 0: return Type<T0>::TypeID; 02682 case 1: return Type<T1>::TypeID; 02683 case 2: return Type<T2>::TypeID; 02684 case 3: return Type<T3>::TypeID; 02685 case 4: return Type<T4>::TypeID; 02686 case 5: return Type<T5>::TypeID; 02687 default: return TypeInvalid; 02688 } 02689 } 02690 02691 virtual void Call(DynParams &cParams) override 02692 { 02693 // Check signature 02694 if (cParams.GetSignature() == GetSignature()) { 02695 // Get typed params 02696 Params<void, T0, T1, T2, T3, T4, T5> &cP = 02697 static_cast<Params<void, T0, T1, T2, T3, T4, T5>&>(cParams); 02698 02699 // Call function 02700 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02701 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5)); 02702 } 02703 } 02704 02705 virtual void Call(const DynParams &cParams) override 02706 { 02707 // Check signature 02708 if (cParams.GetSignature() == GetSignature()) { 02709 // Get typed params 02710 const Params<void, T0, T1, T2, T3, T4, T5> &cP = 02711 static_cast<const Params<void, T0, T1, T2, T3, T4, T5>&>(cParams); 02712 02713 // Call function 02714 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02715 Type<T4> ::ConvertStorageToReal(cP.Param4), Type<T5> ::ConvertStorageToReal(cP.Param5)); 02716 } 02717 } 02718 02719 virtual void Call(const String &sParams) override 02720 { 02721 Params<void, T0, T1, T2, T3, T4, T5> cParams = Params<void, T0, T1, T2, T3, T4, T5>::FromString(sParams); 02722 Call(cParams); 02723 } 02724 02725 virtual void Call(const XmlElement &cElement) override 02726 { 02727 Params<void, T0, T1, T2, T3, T4, T5> cParams = Params<void, T0, T1, T2, T3, T4, T5>::FromXml(cElement); 02728 Call(cParams); 02729 } 02730 02731 virtual String CallWithReturn(const String &sParams) override 02732 { 02733 Params<void, T0, T1, T2, T3, T4, T5> cParams = Params<void, T0, T1, T2, T3, T4, T5>::FromString(sParams); 02734 Call(cParams); 02735 return ""; 02736 } 02737 02738 virtual String CallWithReturn(const XmlElement &cElement) override 02739 { 02740 Params<void, T0, T1, T2, T3, T4, T5> cParams = Params<void, T0, T1, T2, T3, T4, T5>::FromXml(cElement); 02741 Call(cParams); 02742 return ""; 02743 } 02744 }; 02745 02746 /** 02747 * @brief 02748 * Function object (object that can be 'called' like a function / functoid) 02749 * 02750 * @remarks 02751 * Implementation for 5 parameters and a return value 02752 */ 02753 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4> 02754 class Func<R, T0, T1, T2, T3, T4> : public DynFunc { 02755 public: 02756 typedef typename Type<R> ::_Type _R; 02757 typedef typename Type<T0> ::_Type _T0; 02758 typedef typename Type<T1> ::_Type _T1; 02759 typedef typename Type<T2> ::_Type _T2; 02760 typedef typename Type<T3> ::_Type _T3; 02761 typedef typename Type<T4> ::_Type _T4; 02762 02763 Func() 02764 { 02765 } 02766 02767 virtual ~Func() 02768 { 02769 } 02770 02771 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4) 02772 { 02773 return DefaultValue<R>::Default(); 02774 } 02775 02776 virtual String GetSignature() const override 02777 { 02778 return Signature<R, T0, T1, T2, T3, T4>::GetSignatureID(); 02779 } 02780 02781 virtual int GetReturnTypeID() const override 02782 { 02783 return Type<R>::TypeID; 02784 } 02785 02786 virtual uint32 GetNumOfParameters() const override 02787 { 02788 return 5; 02789 } 02790 02791 virtual int GetParameterTypeID(uint32 nIndex) const override 02792 { 02793 switch (nIndex) { 02794 case 0: return Type<T0>::TypeID; 02795 case 1: return Type<T1>::TypeID; 02796 case 2: return Type<T2>::TypeID; 02797 case 3: return Type<T3>::TypeID; 02798 case 4: return Type<T4>::TypeID; 02799 default: return TypeInvalid; 02800 } 02801 } 02802 02803 virtual void Call(DynParams &cParams) override 02804 { 02805 // Check signature 02806 if (cParams.GetSignature() == GetSignature()) { 02807 // Get typed params 02808 Params<R, T0, T1, T2, T3, T4> &cP = static_cast<Params<R, T0, T1, T2, T3, T4>&>(cParams); 02809 02810 // Call function 02811 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02812 Type<T4> ::ConvertStorageToReal(cP.Param4))); 02813 } 02814 } 02815 02816 virtual void Call(const DynParams &cParams) override 02817 { 02818 // Check signature 02819 if (cParams.GetSignature() == GetSignature()) { 02820 // Get typed params 02821 const Params<R, T0, T1, T2, T3, T4> &cP = static_cast<const Params<R, T0, T1, T2, T3, T4>&>(cParams); 02822 02823 // Call function 02824 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02825 Type<T4> ::ConvertStorageToReal(cP.Param4)); 02826 } 02827 } 02828 02829 virtual void Call(const String &sParams) override 02830 { 02831 Params<R, T0, T1, T2, T3, T4> cParams = Params<R, T0, T1, T2, T3, T4>::FromString(sParams); 02832 Call(cParams); 02833 } 02834 02835 virtual void Call(const XmlElement &cElement) override 02836 { 02837 Params<R, T0, T1, T2, T3, T4> cParams = Params<R, T0, T1, T2, T3, T4>::FromXml(cElement); 02838 Call(cParams); 02839 } 02840 02841 virtual String CallWithReturn(const String &sParams) override 02842 { 02843 Params<R, T0, T1, T2, T3, T4> cParams = Params<R, T0, T1, T2, T3, T4>::FromString(sParams); 02844 Call(cParams); 02845 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 02846 } 02847 02848 virtual String CallWithReturn(const XmlElement &cElement) override 02849 { 02850 Params<R, T0, T1, T2, T3, T4> cParams = Params<R, T0, T1, T2, T3, T4>::FromXml(cElement); 02851 Call(cParams); 02852 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 02853 } 02854 }; 02855 02856 /** 02857 * @brief 02858 * Function object (object that can be 'called' like a function / functoid) 02859 * 02860 * @remarks 02861 * Implementation for 5 parameters without a return value 02862 */ 02863 template <typename T0, typename T1, typename T2, typename T3, typename T4> 02864 class Func<void, T0, T1, T2, T3, T4> : public DynFunc { 02865 public: 02866 typedef typename Type<T0> ::_Type _T0; 02867 typedef typename Type<T1> ::_Type _T1; 02868 typedef typename Type<T2> ::_Type _T2; 02869 typedef typename Type<T3> ::_Type _T3; 02870 typedef typename Type<T4> ::_Type _T4; 02871 02872 Func() 02873 { 02874 } 02875 02876 virtual ~Func() 02877 { 02878 } 02879 02880 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3, _T4 t4) 02881 { 02882 } 02883 02884 virtual String GetSignature() const override 02885 { 02886 return Signature<void, T0, T1, T2, T3, T4>::GetSignatureID(); 02887 } 02888 02889 virtual uint32 GetNumOfParameters() const override 02890 { 02891 return 5; 02892 } 02893 02894 virtual int GetParameterTypeID(uint32 nIndex) const override 02895 { 02896 switch (nIndex) { 02897 case 0: return Type<T0>::TypeID; 02898 case 1: return Type<T1>::TypeID; 02899 case 2: return Type<T2>::TypeID; 02900 case 3: return Type<T3>::TypeID; 02901 case 4: return Type<T4>::TypeID; 02902 default: return TypeInvalid; 02903 } 02904 } 02905 02906 virtual void Call(DynParams &cParams) override 02907 { 02908 // Check signature 02909 if (cParams.GetSignature() == GetSignature()) { 02910 // Get typed params 02911 Params<void, T0, T1, T2, T3, T4> &cP = static_cast<Params<void, T0, T1, T2, T3, T4>&>(cParams); 02912 02913 // Call function 02914 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02915 Type<T4> ::ConvertStorageToReal(cP.Param4)); 02916 } 02917 } 02918 02919 virtual void Call(const DynParams &cParams) override 02920 { 02921 // Check signature 02922 if (cParams.GetSignature() == GetSignature()) { 02923 // Get typed params 02924 const Params<void, T0, T1, T2, T3, T4> &cP = static_cast<const Params<void, T0, T1, T2, T3, T4>&>(cParams); 02925 02926 // Call function 02927 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3), 02928 Type<T4> ::ConvertStorageToReal(cP.Param4)); 02929 } 02930 } 02931 02932 virtual void Call(const String &sParams) override 02933 { 02934 Params<void, T0, T1, T2, T3, T4> cParams = Params<void, T0, T1, T2, T3, T4>::FromString(sParams); 02935 Call(cParams); 02936 } 02937 02938 virtual void Call(const XmlElement &cElement) override 02939 { 02940 Params<void, T0, T1, T2, T3, T4> cParams = Params<void, T0, T1, T2, T3, T4>::FromXml(cElement); 02941 Call(cParams); 02942 } 02943 02944 virtual String CallWithReturn(const String &sParams) override 02945 { 02946 Params<void, T0, T1, T2, T3, T4> cParams = Params<void, T0, T1, T2, T3, T4>::FromString(sParams); 02947 Call(cParams); 02948 return ""; 02949 } 02950 02951 virtual String CallWithReturn(const XmlElement &cElement) override 02952 { 02953 Params<void, T0, T1, T2, T3, T4> cParams = Params<void, T0, T1, T2, T3, T4>::FromXml(cElement); 02954 Call(cParams); 02955 return ""; 02956 } 02957 }; 02958 02959 /** 02960 * @brief 02961 * Function object (object that can be 'called' like a function / functoid) 02962 * 02963 * @remarks 02964 * Implementation for 4 parameters and a return value 02965 */ 02966 template <typename R, typename T0, typename T1, typename T2, typename T3> 02967 class Func<R, T0, T1, T2, T3> : public DynFunc { 02968 public: 02969 typedef typename Type<R> ::_Type _R; 02970 typedef typename Type<T0> ::_Type _T0; 02971 typedef typename Type<T1> ::_Type _T1; 02972 typedef typename Type<T2> ::_Type _T2; 02973 typedef typename Type<T3> ::_Type _T3; 02974 02975 Func() 02976 { 02977 } 02978 02979 virtual ~Func() 02980 { 02981 } 02982 02983 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3) 02984 { 02985 return DefaultValue<R>::Default(); 02986 } 02987 02988 virtual String GetSignature() const override 02989 { 02990 return Signature<R, T0, T1, T2, T3>::GetSignatureID(); 02991 } 02992 02993 virtual int GetReturnTypeID() const override 02994 { 02995 return Type<R>::TypeID; 02996 } 02997 02998 virtual uint32 GetNumOfParameters() const override 02999 { 03000 return 4; 03001 } 03002 03003 virtual int GetParameterTypeID(uint32 nIndex) const override 03004 { 03005 switch (nIndex) { 03006 case 0: return Type<T0>::TypeID; 03007 case 1: return Type<T1>::TypeID; 03008 case 2: return Type<T2>::TypeID; 03009 case 3: return Type<T3>::TypeID; 03010 default: return TypeInvalid; 03011 } 03012 } 03013 03014 virtual void Call(DynParams &cParams) override 03015 { 03016 // Check signature 03017 if (cParams.GetSignature() == GetSignature()) { 03018 // Get typed params 03019 Params<R, T0, T1, T2, T3> &cP = static_cast<Params<R, T0, T1, T2, T3>&>(cParams); 03020 03021 // Call function 03022 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3))); 03023 } 03024 } 03025 03026 virtual void Call(const DynParams &cParams) override 03027 { 03028 // Check signature 03029 if (cParams.GetSignature() == GetSignature()) { 03030 // Get typed params 03031 const Params<R, T0, T1, T2, T3> &cP = static_cast<const Params<R, T0, T1, T2, T3>&>(cParams); 03032 03033 // Call function 03034 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3)); 03035 } 03036 } 03037 03038 virtual void Call(const String &sParams) override 03039 { 03040 Params<R, T0, T1, T2, T3> cParams = Params<R, T0, T1, T2, T3>::FromString(sParams); 03041 Call(cParams); 03042 } 03043 03044 virtual void Call(const XmlElement &cElement) override 03045 { 03046 Params<R, T0, T1, T2, T3> cParams = Params<R, T0, T1, T2, T3>::FromXml(cElement); 03047 Call(cParams); 03048 } 03049 03050 virtual String CallWithReturn(const String &sParams) override 03051 { 03052 Params<R, T0, T1, T2, T3> cParams = Params<R, T0, T1, T2, T3>::FromString(sParams); 03053 Call(cParams); 03054 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 03055 } 03056 03057 virtual String CallWithReturn(const XmlElement &cElement) override 03058 { 03059 Params<R, T0, T1, T2, T3> cParams = Params<R, T0, T1, T2, T3>::FromXml(cElement); 03060 Call(cParams); 03061 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 03062 } 03063 }; 03064 03065 /** 03066 * @brief 03067 * Function object (object that can be 'called' like a function / functoid) 03068 * 03069 * @remarks 03070 * Implementation for 4 parameters without a return value 03071 */ 03072 template <typename T0, typename T1, typename T2, typename T3> 03073 class Func<void, T0, T1, T2, T3> : public DynFunc { 03074 public: 03075 typedef typename Type<T0> ::_Type _T0; 03076 typedef typename Type<T1> ::_Type _T1; 03077 typedef typename Type<T2> ::_Type _T2; 03078 typedef typename Type<T3> ::_Type _T3; 03079 03080 Func() 03081 { 03082 } 03083 03084 virtual ~Func() 03085 { 03086 } 03087 03088 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2, _T3 t3) 03089 { 03090 } 03091 03092 virtual String GetSignature() const override 03093 { 03094 return Signature<void, T0, T1, T2, T3>::GetSignatureID(); 03095 } 03096 03097 virtual uint32 GetNumOfParameters() const override 03098 { 03099 return 4; 03100 } 03101 03102 virtual int GetParameterTypeID(uint32 nIndex) const override 03103 { 03104 switch (nIndex) { 03105 case 0: return Type<T0>::TypeID; 03106 case 1: return Type<T1>::TypeID; 03107 case 2: return Type<T2>::TypeID; 03108 case 3: return Type<T3>::TypeID; 03109 default: return TypeInvalid; 03110 } 03111 } 03112 03113 virtual void Call(DynParams &cParams) override 03114 { 03115 // Check signature 03116 if (cParams.GetSignature() == GetSignature()) { 03117 // Get typed params 03118 Params<void, T0, T1, T2, T3> &cP = static_cast<Params<void, T0, T1, T2, T3>&>(cParams); 03119 03120 // Call function 03121 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3)); 03122 } 03123 } 03124 03125 virtual void Call(const DynParams &cParams) override 03126 { 03127 // Check signature 03128 if (cParams.GetSignature() == GetSignature()) { 03129 // Get typed params 03130 const Params<void, T0, T1, T2, T3> &cP = static_cast<const Params<void, T0, T1, T2, T3>&>(cParams); 03131 03132 // Call function 03133 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2), Type<T3> ::ConvertStorageToReal(cP.Param3)); 03134 } 03135 } 03136 03137 virtual void Call(const String &sParams) override 03138 { 03139 Params<void, T0, T1, T2, T3> cParams = Params<void, T0, T1, T2, T3>::FromString(sParams); 03140 Call(cParams); 03141 } 03142 03143 virtual void Call(const XmlElement &cElement) override 03144 { 03145 Params<void, T0, T1, T2, T3> cParams = Params<void, T0, T1, T2, T3>::FromXml(cElement); 03146 Call(cParams); 03147 } 03148 03149 virtual String CallWithReturn(const String &sParams) override 03150 { 03151 Params<void, T0, T1, T2, T3> cParams = Params<void, T0, T1, T2, T3>::FromString(sParams); 03152 Call(cParams); 03153 return ""; 03154 } 03155 03156 virtual String CallWithReturn(const XmlElement &cElement) override 03157 { 03158 Params<void, T0, T1, T2, T3> cParams = Params<void, T0, T1, T2, T3>::FromXml(cElement); 03159 Call(cParams); 03160 return ""; 03161 } 03162 }; 03163 03164 /** 03165 * @brief 03166 * Function object (object that can be 'called' like a function / functoid) 03167 * 03168 * @remarks 03169 * Implementation for 3 parameters and a return value 03170 */ 03171 template <typename R, typename T0, typename T1, typename T2> 03172 class Func<R, T0, T1, T2> : public DynFunc { 03173 public: 03174 typedef typename Type<R> ::_Type _R; 03175 typedef typename Type<T0> ::_Type _T0; 03176 typedef typename Type<T1> ::_Type _T1; 03177 typedef typename Type<T2> ::_Type _T2; 03178 03179 Func() 03180 { 03181 } 03182 03183 virtual ~Func() 03184 { 03185 } 03186 03187 virtual _R operator ()(_T0 t0, _T1 t1, _T2 t2) 03188 { 03189 return DefaultValue<R>::Default(); 03190 } 03191 03192 virtual String GetSignature() const override 03193 { 03194 return Signature<R, T0, T1, T2>::GetSignatureID(); 03195 } 03196 03197 virtual int GetReturnTypeID() const override 03198 { 03199 return Type<R>::TypeID; 03200 } 03201 03202 virtual uint32 GetNumOfParameters() const override 03203 { 03204 return 3; 03205 } 03206 03207 virtual int GetParameterTypeID(uint32 nIndex) const override 03208 { 03209 switch (nIndex) { 03210 case 0: return Type<T0>::TypeID; 03211 case 1: return Type<T1>::TypeID; 03212 case 2: return Type<T2>::TypeID; 03213 default: return TypeInvalid; 03214 } 03215 } 03216 03217 virtual void Call(DynParams &cParams) override 03218 { 03219 // Check signature 03220 if (cParams.GetSignature() == GetSignature()) { 03221 // Get typed params 03222 Params<R, T0, T1, T2> &cP = static_cast<Params<R, T0, T1, T2>&>(cParams); 03223 03224 // Call function 03225 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2))); 03226 } 03227 } 03228 03229 virtual void Call(const DynParams &cParams) override 03230 { 03231 // Check signature 03232 if (cParams.GetSignature() == GetSignature()) { 03233 // Get typed params 03234 const Params<R, T0, T1, T2> &cP = static_cast<const Params<R, T0, T1, T2>&>(cParams); 03235 03236 // Call function 03237 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2)); 03238 } 03239 } 03240 03241 virtual void Call(const String &sParams) override 03242 { 03243 Params<R, T0, T1, T2> cParams = Params<R, T0, T1, T2>::FromString(sParams); 03244 Call(cParams); 03245 } 03246 03247 virtual void Call(const XmlElement &cElement) override 03248 { 03249 Params<R, T0, T1, T2> cParams = Params<R, T0, T1, T2>::FromXml(cElement); 03250 Call(cParams); 03251 } 03252 03253 virtual String CallWithReturn(const String &sParams) override 03254 { 03255 Params<R, T0, T1, T2> cParams = Params<R, T0, T1, T2>::FromString(sParams); 03256 Call(cParams); 03257 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 03258 } 03259 03260 virtual String CallWithReturn(const XmlElement &cElement) 03261 { 03262 Params<R, T0, T1, T2> cParams = Params<R, T0, T1, T2>::FromXml(cElement); 03263 Call(cParams); 03264 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 03265 } 03266 }; 03267 03268 /** 03269 * @brief 03270 * Function object (object that can be 'called' like a function / functoid) 03271 * 03272 * @remarks 03273 * Implementation for 3 parameters without a return value 03274 */ 03275 template <typename T0, typename T1, typename T2> 03276 class Func<void, T0, T1, T2> : public DynFunc { 03277 public: 03278 typedef typename Type<T0> ::_Type _T0; 03279 typedef typename Type<T1> ::_Type _T1; 03280 typedef typename Type<T2> ::_Type _T2; 03281 03282 Func() 03283 { 03284 } 03285 03286 virtual ~Func() 03287 { 03288 } 03289 03290 virtual void operator ()(_T0 t0, _T1 t1, _T2 t2) 03291 { 03292 } 03293 03294 virtual String GetSignature() const override 03295 { 03296 return Signature<void, T0, T1, T2>::GetSignatureID(); 03297 } 03298 03299 virtual uint32 GetNumOfParameters() const override 03300 { 03301 return 3; 03302 } 03303 03304 virtual int GetParameterTypeID(uint32 nIndex) const override 03305 { 03306 switch (nIndex) { 03307 case 0: return Type<T0>::TypeID; 03308 case 1: return Type<T1>::TypeID; 03309 case 2: return Type<T2>::TypeID; 03310 default: return TypeInvalid; 03311 } 03312 } 03313 03314 virtual void Call(DynParams &cParams) override 03315 { 03316 // Check signature 03317 if (cParams.GetSignature() == GetSignature()) { 03318 // Get typed params 03319 Params<void, T0, T1, T2> &cP = static_cast<Params<void, T0, T1, T2>&>(cParams); 03320 03321 // Call function 03322 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2)); 03323 } 03324 } 03325 03326 virtual void Call(const DynParams &cParams) override 03327 { 03328 // Check signature 03329 if (cParams.GetSignature() == GetSignature()) { 03330 // Get typed params 03331 const Params<void, T0, T1, T2> &cP = static_cast<const Params<void, T0, T1, T2>&>(cParams); 03332 03333 // Call function 03334 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1), Type<T2> ::ConvertStorageToReal(cP.Param2)); 03335 } 03336 } 03337 03338 virtual void Call(const String &sParams) override 03339 { 03340 Params<void, T0, T1, T2> cParams = Params<void, T0, T1, T2>::FromString(sParams); 03341 Call(cParams); 03342 } 03343 03344 virtual void Call(const XmlElement &cElement) override 03345 { 03346 Params<void, T0, T1, T2> cParams = Params<void, T0, T1, T2>::FromXml(cElement); 03347 Call(cParams); 03348 } 03349 03350 virtual String CallWithReturn(const String &sParams) override 03351 { 03352 Params<void, T0, T1, T2> cParams = Params<void, T0, T1, T2>::FromString(sParams); 03353 Call(cParams); 03354 return ""; 03355 } 03356 03357 virtual String CallWithReturn(const XmlElement &cElement) override 03358 { 03359 Params<void, T0, T1, T2> cParams = Params<void, T0, T1, T2>::FromXml(cElement); 03360 Call(cParams); 03361 return ""; 03362 } 03363 }; 03364 03365 /** 03366 * @brief 03367 * Function object (object that can be 'called' like a function / functoid) 03368 * 03369 * @remarks 03370 * Implementation for 2 parameters and a return value 03371 */ 03372 template <typename R, typename T0, typename T1> 03373 class Func<R, T0, T1> : public DynFunc { 03374 public: 03375 typedef typename Type<R> ::_Type _R; 03376 typedef typename Type<T0> ::_Type _T0; 03377 typedef typename Type<T1> ::_Type _T1; 03378 03379 Func() 03380 { 03381 } 03382 03383 virtual ~Func() 03384 { 03385 } 03386 03387 virtual _R operator ()(_T0 t0, _T1 t1) 03388 { 03389 return DefaultValue<R>::Default(); 03390 } 03391 03392 virtual String GetSignature() const override 03393 { 03394 return Signature<R, T0, T1>::GetSignatureID(); 03395 } 03396 03397 virtual int GetReturnTypeID() const override 03398 { 03399 return Type<R>::TypeID; 03400 } 03401 03402 virtual uint32 GetNumOfParameters() const override 03403 { 03404 return 2; 03405 } 03406 03407 virtual int GetParameterTypeID(uint32 nIndex) const override 03408 { 03409 switch (nIndex) { 03410 case 0: return Type<T0>::TypeID; 03411 case 1: return Type<T1>::TypeID; 03412 default: return TypeInvalid; 03413 } 03414 } 03415 03416 virtual void Call(DynParams &cParams) override 03417 { 03418 // Check signature 03419 if (cParams.GetSignature() == GetSignature()) { 03420 // Get typed params 03421 Params<R, T0, T1> &cP = static_cast<Params<R, T0, T1>&>(cParams); 03422 03423 // Call function 03424 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1))); 03425 } 03426 } 03427 03428 virtual void Call(const DynParams &cParams) override 03429 { 03430 // Check signature 03431 if (cParams.GetSignature() == GetSignature()) { 03432 // Get typed params 03433 const Params<R, T0, T1> &cP = static_cast<const Params<R, T0, T1>&>(cParams); 03434 03435 // Call function 03436 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1)); 03437 } 03438 } 03439 03440 virtual void Call(const String &sParams) override 03441 { 03442 Params<R, T0, T1> cParams = Params<R, T0, T1>::FromString(sParams); 03443 Call(cParams); 03444 } 03445 03446 virtual void Call(const XmlElement &cElement) override 03447 { 03448 Params<R, T0, T1> cParams = Params<R, T0, T1>::FromXml(cElement); 03449 Call(cParams); 03450 } 03451 03452 virtual String CallWithReturn(const String &sParams) override 03453 { 03454 Params<R, T0, T1> cParams = Params<R, T0, T1>::FromString(sParams); 03455 Call(cParams); 03456 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 03457 } 03458 03459 virtual String CallWithReturn(const XmlElement &cElement) 03460 { 03461 Params<R, T0, T1> cParams = Params<R, T0, T1>::FromXml(cElement); 03462 Call(cParams); 03463 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 03464 } 03465 }; 03466 03467 /** 03468 * @brief 03469 * Function object (object that can be 'called' like a function / functoid) 03470 * 03471 * @remarks 03472 * Implementation for 2 parameters without a return value 03473 */ 03474 template <typename T0, typename T1> 03475 class Func<void, T0, T1> : public DynFunc { 03476 public: 03477 typedef typename Type<T0> ::_Type _T0; 03478 typedef typename Type<T1> ::_Type _T1; 03479 03480 Func() 03481 { 03482 } 03483 03484 virtual ~Func() 03485 { 03486 } 03487 03488 virtual void operator ()(_T0 t0, _T1 t1) 03489 { 03490 } 03491 03492 virtual String GetSignature() const override 03493 { 03494 return Signature<void, T0, T1>::GetSignatureID(); 03495 } 03496 03497 virtual uint32 GetNumOfParameters() const override 03498 { 03499 return 2; 03500 } 03501 03502 virtual int GetParameterTypeID(uint32 nIndex) const override 03503 { 03504 switch (nIndex) { 03505 case 0: return Type<T0>::TypeID; 03506 case 1: return Type<T1>::TypeID; 03507 default: return TypeInvalid; 03508 } 03509 } 03510 03511 virtual void Call(DynParams &cParams) override 03512 { 03513 // Check signature 03514 if (cParams.GetSignature() == GetSignature()) { 03515 // Get typed params 03516 Params<void, T0, T1> &cP = static_cast<Params<void, T0, T1>&>(cParams); 03517 03518 // Call function 03519 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1)); 03520 } 03521 } 03522 03523 virtual void Call(const DynParams &cParams) override 03524 { 03525 // Check signature 03526 if (cParams.GetSignature() == GetSignature()) { 03527 // Get typed params 03528 const Params<void, T0, T1> &cP = static_cast<const Params<void, T0, T1>&>(cParams); 03529 03530 // Call function 03531 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0), Type<T1> ::ConvertStorageToReal(cP.Param1)); 03532 } 03533 } 03534 03535 virtual void Call(const String &sParams) override 03536 { 03537 Params<void, T0, T1> cParams = Params<void, T0, T1>::FromString(sParams); 03538 Call(cParams); 03539 } 03540 03541 virtual void Call(const XmlElement &cElement) override 03542 { 03543 Params<void, T0, T1> cParams = Params<void, T0, T1>::FromXml(cElement); 03544 Call(cParams); 03545 } 03546 03547 virtual String CallWithReturn(const String &sParams) override 03548 { 03549 Params<void, T0, T1> cParams = Params<void, T0, T1>::FromString(sParams); 03550 Call(cParams); 03551 return ""; 03552 } 03553 03554 virtual String CallWithReturn(const XmlElement &cElement) override 03555 { 03556 Params<void, T0, T1> cParams = Params<void, T0, T1>::FromXml(cElement); 03557 Call(cParams); 03558 return ""; 03559 } 03560 }; 03561 03562 /** 03563 * @brief 03564 * Function object (object that can be 'called' like a function / functoid) 03565 * 03566 * @remarks 03567 * Implementation for 1 parameters and a return value 03568 */ 03569 template <typename R, typename T0> 03570 class Func<R, T0> : public DynFunc { 03571 public: 03572 typedef typename Type<R> ::_Type _R; 03573 typedef typename Type<T0> ::_Type _T0; 03574 03575 Func() 03576 { 03577 } 03578 03579 virtual ~Func() 03580 { 03581 } 03582 03583 virtual _R operator ()(_T0 t0) 03584 { 03585 return DefaultValue<R>::Default(); 03586 } 03587 03588 virtual String GetSignature() const override 03589 { 03590 return Signature<R, T0>::GetSignatureID(); 03591 } 03592 03593 virtual int GetReturnTypeID() const override 03594 { 03595 return Type<R>::TypeID; 03596 } 03597 03598 virtual uint32 GetNumOfParameters() const override 03599 { 03600 return 1; 03601 } 03602 03603 virtual int GetParameterTypeID(uint32 nIndex) const override 03604 { 03605 switch (nIndex) { 03606 case 0: return Type<T0>::TypeID; 03607 default: return TypeInvalid; 03608 } 03609 } 03610 03611 virtual void Call(DynParams &cParams) override 03612 { 03613 // Check signature 03614 if (cParams.GetSignature() == GetSignature()) { 03615 // Get typed params 03616 Params<R, T0> &cP = static_cast<Params<R, T0>&>(cParams); 03617 03618 // Call function 03619 cP.Return = Type<R>::ConvertRealToStorage((*this)(Type<T0> ::ConvertStorageToReal(cP.Param0))); 03620 } 03621 } 03622 03623 virtual void Call(const DynParams &cParams) override 03624 { 03625 // Check signature 03626 if (cParams.GetSignature() == GetSignature()) { 03627 // Get typed params 03628 const Params<R, T0> &cP = static_cast<const Params<R, T0>&>(cParams); 03629 03630 // Call function 03631 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0)); 03632 } 03633 } 03634 03635 virtual void Call(const String &sParams) override 03636 { 03637 Params<R, T0> cParams = Params<R, T0>::FromString(sParams); 03638 Call(cParams); 03639 } 03640 03641 virtual void Call(const XmlElement &cElement) override 03642 { 03643 Params<R, T0> cParams = Params<R, T0>::FromXml(cElement); 03644 Call(cParams); 03645 } 03646 03647 virtual String CallWithReturn(const String &sParams) override 03648 { 03649 Params<R, T0> cParams = Params<R, T0>::FromString(sParams); 03650 Call(cParams); 03651 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 03652 } 03653 03654 virtual String CallWithReturn(const XmlElement &cElement) override 03655 { 03656 Params<R, T0> cParams = Params<R, T0>::FromXml(cElement); 03657 Call(cParams); 03658 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 03659 } 03660 }; 03661 03662 /** 03663 * @brief 03664 * Function object (object that can be 'called' like a function / functoid) 03665 * 03666 * @remarks 03667 * Implementation for 1 parameters without a return value 03668 */ 03669 template <typename T0> 03670 class Func<void, T0> : public DynFunc { 03671 public: 03672 typedef typename Type<T0>::_Type _T0; 03673 03674 public: 03675 Func() 03676 { 03677 } 03678 03679 virtual ~Func() 03680 { 03681 } 03682 03683 virtual void operator ()(_T0 t0) 03684 { 03685 } 03686 03687 virtual String GetSignature() const override 03688 { 03689 return Signature<void, T0>::GetSignatureID(); 03690 } 03691 03692 virtual uint32 GetNumOfParameters() const override 03693 { 03694 return 1; 03695 } 03696 03697 virtual int GetParameterTypeID(uint32 nIndex) const override 03698 { 03699 switch (nIndex) { 03700 case 0: return Type<T0>::TypeID; 03701 default: return TypeInvalid; 03702 } 03703 } 03704 03705 virtual void Call(DynParams &cParams) override 03706 { 03707 // Check signature 03708 if (cParams.GetSignature() == GetSignature()) { 03709 // Get typed params 03710 Params<void, T0> &cP = static_cast<Params<void, T0>&>(cParams); 03711 03712 // Call function 03713 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0)); 03714 } 03715 } 03716 03717 virtual void Call(const DynParams &cParams) override 03718 { 03719 // Check signature 03720 if (cParams.GetSignature() == GetSignature()) { 03721 // Get typed params 03722 const Params<void, T0> &cP = static_cast<const Params<void, T0>&>(cParams); 03723 03724 // Call function 03725 (*this)(Type<T0> ::ConvertStorageToReal(cP.Param0)); 03726 } 03727 } 03728 03729 virtual void Call(const String &sParams) override 03730 { 03731 Params<void, T0> cParams = Params<void, T0>::FromString(sParams); 03732 Call(cParams); 03733 } 03734 03735 virtual void Call(const XmlElement &cElement) override 03736 { 03737 Params<void, T0> cParams = Params<void, T0>::FromXml(cElement); 03738 Call(cParams); 03739 } 03740 03741 virtual String CallWithReturn(const String &sParams) override 03742 { 03743 Params<void, T0> cParams = Params<void, T0>::FromString(sParams); 03744 Call(cParams); 03745 return ""; 03746 } 03747 03748 virtual String CallWithReturn(const XmlElement &cElement) override 03749 { 03750 Params<void, T0> cParams = Params<void, T0>::FromXml(cElement); 03751 Call(cParams); 03752 return ""; 03753 } 03754 }; 03755 03756 /** 03757 * @brief 03758 * Function object (object that can be 'called' like a function / functoid) 03759 * 03760 * @remarks 03761 * Implementation for 0 parameters and a return value 03762 */ 03763 template <typename R> 03764 class Func<R> : public DynFunc { 03765 public: 03766 typedef typename Type<R> ::_Type _R; 03767 03768 Func() 03769 { 03770 } 03771 03772 virtual ~Func() 03773 { 03774 } 03775 03776 virtual _R operator ()() 03777 { 03778 return DefaultValue<R>::Default(); 03779 } 03780 03781 virtual String GetSignature() const override 03782 { 03783 return Signature<R>::GetSignatureID(); 03784 } 03785 03786 virtual int GetReturnTypeID() const override 03787 { 03788 return Type<R>::TypeID; 03789 } 03790 03791 virtual uint32 GetNumOfParameters() const override 03792 { 03793 return 0; 03794 } 03795 03796 virtual int GetParameterTypeID(uint32 nIndex) const override 03797 { 03798 // There are no candidates, so the choice is pretty simple 03799 return TypeInvalid; 03800 } 03801 03802 virtual void Call(DynParams &cParams) override 03803 { 03804 // Check signature 03805 if (cParams.GetSignature() == GetSignature()) { 03806 // Get typed params 03807 Params<R> &cP = static_cast<Params<R>&>(cParams); 03808 03809 // Call function 03810 cP.Return = Type<R>::ConvertRealToStorage((*this)()); 03811 } 03812 } 03813 03814 virtual void Call(const DynParams &cParams) override 03815 { 03816 // Check signature 03817 if (cParams.GetSignature() == GetSignature()) { 03818 // Call function 03819 (*this)(); 03820 } 03821 } 03822 03823 virtual void Call(const String &sParams) override 03824 { 03825 Params<R> cParams = Params<R>::FromString(sParams); 03826 Call(cParams); 03827 } 03828 03829 virtual void Call(const XmlElement &cElement) override 03830 { 03831 Params<R> cParams = Params<R>::FromXml(cElement); 03832 Call(cParams); 03833 } 03834 03835 virtual String CallWithReturn(const String &sParams) override 03836 { 03837 Params<R> cParams = Params<R>::FromString(sParams); 03838 Call(cParams); 03839 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 03840 } 03841 03842 virtual String CallWithReturn(const XmlElement &cElement) override 03843 { 03844 Params<R> cParams = Params<R>::FromXml(cElement); 03845 Call(cParams); 03846 return Type<R>::ConvertToString(Type<R>::ConvertStorageToReal(cParams.Return)); 03847 } 03848 }; 03849 03850 /** 03851 * @brief 03852 * Function object (object that can be 'called' like a function / functoid) 03853 * 03854 * @remarks 03855 * Implementation for 0 parameters without a return value 03856 */ 03857 template <> 03858 class Func<void> : public DynFunc { 03859 public: 03860 Func() 03861 { 03862 } 03863 03864 virtual ~Func() 03865 { 03866 } 03867 03868 virtual void operator ()() 03869 { 03870 } 03871 03872 virtual String GetSignature() const override 03873 { 03874 return Signature<void>::GetSignatureID(); 03875 } 03876 03877 virtual int GetParameterTypeID(uint32 nIndex) const override 03878 { 03879 // There are no candidates, so the choice is pretty simple 03880 return TypeInvalid; 03881 } 03882 03883 virtual void Call(DynParams &cParams) override 03884 { 03885 // Check signature 03886 if (cParams.GetSignature() == GetSignature()) { 03887 // Call function 03888 (*this)(); 03889 } 03890 } 03891 03892 virtual void Call(const DynParams &cParams) override 03893 { 03894 // Check signature 03895 if (cParams.GetSignature() == GetSignature()) { 03896 // Call function 03897 (*this)(); 03898 } 03899 } 03900 03901 virtual void Call(const String &sParams) override 03902 { 03903 Params<void> cParams = Params<void>::FromString(sParams); 03904 Call(cParams); 03905 } 03906 03907 virtual void Call(const XmlElement &cElement) override 03908 { 03909 Params<void> cParams = Params<void>::FromXml(cElement); 03910 Call(cParams); 03911 } 03912 03913 virtual String CallWithReturn(const String &sParams) override 03914 { 03915 Params<void> cParams = Params<void>::FromString(sParams); 03916 Call(cParams); 03917 return ""; 03918 } 03919 03920 virtual String CallWithReturn(const XmlElement &cElement) override 03921 { 03922 Params<void> cParams = Params<void>::FromXml(cElement); 03923 Call(cParams); 03924 return ""; 03925 } 03926 }; 03927 03928 03929 //[-------------------------------------------------------] 03930 //[ Namespace ] 03931 //[-------------------------------------------------------] 03932 } // PLCore 03933 03934 03935 #endif // __PLCORE_FUNC_H__
|