Show
Ignore:
Timestamp:
01/16/08 16:07:40 (1 year ago)
Author:
cneumann
Message:

changed: - factory functions return a TransitPtr? that can not be implicitly

converted to C Ptr. Should help with porting.

added: - GlobalRefPtr?, needed for cases where upon return from main

a RefPtr? goes out of scope (it would attempt to access the
FCFactory which is already shutdown at that point).

status: - vrml loader does not compile (needs porting to ref ptr)

  • tutorials compile, run and exit cleanly
  • multithreading and cluster are untested, yet
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/Carsten_PtrWork2/Source/System/FieldContainer/Base/OSGReferenceCountPointer.h

    r1033 r1039  
    4242#endif 
    4343 
    44 #include "OSGConfig.h" 
    45 #include "OSGContainerForwards.h" 
     44#include "OSGReferenceCountPointerDecl.h" 
    4645 
     46#include "OSGBaseInitFunctions.h" 
     47#include "OSGTransitPointer.h" 
    4748#include "OSGFieldContainer.h" 
    4849#include "OSGFieldBundle.h" 
    4950 
    50 #include <boost/shared_ptr.hpp> 
    51  
    52 #ifdef OSG_DOC_FILES_IN_MODULE 
    53 /*! \file OSGReferenceCountPointer.h 
    54     \ingroup GrpSystemFieldContainer 
    55  */ 
    56 #endif 
    57  
    58 OSG_BEGIN_NAMESPACE 
    59  
    60 /*! \ingroup GrpSystemFieldContainer 
    61     \class InternalRefCountPolicy<BaseObjectT> 
    62  */ 
    63  
    64 template <class BaseObjectT> 
    65 struct OSG_SYSTEM_DLLMAPPING InternalRefCountPolicy 
    66 { 
    67     OSG_GEN_NAMED_PTR(BaseObjectT, BaseObject); 
    68  
    69     static void          addRef(BaseObjectPtrConstArg baseObjectPtr);   
    70     static void          subRef(BaseObjectPtrConstArg baseObjectPtr); 
    71     static BaseObjectPtr deref (BaseObjectPtrConstArg baseObjectPtr); 
    72 }; 
    73  
    74 /*! \ingroup GrpSystemFieldContainer 
    75     \class RefCountPolicy<BaseObjectT> 
    76  */ 
    77  
    78 template <class BaseObjectT> 
    79 struct OSG_SYSTEM_DLLMAPPING RefCountPolicy 
    80 { 
    81     OSG_GEN_NAMED_PTR(BaseObjectT, BaseObject); 
    82  
    83     static void          addRef(BaseObjectPtrConstArg baseObjectPtr);   
    84     static void          subRef(BaseObjectPtrConstArg baseObjectPtr); 
    85     static BaseObjectPtr deref (BaseObjectPtrConstArg baseObjectPtr); 
    86 }; 
    87  
    88 /*! \ingroup GrpSystemFieldContainer 
    89     \class MTRefCountPolicy<BaseObjectT> 
    90  */ 
    91  
    92 template <class BaseObjectT> 
    93 struct OSG_SYSTEM_DLLMAPPING MTRefCountPolicy 
    94 { 
    95     OSG_GEN_NAMED_PTR(BaseObjectT, BaseObject); 
    96  
    97     static void          addRef(BaseObjectPtrConstArg baseObjectPtr);   
    98     static void          subRef(BaseObjectPtrConstArg baseObjectPtr); 
    99     static BaseObjectPtr deref (BaseObjectPtrConstArg baseObjectPtr); 
    100 }; 
    101  
    102 template <> 
    103 struct OSG_SYSTEM_DLLMAPPING MTRefCountPolicy<FieldBundle> 
    104 { 
    105     OSG_GEN_NAMED_PTR(FieldBundle, BaseObject); 
    106  
    107     static void          addRef(BaseObjectPtrConstArg baseObjectPtr);   
    108     static void          subRef(BaseObjectPtrConstArg baseObjectPtr); 
    109     static BaseObjectPtr deref (BaseObjectPtrConstArg baseObjectPtr); 
    110 }; 
    111  
    112  
    113 /*! \ingroup GrpSystemFieldContainer 
    114     \class WeakRefCountPolicy<BaseObjectT> 
    115  */ 
    116  
    117 template <class BaseObjectT> 
    118 struct OSG_SYSTEM_DLLMAPPING WeakRefCountPolicy 
    119 { 
    120     OSG_GEN_NAMED_PTR(BaseObjectT, BaseObject); 
    121  
    122     static void          addRef(BaseObjectPtrConstArg baseObjectPtr);   
    123     static void          subRef(BaseObjectPtrConstArg baseObjectPtr); 
    124     static BaseObjectPtr deref (BaseObjectPtrConstArg baseObjectPtr); 
    125 }; 
    126  
    127 namespace detail 
    128 { 
    129     // Internal tag type to designate that a static_cast is requested 
    130     struct StaticCastTag 
    131     { 
    132     }; 
    133  
    134     // Internal tag type to designate that a const_cast is requested 
    135     struct ConstCastTag 
    136     { 
    137     }; 
    138      
    139     // Inernal tag type to designate that a dynamic_cast is requested 
    140     struct DynamicCastTag 
    141     { 
    142     }; 
    143 } // namespace detail 
    144  
    145  
    146 /*! \ingroup GrpSystemFieldContainer 
    147  */ 
    148  
    149 template <class ObjectT,  
    150           class RefCountPolicyT, 
    151           class BaseObjectT = FieldContainer> 
    152 class OSG_SYSTEM_DLLMAPPING ReferenceCountPointer 
    153 { 
    154     /*==========================  PUBLIC  =================================*/ 
    155   public: 
    156     /*---------------------------------------------------------------------*/ 
    157     /*! \name Public Types                                                 */ 
    158     /*! \{                                                                 */ 
    159    
    160     typedef ObjectT                                          Object; 
    161     typedef RefCountPolicyT                                  RefCountPolicy; 
    162     typedef BaseObjectT                                      BaseObject; 
    163     typedef ReferenceCountPointer<Object,  
    164                                   RefCountPolicy, 
    165                                   BaseObject     >           Self; 
    166      
    167     OSG_GEN_NAMED_PTR(Object,     Object    ); 
    168     OSG_GEN_NAMED_PTR(BaseObject, BaseObject); 
    169      
    170     template <class OtherObjectT> 
    171     struct rebind 
    172     { 
    173         typedef ReferenceCountPointer<OtherObjectT, 
    174                                       RefCountPolicy, 
    175                                       BaseObject     >       Type; 
    176     }; 
    177    
    178     /*! \}                                                                 */ 
    179     /*---------------------------------------------------------------------*/ 
    180     /*! \name Constructors                                                 */ 
    181     /*! \{                                                                 */ 
    182    
    183     ReferenceCountPointer(void                                       ); 
    184     ReferenceCountPointer(Self                      const &other     ); 
    185      
    186     explicit 
    187     ReferenceCountPointer(ObjectPtrConstArg                objectPtr ); 
    188      
    189     template <class OtherObjectT, class OtherRefCountPolicyT> 
    190     explicit 
    191     ReferenceCountPointer( 
    192         ReferenceCountPointer<OtherObjectT, 
    193                               OtherRefCountPolicyT, 
    194                               BaseObject           > const &refPtr   ); 
    195                                
    196     template <class OtherObjectT, class OtherRefCountPolicyT> 
    197     ReferenceCountPointer( 
    198         ReferenceCountPointer<OtherObjectT, 
    199                               OtherRefCountPolicyT, 
    200                               BaseObject           > const &refPtr, 
    201         detail::StaticCastTag                                        ); 
    202          
    203     template <class OtherObjectT, class OtherRefCountPolicyT> 
    204     ReferenceCountPointer( 
    205         ReferenceCountPointer<OtherObjectT, 
    206                               OtherRefCountPolicyT, 
    207                               BaseObject           > const &refPtr, 
    208         detail::ConstCastTag                                         ); 
    209      
    210     template <class OtherObjectT, class OtherRefCountPolicyT> 
    211     ReferenceCountPointer( 
    212         ReferenceCountPointer<OtherObjectT, 
    213                               OtherRefCountPolicyT, 
    214                               BaseObject           > const &refPtr, 
    215         detail::DynamicCastTag                                       ); 
    216                                                      
    217     /*! \}                                                                 */ 
    218     /*---------------------------------------------------------------------*/ 
    219     /*! \name Desctructor                                                  */ 
    220     /*! \{                                                                 */ 
    221  
    222     ~ReferenceCountPointer(void); 
    223      
    224     /*! \}                                                                 */ 
    225     /*---------------------------------------------------------------------*/ 
    226     /*! \name Assignment                                                   */ 
    227     /*! \{                                                                 */ 
    228      
    229     Self &operator=(Self                            const &other     ); 
    230     Self &operator=(ObjectPtrConstArg                      objectPtr ); 
    231      
    232     template <class OtherObjectT, class OtherRefCountPolicy> 
    233     Self &operator=( 
    234         ReferenceCountPointer<OtherObjectT, 
    235                               OtherRefCountPolicy, 
    236                               BaseObject          > const &refPtr    ); 
    237          
    238     /*! \}                                                                 */ 
    239     /*---------------------------------------------------------------------*/ 
    240     /*! \name Conversion                                                   */ 
    241     /*! \{                                                                 */ 
    242      
    243     operator ObjectPtr (void) const; 
    244      
    245     /*! \}                                                                 */ 
    246     /*---------------------------------------------------------------------*/ 
    247     /*! \name Access                                                       */ 
    248     /*! \{                                                                 */ 
    249      
    250     ObjectPtr  operator->(void                            ) const; 
    251     Object    &operator* (void                            ) const; 
    252      
    253     ObjectPtr  get       (void                            ) const; 
    254     void       set       (ObjectPtrConstArg     objectPtr ); 
    255      
    256     void       swap      (Self                 &other     ); 
    257         
    258     /*! \}                                                                 */ 
    259     /*=========================  PROTECTED  ===============================*/ 
    260   protected: 
    261  
    262     /*==========================  PRIVATE  ================================*/ 
    263   private: 
    264     /*---------------------------------------------------------------------*/ 
    265     /*! \name Internal Helpers                                             */ 
    266     /*! \{                                                                 */ 
    267    
    268     static BaseObjectPtr castPtrUp  (ObjectPtrConstArg     objectPtr    ); 
    269     static ObjectPtr     castPtrDown(BaseObjectPtrConstArg baseObjectPtr); 
    270      
    271     void                 internalSet(BaseObjectPtrConstArg baseObjectPtr); 
    272      
    273     /*! \}                                                                 */ 
    274     /*---------------------------------------------------------------------*/ 
    275     /*! \name Member                                                       */ 
    276     /*! \{                                                                 */ 
    277      
    278     BaseObjectPtr _baseObjectPtr; 
    279      
    280     /*! \}                                                                 */ 
    281     /*---------------------------------------------------------------------*/ 
    282 }; 
    283  
    284 template <class LHSObjectT, class LHSRefCountPolicyT, 
    285           class RHSObjectT, class RHSRefCountPolicyT, 
    286           class BaseObjectT                           > 
    287 bool 
    288 operator==(ReferenceCountPointer<LHSObjectT,  
    289                                  LHSRefCountPolicyT, 
    290                                  BaseObjectT        > const &lhs, 
    291            ReferenceCountPointer<RHSObjectT, 
    292                                  RHSRefCountPolicyT, 
    293                                  BaseObjectT        > const &rhs); 
    294  
    295  
    296 template <class LHSObjectT, class LHSRefCountPolicyT, 
    297           class RHSObjectT, class RHSRefCountPolicyT, 
    298           class BaseObjectT                           > 
    299 bool 
    300 operator!=(ReferenceCountPointer<LHSObjectT, 
    301                                  LHSRefCountPolicyT, 
    302                                  BaseObjectT        > const &lhs, 
    303            ReferenceCountPointer<RHSObjectT, 
    304                                  RHSRefCountPolicyT, 
    305                                  BaseObjectT        > const &rhs); 
    306  
    307             
    308 template <class LHSObjectT, class LHSRefCountPolicyT, 
    309           class RHSObjectT, class RHSRefCountPolicyT, 
    310           class BaseObjectT                           > 
    311 bool 
    312 operator<(ReferenceCountPointer<LHSObjectT, 
    313                                 LHSRefCountPolicyT, 
    314                                 BaseObjectT        > const &lhs, 
    315           ReferenceCountPointer<RHSObjectT, 
    316                                 RHSRefCountPolicyT, 
    317                                 BaseObjectT        > const &rhs); 
    318  
    319 template <class ObjectT, class RefCountPolicyT, class BaseObjectT> 
    320 struct PtrStripper<ReferenceCountPointer<ObjectT, 
    321                                          RefCountPolicyT, 
    322                                          BaseObjectT     > > 
    323 { 
    324     typedef ReferenceCountPointer<ObjectT, 
    325                                   RefCountPolicyT, 
    326                                   BaseObjectT     >  Ptr; 
    327     typedef typename Ptr::Object                     Object; 
    328 }; 
    329                                  
    330 OSG_END_NAMESPACE 
    331  
    332 namespace boost 
    333 { 
    334  
    335 template <class TargetObjectT,   class SourceObjectT, 
    336           class RefCountPolicyT, class BaseObjectT   > 
    337 OSG::ReferenceCountPointer<TargetObjectT, RefCountPolicyT, BaseObjectT> 
    338 static_pointer_cast(OSG::ReferenceCountPointer<SourceObjectT, 
    339                                                RefCountPolicyT, 
    340                                                BaseObjectT     > const &source); 
    341  
    342 template <class TargetObjectT,   class SourceObjectT, 
    343           class RefCountPolicyT, class BaseObjectT   > 
    344 OSG::ReferenceCountPointer<TargetObjectT, RefCountPolicyT, BaseObjectT> 
    345 const_pointer_cast(OSG::ReferenceCountPointer<SourceObjectT, 
    346                                               RefCountPolicyT, 
    347                                               BaseObjectT     > const &source); 
    348  
    349 template <class TargetObjectT,   class SourceObjectT, 
    350           class RefCountPolicyT, class BaseObjectT   > 
    351 OSG::ReferenceCountPointer<TargetObjectT, RefCountPolicyT, BaseObjectT> 
    352 dynamic_pointer_cast(OSG::ReferenceCountPointer<SourceObjectT, 
    353                                                 RefCountPolicyT, 
    354                                                 BaseObjectT     > const &source); 
    355            
    356 } // namespace boost 
    357            
    35851#include "OSGReferenceCountPointer.inl" 
    35952