CrystalSpace

Public API Reference

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.1 by doxygen 1.5.3