Changeset 1148

Show
Ignore:
Timestamp:
04/10/08 21:21:08 (1 month ago)
Author:
vossg
Message:

changed: sfield cleanup

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/Source/System/FieldContainer/Fields/Handle/OSGFieldContainerSFieldHandle.h

    r1131 r1148  
    204204    /*==========================  PUBLIC  =================================*/ 
    205205 
    206     typedef boost::function<void (typename FieldT::const_reference)> SetMethod; 
     206    typedef boost::function<void (typename FieldT::const_value)> SetMethod; 
    207207 
    208208    SetMethod _fSetMethod; 

  • trunk/Source/System/FieldContainer/Fields/Handle/OSGFieldContainerSFieldHandle.inl

    r1131 r1148  
    339339void EditFCPtrSFieldHandle<FieldT>::setValue(FieldContainerPtrConstArg rhs) 
    340340{ 
    341     typename FieldT::const_reference pVal =  
    342         dynamic_cast<typename FieldT::const_reference>(rhs); 
     341    typename FieldT::const_value pVal =  
     342        dynamic_cast<typename FieldT::const_value>(rhs); 
    343343 
    344344    if(rhs != NULL && pVal == NULL) 

  • trunk/Source/System/FieldContainer/Fields/PointerFields/OSGChildAccessHandler.h

    r1143 r1148  
    6262class ChildPointerMFieldBase; 
    6363 
    64 template <Int32 NamespaceI> 
     64template <typename AccessHandlerT, Int32 NamespaceI> 
    6565class ChildPointerSFieldBase; 
    6666 
    …… 
    8484     
    8585    typedef ChildPointerMFieldBase <0> MFieldType; 
    86     typedef ChildPointerSFieldBase <0> SFieldType; 
     86    typedef ChildPointerSFieldBase <Self, 0> SFieldType; 
    8787     
    8888    /*! \}                                                                 */ 

  • trunk/Source/System/FieldContainer/Fields/PointerFields/OSGChildAccessHandler.inl

    r1143 r1148  
    109109                   dcastSField(pSField)->getChildFieldId   (), 
    110110                   pObj, 
    111                    dcastSField(pSField)->getParentFieldId () ); 
     111                   dcastSField(pSField)->getParentFieldPos () ); 
    112112    } 
    113113} 
    …… 
    125125                   dcastMField(pMField)->getChildFieldId   (), 
    126126                   pObj, 
    127                    dcastMField(pMField)->getParentFieldId () ); 
     127                   dcastMField(pMField)->getParentFieldPos () ); 
    128128    } 
    129129} 
    …… 
    138138        unlinkParent(dcastSField(pSField)->getEnclosingObject(), 
    139139                     pObj, 
    140                      dcastSField(pSField)->getParentFieldId() ); 
     140                     dcastSField(pSField)->getParentFieldPos() ); 
    141141 
    142142        RefCountPolicyType::subRef(pObj/*, false*/); 
    …… 
    153153        unlinkParent(dcastMField(pMField)->getEnclosingObject(), 
    154154                     pObj, 
    155                      dcastMField(pMField)->getParentFieldId() ); 
     155                     dcastMField(pMField)->getParentFieldPos() ); 
    156156 
    157157        RefCountPolicyType::subRef(pObj/*, false*/); 
    …… 
    171171        unlinkParent(dcastSField(pSField)->getEnclosingObject(), 
    172172                     pOldObj, 
    173                      dcastSField(pSField)->getParentFieldId() ); 
     173                     dcastSField(pSField)->getParentFieldPos()); 
    174174 
    175175        RefCountPolicyType::subRef(pOldObj/*, false*/); 
    …… 
    181181                   dcastSField(pSField)->getChildFieldId   (), 
    182182                   pNewObj, 
    183                    dcastSField(pSField)->getParentFieldId ()); 
     183                   dcastSField(pSField)->getParentFieldPos ()); 
    184184    } 
    185185} 
    …… 
    197197        unlinkParent(dcastMField(pMField)->getEnclosingObject(), 
    198198                     pOldObj, 
    199                      dcastMField(pMField)->getParentFieldId() ); 
     199                     dcastMField(pMField)->getParentFieldPos() ); 
    200200 
    201201        RefCountPolicyType::subRef(pOldObj/*, false*/); 
    …… 
    207207                   dcastMField(pMField)->getChildFieldId   (), 
    208208                   pNewObj, 
    209                    dcastMField(pMField)->getParentFieldId ()); 
     209                   dcastMField(pMField)->getParentFieldPos ()); 
    210210    } 
    211211} 
    …… 
    253253{ 
    254254    onSyncAdd(pSField, pNewObj); 
    255     onSyncSub(pSField, pOldObj); 
     255 
     256    if(pOldObj != NullFC) 
     257    { 
     258        Thread::getCurrentChangeList()->addDelayedSubRef< 
     259            RefCountPolicyT>(pOldObj); 
     260    } 
     261 
     262//    onSyncSub(pSField, pOldObj); 
    256263} 
    257264 
    …… 
    263270{ 
    264271    onSyncAdd(pMField, pNewObj); 
    265     onSyncSub(pMField, pOldObj); 
     272 
     273    if(pOldObj != NullFC) 
     274    { 
     275        Thread::getCurrentChangeList()->addDelayedSubRef< 
     276            RefCountPolicyT>(pOldObj); 
     277    } 
     278 
     279//    onSyncSub(pMField, pOldObj); 
    266280} 
    267281 

  • trunk/Source/System/FieldContainer/Fields/PointerFields/OSGChildPointerMFieldBase.h

    r1143 r1148  
    6262    void   setChildFieldId (UInt16 const childFieldId ); 
    6363     
    64     UInt16 getParentFieldId(void                      ) const; 
     64    UInt16 getParentFieldPos(void                      ) const; 
    6565    void   setParentFieldId(UInt16 const parentFieldId); 
    6666     

  • trunk/Source/System/FieldContainer/Fields/PointerFields/OSGChildPointerMFieldBase.inl

    r1122 r1148  
    8989template <Int32 NamespaceI> 
    9090inline UInt16 
    91     ChildPointerMFieldBase<NamespaceI>::getParentFieldId(void) const 
     91    ChildPointerMFieldBase<NamespaceI>::getParentFieldPos(void) const 
    9292{ 
    9393    return _parentFieldId; 

  • trunk/Source/System/FieldContainer/Fields/PointerFields/OSGChildPointerSField.h

    r1147 r1148  
    5858/*---------------------------------------------------------------------------*/ 
    5959 
    60 template <class ObjectTypeT, 
    61           Int32 NamespaceI  = 0> 
    62 class ChildPointerSField : public ChildPointerSFieldBase<NamespaceI> 
     60template <class    ObjectTypeT, 
     61          typename RefCountPolicy, 
     62          Int32    NamespaceI  = 0> 
     63class ChildPointerSField :  
     64    public ChildPointerSFieldBase<ChildAccessHandler<RefCountPolicy>, 
     65                                  NamespaceI                       > 
    6366{ 
    6467 
    …… 
    7174    /*! \{                                                                 */ 
    7275     
    73     typedef ObjectTypeT                              ObjectType; 
     76    typedef ChildPointerSFieldBase< 
     77                ChildAccessHandler<RefCountPolicy>, 
     78                NamespaceI                        >          Inherited; 
    7479     
    75     typedef ChildPointerSFieldBase<NamespaceI >      Inherited; 
    76     typedef ChildPointerSField    <ObjectType, 
    77                                    NamespaceI >      Self; 
     80    typedef ChildPointerSField                               Self; 
    7881                                    
     82    typedef ObjectTypeT *                                    value_type; 
     83    typedef ObjectTypeT * const                              const_value; 
     84          
     85    typedef value_type                                       StoredType; 
    7986     
    80     typedef ObjectTypeT * ValueType; 
    81     typedef ObjectTypeT * const ArgumentType; 
    82     typedef ObjectTypeT * value_type; 
     87    typedef FieldTraits           <value_type, 
     88                                   NamespaceI              > SFieldTraits; 
    8389 
    84         
    85     typedef ValueType *pointer; 
    86     typedef ArgumentType *const_pointer; 
     90    typedef FieldDescription      <SFieldTraits, 
     91                                   FieldType::SingleField, 
     92                                   UnrecordedRefCountPolicy, 
     93                                   FieldType::ChildPtrField> Description; 
    8794 
    88     typedef ValueType const                             &const_reference;  
    89      
    90     typedef typename Inherited::StoredType           StoredType; 
    91      
    92     typedef FieldTraits     <ValueType, 
    93                              NamespaceI                    >  SFieldTraits; 
     95    typedef typename SFieldTraits::ParentType                ParentT; 
    9496 
    95     typedef FieldDescription<SFieldTraits, 
    96                              FieldType::SingleField, 
    97                              UnrecordedRefCountPolicy, 
    98                              FieldType::ChildPtrField>  Description; 
    99   protected: 
     97    typedef ObjectTypeT                                      ObjectType; 
    10098 
    10199    /*! \}                                                                 */ 
    …… 
    118116    /*! \name Constructors                                                 */ 
    119117    /*! \{                                                                 */ 
    120      
    121              ChildPointerSField(void              ); 
    122              ChildPointerSField(Self const &source); 
    123     explicit ChildPointerSField(ValueType   value ); 
    124      
     118 
     119    ChildPointerSField(ParentT     pParent, 
     120                       UInt16      usParentFieldPos);  
     121 
     122    ChildPointerSField(const_value value, 
     123                       ParentT     pParent, 
     124                       UInt16      usParentFieldPos);  
     125 
    125126    /*! \}                                                                 */ 
    126127    /*---------------------------------------------------------------------*/ 
    …… 
    135136    /*! \{                                                                 */ 
    136137     
    137     const_reference getValue (void           ) const; 
     138    const_value getValue (      void               ) const; 
    138139     
    139     void            setValue (ValueType   value ); 
    140     void            setValue (Self const &source); 
     140    void        setValue (      const_value  value ); 
     141    void        setValue (const Self        &source); 
    141142     
     143    /*! \}                                                                 */ 
     144    /*---------------------------------------------------------------------*/ 
     145    /*! \name Binary IO                                                    */ 
     146    /*! \{                                                                 */ 
     147 
     148    void copyFromBin(BinaryDataHandler &pMem); 
     149 
     150    /*! \}                                                                 */ 
     151    /*---------------------------------------------------------------------*/ 
     152    /*! \name MT Sync                                                      */ 
     153    /*! \{                                                                 */ 
     154 
     155#ifdef OSG_MT_CPTR_ASPECT 
     156    void syncWith(Self &source); 
     157#endif 
     158 
    142159    /*! \}                                                                 */ 
    143160    /*---------------------------------------------------------------------*/ 
    144161    /*! \name Assignment                                                   */ 
    145162    /*! \{                                                                 */ 
    146  
    147     void operator = (Self const &source); 
    148      
     163    
    149164    /*! \}                                                                 */ 
    150165    /*=========================  PROTECTED  ===============================*/ 
    …… 
    163178  private: 
    164179 
     180    /*!\brief prohibit default function (move to 'public' if needed) */ 
     181    ChildPointerSField(const Self &source); 
     182    /*!\brief prohibit default function (move to 'public' if needed) */ 
     183    void operator = (const Self &source); 
    165184}; 
    166185 

  • trunk/Source/System/FieldContainer/Fields/PointerFields/OSGChildPointerSField.inl

    r1147 r1148  
    5353/* Class Type                                                              */ 
    5454 
    55 template <class ObjectTypeT, Int32 NamespaceI> inline  
     55template <class ObjectTypeT, typename RefCountPolicy, Int32 NamespaceI> inline  
    5656FieldType const &ChildPointerSField<ObjectTypeT, 
    57                                     NamespaceI >::getClassType(void) 
     57                                    RefCountPolicy, 
     58                                    NamespaceI    >::getClassType(void) 
    5859{ 
    5960    return _fieldType; 
    …… 
    6364/* Constructors                                                            */ 
    6465 
    65 template <class ObjectTypeT, Int32 NamespaceI> inline 
     66template <class ObjectTypeT, typename RefCountPolicy, Int32 NamespaceI> inline 
    6667ChildPointerSField<ObjectTypeT, 
    67                    NamespaceI >::ChildPointerSField(void) :  
    68     Inherited() 
     68                   RefCountPolicy, 
     69                   NamespaceI    >::ChildPointerSField( 
     70                       ParentT pParent, 
     71                       UInt16  usParentFieldPos) :  
     72    Inherited(pParent,  
     73              usParentFieldPos) 
    6974{ 
    70     // nothing to do 
    7175} 
    7276 
    73 template <class ObjectTypeT, Int32 NamespaceI> inline 
     77template <class ObjectTypeT, typename RefCountPolicy, Int32 NamespaceI> inline 
    7478ChildPointerSField<ObjectTypeT, 
    75                    NamespaceI >::ChildPointerSField(Self const &source) : 
    76     Inherited(source) 
     79                   RefCountPolicy, 
     80                   NamespaceI    >::ChildPointerSField( 
     81                       const_value value, 
     82                       ParentT     pParent, 
     83                       UInt16      usParentFieldPos) : 
     84    Inherited(value, 
     85              pParent, 
     86              usParentFieldPos) 
    7787{ 
    78     // nothing to do 
    79 } 
    80  
    81 template <class ObjectTypeT, Int32 NamespaceI> inline 
    82 ChildPointerSField<ObjectTypeT, 
    83                    NamespaceI >::ChildPointerSField(ValueType value) : 
    84     Inherited(value) 
    85 { 
    86     // nothing to do 
    8788} 
    8889 
    …… 
    9091/* Destructor                                                              */ 
    9192 
    92 template <class ObjectTypeT, Int32 NamespaceI> inline 
     93template <class ObjectTypeT, typename RefCountPolicy, Int32 NamespaceI> inline 
    9394ChildPointerSField<ObjectTypeT, 
    94                    NamespaceI >::~ChildPointerSField(void) 
     95                   RefCountPolicy, 
     96                   NamespaceI    >::~ChildPointerSField(void) 
    9597{ 
    9698} 
    …… 
    99101/* Access                                                                  */ 
    100102 
    101 template <class ObjectTypeT, Int32 NamespaceI> inline  
     103template <class ObjectTypeT, typename RefCountPolicy, Int32 NamespaceI> inline  
    102104typename ChildPointerSField<ObjectTypeT, 
    103                             NamespaceI >::const_reference 
     105                            RefCountPolicy, 
     106                            NamespaceI    >::const_value 
    104107    ChildPointerSField<ObjectTypeT, 
    105                        NamespaceI >::getValue(void) const 
     108                       RefCountPolicy, 
     109                       NamespaceI    >::getValue(void) const 
    106110{ 
    107     return reinterpret_cast<const_reference>(this->getRawStore()); 
     111    return static_cast<const_value>(this->ptrStoreGet()); 
    108112} 
    109113 
    110 template <class ObjectTypeT, Int32 NamespaceI> inline  
     114template <class ObjectTypeT, typename RefCountPolicy, Int32 NamespaceI> inline  
    111115void ChildPointerSField<ObjectTypeT, 
    112                         NamespaceI >::setValue(ValueType value) 
     116                        RefCountPolicy, 
     117                        NamespaceI    >::setValue(const_value value) 
    113118{ 
    114119    this->ptrStoreSet(value); 
    115120} 
    116121 
    117 template <class ObjectTypeT, Int32 NamespaceI> inline  
     122template <class ObjectTypeT, typename RefCountPolicy, Int32 NamespaceI> inline  
    118123void ChildPointerSField<ObjectTypeT, 
    119                         NamespaceI >::setValue(Self const &source) 
     124                        RefCountPolicy, 
     125                        NamespaceI    >::setValue(const Self &source) 
    120126{ 
    121127    this->ptrStoreSet(source.ptrStoreGet()); 
    122128} 
     129 
     130template <class    ObjectTypeT,  
     131          typename RefCountPolicy, 
     132          Int32    NamespaceI    > inline  
     133void ChildPointerSField<ObjectTypeT, 
     134                        RefCountPolicy, 
     135                        NamespaceI    >::copyFromBin(BinaryDataHandler &pMem) 
     136{ 
     137    Inherited::copyFromBin(pMem); 
     138} 
     139 
     140#ifdef OSG_MT_CPTR_ASPECT 
     141template <class    ObjectTypeT,  
     142          typename RefCountPolicy, 
     143          Int32    NamespaceI    > inline  
     144void ChildPointerSField<ObjectTypeT, 
     145                        RefCountPolicy, 
     146                        NamespaceI    >::syncWith(Self &source) 
     147{ 
     148    Inherited::syncWith(source); 
     149} 
     150#endif 
    123151 
    124152/*-------------------------------------------------------------------------*/ 
    …… 
    135163/* Assignment                                                              */ 
    136164 
    137 template <class ObjectTypeT, Int32 NamespaceI> inline  
    138 void ChildPointerSField<ObjectTypeT, 
    139                         NamespaceI >::operator =(Self const &other) 
    140 {    
    141     this->ptrStoreSet(other.ptrStoreGet()); 
    142 } 
    143  
    144165OSG_END_NAMESPACE 

  • trunk/Source/System/FieldContainer/Fields/PointerFields/OSGChildPointerSFieldBase.h

    r1143 r1148  
    2121 
    2222 
    23 template <Int32 NamespaceI = 0> 
     23template <typename AccessHandlerT, 
     24          Int32    NamespaceI = 0> 
    2425class ChildPointerSFieldBase  
    25     : public PointerSFieldCommon<UnrecChildAccessHandler, NamespaceI> 
     26    : public PointerSFieldCommon<AccessHandlerT, NamespaceI> 
    2627{ 
    2728    /*==========================  PUBLIC  =================================*/ 
     29 
    2830  public: 
     31 
    2932    /*---------------------------------------------------------------------*/ 
    3033    /*! \name Public Types                                                 */ 
    3134    /*! \{                                                                 */ 
    3235        
    33     typedef PointerSFieldCommon<UnrecChildAccessHandler, 
    34                                 NamespaceI             > Inherited; 
    35     typedef ChildPointerSFieldBase                   Self; 
     36    typedef PointerSFieldCommon   <AccessHandlerT, 
     37                                   NamespaceI    > Inherited; 
     38    typedef ChildPointerSFieldBase                 Self; 
    3639     
     40    typedef const FieldContainerPtr                const_value; 
     41 
    3742    /*! \}                                                                 */ 
     43    /*=========================  PROTECTED  ===============================*/ 
     44 
     45  protected: 
     46 
    3847    /*---------------------------------------------------------------------*/ 
    3948    /*! \name Constructors                                                 */ 
    4049    /*! \{                                                                 */ 
    4150     
    42              ChildPointerSFieldBase(void                          ); 
    43              ChildPointerSFieldBase(Self const             &source); 
    44     explicit ChildPointerSFieldBase(FieldContainerPtrConst  value ); 
     51    ChildPointerSFieldBase(const FieldContainerPtr  pParent, 
     52                                 UInt16             usParentFieldPos); 
     53 
     54    ChildPointerSFieldBase(      const_value        value, 
     55                           const FieldContainerPtr  pParent, 
     56                                 UInt16             usParentFieldPos); 
    4557     
    4658    /*! \}                                                                 */ 
    …… 
    5668    /*! \{                                                                 */ 
    5769     
    58     FieldContainerPtr getEnclosingObject(void                       ) const; 
    59     void              setEnclosingObject(FieldContainerPtrConst pObj); 
     70    FieldContainerPtr getEnclosingObject(      void                   ) const; 
     71    void              setEnclosingObject(const FieldContainerPtr pObj ); 
    6072     
    61     UInt16 getChildFieldId (void                      ) const; 
    62     void   setChildFieldId (UInt16 const childFieldId ); 
     73    UInt16            getChildFieldId   (      void                   ) const; 
     74    void              setChildFieldId   (const UInt16 childFieldId    ); 
    6375     
    64     UInt16 getParentFieldId(void                      ) const; 
    65     void   setParentFieldId(UInt16 const parentFieldId); 
    66      
     76    UInt16            getParentFieldPos (      void                   ) const; 
     77    void              setParentFieldPos (const UInt16 usParentFieldPos); 
     78 
    6779    /*! \}                                                                 */ 
    68     /*=========================  PROTECTED  ===============================*/ 
    69   protected: 
    7080    /*---------------------------------------------------------------------*/ 
    7181    /*! \name Members                                                      */ 
    …… 
    7484    FieldContainerPtr _pEnclosingObj; 
    7585    UInt16            _childFieldId; 
    76     UInt16            _parentFieldId; 
     86    UInt16            _usParentFieldPos; 
    7787   
    7888    /*! \}                                                                 */ 
    7989    /*==========================  PRIVATE  ================================*/ 
    8090  private:  
     91 
     92    template<typename RefCountPolicyT> 
     93    friend class ChildAccessHandler; 
     94 
     95    /*!\brief prohibit default function (move to 'public' if needed) */ 
     96    ChildPointerSFieldBase(const Self &source); 
     97    /*!\brief prohibit default function (move to 'public' if needed) */ 
     98    void operator = (const Self &source); 
    8199}; 
    82100 

  • trunk/Source/System/FieldContainer/Fields/PointerFields/OSGChildPointerSFieldBase.inl

    r1122 r1148  
    1111/* Constructors                                                            */ 
    1212 
    13 template <Int32 NamespaceI> 
    14 inline 
    15     ChildPointerSFieldBase<NamespaceI>::ChildPointerSFieldBase(void) 
    16     : Inherited     (    ), 
    17       _pEnclosingObj(NULL), 
    18       _childFieldId (0   ), 
    19       _parentFieldId(0   ) 
     13template <typename AccessHandlerT, Int32 NamespaceI> inline 
     14ChildPointerSFieldBase<AccessHandlerT,  
     15                       NamespaceI>::ChildPointerSFieldBase( 
     16                           const FieldContainerPtr  pParent, 
     17                                 UInt16             usParentFieldPos) : 
     18      Inherited       (                ), 
     19     _pEnclosingObj   (pParent         ), 
     20     _childFieldId    (0xFFFF          ), 
     21     _usParentFieldPos(usParentFieldPos) 
    2022{ 
    2123} 
    2224 
    23 template <Int32 NamespaceI> 
    24 inline 
    25     ChildPointerSFieldBase<NamespaceI>::ChildPointerSFieldBase( 
    26         Self const &source) 
    27     : Inherited     (source               ), 
    28       _pEnclosingObj(source._pEnclosingObj), 
    29       _childFieldId (source._childFieldId ), 
    30       _parentFieldId(source._parentFieldId) 
     25template <typename AccessHandlerT, Int32 NamespaceI> inline 
     26ChildPointerSFieldBase<AccessHandlerT,  
     27                       NamespaceI>::ChildPointerSFieldBase( 
     28                                 const_value        value, 
     29                           const FieldContainerPtr  pParent, 
     30                                 UInt16             usParentFieldPos) :  
     31     Inherited       (                ), 
     32    _pEnclosingObj   (pParent         ), 
     33    _childFieldId    (0xFFFF          ), 
     34    _usParentFieldPos(usParentFieldPos) 
    3135{ 
    32 } 
    33  
    34 template <Int32 NamespaceI> 
    35 inline 
    36     ChildPointerSFieldBase<NamespaceI>::ChildPointerSFieldBase( 
    37         FieldContainerPtrConst value) 
    38     : Inherited     (value), 
    39       _pEnclosingObj(NULL ), 
    40       _childFieldId (0    ), 
    41       _parentFieldId(0    ) 
    42 { 
     36    this->ptrStoreSet(value); 
    4337} 
    4438 
    …… 
    4640/* Destructor                                                              */ 
    4741 
    48 template <Int32 NamespaceI> 
    49 inline 
    50     ChildPointerSFieldBase<NamespaceI>::~ChildPointerSFieldBase(void) 
     42template <typename AccessHandlerT, Int32 NamespaceI> inline 
     43ChildPointerSFieldBase<AccessHandlerT,  
     44                       NamespaceI    >::~ChildPointerSFieldBase(void) 
    5145{ 
    52     // nothing to do 
    5346} 
    5447 
    …… 
    5649/* Child Linking Information                                               */ 
    5750 
    58 template <Int32 NamespaceI> 
    59 inline FieldContainerPtr 
    60     ChildPointerSFieldBase<NamespaceI>::getEnclosingObject(void) const 
     51template <typename AccessHandlerT, Int32 NamespaceI> inline  
     52FieldContainerPtr  
     53    ChildPointerSFieldBase<AccessHandlerT,  
     54                           NamespaceI    >::getEnclosingObject(void) const 
    6155{ 
    6256    return _pEnclosingObj; 
    6357} 
    6458 
    65 template <Int32 NamespaceI> 
    66 inline void 
    67     ChildPointerSFieldBase<NamespaceI>::setEnclosingObject( 
    68         FieldContainerPtrConst pObj) 
     59template <typename AccessHandlerT, Int32 NamespaceI> inline  
     60void ChildPointerSFieldBase<AccessHandlerT, NamespaceI>::setEnclosingObject( 
     61    const FieldContainerPtr pObj) 
    6962{ 
    7063    _pEnclosingObj = pObj; 
    7164} 
    7265 
    73 template <Int32 NamespaceI> 
    74 inline UInt16 
    75     ChildPointerSFieldBase<NamespaceI>::getChildFieldId(void) const 
     66template <typename AccessHandlerT, Int32 NamespaceI> inline  
     67UInt16 ChildPointerSFieldBase<AccessHandlerT,  
     68                              NamespaceI    >::getChildFieldId(void) const 
    7669{ 
    7770    return _childFieldId; 
    7871} 
    7972 
    80 template <Int32 NamespaceI> 
    81 inline void 
    82     ChildPointerSFieldBase<NamespaceI>::setChildFieldId( 
    83         UInt16 const childFieldId) 
     73template <typename AccessHandlerT, Int32 NamespaceI> inline  
     74void ChildPointerSFieldBase<AccessHandlerT,  
     75                            NamespaceI    >::setChildFieldId( 
     76                                const UInt16 childFieldId) 
    8477{ 
    8578    _childFieldId = childFieldId; 
    8679} 
    8780 
    88 template <Int32 NamespaceI> 
    89 inline UInt16 
    90     ChildPointerSFieldBase<NamespaceI>::getParentFieldId(void) const 
     81template <typename AccessHandlerT, Int32 NamespaceI> inline  
     82UInt16 ChildPointerSFieldBase<AccessHandlerT,  
     83                              NamespaceI    >::getParentFieldPos(void) const 
    9184{ 
    92     return _parentFieldId; 
     85    return _usParentFieldPos; 
    9386} 
    9487 
    95 template <Int32 NamespaceI> 
    96 inline void 
    97     ChildPointerSFieldBase<NamespaceI>::setParentFieldId( 
    98         UInt16 const parentFieldId) 
     88template <typename AccessHandlerT, Int32 NamespaceI> inline  
     89void ChildPointerSFieldBase<AccessHandlerT, NamespaceI>::setParentFieldPos( 
     90    const UInt16 usParentFieldPos) 
    9991{ 
    100     _parentFieldId = parentFieldId; 
     92    _usParentFieldPos = usParentFieldPos; 
    10193} 
    10294 

  • trunk/Source/System/FieldContainer/Fields/PointerFields/OSGParentPointerSField.h

    r1147 r1148  
    6060/*---------------------------------------------------------------------------*/ 
    6161 
    62 template <class ObjectTypeT, 
    63           Int32 NamespaceI  = 0> 
     62template <class    ObjectTypeT, 
     63          typename RefCountPolicy, 
     64          Int32    NamespaceI  = 0> 
    6465class ParentPointerSField :  
    65     public PointerSFieldCommon<NoRefCountAccessHandler, NamespaceI> 
     66    public PointerSFieldCommon<PointerAccessHandler<RefCountPolicy>,  
     67                               NamespaceI                          > 
    6668{ 
    6769    /*==========================  PUBLIC  =================================*/ 
    …… 
    7274    /*! \name Public Types                                                 */ 
    7375    /*! \{                                                                 */ 
    74  
    75     typedef          ObjectTypeT                           ObjectType; 
    7676         
    77     typedef          PointerSFieldCommon    <NoRefCountAccessHandler, 
    78                                              NamespaceI  > Inherited; 
    79     typedef          ParentPointerSField    <ObjectTypeT, 
    80                                              NamespaceI  > Self; 
     77    typedef PointerSFieldCommon< 
     78                PointerAccessHandler<RefCountPolicy>,  
     79                NamespaceI                               > Inherited; 
     80 
     81    typedef ParentPointerSField                            Self; 
    8182                                              
    82     typedef ObjectTypeT * ValueType; 
    83     typedef ObjectTypeT * const ArgumentType; 
    84     typedef ObjectTypeT * value_type; 
    85  
    86     typedef ArgumentType *const_pointer; 
    87     typedef ValueType const                             &const_reference;  
    88      
    89     typedef UInt16                                  IdStoredType; 
    90     typedef UInt16                                 &IdStoredTypeRef; 
    91     typedef UInt16 const                           &IdStoredTypeConstRef; 
    92      
    93     typedef FieldTraits<IdStoredType >              IdBaseTraitsType; 
    94      
    95     typedef FieldTraits     <ValueType, 
    96                              NamespaceI                     >  SFieldTraits; 
    97     typedef FieldDescription<SFieldTraits, 
    98                              FieldType::SingleField, 
    99                              NoRefCountPolicy, 
    100                              FieldType::ParentPtrField  >  Description; 
    101   protected: 
     83    typedef ObjectTypeT *                                  value_type; 
     84    typedef ObjectTypeT * const                            const_value; 
     85 
     86     
     87    typedef FieldTraits        <UInt16                   > PosSFieldTraits; 
     88     
     89    typedef FieldTraits        <value_type, 
     90                                NamespaceI               > PtrSFieldTraits; 
     91    typedef PtrSFieldTraits                                SFieldTraits; 
     92 
     93    typedef FieldDescription   <PtrSFieldTraits, 
     94                                FieldType::SingleField, 
     95                                NoRefCountPolicy, 
     96                                FieldType::ParentPtrField> Description; 
     97 
     98    typedef ObjectTypeT                                    ObjectType; 
    10299     
    103100    // handles 
    …… 
    128125    /*! \{                                                                 */ 
    129126 
    130     static FieldType const &getClassType(void); 
     127    static const FieldType &getClassType(void); 
    131128     
    132129    /*! \}                                                                 */ 
    …… 
    135132    /*! \{                                                                 */ 
    136133 
    137     ParentPointerSField(void                          ); 
    138     ParentPointerSField(Self const   &other           ); 
    139     ParentPointerSField(ValueType     ptrValue, 
    140                         IdStoredType  idValue = 0x0000); 
     134    ParentPointerSField(const_value value, 
     135                        UInt16      uiParentFieldPos = 0xFFFF); 
    141136 
    142137    /*! \}                                                                 */ 
    …… 
    149144    /*! \}                                                                 */ 
    150145    /*---------------------------------------------------------------------*/ 
     146    /*! \name Access                                                       */ 
     147    /*! \{                                                                 */ 
     148     
     149    const_value getValue         (void) const; 
     150    UInt16      getParentFieldPos(void) const; 
     151 
     152    /*! \}                                      &nb