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