csutil/scf_implgen_p.h
00001 /* 00002 Crystal Space Shared Class Facility (SCF) 00003 Copyright (C) 2005 by Marten Svanfeldt and Michael D. Adams 00004 00005 This library is free software; you can redistribute it and/or 00006 modify it under the terms of the GNU Library General Public 00007 License as published by the Free Software Foundation; either 00008 version 2 of the License, or (at your option) any later version. 00009 00010 This library is distributed in the hope that it will be useful, 00011 but WITHOUT ANY WARRANTY; without even the implied warranty of 00012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00013 Library General Public License for more details. 00014 00015 You should have received a copy of the GNU Library General Public 00016 License along with this library; if not, write to the Free 00017 Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 00018 */ 00019 00020 /* 00021 * This header have been generated from scf_implgen.h by using 00022 * gcc -E -x c -P -DSCF_IN_IMPLEMENTATION_H -I.. scf_implgen.h 00023 * after which the result was put into scf_implgen_p_template.h manually! 00024 */ 00025 00026 #if !defined(SCF_IN_IMPLEMENTATION_H) 00027 #error Do not include this file directly. Included from scf_implementation.h 00028 #endif 00029 00030 // This is a big header, so help MSVC a bit 00031 #ifdef CS_COMPILER_MSVC 00032 #pragma once 00033 #endif 00034 00035 #include "csutil/win32/msvc_deprecated_warn_off.h" 00036 00037 template<class Class > 00038 class CS_CRYSTALSPACE_EXPORT scfImplementation0 : 00039 public scfImplementation<Class> 00040 00041 { 00042 public: 00043 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 00044 { 00045 return scfImplementation<Class>::QueryInterface(id, version); 00046 } 00047 00048 protected: 00049 00050 scfImplementation0(Class *object, iBase *parent=0) 00051 : scfImplementation<Class>(object, parent) 00052 { 00053 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00054 AddReftrackerAliases(); 00055 } 00056 virtual ~scfImplementation0() 00057 { 00058 RemoveReftrackerAliases(); 00059 } 00060 00061 typedef scfImplementation0<Class > scfImplementationType; 00062 typedef Class scfClassType; 00063 00064 private: 00065 template<typename I> 00066 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 00067 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 00068 { 00069 if (id == scfInterfaceTraits<I>::GetID() && 00070 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 00071 { 00072 scfObject->IncRef(); 00073 return static_cast< 00074 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 00075 } 00076 else 00077 { 00078 return 0; 00079 } 00080 } 00081 00082 template<typename I> 00083 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 00084 Class* scfObject) 00085 { 00086 csRefTrackerAccess::AddAlias( 00087 static_cast< 00088 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00089 scfObject); 00090 } 00091 00092 template<typename I> 00093 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 00094 Class* scfObject) 00095 { 00096 csRefTrackerAccess::RemoveAlias( 00097 static_cast< 00098 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00099 scfObject); 00100 } 00101 00102 void AddReftrackerAliases () 00103 { 00104 00105 AddReftrackerAlias<iBase>(this->scfObject); 00106 } 00107 00108 void RemoveReftrackerAliases () 00109 { 00110 00111 RemoveReftrackerAlias<iBase>(this->scfObject); 00112 } 00113 }; 00114 template<class Class ,class I1> 00115 class CS_CRYSTALSPACE_EXPORT scfImplementation1 : 00116 public scfImplementation<Class> 00117 ,public I1 00118 { 00119 public: 00120 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 00121 { 00122 00123 void *x; 00124 if((x = GetInterface<I1>(this->scfObject, id, version)) != 0) return x; 00125 return scfImplementation<Class>::QueryInterface(id, version); 00126 } 00127 00128 protected: 00129 00130 scfImplementation1(Class *object, iBase *parent=0) 00131 : scfImplementation<Class>(object, parent) 00132 { 00133 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00134 AddReftrackerAliases(); 00135 } 00136 virtual ~scfImplementation1() 00137 { 00138 RemoveReftrackerAliases(); 00139 } 00140 00141 typedef scfImplementation1<Class ,I1> scfImplementationType; 00142 typedef Class scfClassType; 00143 00144 private: 00145 template<typename I> 00146 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 00147 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 00148 { 00149 if (id == scfInterfaceTraits<I>::GetID() && 00150 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 00151 { 00152 scfObject->IncRef(); 00153 return static_cast< 00154 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 00155 } 00156 else 00157 { 00158 return 0; 00159 } 00160 } 00161 00162 template<typename I> 00163 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 00164 Class* scfObject) 00165 { 00166 csRefTrackerAccess::AddAlias( 00167 static_cast< 00168 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00169 scfObject); 00170 } 00171 00172 template<typename I> 00173 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 00174 Class* scfObject) 00175 { 00176 csRefTrackerAccess::RemoveAlias( 00177 static_cast< 00178 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00179 scfObject); 00180 } 00181 00182 void AddReftrackerAliases () 00183 { 00184 00185 AddReftrackerAlias<iBase>(this->scfObject); 00186 00187 00188 AddReftrackerAlias<I1>(this->scfObject); 00189 } 00190 00191 void RemoveReftrackerAliases () 00192 { 00193 00194 RemoveReftrackerAlias<iBase>(this->scfObject); 00195 00196 00197 RemoveReftrackerAlias<I1>(this->scfObject); 00198 } 00199 }; 00200 template<class Class ,class I1, class I2> 00201 class CS_CRYSTALSPACE_EXPORT scfImplementation2 : 00202 public scfImplementation<Class> 00203 ,public I1, public I2 00204 { 00205 public: 00206 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 00207 { 00208 00209 void *x; 00210 if((x = GetInterface<I1>(this->scfObject, id, version)) != 0) return x; 00211 00212 00213 if((x = GetInterface<I2>(this->scfObject, id, version)) != 0) return x; 00214 return scfImplementation<Class>::QueryInterface(id, version); 00215 } 00216 00217 protected: 00218 00219 scfImplementation2(Class *object, iBase *parent=0) 00220 : scfImplementation<Class>(object, parent) 00221 { 00222 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00223 AddReftrackerAliases(); 00224 } 00225 virtual ~scfImplementation2() 00226 { 00227 RemoveReftrackerAliases(); 00228 } 00229 00230 typedef scfImplementation2<Class ,I1, I2> scfImplementationType; 00231 typedef Class scfClassType; 00232 00233 private: 00234 template<typename I> 00235 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 00236 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 00237 { 00238 if (id == scfInterfaceTraits<I>::GetID() && 00239 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 00240 { 00241 scfObject->IncRef(); 00242 return static_cast< 00243 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 00244 } 00245 else 00246 { 00247 return 0; 00248 } 00249 } 00250 00251 template<typename I> 00252 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 00253 Class* scfObject) 00254 { 00255 csRefTrackerAccess::AddAlias( 00256 static_cast< 00257 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00258 scfObject); 00259 } 00260 00261 template<typename I> 00262 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 00263 Class* scfObject) 00264 { 00265 csRefTrackerAccess::RemoveAlias( 00266 static_cast< 00267 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00268 scfObject); 00269 } 00270 00271 void AddReftrackerAliases () 00272 { 00273 00274 AddReftrackerAlias<iBase>(this->scfObject); 00275 00276 00277 AddReftrackerAlias<I1>(this->scfObject); 00278 00279 00280 AddReftrackerAlias<I2>(this->scfObject); 00281 } 00282 00283 void RemoveReftrackerAliases () 00284 { 00285 00286 RemoveReftrackerAlias<iBase>(this->scfObject); 00287 00288 00289 RemoveReftrackerAlias<I1>(this->scfObject); 00290 00291 00292 RemoveReftrackerAlias<I2>(this->scfObject); 00293 } 00294 }; 00295 template<class Class ,class I1, class I2, class I3> 00296 class CS_CRYSTALSPACE_EXPORT scfImplementation3 : 00297 public scfImplementation<Class> 00298 ,public I1, public I2, public I3 00299 { 00300 public: 00301 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 00302 { 00303 00304 void *x; 00305 if((x = GetInterface<I1>(this->scfObject, id, version)) != 0) return x; 00306 00307 00308 if((x = GetInterface<I2>(this->scfObject, id, version)) != 0) return x; 00309 00310 00311 if((x = GetInterface<I3>(this->scfObject, id, version)) != 0) return x; 00312 return scfImplementation<Class>::QueryInterface(id, version); 00313 } 00314 00315 protected: 00316 00317 scfImplementation3(Class *object, iBase *parent=0) 00318 : scfImplementation<Class>(object, parent) 00319 { 00320 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00321 AddReftrackerAliases(); 00322 } 00323 virtual ~scfImplementation3() 00324 { 00325 RemoveReftrackerAliases(); 00326 } 00327 00328 typedef scfImplementation3<Class ,I1, I2, I3> scfImplementationType; 00329 typedef Class scfClassType; 00330 00331 private: 00332 template<typename I> 00333 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 00334 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 00335 { 00336 if (id == scfInterfaceTraits<I>::GetID() && 00337 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 00338 { 00339 scfObject->IncRef(); 00340 return static_cast< 00341 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 00342 } 00343 else 00344 { 00345 return 0; 00346 } 00347 } 00348 00349 template<typename I> 00350 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 00351 Class* scfObject) 00352 { 00353 csRefTrackerAccess::AddAlias( 00354 static_cast< 00355 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00356 scfObject); 00357 } 00358 00359 template<typename I> 00360 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 00361 Class* scfObject) 00362 { 00363 csRefTrackerAccess::RemoveAlias( 00364 static_cast< 00365 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00366 scfObject); 00367 } 00368 00369 void AddReftrackerAliases () 00370 { 00371 00372 AddReftrackerAlias<iBase>(this->scfObject); 00373 00374 00375 AddReftrackerAlias<I1>(this->scfObject); 00376 00377 00378 AddReftrackerAlias<I2>(this->scfObject); 00379 00380 00381 AddReftrackerAlias<I3>(this->scfObject); 00382 } 00383 00384 void RemoveReftrackerAliases () 00385 { 00386 00387 RemoveReftrackerAlias<iBase>(this->scfObject); 00388 00389 00390 RemoveReftrackerAlias<I1>(this->scfObject); 00391 00392 00393 RemoveReftrackerAlias<I2>(this->scfObject); 00394 00395 00396 RemoveReftrackerAlias<I3>(this->scfObject); 00397 } 00398 }; 00399 template<class Class ,class I1, class I2, class I3, class I4> 00400 class CS_CRYSTALSPACE_EXPORT scfImplementation4 : 00401 public scfImplementation<Class> 00402 ,public I1, public I2, public I3, public I4 00403 { 00404 public: 00405 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 00406 { 00407 00408 void *x; 00409 if((x = GetInterface<I1>(this->scfObject, id, version)) != 0) return x; 00410 00411 00412 if((x = GetInterface<I2>(this->scfObject, id, version)) != 0) return x; 00413 00414 00415 if((x = GetInterface<I3>(this->scfObject, id, version)) != 0) return x; 00416 00417 00418 if((x = GetInterface<I4>(this->scfObject, id, version)) != 0) return x; 00419 return scfImplementation<Class>::QueryInterface(id, version); 00420 } 00421 00422 protected: 00423 00424 scfImplementation4(Class *object, iBase *parent=0) 00425 : scfImplementation<Class>(object, parent) 00426 { 00427 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00428 AddReftrackerAliases(); 00429 } 00430 virtual ~scfImplementation4() 00431 { 00432 RemoveReftrackerAliases(); 00433 } 00434 00435 typedef scfImplementation4<Class ,I1, I2, I3, I4> scfImplementationType; 00436 typedef Class scfClassType; 00437 00438 private: 00439 template<typename I> 00440 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 00441 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 00442 { 00443 if (id == scfInterfaceTraits<I>::GetID() && 00444 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 00445 { 00446 scfObject->IncRef(); 00447 return static_cast< 00448 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 00449 } 00450 else 00451 { 00452 return 0; 00453 } 00454 } 00455 00456 template<typename I> 00457 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 00458 Class* scfObject) 00459 { 00460 csRefTrackerAccess::AddAlias( 00461 static_cast< 00462 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00463 scfObject); 00464 } 00465 00466 template<typename I> 00467 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 00468 Class* scfObject) 00469 { 00470 csRefTrackerAccess::RemoveAlias( 00471 static_cast< 00472 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00473 scfObject); 00474 } 00475 00476 void AddReftrackerAliases () 00477 { 00478 00479 AddReftrackerAlias<iBase>(this->scfObject); 00480 00481 00482 AddReftrackerAlias<I1>(this->scfObject); 00483 00484 00485 AddReftrackerAlias<I2>(this->scfObject); 00486 00487 00488 AddReftrackerAlias<I3>(this->scfObject); 00489 00490 00491 AddReftrackerAlias<I4>(this->scfObject); 00492 } 00493 00494 void RemoveReftrackerAliases () 00495 { 00496 00497 RemoveReftrackerAlias<iBase>(this->scfObject); 00498 00499 00500 RemoveReftrackerAlias<I1>(this->scfObject); 00501 00502 00503 RemoveReftrackerAlias<I2>(this->scfObject); 00504 00505 00506 RemoveReftrackerAlias<I3>(this->scfObject); 00507 00508 00509 RemoveReftrackerAlias<I4>(this->scfObject); 00510 } 00511 }; 00512 template<class Class ,class I1, class I2, class I3, class I4, class I5> 00513 class CS_CRYSTALSPACE_EXPORT scfImplementation5 : 00514 public scfImplementation<Class> 00515 ,public I1, public I2, public I3, public I4, public I5 00516 { 00517 public: 00518 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 00519 { 00520 00521 void *x; 00522 if((x = GetInterface<I1>(this->scfObject, id, version)) != 0) return x; 00523 00524 00525 if((x = GetInterface<I2>(this->scfObject, id, version)) != 0) return x; 00526 00527 00528 if((x = GetInterface<I3>(this->scfObject, id, version)) != 0) return x; 00529 00530 00531 if((x = GetInterface<I4>(this->scfObject, id, version)) != 0) return x; 00532 00533 00534 if((x = GetInterface<I5>(this->scfObject, id, version)) != 0) return x; 00535 return scfImplementation<Class>::QueryInterface(id, version); 00536 } 00537 00538 protected: 00539 00540 scfImplementation5(Class *object, iBase *parent=0) 00541 : scfImplementation<Class>(object, parent) 00542 { 00543 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00544 AddReftrackerAliases(); 00545 } 00546 virtual ~scfImplementation5() 00547 { 00548 RemoveReftrackerAliases(); 00549 } 00550 00551 typedef scfImplementation5<Class ,I1, I2, I3, I4, I5> scfImplementationType; 00552 typedef Class scfClassType; 00553 00554 private: 00555 template<typename I> 00556 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 00557 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 00558 { 00559 if (id == scfInterfaceTraits<I>::GetID() && 00560 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 00561 { 00562 scfObject->IncRef(); 00563 return static_cast< 00564 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 00565 } 00566 else 00567 { 00568 return 0; 00569 } 00570 } 00571 00572 template<typename I> 00573 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 00574 Class* scfObject) 00575 { 00576 csRefTrackerAccess::AddAlias( 00577 static_cast< 00578 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00579 scfObject); 00580 } 00581 00582 template<typename I> 00583 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 00584 Class* scfObject) 00585 { 00586 csRefTrackerAccess::RemoveAlias( 00587 static_cast< 00588 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00589 scfObject); 00590 } 00591 00592 void AddReftrackerAliases () 00593 { 00594 00595 AddReftrackerAlias<iBase>(this->scfObject); 00596 00597 00598 AddReftrackerAlias<I1>(this->scfObject); 00599 00600 00601 AddReftrackerAlias<I2>(this->scfObject); 00602 00603 00604 AddReftrackerAlias<I3>(this->scfObject); 00605 00606 00607 AddReftrackerAlias<I4>(this->scfObject); 00608 00609 00610 AddReftrackerAlias<I5>(this->scfObject); 00611 } 00612 00613 void RemoveReftrackerAliases () 00614 { 00615 00616 RemoveReftrackerAlias<iBase>(this->scfObject); 00617 00618 00619 RemoveReftrackerAlias<I1>(this->scfObject); 00620 00621 00622 RemoveReftrackerAlias<I2>(this->scfObject); 00623 00624 00625 RemoveReftrackerAlias<I3>(this->scfObject); 00626 00627 00628 RemoveReftrackerAlias<I4>(this->scfObject); 00629 00630 00631 RemoveReftrackerAlias<I5>(this->scfObject); 00632 } 00633 }; 00634 template<class Class ,class I1, class I2, class I3, class I4, class I5, class I6> 00635 class CS_CRYSTALSPACE_EXPORT scfImplementation6 : 00636 public scfImplementation<Class> 00637 ,public I1, public I2, public I3, public I4, public I5, public I6 00638 { 00639 public: 00640 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 00641 { 00642 00643 void *x; 00644 if((x = GetInterface<I1>(this->scfObject, id, version)) != 0) return x; 00645 00646 00647 if((x = GetInterface<I2>(this->scfObject, id, version)) != 0) return x; 00648 00649 00650 if((x = GetInterface<I3>(this->scfObject, id, version)) != 0) return x; 00651 00652 00653 if((x = GetInterface<I4>(this->scfObject, id, version)) != 0) return x; 00654 00655 00656 if((x = GetInterface<I5>(this->scfObject, id, version)) != 0) return x; 00657 00658 00659 if((x = GetInterface<I6>(this->scfObject, id, version)) != 0) return x; 00660 return scfImplementation<Class>::QueryInterface(id, version); 00661 } 00662 00663 protected: 00664 00665 scfImplementation6(Class *object, iBase *parent=0) 00666 : scfImplementation<Class>(object, parent) 00667 { 00668 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00669 AddReftrackerAliases(); 00670 } 00671 virtual ~scfImplementation6() 00672 { 00673 RemoveReftrackerAliases(); 00674 } 00675 00676 typedef scfImplementation6<Class ,I1, I2, I3, I4, I5, I6> scfImplementationType; 00677 typedef Class scfClassType; 00678 00679 private: 00680 template<typename I> 00681 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 00682 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 00683 { 00684 if (id == scfInterfaceTraits<I>::GetID() && 00685 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 00686 { 00687 scfObject->IncRef(); 00688 return static_cast< 00689 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 00690 } 00691 else 00692 { 00693 return 0; 00694 } 00695 } 00696 00697 template<typename I> 00698 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 00699 Class* scfObject) 00700 { 00701 csRefTrackerAccess::AddAlias( 00702 static_cast< 00703 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00704 scfObject); 00705 } 00706 00707 template<typename I> 00708 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 00709 Class* scfObject) 00710 { 00711 csRefTrackerAccess::RemoveAlias( 00712 static_cast< 00713 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00714 scfObject); 00715 } 00716 00717 void AddReftrackerAliases () 00718 { 00719 00720 AddReftrackerAlias<iBase>(this->scfObject); 00721 00722 00723 AddReftrackerAlias<I1>(this->scfObject); 00724 00725 00726 AddReftrackerAlias<I2>(this->scfObject); 00727 00728 00729 AddReftrackerAlias<I3>(this->scfObject); 00730 00731 00732 AddReftrackerAlias<I4>(this->scfObject); 00733 00734 00735 AddReftrackerAlias<I5>(this->scfObject); 00736 00737 00738 AddReftrackerAlias<I6>(this->scfObject); 00739 } 00740 00741 void RemoveReftrackerAliases () 00742 { 00743 00744 RemoveReftrackerAlias<iBase>(this->scfObject); 00745 00746 00747 RemoveReftrackerAlias<I1>(this->scfObject); 00748 00749 00750 RemoveReftrackerAlias<I2>(this->scfObject); 00751 00752 00753 RemoveReftrackerAlias<I3>(this->scfObject); 00754 00755 00756 RemoveReftrackerAlias<I4>(this->scfObject); 00757 00758 00759 RemoveReftrackerAlias<I5>(this->scfObject); 00760 00761 00762 RemoveReftrackerAlias<I6>(this->scfObject); 00763 } 00764 }; 00765 template<class Class ,class I1, class I2, class I3, class I4, class I5, class I6, class I7> 00766 class CS_CRYSTALSPACE_EXPORT scfImplementation7 : 00767 public scfImplementation<Class> 00768 ,public I1, public I2, public I3, public I4, public I5, public I6, public I7 00769 { 00770 public: 00771 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 00772 { 00773 00774 void *x; 00775 if((x = GetInterface<I1>(this->scfObject, id, version)) != 0) return x; 00776 00777 00778 if((x = GetInterface<I2>(this->scfObject, id, version)) != 0) return x; 00779 00780 00781 if((x = GetInterface<I3>(this->scfObject, id, version)) != 0) return x; 00782 00783 00784 if((x = GetInterface<I4>(this->scfObject, id, version)) != 0) return x; 00785 00786 00787 if((x = GetInterface<I5>(this->scfObject, id, version)) != 0) return x; 00788 00789 00790 if((x = GetInterface<I6>(this->scfObject, id, version)) != 0) return x; 00791 00792 00793 if((x = GetInterface<I7>(this->scfObject, id, version)) != 0) return x; 00794 return scfImplementation<Class>::QueryInterface(id, version); 00795 } 00796 00797 protected: 00798 00799 scfImplementation7(Class *object, iBase *parent=0) 00800 : scfImplementation<Class>(object, parent) 00801 { 00802 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00803 AddReftrackerAliases(); 00804 } 00805 virtual ~scfImplementation7() 00806 { 00807 RemoveReftrackerAliases(); 00808 } 00809 00810 typedef scfImplementation7<Class ,I1, I2, I3, I4, I5, I6, I7> scfImplementationType; 00811 typedef Class scfClassType; 00812 00813 private: 00814 template<typename I> 00815 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 00816 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 00817 { 00818 if (id == scfInterfaceTraits<I>::GetID() && 00819 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 00820 { 00821 scfObject->IncRef(); 00822 return static_cast< 00823 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 00824 } 00825 else 00826 { 00827 return 0; 00828 } 00829 } 00830 00831 template<typename I> 00832 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 00833 Class* scfObject) 00834 { 00835 csRefTrackerAccess::AddAlias( 00836 static_cast< 00837 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00838 scfObject); 00839 } 00840 00841 template<typename I> 00842 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 00843 Class* scfObject) 00844 { 00845 csRefTrackerAccess::RemoveAlias( 00846 static_cast< 00847 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 00848 scfObject); 00849 } 00850 00851 void AddReftrackerAliases () 00852 { 00853 00854 AddReftrackerAlias<iBase>(this->scfObject); 00855 00856 00857 AddReftrackerAlias<I1>(this->scfObject); 00858 00859 00860 AddReftrackerAlias<I2>(this->scfObject); 00861 00862 00863 AddReftrackerAlias<I3>(this->scfObject); 00864 00865 00866 AddReftrackerAlias<I4>(this->scfObject); 00867 00868 00869 AddReftrackerAlias<I5>(this->scfObject); 00870 00871 00872 AddReftrackerAlias<I6>(this->scfObject); 00873 00874 00875 AddReftrackerAlias<I7>(this->scfObject); 00876 } 00877 00878 void RemoveReftrackerAliases () 00879 { 00880 00881 RemoveReftrackerAlias<iBase>(this->scfObject); 00882 00883 00884 RemoveReftrackerAlias<I1>(this->scfObject); 00885 00886 00887 RemoveReftrackerAlias<I2>(this->scfObject); 00888 00889 00890 RemoveReftrackerAlias<I3>(this->scfObject); 00891 00892 00893 RemoveReftrackerAlias<I4>(this->scfObject); 00894 00895 00896 RemoveReftrackerAlias<I5>(this->scfObject); 00897 00898 00899 RemoveReftrackerAlias<I6>(this->scfObject); 00900 00901 00902 RemoveReftrackerAlias<I7>(this->scfObject); 00903 } 00904 }; 00905 template<class Class ,class Super> 00906 class CS_CRYSTALSPACE_EXPORT scfImplementationExt0 : 00907 public Super 00908 00909 { 00910 public: 00911 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 00912 { 00913 return Super::QueryInterface(id, version); 00914 } 00915 00916 protected: 00917 scfImplementationExt0(Class *object) 00918 : Super(), scfObject(object) 00919 { 00920 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00921 AddReftrackerAliases(); 00922 } 00923 00924 template<class T1> 00925 scfImplementationExt0(Class *object, T1 t1) 00926 : Super(t1), scfObject(object) 00927 { 00928 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00929 AddReftrackerAliases(); 00930 } 00931 00932 template<class T1, class T2> 00933 scfImplementationExt0(Class *object, T1 t1, T2 t2) 00934 : Super(t1, t2), scfObject(object) 00935 { 00936 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00937 AddReftrackerAliases(); 00938 } 00939 00940 template<class T1, class T2, class T3> 00941 scfImplementationExt0(Class *object, T1 t1, T2 t2, T3 t3) 00942 : Super(t1, t2, t3), scfObject(object) 00943 { 00944 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00945 AddReftrackerAliases(); 00946 } 00947 00948 template<class T1, class T2, class T3, class T4> 00949 scfImplementationExt0(Class *object, T1 t1, T2 t2, T3 t3, T4 t4) 00950 : Super(t1, t2, t3, t4), scfObject(object) 00951 { 00952 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00953 AddReftrackerAliases(); 00954 } 00955 00956 template<class T1, class T2, class T3, class T4, class T5> 00957 scfImplementationExt0(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) 00958 : Super(t1, t2, t3, t4, t5), scfObject(object) 00959 { 00960 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00961 AddReftrackerAliases(); 00962 } 00963 00964 template<class T1, class T2, class T3, class T4, class T5, class T6> 00965 scfImplementationExt0(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) 00966 : Super(t1, t2, t3, t4, t5, t6), scfObject(object) 00967 { 00968 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 00969 AddReftrackerAliases(); 00970 } 00971 00972 Class *scfObject; 00973 00974 00975 virtual ~scfImplementationExt0() 00976 { 00977 RemoveReftrackerAliases(); 00978 } 00979 00980 typedef scfImplementationExt0<Class ,Super> scfImplementationType; 00981 typedef Class scfClassType; 00982 00983 private: 00984 template<typename I> 00985 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 00986 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 00987 { 00988 if (id == scfInterfaceTraits<I>::GetID() && 00989 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 00990 { 00991 scfObject->IncRef(); 00992 return static_cast< 00993 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 00994 } 00995 else 00996 { 00997 return 0; 00998 } 00999 } 01000 01001 template<typename I> 01002 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 01003 Class* scfObject) 01004 { 01005 csRefTrackerAccess::AddAlias( 01006 static_cast< 01007 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 01008 scfObject); 01009 } 01010 01011 template<typename I> 01012 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 01013 Class* scfObject) 01014 { 01015 csRefTrackerAccess::RemoveAlias( 01016 static_cast< 01017 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 01018 scfObject); 01019 } 01020 01021 void AddReftrackerAliases () 01022 { 01023 } 01024 01025 void RemoveReftrackerAliases () 01026 { 01027 } 01028 }; 01029 template<class Class ,class Super ,class I1> 01030 class CS_CRYSTALSPACE_EXPORT scfImplementationExt1 : 01031 public Super 01032 ,public I1 01033 { 01034 public: 01035 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 01036 { 01037 01038 void *x; 01039 if((x = GetInterface<I1>(this->scfObject, id, version)) != 0) return x; 01040 return Super::QueryInterface(id, version); 01041 } 01042 01043 protected: 01044 scfImplementationExt1(Class *object) 01045 : Super(), scfObject(object) 01046 { 01047 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01048 AddReftrackerAliases(); 01049 } 01050 01051 template<class T1> 01052 scfImplementationExt1(Class *object, T1 t1) 01053 : Super(t1), scfObject(object) 01054 { 01055 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01056 AddReftrackerAliases(); 01057 } 01058 01059 template<class T1, class T2> 01060 scfImplementationExt1(Class *object, T1 t1, T2 t2) 01061 : Super(t1, t2), scfObject(object) 01062 { 01063 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01064 AddReftrackerAliases(); 01065 } 01066 01067 template<class T1, class T2, class T3> 01068 scfImplementationExt1(Class *object, T1 t1, T2 t2, T3 t3) 01069 : Super(t1, t2, t3), scfObject(object) 01070 { 01071 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01072 AddReftrackerAliases(); 01073 } 01074 01075 template<class T1, class T2, class T3, class T4> 01076 scfImplementationExt1(Class *object, T1 t1, T2 t2, T3 t3, T4 t4) 01077 : Super(t1, t2, t3, t4), scfObject(object) 01078 { 01079 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01080 AddReftrackerAliases(); 01081 } 01082 01083 template<class T1, class T2, class T3, class T4, class T5> 01084 scfImplementationExt1(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) 01085 : Super(t1, t2, t3, t4, t5), scfObject(object) 01086 { 01087 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01088 AddReftrackerAliases(); 01089 } 01090 01091 template<class T1, class T2, class T3, class T4, class T5, class T6> 01092 scfImplementationExt1(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) 01093 : Super(t1, t2, t3, t4, t5, t6), scfObject(object) 01094 { 01095 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01096 AddReftrackerAliases(); 01097 } 01098 01099 Class *scfObject; 01100 01101 01102 virtual ~scfImplementationExt1() 01103 { 01104 RemoveReftrackerAliases(); 01105 } 01106 01107 typedef scfImplementationExt1<Class ,Super ,I1> scfImplementationType; 01108 typedef Class scfClassType; 01109 01110 private: 01111 template<typename I> 01112 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 01113 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 01114 { 01115 if (id == scfInterfaceTraits<I>::GetID() && 01116 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 01117 { 01118 scfObject->IncRef(); 01119 return static_cast< 01120 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 01121 } 01122 else 01123 { 01124 return 0; 01125 } 01126 } 01127 01128 template<typename I> 01129 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 01130 Class* scfObject) 01131 { 01132 csRefTrackerAccess::AddAlias( 01133 static_cast< 01134 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 01135 scfObject); 01136 } 01137 01138 template<typename I> 01139 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 01140 Class* scfObject) 01141 { 01142 csRefTrackerAccess::RemoveAlias( 01143 static_cast< 01144 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 01145 scfObject); 01146 } 01147 01148 void AddReftrackerAliases () 01149 { 01150 01151 01152 01153 01154 AddReftrackerAlias<I1>(this->scfObject); 01155 } 01156 01157 void RemoveReftrackerAliases () 01158 { 01159 01160 01161 01162 01163 RemoveReftrackerAlias<I1>(this->scfObject); 01164 } 01165 }; 01166 template<class Class ,class Super ,class I1, class I2> 01167 class CS_CRYSTALSPACE_EXPORT scfImplementationExt2 : 01168 public Super 01169 ,public I1, public I2 01170 { 01171 public: 01172 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 01173 { 01174 01175 void *x; 01176 if((x = GetInterface<I1>(this->scfObject, id, version)) != 0) return x; 01177 01178 01179 if((x = GetInterface<I2>(this->scfObject, id, version)) != 0) return x; 01180 return Super::QueryInterface(id, version); 01181 } 01182 01183 protected: 01184 scfImplementationExt2(Class *object) 01185 : Super(), scfObject(object) 01186 { 01187 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01188 AddReftrackerAliases(); 01189 } 01190 01191 template<class T1> 01192 scfImplementationExt2(Class *object, T1 t1) 01193 : Super(t1), scfObject(object) 01194 { 01195 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01196 AddReftrackerAliases(); 01197 } 01198 01199 template<class T1, class T2> 01200 scfImplementationExt2(Class *object, T1 t1, T2 t2) 01201 : Super(t1, t2), scfObject(object) 01202 { 01203 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01204 AddReftrackerAliases(); 01205 } 01206 01207 template<class T1, class T2, class T3> 01208 scfImplementationExt2(Class *object, T1 t1, T2 t2, T3 t3) 01209 : Super(t1, t2, t3), scfObject(object) 01210 { 01211 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01212 AddReftrackerAliases(); 01213 } 01214 01215 template<class T1, class T2, class T3, class T4> 01216 scfImplementationExt2(Class *object, T1 t1, T2 t2, T3 t3, T4 t4) 01217 : Super(t1, t2, t3, t4), scfObject(object) 01218 { 01219 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01220 AddReftrackerAliases(); 01221 } 01222 01223 template<class T1, class T2, class T3, class T4, class T5> 01224 scfImplementationExt2(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) 01225 : Super(t1, t2, t3, t4, t5), scfObject(object) 01226 { 01227 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01228 AddReftrackerAliases(); 01229 } 01230 01231 template<class T1, class T2, class T3, class T4, class T5, class T6> 01232 scfImplementationExt2(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) 01233 : Super(t1, t2, t3, t4, t5, t6), scfObject(object) 01234 { 01235 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01236 AddReftrackerAliases(); 01237 } 01238 01239 Class *scfObject; 01240 01241 01242 virtual ~scfImplementationExt2() 01243 { 01244 RemoveReftrackerAliases(); 01245 } 01246 01247 typedef scfImplementationExt2<Class ,Super ,I1, I2> scfImplementationType; 01248 typedef Class scfClassType; 01249 01250 private: 01251 template<typename I> 01252 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 01253 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 01254 { 01255 if (id == scfInterfaceTraits<I>::GetID() && 01256 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 01257 { 01258 scfObject->IncRef(); 01259 return static_cast< 01260 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 01261 } 01262 else 01263 { 01264 return 0; 01265 } 01266 } 01267 01268 template<typename I> 01269 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 01270 Class* scfObject) 01271 { 01272 csRefTrackerAccess::AddAlias( 01273 static_cast< 01274 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 01275 scfObject); 01276 } 01277 01278 template<typename I> 01279 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 01280 Class* scfObject) 01281 { 01282 csRefTrackerAccess::RemoveAlias( 01283 static_cast< 01284 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 01285 scfObject); 01286 } 01287 01288 void AddReftrackerAliases () 01289 { 01290 01291 01292 01293 01294 AddReftrackerAlias<I1>(this->scfObject); 01295 01296 01297 AddReftrackerAlias<I2>(this->scfObject); 01298 } 01299 01300 void RemoveReftrackerAliases () 01301 { 01302 01303 01304 01305 01306 RemoveReftrackerAlias<I1>(this->scfObject); 01307 01308 01309 RemoveReftrackerAlias<I2>(this->scfObject); 01310 } 01311 }; 01312 template<class Class ,class Super ,class I1, class I2, class I3> 01313 class CS_CRYSTALSPACE_EXPORT scfImplementationExt3 : 01314 public Super 01315 ,public I1, public I2, public I3 01316 { 01317 public: 01318 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 01319 { 01320 01321 void *x; 01322 if((x = GetInterface<I1>(this->scfObject, id, version)) != 0) return x; 01323 01324 01325 if((x = GetInterface<I2>(this->scfObject, id, version)) != 0) return x; 01326 01327 01328 if((x = GetInterface<I3>(this->scfObject, id, version)) != 0) return x; 01329 return Super::QueryInterface(id, version); 01330 } 01331 01332 protected: 01333 scfImplementationExt3(Class *object) 01334 : Super(), scfObject(object) 01335 { 01336 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01337 AddReftrackerAliases(); 01338 } 01339 01340 template<class T1> 01341 scfImplementationExt3(Class *object, T1 t1) 01342 : Super(t1), scfObject(object) 01343 { 01344 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01345 AddReftrackerAliases(); 01346 } 01347 01348 template<class T1, class T2> 01349 scfImplementationExt3(Class *object, T1 t1, T2 t2) 01350 : Super(t1, t2), scfObject(object) 01351 { 01352 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01353 AddReftrackerAliases(); 01354 } 01355 01356 template<class T1, class T2, class T3> 01357 scfImplementationExt3(Class *object, T1 t1, T2 t2, T3 t3) 01358 : Super(t1, t2, t3), scfObject(object) 01359 { 01360 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01361 AddReftrackerAliases(); 01362 } 01363 01364 template<class T1, class T2, class T3, class T4> 01365 scfImplementationExt3(Class *object, T1 t1, T2 t2, T3 t3, T4 t4) 01366 : Super(t1, t2, t3, t4), scfObject(object) 01367 { 01368 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01369 AddReftrackerAliases(); 01370 } 01371 01372 template<class T1, class T2, class T3, class T4, class T5> 01373 scfImplementationExt3(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) 01374 : Super(t1, t2, t3, t4, t5), scfObject(object) 01375 { 01376 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01377 AddReftrackerAliases(); 01378 } 01379 01380 template<class T1, class T2, class T3, class T4, class T5, class T6> 01381 scfImplementationExt3(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) 01382 : Super(t1, t2, t3, t4, t5, t6), scfObject(object) 01383 { 01384 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01385 AddReftrackerAliases(); 01386 } 01387 01388 Class *scfObject; 01389 01390 01391 virtual ~scfImplementationExt3() 01392 { 01393 RemoveReftrackerAliases(); 01394 } 01395 01396 typedef scfImplementationExt3<Class ,Super ,I1, I2, I3> scfImplementationType; 01397 typedef Class scfClassType; 01398 01399 private: 01400 template<typename I> 01401 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 01402 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 01403 { 01404 if (id == scfInterfaceTraits<I>::GetID() && 01405 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 01406 { 01407 scfObject->IncRef(); 01408 return static_cast< 01409 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 01410 } 01411 else 01412 { 01413 return 0; 01414 } 01415 } 01416 01417 template<typename I> 01418 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 01419 Class* scfObject) 01420 { 01421 csRefTrackerAccess::AddAlias( 01422 static_cast< 01423 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 01424 scfObject); 01425 } 01426 01427 template<typename I> 01428 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 01429 Class* scfObject) 01430 { 01431 csRefTrackerAccess::RemoveAlias( 01432 static_cast< 01433 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 01434 scfObject); 01435 } 01436 01437 void AddReftrackerAliases () 01438 { 01439 01440 01441 01442 01443 AddReftrackerAlias<I1>(this->scfObject); 01444 01445 01446 AddReftrackerAlias<I2>(this->scfObject); 01447 01448 01449 AddReftrackerAlias<I3>(this->scfObject); 01450 } 01451 01452 void RemoveReftrackerAliases () 01453 { 01454 01455 01456 01457 01458 RemoveReftrackerAlias<I1>(this->scfObject); 01459 01460 01461 RemoveReftrackerAlias<I2>(this->scfObject); 01462 01463 01464 RemoveReftrackerAlias<I3>(this->scfObject); 01465 } 01466 }; 01467 template<class Class ,class Super ,class I1, class I2, class I3, class I4> 01468 class CS_CRYSTALSPACE_EXPORT scfImplementationExt4 : 01469 public Super 01470 ,public I1, public I2, public I3, public I4 01471 { 01472 public: 01473 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 01474 { 01475 01476 void *x; 01477 if((x = GetInterface<I1>(this->scfObject, id, version)) != 0) return x; 01478 01479 01480 if((x = GetInterface<I2>(this->scfObject, id, version)) != 0) return x; 01481 01482 01483 if((x = GetInterface<I3>(this->scfObject, id, version)) != 0) return x; 01484 01485 01486 if((x = GetInterface<I4>(this->scfObject, id, version)) != 0) return x; 01487 return Super::QueryInterface(id, version); 01488 } 01489 01490 protected: 01491 scfImplementationExt4(Class *object) 01492 : Super(), scfObject(object) 01493 { 01494 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01495 AddReftrackerAliases(); 01496 } 01497 01498 template<class T1> 01499 scfImplementationExt4(Class *object, T1 t1) 01500 : Super(t1), scfObject(object) 01501 { 01502 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01503 AddReftrackerAliases(); 01504 } 01505 01506 template<class T1, class T2> 01507 scfImplementationExt4(Class *object, T1 t1, T2 t2) 01508 : Super(t1, t2), scfObject(object) 01509 { 01510 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01511 AddReftrackerAliases(); 01512 } 01513 01514 template<class T1, class T2, class T3> 01515 scfImplementationExt4(Class *object, T1 t1, T2 t2, T3 t3) 01516 : Super(t1, t2, t3), scfObject(object) 01517 { 01518 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01519 AddReftrackerAliases(); 01520 } 01521 01522 template<class T1, class T2, class T3, class T4> 01523 scfImplementationExt4(Class *object, T1 t1, T2 t2, T3 t3, T4 t4) 01524 : Super(t1, t2, t3, t4), scfObject(object) 01525 { 01526 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01527 AddReftrackerAliases(); 01528 } 01529 01530 template<class T1, class T2, class T3, class T4, class T5> 01531 scfImplementationExt4(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) 01532 : Super(t1, t2, t3, t4, t5), scfObject(object) 01533 { 01534 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01535 AddReftrackerAliases(); 01536 } 01537 01538 template<class T1, class T2, class T3, class T4, class T5, class T6> 01539 scfImplementationExt4(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) 01540 : Super(t1, t2, t3, t4, t5, t6), scfObject(object) 01541 { 01542 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01543 AddReftrackerAliases(); 01544 } 01545 01546 Class *scfObject; 01547 01548 01549 virtual ~scfImplementationExt4() 01550 { 01551 RemoveReftrackerAliases(); 01552 } 01553 01554 typedef scfImplementationExt4<Class ,Super ,I1, I2, I3, I4> scfImplementationType; 01555 typedef Class scfClassType; 01556 01557 private: 01558 template<typename I> 01559 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 01560 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 01561 { 01562 if (id == scfInterfaceTraits<I>::GetID() && 01563 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 01564 { 01565 scfObject->IncRef(); 01566 return static_cast< 01567 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 01568 } 01569 else 01570 { 01571 return 0; 01572 } 01573 } 01574 01575 template<typename I> 01576 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 01577 Class* scfObject) 01578 { 01579 csRefTrackerAccess::AddAlias( 01580 static_cast< 01581 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 01582 scfObject); 01583 } 01584 01585 template<typename I> 01586 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 01587 Class* scfObject) 01588 { 01589 csRefTrackerAccess::RemoveAlias( 01590 static_cast< 01591 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 01592 scfObject); 01593 } 01594 01595 void AddReftrackerAliases () 01596 { 01597 01598 01599 01600 01601 AddReftrackerAlias<I1>(this->scfObject); 01602 01603 01604 AddReftrackerAlias<I2>(this->scfObject); 01605 01606 01607 AddReftrackerAlias<I3>(this->scfObject); 01608 01609 01610 AddReftrackerAlias<I4>(this->scfObject); 01611 } 01612 01613 void RemoveReftrackerAliases () 01614 { 01615 01616 01617 01618 01619 RemoveReftrackerAlias<I1>(this->scfObject); 01620 01621 01622 RemoveReftrackerAlias<I2>(this->scfObject); 01623 01624 01625 RemoveReftrackerAlias<I3>(this->scfObject); 01626 01627 01628 RemoveReftrackerAlias<I4>(this->scfObject); 01629 } 01630 }; 01631 template<class Class ,class Super ,class I1, class I2, class I3, class I4, class I5> 01632 class CS_CRYSTALSPACE_EXPORT scfImplementationExt5 : 01633 public Super 01634 ,public I1, public I2, public I3, public I4, public I5 01635 { 01636 public: 01637 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 01638 { 01639 01640 void *x; 01641 if((x = GetInterface<I1>(this->scfObject, id, version)) != 0) return x; 01642 01643 01644 if((x = GetInterface<I2>(this->scfObject, id, version)) != 0) return x; 01645 01646 01647 if((x = GetInterface<I3>(this->scfObject, id, version)) != 0) return x; 01648 01649 01650 if((x = GetInterface<I4>(this->scfObject, id, version)) != 0) return x; 01651 01652 01653 if((x = GetInterface<I5>(this->scfObject, id, version)) != 0) return x; 01654 return Super::QueryInterface(id, version); 01655 } 01656 01657 protected: 01658 scfImplementationExt5(Class *object) 01659 : Super(), scfObject(object) 01660 { 01661 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01662 AddReftrackerAliases(); 01663 } 01664 01665 template<class T1> 01666 scfImplementationExt5(Class *object, T1 t1) 01667 : Super(t1), scfObject(object) 01668 { 01669 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01670 AddReftrackerAliases(); 01671 } 01672 01673 template<class T1, class T2> 01674 scfImplementationExt5(Class *object, T1 t1, T2 t2) 01675 : Super(t1, t2), scfObject(object) 01676 { 01677 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01678 AddReftrackerAliases(); 01679 } 01680 01681 template<class T1, class T2, class T3> 01682 scfImplementationExt5(Class *object, T1 t1, T2 t2, T3 t3) 01683 : Super(t1, t2, t3), scfObject(object) 01684 { 01685 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01686 AddReftrackerAliases(); 01687 } 01688 01689 template<class T1, class T2, class T3, class T4> 01690 scfImplementationExt5(Class *object, T1 t1, T2 t2, T3 t3, T4 t4) 01691 : Super(t1, t2, t3, t4), scfObject(object) 01692 { 01693 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01694 AddReftrackerAliases(); 01695 } 01696 01697 template<class T1, class T2, class T3, class T4, class T5> 01698 scfImplementationExt5(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) 01699 : Super(t1, t2, t3, t4, t5), scfObject(object) 01700 { 01701 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01702 AddReftrackerAliases(); 01703 } 01704 01705 template<class T1, class T2, class T3, class T4, class T5, class T6> 01706 scfImplementationExt5(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) 01707 : Super(t1, t2, t3, t4, t5, t6), scfObject(object) 01708 { 01709 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01710 AddReftrackerAliases(); 01711 } 01712 01713 Class *scfObject; 01714 01715 01716 virtual ~scfImplementationExt5() 01717 { 01718 RemoveReftrackerAliases(); 01719 } 01720 01721 typedef scfImplementationExt5<Class ,Super ,I1, I2, I3, I4, I5> scfImplementationType; 01722 typedef Class scfClassType; 01723 01724 private: 01725 template<typename I> 01726 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 01727 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 01728 { 01729 if (id == scfInterfaceTraits<I>::GetID() && 01730 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 01731 { 01732 scfObject->IncRef(); 01733 return static_cast< 01734 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 01735 } 01736 else 01737 { 01738 return 0; 01739 } 01740 } 01741 01742 template<typename I> 01743 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 01744 Class* scfObject) 01745 { 01746 csRefTrackerAccess::AddAlias( 01747 static_cast< 01748 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 01749 scfObject); 01750 } 01751 01752 template<typename I> 01753 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 01754 Class* scfObject) 01755 { 01756 csRefTrackerAccess::RemoveAlias( 01757 static_cast< 01758 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 01759 scfObject); 01760 } 01761 01762 void AddReftrackerAliases () 01763 { 01764 01765 01766 01767 01768 AddReftrackerAlias<I1>(this->scfObject); 01769 01770 01771 AddReftrackerAlias<I2>(this->scfObject); 01772 01773 01774 AddReftrackerAlias<I3>(this->scfObject); 01775 01776 01777 AddReftrackerAlias<I4>(this->scfObject); 01778 01779 01780 AddReftrackerAlias<I5>(this->scfObject); 01781 } 01782 01783 void RemoveReftrackerAliases () 01784 { 01785 01786 01787 01788 01789 RemoveReftrackerAlias<I1>(this->scfObject); 01790 01791 01792 RemoveReftrackerAlias<I2>(this->scfObject); 01793 01794 01795 RemoveReftrackerAlias<I3>(this->scfObject); 01796 01797 01798 RemoveReftrackerAlias<I4>(this->scfObject); 01799 01800 01801 RemoveReftrackerAlias<I5>(this->scfObject); 01802 } 01803 }; 01804 template<class Class ,class Super ,class I1, class I2, class I3, class I4, class I5, class I6> 01805 class CS_CRYSTALSPACE_EXPORT scfImplementationExt6 : 01806 public Super 01807 ,public I1, public I2, public I3, public I4, public I5, public I6 01808 { 01809 public: 01810 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 01811 { 01812 01813 void *x; 01814 if((x = GetInterface<I1>(this->scfObject, id, version)) != 0) return x; 01815 01816 01817 if((x = GetInterface<I2>(this->scfObject, id, version)) != 0) return x; 01818 01819 01820 if((x = GetInterface<I3>(this->scfObject, id, version)) != 0) return x; 01821 01822 01823 if((x = GetInterface<I4>(this->scfObject, id, version)) != 0) return x; 01824 01825 01826 if((x = GetInterface<I5>(this->scfObject, id, version)) != 0) return x; 01827 01828 01829 if((x = GetInterface<I6>(this->scfObject, id, version)) != 0) return x; 01830 return Super::QueryInterface(id, version); 01831 } 01832 01833 protected: 01834 scfImplementationExt6(Class *object) 01835 : Super(), scfObject(object) 01836 { 01837 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01838 AddReftrackerAliases(); 01839 } 01840 01841 template<class T1> 01842 scfImplementationExt6(Class *object, T1 t1) 01843 : Super(t1), scfObject(object) 01844 { 01845 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01846 AddReftrackerAliases(); 01847 } 01848 01849 template<class T1, class T2> 01850 scfImplementationExt6(Class *object, T1 t1, T2 t2) 01851 : Super(t1, t2), scfObject(object) 01852 { 01853 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01854 AddReftrackerAliases(); 01855 } 01856 01857 template<class T1, class T2, class T3> 01858 scfImplementationExt6(Class *object, T1 t1, T2 t2, T3 t3) 01859 : Super(t1, t2, t3), scfObject(object) 01860 { 01861 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01862 AddReftrackerAliases(); 01863 } 01864 01865 template<class T1, class T2, class T3, class T4> 01866 scfImplementationExt6(Class *object, T1 t1, T2 t2, T3 t3, T4 t4) 01867 : Super(t1, t2, t3, t4), scfObject(object) 01868 { 01869 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01870 AddReftrackerAliases(); 01871 } 01872 01873 template<class T1, class T2, class T3, class T4, class T5> 01874 scfImplementationExt6(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) 01875 : Super(t1, t2, t3, t4, t5), scfObject(object) 01876 { 01877 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01878 AddReftrackerAliases(); 01879 } 01880 01881 template<class T1, class T2, class T3, class T4, class T5, class T6> 01882 scfImplementationExt6(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) 01883 : Super(t1, t2, t3, t4, t5, t6), scfObject(object) 01884 { 01885 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 01886 AddReftrackerAliases(); 01887 } 01888 01889 Class *scfObject; 01890 01891 01892 virtual ~scfImplementationExt6() 01893 { 01894 RemoveReftrackerAliases(); 01895 } 01896 01897 typedef scfImplementationExt6<Class ,Super ,I1, I2, I3, I4, I5, I6> scfImplementationType; 01898 typedef Class scfClassType; 01899 01900 private: 01901 template<typename I> 01902 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 01903 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 01904 { 01905 if (id == scfInterfaceTraits<I>::GetID() && 01906 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 01907 { 01908 scfObject->IncRef(); 01909 return static_cast< 01910 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 01911 } 01912 else 01913 { 01914 return 0; 01915 } 01916 } 01917 01918 template<typename I> 01919 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 01920 Class* scfObject) 01921 { 01922 csRefTrackerAccess::AddAlias( 01923 static_cast< 01924 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 01925 scfObject); 01926 } 01927 01928 template<typename I> 01929 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 01930 Class* scfObject) 01931 { 01932 csRefTrackerAccess::RemoveAlias( 01933 static_cast< 01934 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 01935 scfObject); 01936 } 01937 01938 void AddReftrackerAliases () 01939 { 01940 01941 01942 01943 01944 AddReftrackerAlias<I1>(this->scfObject); 01945 01946 01947 AddReftrackerAlias<I2>(this->scfObject); 01948 01949 01950 AddReftrackerAlias<I3>(this->scfObject); 01951 01952 01953 AddReftrackerAlias<I4>(this->scfObject); 01954 01955 01956 AddReftrackerAlias<I5>(this->scfObject); 01957 01958 01959 AddReftrackerAlias<I6>(this->scfObject); 01960 } 01961 01962 void RemoveReftrackerAliases () 01963 { 01964 01965 01966 01967 01968 RemoveReftrackerAlias<I1>(this->scfObject); 01969 01970 01971 RemoveReftrackerAlias<I2>(this->scfObject); 01972 01973 01974 RemoveReftrackerAlias<I3>(this->scfObject); 01975 01976 01977 RemoveReftrackerAlias<I4>(this->scfObject); 01978 01979 01980 RemoveReftrackerAlias<I5>(this->scfObject); 01981 01982 01983 RemoveReftrackerAlias<I6>(this->scfObject); 01984 } 01985 }; 01986 template<class Class ,class Super ,class I1, class I2, class I3, class I4, class I5, class I6, class I7> 01987 class CS_CRYSTALSPACE_EXPORT scfImplementationExt7 : 01988 public Super 01989 ,public I1, public I2, public I3, public I4, public I5, public I6, public I7 01990 { 01991 public: 01992 inline void *QueryInterface(scfInterfaceID id, scfInterfaceVersion version) 01993 { 01994 01995 void *x; 01996 if((x = GetInterface<I1>(this->scfObject, id, version)) != 0) return x; 01997 01998 01999 if((x = GetInterface<I2>(this->scfObject, id, version)) != 0) return x; 02000 02001 02002 if((x = GetInterface<I3>(this->scfObject, id, version)) != 0) return x; 02003 02004 02005 if((x = GetInterface<I4>(this->scfObject, id, version)) != 0) return x; 02006 02007 02008 if((x = GetInterface<I5>(this->scfObject, id, version)) != 0) return x; 02009 02010 02011 if((x = GetInterface<I6>(this->scfObject, id, version)) != 0) return x; 02012 02013 02014 if((x = GetInterface<I7>(this->scfObject, id, version)) != 0) return x; 02015 return Super::QueryInterface(id, version); 02016 } 02017 02018 protected: 02019 scfImplementationExt7(Class *object) 02020 : Super(), scfObject(object) 02021 { 02022 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 02023 AddReftrackerAliases(); 02024 } 02025 02026 template<class T1> 02027 scfImplementationExt7(Class *object, T1 t1) 02028 : Super(t1), scfObject(object) 02029 { 02030 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 02031 AddReftrackerAliases(); 02032 } 02033 02034 template<class T1, class T2> 02035 scfImplementationExt7(Class *object, T1 t1, T2 t2) 02036 : Super(t1, t2), scfObject(object) 02037 { 02038 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 02039 AddReftrackerAliases(); 02040 } 02041 02042 template<class T1, class T2, class T3> 02043 scfImplementationExt7(Class *object, T1 t1, T2 t2, T3 t3) 02044 : Super(t1, t2, t3), scfObject(object) 02045 { 02046 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 02047 AddReftrackerAliases(); 02048 } 02049 02050 template<class T1, class T2, class T3, class T4> 02051 scfImplementationExt7(Class *object, T1 t1, T2 t2, T3 t3, T4 t4) 02052 : Super(t1, t2, t3, t4), scfObject(object) 02053 { 02054 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 02055 AddReftrackerAliases(); 02056 } 02057 02058 template<class T1, class T2, class T3, class T4, class T5> 02059 scfImplementationExt7(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) 02060 : Super(t1, t2, t3, t4, t5), scfObject(object) 02061 { 02062 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 02063 AddReftrackerAliases(); 02064 } 02065 02066 template<class T1, class T2, class T3, class T4, class T5, class T6> 02067 scfImplementationExt7(Class *object, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) 02068 : Super(t1, t2, t3, t4, t5, t6), scfObject(object) 02069 { 02070 csRefTrackerAccess::SetDescription (object, CS_TYPENAME (Class)); 02071 AddReftrackerAliases(); 02072 } 02073 02074 Class *scfObject; 02075 02076 02077 virtual ~scfImplementationExt7() 02078 { 02079 RemoveReftrackerAliases(); 02080 } 02081 02082 typedef scfImplementationExt7<Class ,Super ,I1, I2, I3, I4, I5, I6, I7> scfImplementationType; 02083 typedef Class scfClassType; 02084 02085 private: 02086 template<typename I> 02087 CS_FORCEINLINE_TEMPLATEMETHOD static void* GetInterface ( 02088 Class* scfObject, scfInterfaceID id, scfInterfaceVersion version) 02089 { 02090 if (id == scfInterfaceTraits<I>::GetID() && 02091 scfCompatibleVersion(version, scfInterfaceTraits<I>::GetVersion())) 02092 { 02093 scfObject->IncRef(); 02094 return static_cast< 02095 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject); 02096 } 02097 else 02098 { 02099 return 0; 02100 } 02101 } 02102 02103 template<typename I> 02104 CS_FORCEINLINE_TEMPLATEMETHOD static void AddReftrackerAlias ( 02105 Class* scfObject) 02106 { 02107 csRefTrackerAccess::AddAlias( 02108 static_cast< 02109 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 02110 scfObject); 02111 } 02112 02113 template<typename I> 02114 CS_FORCEINLINE_TEMPLATEMETHOD static void RemoveReftrackerAlias ( 02115 Class* scfObject) 02116 { 02117 csRefTrackerAccess::RemoveAlias( 02118 static_cast< 02119 typename scfInterfaceTraits<I>::InterfaceType*> (scfObject), 02120 scfObject); 02121 } 02122 02123 void AddReftrackerAliases () 02124 { 02125 02126 02127 02128 02129 AddReftrackerAlias<I1>(this->scfObject); 02130 02131 02132 AddReftrackerAlias<I2>(this->scfObject); 02133 02134 02135 AddReftrackerAlias<I3>(this->scfObject); 02136 02137 02138 AddReftrackerAlias<I4>(this->scfObject); 02139 02140 02141 AddReftrackerAlias<I5>(this->scfObject); 02142 02143 02144 AddReftrackerAlias<I6>(this->scfObject); 02145 02146 02147 AddReftrackerAlias<I7>(this->scfObject); 02148 } 02149 02150 void RemoveReftrackerAliases () 02151 { 02152 02153 02154 02155 02156 RemoveReftrackerAlias<I1>(this->scfObject); 02157 02158 02159 RemoveReftrackerAlias<I2>(this->scfObject); 02160 02161 02162 RemoveReftrackerAlias<I3>(this->scfObject); 02163 02164 02165 RemoveReftrackerAlias<I4>(this->scfObject); 02166 02167 02168 RemoveReftrackerAlias<I5>(this->scfObject); 02169 02170 02171 RemoveReftrackerAlias<I6>(this->scfObject); 02172 02173 02174 RemoveReftrackerAlias<I7>(this->scfObject); 02175 } 02176 }; 02177 02178 #include "csutil/win32/msvc_deprecated_warn_on.h"
Generated for Crystal Space 1.2 by doxygen 1.4.7