Show
Ignore:
Timestamp:
10/20/07 18:11:52 (1 year ago)
Author:
cneumann
Message:

added: RootObjectT template paremter for ReferenceCountPointer?

and ParentPointer? templates - allows use for FieldBundles?

compile fixes - but still not done

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Base/OSGParentPointer.inl

    r973 r976  
    4747 
    4848/*-------------------------------------------------------------------------*/ 
    49 /* ParentPointer<ContainerT>                                               */ 
     49/* ParentPointer<ObjectT, RootObjectT>                                     */ 
    5050/*-------------------------------------------------------------------------*/ 
    5151 
    …… 
    5353/* Internal Helpers                                                        */ 
    5454 
    55 template <class ContainerT> 
    56 inline FieldContainerPtr 
    57 ParentPointer<ContainerT, RefCountPolicyT>::castPtrUp( 
    58     ContainerPtrConstArg pContainer) const 
    59 { 
    60     return static_cast<FieldContainerPtr>(static_cast<void *>(pContainer)); 
    61 } 
    62  
    63 template <class ContainerT> 
    64 inline typename 
    65     ParentPointer<ContainerT, RefCountPolicyT>::ContainerPtr 
    66 ParentPointer<ContainerT, RefCountPolicyT>::castPtrDown( 
    67     FieldContainerPtrConstArg pContainer) const 
    68 { 
    69     return static_cast<ContainerPtr>(static_cast<void *>(pContainer)); 
     55template <class ObjectT, class RootObjectT> 
     56inline typename ParentPointer<ObjectT, RootObjectT>::RootObjectPtr 
     57ParentPointer<ObjectT, RootObjectT>::castPtrUp(ObjectPtrConstArg objectPtr) 
     58{ 
     59    return static_cast<RootObjectPtr>(static_cast<void *>(objectPtr)); 
     60} 
     61 
     62template <class ObjectT, class RootObjectT> 
     63inline typename ParentPointer<ObjectT, RootObjectT>::ObjectPtr 
     64ParentPointer<ObjectT, RootObjectT>::castPtrDown( 
     65    RootObjectPtrConstArg rootObjectPtr) 
     66{ 
     67    return static_cast<ObjectPtr>(static_cast<void *>(rootObjectPtr)); 
    7068} 
    7169 
    …… 
    7371/* Constructors                                                            */ 
    7472 
    75 template <class ContainerT> 
    76 inline  
    77 ParentPointer<ContainerT>::ParentPointer(void) 
     73template <class ObjectT, class RootObjectT> 
     74inline  
     75ParentPointer<ObjectT, RootObjectT>::ParentPointer(void) 
    7876    : _pointer      (NullFC), 
    7977      _parentFieldId(0xFFFF) 
    …… 
    8179} 
    8280 
    83 template <class ContainerT> 
    84 inline  
    85 ParentPointer<ContainerT>::ParentPointer(Self const &other) 
     81template <class ObjectT, class RootObjectT> 
     82inline  
     83ParentPointer<ObjectT, RootObjectT>::ParentPointer(Self const &other) 
    8684    : _pointer      (other._pointer      ), 
    8785      _parentFieldId(other._parentFieldId) 
    …… 
    9088     
    9189     
    92 template <class ContainerT> 
    93 inline  
    94 ParentPointer<ContainerT>::ParentPointer( 
    95     ContainerPtrConstArg pContainer, 
     90template <class ObjectT, class RootObjectT> 
     91inline  
     92ParentPointer<ObjectT, RootObjectT>::ParentPointer( 
     93    ObjectPtrConstArg pObject, 
    9694    UInt16         const fieldId = 0xFFFF) 
    9795    : _pointer      (pContainer), 
    …… 
    10098} 
    10199                               
    102 template <class                        PointerTypeT     > 
    103 template <class OtherContainerT, class OtherPointerTypeT> 
    104 inline  
    105 ParentPointer<ContainerT>::ParentPointer( 
    106     ParentPointer<OtherContainerT, 
    107                   OtherPointerTypeT> const &parentPtr) 
     100template <class ObjectT, class RootObjectT> 
     101template <class OtherObjectT              > 
     102inline  
     103ParentPointer<ObjectT, RootObjectT>::ParentPointer( 
     104    ParentPointer<OtherObjectT, RootObjectT> const &parentPtr) 
    108105    : _pointer      (Self::castPtrUp(parentPtr.get())), 
    109106      _parentFieldId(parentPtr.getFieldId()          ) 
    …… 
    111108} 
    112109 
    113 template <class ContainerT,      class PointerTypeT        >     
    114 template <class OtherContainerT, class OtherRefCountPolicyT> 
    115 inline  
    116 ParentPointer<ContainerT>::ParentPointer( 
    117     ReferenceCountPointer<OtherContainerT, 
    118                           OtherRefCountPolicyT> const &refPtr, 
    119     UInt16                                      const  fieldId = 0xFFFF) 
     110template <class ObjectT,      class RootObjectT         > 
     111template <class OtherObjectT, class OtherRefCountPolicyT> 
     112inline  
     113ParentPointer<ObjectT, RootObjectT>::ParentPointer( 
     114    ReferenceCountPointer<OtherObjectT, 
     115                          OtherRefCountPolicyT, 
     116                          RootObjectT          > const &refPtr, 
     117    UInt16                                       const  fieldId = 0xFFFF) 
    120118    : _pointer      (Self::castPtrUp(refPtr.get())), 
    121119      _parentFieldId(fieldId                      ) 
    …… 
    126124/* Destructor                                                              */ 
    127125 
    128 template <class ContainerT> 
    129 inline  
    130 ParentPointer<ContainerT>::~ParentPointer(void) 
     126template <class ObjectT, class RootObjectT> 
     127inline  
     128ParentPointer<ObjectT, RootObjectT>::~ParentPointer(void) 
    131129{ 
    132130} 
    …… 
    135133/* Assignment                                                              */ 
    136134 
    137 template <class ContainerT> 
    138 inline typename ParentPointer<ContainerT>::Self & 
    139 ParentPointer<ContainerT>::operator=(Self const &other) 
     135template <class ObjectT, class RootObjectT> 
     136inline typename ParentPointer<ObjectT, RootObjectT>::Self & 
     137ParentPointer<ObjectT, RootObjectT>::operator=(Self const &other) 
    140138{ 
    141139    _pointer       = other._pointer; 
    …… 
    145143} 
    146144 
    147 template <class ContainerT> 
    148 inline typename ParentPointer<ContainerT>::Self & 
    149 ParentPointer<ContainerT>::operator=( 
    150     ContainerPtrConstArg pContainer) 
     145template <class ObjectT, class RootObjectT> 
     146inline typename ParentPointer<ObjectT, RootObjectT>::Self & 
     147ParentPointer<ObjectT, RootObjectT>::operator=( 
     148    ObjectPtrConstArg pContainer) 
    151149{ 
    152150    _pointer       = Self::castPtrUp(pContainer); 
    …… 
    156154} 
    157155 
    158 template <class ContainerT,      class PointerTypeT     > 
    159 template <class OtherContainerT, class OtherPointerTypeT> 
    160 inline typename ParentPointer<ContainerT>::Self & 
    161 ParentPointer<ContainerT>::operator=( 
    162     ParentPointer<OtherContainerT, 
    163                   OtherPointerTypeT> const &parentPtr) 
     156template <class ObjectT, class RootObjectT> 
     157template <class OtherObjectT> 
     158inline typename ParentPointer<ObjectT, RootObjectT>::Self & 
     159ParentPointer<ObjectT, RootObjectT>::operator=( 
     160    ParentPointer<OtherObjectT, RootObjectT> const &parentPtr) 
    164161{ 
    165162    _pointer       = Self::castPtrUp(parentPtr.get()); 
    …… 
    169166} 
    170167 
    171 template <                       class ContainerT, class PointerTypeT        >     
    172 template <class OtherContainerT, class OtherRefCountPolicyT> 
    173 inline  
    174 ParentPointer<ContainerT>::operator=( 
    175     ReferenceCountPointer<OtherContainerT, 
    176                           OtherRefCountPolicyT> const &refPtr) 
     168template <class ObjectT,      class RootObjectT         > 
     169template <class OtherObjectT, class OtherRefCountPolicyT> 
     170inline  
     171ParentPointer<ObjectT, RootObjectT>::operator=( 
     172    ReferenceCountPointer<OtherObjectT, 
     173                          OtherRefCountPolicyT, 
     174                          RootObjectT          > const &refPtr) 
    177175{ 
    178176    _pointer       = Self::castPtrUp(refPtr.get()); 
    …… 
    185183/* Conversion                                                              */ 
    186184 
    187 template <class ContainerT> 
    188 inline  
    189 ParentPointer<ContainerT>::operator ContainerPtr(void) const 
     185template <class ObjectT, class RootObjectT> 
     186inline  
     187ParentPointer<ObjectT, RootObjectT>::operator ObjectPtr(void) const 
    190188{ 
    191189    return Self::castPtrDown(_pointer.get()); 
    …… 
    195193/* Access                                                                  */ 
    196194 
    197 template <class ContainerT> 
    198 inline typename ParentPoiner<ContainerT>::ContainerPtr 
    199 ParentPointer<ContainerT>::operator->(void) const 
     195template <class ObjectT, class RootObjectT> 
     196inline typename ParentPoiner<ObjectT, RootObjectT>::ObjectPtr 
     197ParentPointer<ObjectT, RootObjectT>::operator->(void) const 
    200198{ 
    201199    return Self::castPtrDown(_pointer.get()); 
    202200} 
    203201 
    204 template <class ContainerT> 
    205 inline typename ParentPoiner<ContainerT>::Container & 
    206 ParentPointer<ContainerT>::operator*(void) const 
     202template <class ObjectT, class RootObjectT> 
     203inline typename ParentPoiner<ObjectT, RootObjectT>::Object & 
     204ParentPointer<ObjectT, RootObjectT>::operator*(void) const 
    207205{ 
    208206    return *(Self::castPtrDown(_pointer.get())); 
    209207} 
    210208 
    211 template <class ContainerT> 
    212 inline typename ParentPoiner<ContainerT>::ContainerPtr 
    213 ParentPointer<ContainerT>::get(void) const 
     209template <class ObjectT, class RootObjectT> 
     210inline typename ParentPoiner<ObjectT, RootObjectT>::ObjectPtr 
     211ParentPointer<ObjectT, RootObjectT>::get(void) const 
    214212{ 
    215213    return Self::castPtrDown(_pointer.get()); 
    216214} 
    217215 
    218 template <class ContainerT> 
     216template <class ObjectT, class RootObjectT> 
    219217inline void 
    220 ParentPointer<ContainerT>::set( 
    221     ContainerPtrConstArg  pContainer) 
     218ParentPointer<ObjectT, RootObjectT>::set( 
     219    ObjectPtrConstArg  pContainer) 
    222220{ 
    223221    _pointer = Self::castPtrUp(pContainer); 
    224222} 
    225223     
    226 template <class ContainerT> 
     224template <class ObjectT, class RootObjectT> 
    227225inline UInt16 
    228 ParentPointer<ContainerT>::getFieldId(void) const 
     226ParentPointer<ObjectT, RootObjectT>::getFieldId(void) const 
    229227{ 
    230228    return _parentFieldId; 
    231229} 
    232230 
    233 template <class ContainerT> 
     231template <class ObjectT, class RootObjectT> 
    234232inline void 
    235 ParentPointer<ContainerT>::setFieldId(UInt16 const  fieldId) 
     233ParentPointer<ObjectT, RootObjectT>::setFieldId(UInt16 const  fieldId) 
    236234{ 
    237235    _parentFieldId = fieldId; 
    238236} 
    239237     
    240 template <class ContainerT> 
     238template <class ObjectT, class RootObjectT> 
    241239inline void 
    242 ParentPointer<ContainerT>::swap(Self &other) 
     240ParentPointer<ObjectT, RootObjectT>::swap(Self &other) 
    243241{ 
    244242    _pointer.swap(other._pointer);