 | PixelLight 0.9.10-R1 Copyright (C) 2002-2011 by The PixelLight Team Last modified Fri Dec 23 2011 15:51:01 |  | The content of this PixelLight
document is published under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported |
|
PixelLightAPI
.
|
00001 /*********************************************************\ 00002 * File: Signature.h * 00003 * 00004 * Copyright (C) 2002-2011 The PixelLight Team (http://www.pixellight.org/) 00005 * 00006 * This file is part of PixelLight. 00007 * 00008 * PixelLight is free software: you can redistribute it and/or modify 00009 * it under the terms of the GNU Lesser General Public License as published by 00010 * the Free Software Foundation, either version 3 of the License, or 00011 * (at your option) any later version. 00012 * 00013 * PixelLight is distributed in the hope that it will be useful, 00014 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00016 * GNU Lesser General Public License for more details. 00017 * 00018 * You should have received a copy of the GNU Lesser General Public License 00019 * along with PixelLight. If not, see <http://www.gnu.org/licenses/>. 00020 \*********************************************************/ 00021 00022 00023 #ifndef __PLCORE_SIGNATURE_H__ 00024 #define __PLCORE_SIGNATURE_H__ 00025 #pragma once 00026 00027 00028 //[-------------------------------------------------------] 00029 //[ Includes ] 00030 //[-------------------------------------------------------] 00031 #include "PLCore/Base/Type/Type.h" 00032 #include "PLCore/Base/Tools/TypeTraits.h" 00033 00034 00035 //[-------------------------------------------------------] 00036 //[ Namespace ] 00037 //[-------------------------------------------------------] 00038 namespace PLCore { 00039 00040 00041 //[-------------------------------------------------------] 00042 //[ Classes ] 00043 //[-------------------------------------------------------] 00044 /** 00045 * @brief 00046 * Convert signature to string 00047 */ 00048 template <typename R = NullType, 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> 00049 class SignatureString { 00050 00051 00052 //[-------------------------------------------------------] 00053 //[ Public static functions ] 00054 //[-------------------------------------------------------] 00055 public: 00056 /** 00057 * @brief 00058 * Get signature as a string 00059 * 00060 * @return 00061 * Signature description (e.g. "void(int,float)") 00062 */ 00063 static String GetSignatureID() { 00064 // On runtime the signature doesn't change, so construct it only once and then just reuse it 00065 static String sSignature; 00066 if (sSignature.GetLength()) { 00067 // Return the already constructed signature 00068 return sSignature; 00069 } else { 00070 String sType; 00071 00072 // Return type 00073 sSignature = Type<R>::GetTypeName(); 00074 sSignature += '('; 00075 00076 // Type 0 00077 sType = Type<T0>::GetTypeName(); 00078 if (sType.GetLength()) 00079 sSignature += sType; 00080 00081 // Type 1 00082 sType = Type<T1>::GetTypeName(); 00083 if (sType.GetLength()) { 00084 sSignature += ','; 00085 sSignature += sType; 00086 } 00087 00088 // Type 2 00089 sType = Type<T2>::GetTypeName(); 00090 if (sType.GetLength()) { 00091 sSignature += ','; 00092 sSignature += sType; 00093 } 00094 00095 // Type 3 00096 sType = Type<T3>::GetTypeName(); 00097 if (sType.GetLength()) { 00098 sSignature += ','; 00099 sSignature += sType; 00100 } 00101 00102 // Type 4 00103 sType = Type<T4>::GetTypeName(); 00104 if (sType.GetLength()) { 00105 sSignature += ','; 00106 sSignature += sType; 00107 } 00108 00109 // Type 5 00110 sType = Type<T5>::GetTypeName(); 00111 if (sType.GetLength()) { 00112 sSignature += ','; 00113 sSignature += sType; 00114 } 00115 00116 // Type 6 00117 sType = Type<T6>::GetTypeName(); 00118 if (sType.GetLength()) { 00119 sSignature += ','; 00120 sSignature += sType; 00121 } 00122 00123 // Type 7 00124 sType = Type<T7>::GetTypeName(); 00125 if (sType.GetLength()) { 00126 sSignature += ','; 00127 sSignature += sType; 00128 } 00129 00130 // Type 8 00131 sType = Type<T8>::GetTypeName(); 00132 if (sType.GetLength()) { 00133 sSignature += ','; 00134 sSignature += sType; 00135 } 00136 00137 // Type 9 00138 sType = Type<T9>::GetTypeName(); 00139 if (sType.GetLength()) { 00140 sSignature += ','; 00141 sSignature += sType; 00142 } 00143 00144 // Type 10 00145 sType = Type<T10>::GetTypeName(); 00146 if (sType.GetLength()) { 00147 sSignature += ','; 00148 sSignature += sType; 00149 } 00150 00151 // Type 11 00152 sType = Type<T11>::GetTypeName(); 00153 if (sType.GetLength()) { 00154 sSignature += ','; 00155 sSignature += sType; 00156 } 00157 00158 // Type 12 00159 sType = Type<T12>::GetTypeName(); 00160 if (sType.GetLength()) { 00161 sSignature += ','; 00162 sSignature += sType; 00163 } 00164 00165 // Type 13 00166 sType = Type<T13>::GetTypeName(); 00167 if (sType.GetLength()) { 00168 sSignature += ','; 00169 sSignature += sType; 00170 } 00171 00172 // Type 14 00173 sType = Type<T14>::GetTypeName(); 00174 if (sType.GetLength()) { 00175 sSignature += ','; 00176 sSignature += sType; 00177 } 00178 00179 // Type 15 00180 sType = Type<T15>::GetTypeName(); 00181 if (sType.GetLength()) { 00182 sSignature += ','; 00183 sSignature += sType; 00184 } 00185 00186 // Done 00187 sSignature += ')'; 00188 return sSignature; 00189 } 00190 } 00191 }; 00192 00193 00194 /** 00195 * @brief 00196 * Signature for a function 00197 * 00198 * @remarks 00199 * Implementation for up to 16 parameters 00200 */ 00201 template <typename R = NullType, 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> 00202 class Signature { 00203 00204 00205 //[-------------------------------------------------------] 00206 //[ Public data types ] 00207 //[-------------------------------------------------------] 00208 public: 00209 // Composed types 00210 typedef R (*FuncType)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15); // Function pointer 00211 00212 00213 //[-------------------------------------------------------] 00214 //[ Public static functions ] 00215 //[-------------------------------------------------------] 00216 public: 00217 /** 00218 * @brief 00219 * Get signature as a string 00220 * 00221 * @return 00222 * Signature description (e.g. "void(int,float)") 00223 */ 00224 static String GetSignatureID() { 00225 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::GetSignatureID(); 00226 } 00227 00228 00229 }; 00230 00231 /** 00232 * @brief 00233 * Signature for a function 00234 * 00235 * @remarks 00236 * Implementation for 15 parameters 00237 */ 00238 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> 00239 class Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> { 00240 00241 00242 public: 00243 // Composed types 00244 typedef R (*FuncType)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14); // Function pointer 00245 00246 // Get signature as a string 00247 static String GetSignatureID() { 00248 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::GetSignatureID(); 00249 } 00250 00251 00252 }; 00253 00254 /** 00255 * @brief 00256 * Signature for a function 00257 * 00258 * @remarks 00259 * Implementation for 14 parameters 00260 */ 00261 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> 00262 class Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> { 00263 00264 00265 public: 00266 // Composed types 00267 typedef R (*FuncType)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13); // Function pointer 00268 00269 // Get signature as a string 00270 static String GetSignatureID() { 00271 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::GetSignatureID(); 00272 } 00273 00274 00275 }; 00276 00277 /** 00278 * @brief 00279 * Signature for a function 00280 * 00281 * @remarks 00282 * Implementation for 13 parameters 00283 */ 00284 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> 00285 class Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> { 00286 00287 00288 public: 00289 // Composed types 00290 typedef R (*FuncType)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12); // Function pointer 00291 00292 // Get signature as a string 00293 static String GetSignatureID() { 00294 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::GetSignatureID(); 00295 } 00296 00297 00298 }; 00299 00300 /** 00301 * @brief 00302 * Signature for a function 00303 * 00304 * @remarks 00305 * Implementation for 12 parameters 00306 */ 00307 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> 00308 class Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> { 00309 00310 00311 public: 00312 // Composed types 00313 typedef R (*FuncType)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11); // Function pointer 00314 00315 // Get signature as a string 00316 static String GetSignatureID() { 00317 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::GetSignatureID(); 00318 } 00319 00320 00321 }; 00322 00323 /** 00324 * @brief 00325 * Signature for a function 00326 * 00327 * @remarks 00328 * Implementation for 11 parameters 00329 */ 00330 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> 00331 class Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> { 00332 00333 00334 public: 00335 // Composed types 00336 typedef R (*FuncType)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10); // Function pointer 00337 00338 // Get signature as a string 00339 static String GetSignatureID() { 00340 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::GetSignatureID(); 00341 } 00342 00343 00344 }; 00345 00346 /** 00347 * @brief 00348 * Signature for a function 00349 * 00350 * @remarks 00351 * Implementation for 10 parameters 00352 */ 00353 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> 00354 class Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> { 00355 00356 00357 public: 00358 // Composed types 00359 typedef R (*FuncType)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9); // Function pointer 00360 00361 // Get signature as a string 00362 static String GetSignatureID() { 00363 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::GetSignatureID(); 00364 } 00365 00366 00367 }; 00368 00369 /** 00370 * @brief 00371 * Signature for a function 00372 * 00373 * @remarks 00374 * Implementation for 9 parameters 00375 */ 00376 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> 00377 class Signature<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> { 00378 00379 00380 public: 00381 // Composed types 00382 typedef R (*FuncType)(T0, T1, T2, T3, T4, T5, T6, T7, T8); // Function pointer 00383 00384 // Get signature as a string 00385 static String GetSignatureID() { 00386 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8>::GetSignatureID(); 00387 } 00388 00389 00390 }; 00391 00392 /** 00393 * @brief 00394 * Signature for a function 00395 * 00396 * @remarks 00397 * Implementation for 8 parameters 00398 */ 00399 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> 00400 class Signature<R, T0, T1, T2, T3, T4, T5, T6, T7> { 00401 00402 00403 public: 00404 // Composed types 00405 typedef R (*FuncType)(T0, T1, T2, T3, T4, T5, T6, T7); // Function pointer 00406 00407 // Get signature as a string 00408 static String GetSignatureID() { 00409 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7>::GetSignatureID(); 00410 } 00411 00412 00413 }; 00414 00415 /** 00416 * @brief 00417 * Signature for a function 00418 * 00419 * @remarks 00420 * Implementation for 7 parameters 00421 */ 00422 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> 00423 class Signature<R, T0, T1, T2, T3, T4, T5, T6> { 00424 00425 00426 public: 00427 // Composed types 00428 typedef R (*FuncType)(T0, T1, T2, T3, T4, T5, T6); // Function pointer 00429 00430 // Get signature as a string 00431 static String GetSignatureID() { 00432 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6>::GetSignatureID(); 00433 } 00434 00435 00436 }; 00437 00438 /** 00439 * @brief 00440 * Signature for a function 00441 * 00442 * @remarks 00443 * Implementation for 6 parameters 00444 */ 00445 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5> 00446 class Signature<R, T0, T1, T2, T3, T4, T5> { 00447 00448 00449 public: 00450 // Composed types 00451 typedef R (*FuncType)(T0, T1, T2, T3, T4, T5); // Function pointer 00452 00453 // Get signature as a string 00454 static String GetSignatureID() { 00455 return SignatureString<R, T0, T1, T2, T3, T4, T5>::GetSignatureID(); 00456 } 00457 00458 00459 }; 00460 00461 /** 00462 * @brief 00463 * Signature for a function 00464 * 00465 * @remarks 00466 * Implementation for 5 parameters 00467 */ 00468 template <typename R, typename T0, typename T1, typename T2, typename T3, typename T4> 00469 class Signature<R, T0, T1, T2, T3, T4> { 00470 00471 00472 public: 00473 // Composed types 00474 typedef R (*FuncType)(T0, T1, T2, T3, T4); // Function pointer 00475 00476 // Get signature as a string 00477 static String GetSignatureID() { 00478 return SignatureString<R, T0, T1, T2, T3, T4>::GetSignatureID(); 00479 } 00480 00481 00482 }; 00483 00484 /** 00485 * @brief 00486 * Signature for a function 00487 * 00488 * @remarks 00489 * Implementation for 4 parameters 00490 */ 00491 template <typename R, typename T0, typename T1, typename T2, typename T3> 00492 class Signature<R, T0, T1, T2, T3> { 00493 00494 00495 public: 00496 // Composed types 00497 typedef R (*FuncType)(T0, T1, T2, T3); // Function pointer 00498 00499 // Get signature as a string 00500 static String GetSignatureID() { 00501 return SignatureString<R, T0, T1, T2, T3>::GetSignatureID(); 00502 } 00503 00504 00505 }; 00506 00507 /** 00508 * @brief 00509 * Signature for a function 00510 * 00511 * @remarks 00512 * Implementation for 3 parameters 00513 */ 00514 template <typename R, typename T0, typename T1, typename T2> 00515 class Signature<R, T0, T1, T2> { 00516 00517 00518 public: 00519 // Composed types 00520 typedef R (*FuncType)(T0, T1, T2); // Function pointer 00521 00522 // Get signature as a string 00523 static String GetSignatureID() { 00524 return SignatureString<R, T0, T1, T2>::GetSignatureID(); 00525 } 00526 00527 00528 }; 00529 00530 /** 00531 * @brief 00532 * Signature for a function 00533 * 00534 * @remarks 00535 * Implementation for 2 parameters 00536 */ 00537 template <typename R, typename T0, typename T1> 00538 class Signature<R, T0, T1> { 00539 00540 00541 public: 00542 // Composed types 00543 typedef R (*FuncType)(T0, T1); // Function pointer 00544 00545 // Get signature as a string 00546 static String GetSignatureID() { 00547 return SignatureString<R, T0, T1>::GetSignatureID(); 00548 } 00549 00550 00551 }; 00552 00553 /** 00554 * @brief 00555 * Signature for a function 00556 * 00557 * @remarks 00558 * Implementation for 1 parameters 00559 */ 00560 template <typename R, typename T0> 00561 class Signature<R, T0> { 00562 00563 00564 public: 00565 // Composed types 00566 typedef R (*FuncType)(T0); // Function pointer 00567 00568 // Get signature as a string 00569 static String GetSignatureID() { 00570 return SignatureString<R, T0>::GetSignatureID(); 00571 } 00572 00573 00574 }; 00575 00576 /** 00577 * @brief 00578 * Signature for a function 00579 * 00580 * @remarks 00581 * Implementation for 0 parameters 00582 */ 00583 template <typename R> 00584 class Signature<R> { 00585 00586 00587 public: 00588 // Composed types 00589 typedef R (*FuncType)(); // Function pointer 00590 00591 // Get signature as a string 00592 static String GetSignatureID() { 00593 return SignatureString<R>::GetSignatureID(); 00594 } 00595 00596 00597 }; 00598 00599 /** 00600 * @brief 00601 * Signature for a method 00602 * 00603 * @remarks 00604 * Implementation for up to 16 parameters 00605 */ 00606 template <typename CLASS = NullType, typename R = NullType, 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> 00607 class MethodSignature { 00608 00609 00610 //[-------------------------------------------------------] 00611 //[ Public data types ] 00612 //[-------------------------------------------------------] 00613 public: 00614 // Storage types 00615 typedef typename Type<R> ::_Type _R; 00616 typedef typename Type<T0> ::_Type _T0; 00617 typedef typename Type<T1> ::_Type _T1; 00618 typedef typename Type<T2> ::_Type _T2; 00619 typedef typename Type<T3> ::_Type _T3; 00620 typedef typename Type<T4> ::_Type _T4; 00621 typedef typename Type<T5> ::_Type _T5; 00622 typedef typename Type<T6> ::_Type _T6; 00623 typedef typename Type<T7> ::_Type _T7; 00624 typedef typename Type<T8> ::_Type _T8; 00625 typedef typename Type<T9> ::_Type _T9; 00626 typedef typename Type<T10>::_Type _T10; 00627 typedef typename Type<T11>::_Type _T11; 00628 typedef typename Type<T12>::_Type _T12; 00629 typedef typename Type<T13>::_Type _T13; 00630 typedef typename Type<T14>::_Type _T14; 00631 typedef typename Type<T15>::_Type _T15; 00632 00633 // Composed types 00634 typedef _R (*FuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14, _T15); // Function pointer 00635 typedef _R (CLASS::*MemFuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14, _T15); // Member function pointer 00636 00637 00638 //[-------------------------------------------------------] 00639 //[ Public static functions ] 00640 //[-------------------------------------------------------] 00641 public: 00642 /** 00643 * @brief 00644 * Get signature as a string 00645 * 00646 * @return 00647 * Signature description (e.g. "void(int,float)") 00648 */ 00649 static String GetSignatureID() { 00650 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::GetSignatureID(); 00651 } 00652 00653 00654 }; 00655 00656 /** 00657 * @brief 00658 * Signature for a method 00659 * 00660 * @remarks 00661 * Implementation for 15 parameters 00662 */ 00663 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14> 00664 class MethodSignature<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> { 00665 00666 00667 public: 00668 // Storage types 00669 typedef typename Type<R> ::_Type _R; 00670 typedef typename Type<T0> ::_Type _T0; 00671 typedef typename Type<T1> ::_Type _T1; 00672 typedef typename Type<T2> ::_Type _T2; 00673 typedef typename Type<T3> ::_Type _T3; 00674 typedef typename Type<T4> ::_Type _T4; 00675 typedef typename Type<T5> ::_Type _T5; 00676 typedef typename Type<T6> ::_Type _T6; 00677 typedef typename Type<T7> ::_Type _T7; 00678 typedef typename Type<T8> ::_Type _T8; 00679 typedef typename Type<T9> ::_Type _T9; 00680 typedef typename Type<T10>::_Type _T10; 00681 typedef typename Type<T11>::_Type _T11; 00682 typedef typename Type<T12>::_Type _T12; 00683 typedef typename Type<T13>::_Type _T13; 00684 typedef typename Type<T14>::_Type _T14; 00685 00686 // Composed types 00687 typedef _R (*FuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14); // Function pointer 00688 typedef _R (CLASS::*MemFuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14); // Member function pointer 00689 00690 // Get signature as a string 00691 static String GetSignatureID() { 00692 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::GetSignatureID(); 00693 } 00694 00695 00696 }; 00697 00698 /** 00699 * @brief 00700 * Signature for a method 00701 * 00702 * @remarks 00703 * Implementation for 14 parameters 00704 */ 00705 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13> 00706 class MethodSignature<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> { 00707 00708 00709 public: 00710 // Storage types 00711 typedef typename Type<R> ::_Type _R; 00712 typedef typename Type<T0> ::_Type _T0; 00713 typedef typename Type<T1> ::_Type _T1; 00714 typedef typename Type<T2> ::_Type _T2; 00715 typedef typename Type<T3> ::_Type _T3; 00716 typedef typename Type<T4> ::_Type _T4; 00717 typedef typename Type<T5> ::_Type _T5; 00718 typedef typename Type<T6> ::_Type _T6; 00719 typedef typename Type<T7> ::_Type _T7; 00720 typedef typename Type<T8> ::_Type _T8; 00721 typedef typename Type<T9> ::_Type _T9; 00722 typedef typename Type<T10>::_Type _T10; 00723 typedef typename Type<T11>::_Type _T11; 00724 typedef typename Type<T12>::_Type _T12; 00725 typedef typename Type<T13>::_Type _T13; 00726 00727 // Composed types 00728 typedef _R (*FuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13); // Function pointer 00729 typedef _R (CLASS::*MemFuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13); // Member function pointer 00730 00731 // Get signature as a string 00732 static String GetSignatureID() { 00733 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::GetSignatureID(); 00734 } 00735 00736 00737 }; 00738 00739 /** 00740 * @brief 00741 * Signature for a method 00742 * 00743 * @remarks 00744 * Implementation for 13 parameters 00745 */ 00746 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12> 00747 class MethodSignature<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> { 00748 00749 00750 public: 00751 // Storage types 00752 typedef typename Type<R> ::_Type _R; 00753 typedef typename Type<T0> ::_Type _T0; 00754 typedef typename Type<T1> ::_Type _T1; 00755 typedef typename Type<T2> ::_Type _T2; 00756 typedef typename Type<T3> ::_Type _T3; 00757 typedef typename Type<T4> ::_Type _T4; 00758 typedef typename Type<T5> ::_Type _T5; 00759 typedef typename Type<T6> ::_Type _T6; 00760 typedef typename Type<T7> ::_Type _T7; 00761 typedef typename Type<T8> ::_Type _T8; 00762 typedef typename Type<T9> ::_Type _T9; 00763 typedef typename Type<T10>::_Type _T10; 00764 typedef typename Type<T11>::_Type _T11; 00765 typedef typename Type<T12>::_Type _T12; 00766 00767 // Composed types 00768 typedef _R (*FuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12); // Function pointer 00769 typedef _R (CLASS::*MemFuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12); // Member function pointer 00770 00771 // Get signature as a string 00772 static String GetSignatureID() { 00773 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::GetSignatureID(); 00774 } 00775 00776 00777 }; 00778 00779 /** 00780 * @brief 00781 * Signature for a method 00782 * 00783 * @remarks 00784 * Implementation for 12 parameters 00785 */ 00786 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11> 00787 class MethodSignature<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> { 00788 00789 00790 public: 00791 // Storage types 00792 typedef typename Type<R> ::_Type _R; 00793 typedef typename Type<T0> ::_Type _T0; 00794 typedef typename Type<T1> ::_Type _T1; 00795 typedef typename Type<T2> ::_Type _T2; 00796 typedef typename Type<T3> ::_Type _T3; 00797 typedef typename Type<T4> ::_Type _T4; 00798 typedef typename Type<T5> ::_Type _T5; 00799 typedef typename Type<T6> ::_Type _T6; 00800 typedef typename Type<T7> ::_Type _T7; 00801 typedef typename Type<T8> ::_Type _T8; 00802 typedef typename Type<T9> ::_Type _T9; 00803 typedef typename Type<T10>::_Type _T10; 00804 typedef typename Type<T11>::_Type _T11; 00805 00806 // Composed types 00807 typedef _R (*FuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11); // Function pointer 00808 typedef _R (CLASS::*MemFuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11); // Member function pointer 00809 00810 // Get signature as a string 00811 static String GetSignatureID() { 00812 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::GetSignatureID(); 00813 } 00814 00815 00816 }; 00817 00818 /** 00819 * @brief 00820 * Signature for a method 00821 * 00822 * @remarks 00823 * Implementation for 11 parameters 00824 */ 00825 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> 00826 class MethodSignature<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> { 00827 00828 00829 public: 00830 // Storage types 00831 typedef typename Type<R> ::_Type _R; 00832 typedef typename Type<T0> ::_Type _T0; 00833 typedef typename Type<T1> ::_Type _T1; 00834 typedef typename Type<T2> ::_Type _T2; 00835 typedef typename Type<T3> ::_Type _T3; 00836 typedef typename Type<T4> ::_Type _T4; 00837 typedef typename Type<T5> ::_Type _T5; 00838 typedef typename Type<T6> ::_Type _T6; 00839 typedef typename Type<T7> ::_Type _T7; 00840 typedef typename Type<T8> ::_Type _T8; 00841 typedef typename Type<T9> ::_Type _T9; 00842 typedef typename Type<T10>::_Type _T10; 00843 00844 // Composed types 00845 typedef _R (*FuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10); // Function pointer 00846 typedef _R (CLASS::*MemFuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10); // Member function pointer 00847 00848 // Get signature as a string 00849 static String GetSignatureID() { 00850 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::GetSignatureID(); 00851 } 00852 00853 00854 }; 00855 00856 /** 00857 * @brief 00858 * Signature for a method 00859 * 00860 * @remarks 00861 * Implementation for 10 parameters 00862 */ 00863 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> 00864 class MethodSignature<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> { 00865 00866 00867 public: 00868 // Storage types 00869 typedef typename Type<R> ::_Type _R; 00870 typedef typename Type<T0>::_Type _T0; 00871 typedef typename Type<T1>::_Type _T1; 00872 typedef typename Type<T2>::_Type _T2; 00873 typedef typename Type<T3>::_Type _T3; 00874 typedef typename Type<T4>::_Type _T4; 00875 typedef typename Type<T5>::_Type _T5; 00876 typedef typename Type<T6>::_Type _T6; 00877 typedef typename Type<T7>::_Type _T7; 00878 typedef typename Type<T8>::_Type _T8; 00879 typedef typename Type<T9>::_Type _T9; 00880 00881 // Composed types 00882 typedef _R (*FuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9); // Function pointer 00883 typedef _R (CLASS::*MemFuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9); // Member function pointer 00884 00885 // Get signature as a string 00886 static String GetSignatureID() { 00887 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::GetSignatureID(); 00888 } 00889 00890 00891 }; 00892 00893 /** 00894 * @brief 00895 * Signature for a method 00896 * 00897 * @remarks 00898 * Implementation for 9 parameters 00899 */ 00900 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> 00901 class MethodSignature<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7, T8> { 00902 00903 00904 public: 00905 // Storage types 00906 typedef typename Type<R> ::_Type _R; 00907 typedef typename Type<T0>::_Type _T0; 00908 typedef typename Type<T1>::_Type _T1; 00909 typedef typename Type<T2>::_Type _T2; 00910 typedef typename Type<T3>::_Type _T3; 00911 typedef typename Type<T4>::_Type _T4; 00912 typedef typename Type<T5>::_Type _T5; 00913 typedef typename Type<T6>::_Type _T6; 00914 typedef typename Type<T7>::_Type _T7; 00915 typedef typename Type<T8>::_Type _T8; 00916 00917 // Composed types 00918 typedef _R (*FuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8); // Function pointer 00919 typedef _R (CLASS::*MemFuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8); // Member function pointer 00920 00921 // Get signature as a string 00922 static String GetSignatureID() { 00923 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7, T8>::GetSignatureID(); 00924 } 00925 00926 00927 }; 00928 00929 /** 00930 * @brief 00931 * Signature for a method 00932 * 00933 * @remarks 00934 * Implementation for 8 parameters 00935 */ 00936 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> 00937 class MethodSignature<CLASS, R, T0, T1, T2, T3, T4, T5, T6, T7> { 00938 00939 00940 public: 00941 // Storage types 00942 typedef typename Type<R> ::_Type _R; 00943 typedef typename Type<T0>::_Type _T0; 00944 typedef typename Type<T1>::_Type _T1; 00945 typedef typename Type<T2>::_Type _T2; 00946 typedef typename Type<T3>::_Type _T3; 00947 typedef typename Type<T4>::_Type _T4; 00948 typedef typename Type<T5>::_Type _T5; 00949 typedef typename Type<T6>::_Type _T6; 00950 typedef typename Type<T7>::_Type _T7; 00951 00952 // Composed types 00953 typedef _R (*FuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7); // Function pointer 00954 typedef _R (CLASS::*MemFuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7); // Member function pointer 00955 00956 // Get signature as a string 00957 static String GetSignatureID() { 00958 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6, T7>::GetSignatureID(); 00959 } 00960 00961 00962 }; 00963 00964 /** 00965 * @brief 00966 * Signature for a method 00967 * 00968 * @remarks 00969 * Implementation for 7 parameters 00970 */ 00971 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> 00972 class MethodSignature<CLASS, R, T0, T1, T2, T3, T4, T5, T6> { 00973 00974 00975 public: 00976 // Storage types 00977 typedef typename Type<R> ::_Type _R; 00978 typedef typename Type<T0>::_Type _T0; 00979 typedef typename Type<T1>::_Type _T1; 00980 typedef typename Type<T2>::_Type _T2; 00981 typedef typename Type<T3>::_Type _T3; 00982 typedef typename Type<T4>::_Type _T4; 00983 typedef typename Type<T5>::_Type _T5; 00984 typedef typename Type<T6>::_Type _T6; 00985 00986 // Composed types 00987 typedef _R (*FuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6); // Function pointer 00988 typedef _R (CLASS::*MemFuncType)(_T0, _T1, _T2, _T3, _T4, _T5, _T6); // Member function pointer 00989 00990 // Get signature as a string 00991 static String GetSignatureID() { 00992 return SignatureString<R, T0, T1, T2, T3, T4, T5, T6>::GetSignatureID(); 00993 } 00994 00995 00996 }; 00997 00998 /** 00999 * @brief 01000 * Signature for a method 01001 * 01002 * @remarks 01003 * Implementation for 6 parameters 01004 */ 01005 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5> 01006 class MethodSignature<CLASS, R, T0, T1, T2, T3, T4, T5> { 01007 01008 01009 public: 01010 // Storage types 01011 typedef typename Type<R> ::_Type _R; 01012 typedef typename Type<T0>::_Type _T0; 01013 typedef typename Type<T1>::_Type _T1; 01014 typedef typename Type<T2>::_Type _T2; 01015 typedef typename Type<T3>::_Type _T3; 01016 typedef typename Type<T4>::_Type _T4; 01017 typedef typename Type<T5>::_Type _T5; 01018 01019 // Composed types 01020 typedef _R (*FuncType)(_T0, _T1, _T2, _T3, _T4, _T5); // Function pointer 01021 typedef _R (CLASS::*MemFuncType)(_T0, _T1, _T2, _T3, _T4, _T5); // Member function pointer 01022 01023 // Get signature as a string 01024 static String GetSignatureID() { 01025 return SignatureString<R, T0, T1, T2, T3, T4, T5>::GetSignatureID(); 01026 } 01027 01028 01029 }; 01030 01031 /** 01032 * @brief 01033 * Signature for a method 01034 * 01035 * @remarks 01036 * Implementation for 5 parameters 01037 */ 01038 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3, typename T4> 01039 class MethodSignature<CLASS, R, T0, T1, T2, T3, T4> { 01040 01041 01042 public: 01043 // Storage types 01044 typedef typename Type<R> ::_Type _R; 01045 typedef typename Type<T0>::_Type _T0; 01046 typedef typename Type<T1>::_Type _T1; 01047 typedef typename Type<T2>::_Type _T2; 01048 typedef typename Type<T3>::_Type _T3; 01049 typedef typename Type<T4>::_Type _T4; 01050 01051 // Composed types 01052 typedef _R (*FuncType)(_T0, _T1, _T2, _T3, _T4); // Function pointer 01053 typedef _R (CLASS::*MemFuncType)(_T0, _T1, _T2, _T3, _T4); // Member function pointer 01054 01055 // Get signature as a string 01056 static String GetSignatureID() { 01057 return SignatureString<R, T0, T1, T2, T3, T4>::GetSignatureID(); 01058 } 01059 01060 01061 }; 01062 01063 /** 01064 * @brief 01065 * Signature for a method 01066 * 01067 * @remarks 01068 * Implementation for 4 parameters 01069 */ 01070 template <typename CLASS, typename R, typename T0, typename T1, typename T2, typename T3> 01071 class MethodSignature<CLASS, R, T0, T1, T2, T3> { 01072 01073 01074 public: 01075 // Storage types 01076 typedef typename Type<R> ::_Type _R; 01077 typedef typename Type<T0>::_Type _T0; 01078 typedef typename Type<T1>::_Type _T1; 01079 typedef typename Type<T2>::_Type _T2; 01080 typedef typename Type<T3>::_Type _T3; 01081 01082 // Composed types 01083 typedef _R (*FuncType)(_T0, _T1, _T2, _T3); // Function pointer 01084 typedef _R (CLASS::*MemFuncType)(_T0, _T1, _T2, _T3); // Member function pointer 01085 01086 // Get signature as a string 01087 static String GetSignatureID() { 01088 return SignatureString<R, T0, T1, T2, T3>::GetSignatureID(); 01089 } 01090 01091 01092 }; 01093 01094 /** 01095 * @brief 01096 * Signature for a method 01097 * 01098 * @remarks 01099 * Implementation for 3 parameters 01100 */ 01101 template <typename CLASS, typename R, typename T0, typename T1, typename T2> 01102 class MethodSignature<CLASS, R, T0, T1, T2> { 01103 01104 01105 public: 01106 // Storage types 01107 typedef typename Type<R> ::_Type _R; 01108 typedef typename Type<T0>::_Type _T0; 01109 typedef typename Type<T1>::_Type _T1; 01110 typedef typename Type<T2>::_Type _T2; 01111 01112 // Composed types 01113 typedef _R (*FuncType)(_T0, _T1, _T2); // Function pointer 01114 typedef _R (CLASS::*MemFuncType)(_T0, _T1, _T2); // Member function pointer 01115 01116 // Get signature as a string 01117 static String GetSignatureID() { 01118 return SignatureString<R, T0, T1, T2>::GetSignatureID(); 01119 } 01120 01121 01122 }; 01123 01124 /** 01125 * @brief 01126 * Signature for a method 01127 * 01128 * @remarks 01129 * Implementation for 2 parameters 01130 */ 01131 template <typename CLASS, typename R, typename T0, typename T1> 01132 class MethodSignature<CLASS, R, T0, T1> { 01133 01134 01135 public: 01136 // Storage types 01137 typedef typename Type<R> ::_Type _R; 01138 typedef typename Type<T0>::_Type _T0; 01139 typedef typename Type<T1>::_Type _T1; 01140 01141 // Composed types 01142 typedef _R (*FuncType)(_T0, _T1); // Function pointer 01143 typedef _R (CLASS::*MemFuncType)(_T0, _T1); // Member function pointer 01144 01145 // Get signature as a string 01146 static String GetSignatureID() { 01147 return SignatureString<R, T0, T1>::GetSignatureID(); 01148 } 01149 01150 01151 }; 01152 01153 /** 01154 * @brief 01155 * Signature for a method 01156 * 01157 * @remarks 01158 * Implementation for 1 parameter 01159 */ 01160 template <typename CLASS, typename R, typename T0> 01161 class MethodSignature<CLASS, R, T0> { 01162 01163 01164 public: 01165 // Storage types 01166 typedef typename Type<R> ::_Type _R; 01167 typedef typename Type<T0>::_Type _T0; 01168 01169 // Composed types 01170 typedef _R (*FuncType)(_T0); // Function pointer 01171 typedef _R (CLASS::*MemFuncType)(_T0); // Member function pointer 01172 01173 // Get signature as a string 01174 static String GetSignatureID() { 01175 return SignatureString<R, T0>::GetSignatureID(); 01176 } 01177 01178 01179 }; 01180 01181 /** 01182 * @brief 01183 * Signature for a method 01184 * 01185 * @remarks 01186 * Implementation for 0 parameter 01187 */ 01188 template <typename CLASS, typename R> 01189 class MethodSignature<CLASS, R> { 01190 01191 01192 public: 01193 // Storage types 01194 typedef typename Type<R>::_Type _R; 01195 01196 // Composed types 01197 typedef _R (*FuncType)(); // Function pointer 01198 typedef _R (CLASS::*MemFuncType)(); // Member function pointer 01199 01200 // Get signature as a string 01201 static String GetSignatureID() { 01202 return SignatureString<R>::GetSignatureID(); 01203 } 01204 01205 01206 }; 01207 01208 01209 template <typename R = NullType, 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> 01210 class Typelist { 01211 public: 01212 typedef typename Type<R> ::_Type TypeR; 01213 typedef typename Type<T0> ::_Type Type0; 01214 typedef typename Type<T1> ::_Type Type1; 01215 typedef typename Type<T2> ::_Type Type2; 01216 typedef typename Type<T3> ::_Type Type3; 01217 typedef typename Type<T4> ::_Type Type4; 01218 typedef typename Type<T5> ::_Type Type5; 01219 typedef typename Type<T6> ::_Type Type6; 01220 typedef typename Type<T7> ::_Type Type7; 01221 typedef typename Type<T8> ::_Type Type8; 01222 typedef typename Type<T9> ::_Type Type9; 01223 typedef typename Type<T10>::_Type Type10; 01224 typedef typename Type<T11>::_Type Type11; 01225 typedef typename Type<T12>::_Type Type12; 01226 typedef typename Type<T13>::_Type Type13; 01227 typedef typename Type<T14>::_Type Type14; 01228 typedef typename Type<T15>::_Type Type15; 01229 }; 01230 01231 template <typename CLASS, typename TYPELIST> 01232 class ClassTypelist { 01233 public: 01234 typedef CLASS Class; 01235 typedef typename TYPELIST::TypeR TypeR; 01236 typedef typename TYPELIST::Type0 Type0; 01237 typedef typename TYPELIST::Type1 Type1; 01238 typedef typename TYPELIST::Type2 Type2; 01239 typedef typename TYPELIST::Type3 Type3; 01240 typedef typename TYPELIST::Type4 Type4; 01241 typedef typename TYPELIST::Type5 Type5; 01242 typedef typename TYPELIST::Type6 Type6; 01243 typedef typename TYPELIST::Type7 Type7; 01244 typedef typename TYPELIST::Type8 Type8; 01245 typedef typename TYPELIST::Type9 Type9; 01246 typedef typename TYPELIST::Type10 Type10; 01247 typedef typename TYPELIST::Type11 Type11; 01248 typedef typename TYPELIST::Type12 Type12; 01249 typedef typename TYPELIST::Type13 Type13; 01250 typedef typename TYPELIST::Type14 Type14; 01251 typedef typename TYPELIST::Type15 Type15; 01252 01253 typedef MethodSignature<Class, TypeR, Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, 01254 Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15> TypeMethodSignature; 01255 }; 01256 01257 01258 //[-------------------------------------------------------] 01259 //[ Namespace ] 01260 //[-------------------------------------------------------] 01261 } // PLCore 01262 01263 01264 #endif // __PLCORE_SIGNATURE_H__
|