Show
Ignore:
Timestamp:
04/02/08 14:18:07 (8 months ago)
Author:
cneumann
Message:

replaced pointer field implementation
split FieldContainer/Fields? directory into Base and Handle subdir

Status: - ref counting seems to work (mt, cluster)

  • new OSB loader works (well, the unittest does)
  • VRML loader is deactivated
  • get/edit handle for dynamic (pointer) fields missing
  • need to remove some more old files - they get moved in this commit
  • generated (i.e. base) code in following commit
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/Carsten_PtrWork2/Source/Base/Field/OSGFieldTraits.inl

    r1033 r1072  
    3939OSG_BEGIN_NAMESPACE 
    4040 
    41 template <class DescT,  
    42           enum FieldType::Cardinality FieldCardE> inline 
    43 FieldDescription<DescT, 
    44                  FieldCardE>::FieldDescription( 
     41/*-------------------------------------------------------------------------*/ 
     42/* Constructors                                                            */ 
     43 
     44template <class DescTypeT, 
     45          enum  FieldType::Cardinality FieldCardE, 
     46          enum  FieldType::Class       FieldClassE> 
     47inline 
     48    FieldDescription<DescTypeT, 
     49                     FieldCardE, 
     50                     FieldClassE>::FieldDescription( 
    4551    const FieldType       &elementType, 
    4652    const Char8           *szName, 
    …… 
    6369              fGetMethod   ) 
    6470{ 
    65 } 
    66  
    67 template <class DescT,  
    68           enum FieldType::Cardinality FieldCardE> inline 
    69 FieldDescription<DescT, 
    70                  FieldCardE>::FieldDescription( 
     71    // nothing to do 
     72} 
     73 
     74template <class DescTypeT, 
     75          enum  FieldType::Cardinality FieldCardE, 
     76          enum  FieldType::Class       FieldClassE> 
     77inline 
     78    FieldDescription<DescTypeT, 
     79                     FieldCardE, 
     80                     FieldClassE>::FieldDescription( 
    7181    const FieldType            &elementType, 
    7282    const Char8                *szName, 
    …… 
    8999              fIndexedGetMethod  ) 
    90100{ 
    91 } 
    92  
    93 template <class DescT,  
    94           enum FieldType::Cardinality FieldCardE> inline 
    95 FieldDescription<DescT, 
    96                  FieldCardE>::FieldDescription( 
     101    // nothing to do 
     102} 
     103 
     104template <class DescTypeT, 
     105          enum  FieldType::Cardinality FieldCardE, 
     106          enum  FieldType::Class       FieldClassE> 
     107inline 
     108    FieldDescription<DescTypeT, 
     109                     FieldCardE, 
     110                     FieldClassE>::FieldDescription( 
    97111    const FieldDescription &source) : 
    98112 
    99113    Inherited(source) 
    100114{ 
    101 } 
    102  
    103 template <class DescT,  
    104           enum FieldType::Cardinality FieldCardE> inline 
    105 FieldDescription<DescT, 
    106                  FieldCardE>::~FieldDescription(void) 
    107 { 
    108 } 
    109  
    110 template <class DescT,  
    111           enum FieldType::Cardinality FieldCardE> inline 
    112 typename FieldDescription<DescT, 
    113                           FieldCardE>::HandledField const * 
    114     FieldDescription<DescT, 
    115                      FieldCardE>::dcast_const(const Field *pField) const 
    116 { 
    117     return static_cast<const HandledField *>(pField); 
    118 } 
    119  
    120 template <class DescT,  
    121           enum FieldType::Cardinality FieldCardE> inline 
    122 typename FieldDescription<DescT, 
    123                           FieldCardE>::HandledField * 
    124     FieldDescription<DescT, 
    125                      FieldCardE>::dcast(Field *pField) const 
    126 { 
    127     return static_cast<HandledField *>(pField); 
    128 } 
    129  
    130 template <class DescT,  
    131           enum FieldType::Cardinality FieldCardE> inline 
    132 Field *FieldDescription<DescT, 
    133                         FieldCardE>::createField(FieldContainer *) const 
    134 { 
    135     return new HandledField(); 
    136 } 
    137  
    138 template <class DescT,  
    139           enum FieldType::Cardinality FieldCardE> inline 
    140 void FieldDescription<DescT, 
    141                       FieldCardE>::destroyField(Field *pField) const 
    142 { 
    143     HandledField *pDelField = dcast(pField); 
     115    // nothing to do 
     116} 
     117 
     118/*-------------------------------------------------------------------------*/ 
     119/* Destructor                                                              */ 
     120 
     121template <class DescTypeT, 
     122          enum  FieldType::Cardinality FieldCardE, 
     123          enum  FieldType::Class       FieldClassE> 
     124inline 
     125    FieldDescription<DescTypeT, 
     126                     FieldCardE, 
     127                     FieldClassE>::~FieldDescription(void) 
     128{ 
     129    // nothing to do 
     130} 
     131 
     132/*-------------------------------------------------------------------------*/ 
     133/* Class specific                                                          */ 
     134 
     135template <class DescTypeT, 
     136          enum  FieldType::Cardinality FieldCardE, 
     137          enum  FieldType::Class       FieldClassE> 
     138inline typename FieldDescription<DescTypeT, 
     139                                 FieldCardE, 
     140                                 FieldClassE>::HandledFieldType const * 
     141    FieldDescription<DescTypeT, 
     142                     FieldCardE, 
     143                     FieldClassE>::dcast_const(const Field *pField) const 
     144{ 
     145    return static_cast<const HandledFieldType *>(pField); 
     146} 
     147 
     148template <class DescTypeT, 
     149          enum  FieldType::Cardinality FieldCardE, 
     150          enum  FieldType::Class       FieldClassE> 
     151inline typename FieldDescription<DescTypeT, 
     152                                 FieldCardE, 
     153                                 FieldClassE>::HandledFieldType * 
     154    FieldDescription<DescTypeT, 
     155                     FieldCardE, 
     156                     FieldClassE>::dcast(Field *pField) const 
     157{ 
     158    return static_cast<HandledFieldType *>(pField); 
     159} 
     160 
     161template <class DescTypeT, 
     162          enum  FieldType::Cardinality FieldCardE, 
     163          enum  FieldType::Class       FieldClassE> 
     164inline Field * 
     165    FieldDescription<DescTypeT, 
     166                     FieldCardE, 
     167                     FieldClassE>::createField(FieldContainerPtr) const 
     168{ 
     169    return new HandledFieldType(); 
     170} 
     171 
     172template <class DescTypeT, 
     173          enum  FieldType::Cardinality FieldCardE, 
     174          enum  FieldType::Class       FieldClassE> 
     175inline void 
     176    FieldDescription<DescTypeT, 
     177                     FieldCardE, 
     178                     FieldClassE>::destroyField(Field *pField) const 
     179{ 
     180    HandledFieldType *pDelField = dcast(pField); 
    144181 
    145182    delete pDelField; 
    146183} 
    147184 
    148 template <class DescT,  
    149           enum FieldType::Cardinality FieldCardE> inline 
    150 FieldDescriptionBase *FieldDescription<DescT, 
    151                                        FieldCardE>::clone(void) const 
     185template <class DescTypeT, 
     186          enum  FieldType::Cardinality FieldCardE, 
     187          enum  FieldType::Class       FieldClassE> 
     188inline FieldDescriptionBase * 
     189    FieldDescription<DescTypeT, 
     190                     FieldCardE, 
     191                     FieldClassE>::clone(void) const 
    152192{ 
    153193    return new Self(*this); 
    154194} 
    155195 
    156 template <class DescT,  
    157           enum FieldType::Cardinality FieldCardE> 
     196template <class DescTypeT, 
     197          enum  FieldType::Cardinality FieldCardE, 
     198          enum  FieldType::Class       FieldClassE> 
    158199inline GetFieldHandlePtr  
    159 FieldDescription<DescT, 
    160                  FieldCardE>::createGetHandler(Field const *pField) const 
    161 { 
    162     HandledField const *pTypedField = dcast_const(pField); 
     200    FieldDescription<DescTypeT, 
     201                     FieldCardE, 
     202                     FieldClassE>::createGetHandler(Field const *pField) const 
     203{ 
     204    HandledFieldType const *pTypedField = dcast_const(pField); 
    163205     
    164206    GetHandlePtr retVal(new GetHandle(pTypedField, this)); 
    …… 
    167209} 
    168210 
    169 template <class DescT,  
    170           enum FieldType::Cardinality FieldCardE> inline 
    171 EditFieldHandlePtr  
    172     FieldDescription<DescT, 
    173                      FieldCardE>::createEditHandler(Field *pField) const 
    174 { 
    175     HandledField *pTypedField = dcast(pField); 
     211template <class DescTypeT, 
     212          enum  FieldType::Cardinality FieldCardE, 
     213          enum  FieldType::Class       FieldClassE> 
     214inline EditFieldHandlePtr 
     215    FieldDescription<DescTypeT, 
     216                     FieldCardE, 
     217                     FieldClassE>::createEditHandler(Field *pField) const 
     218{ 
     219    HandledFieldType *pTypedField = dcast(pField); 
    176220     
    177221    EditHandlePtr retVal(new EditHandle(pTypedField, this)); 
    …… 
    180224} 
    181225 
    182 template <class DescT,  
    183           enum FieldType::Cardinality FieldCardE> 
     226template <class DescTypeT, 
     227          enum  FieldType::Cardinality FieldCardE, 
     228          enum  FieldType::Class       FieldClassE> 
    184229inline GetFieldHandlePtr  
    185 FieldDescription<DescT, 
    186                  FieldCardE>::createDynamicGetHandler(Field const *pField) const 
    187 { 
    188     HandledField const *pTypedField = dcast_const(pField); 
     230    FieldDescription<DescTypeT, 
     231                     FieldCardE, 
     232                     FieldClassE>::createDynamicGetHandler( 
     233        Field const *pField) const 
     234{ 
     235    HandledFieldType const *pTypedField = dcast_const(pField); 
    189236     
    190237    GetHandlePtr retVal(new DynamicGetHandle(pTypedField, this)); 
    …… 
    193240} 
    194241 
    195 template <class DescT,  
    196           enum FieldType::Cardinality FieldCardE> inline 
    197 EditFieldHandlePtr  
    198     FieldDescription<DescT, 
    199                      FieldCardE>::createDynamicEditHandler(Field *pField) const 
    200 { 
    201     HandledField *pTypedField = dcast(pField); 
     242template <class DescTypeT, 
     243          enum  FieldType::Cardinality FieldCardE, 
     244          enum  FieldType::Class       FieldClassE> 
     245inline EditFieldHandlePtr  
     246    FieldDescription<DescTypeT, 
     247                     FieldCardE, 
     248                     FieldClassE>::createDynamicEditHandler(Field *pField) const 
     249{ 
     250    HandledFieldType *pTypedField = dcast(pField); 
    202251     
    203252    EditHandlePtr retVal(new DynamicEditHandle(pTypedField, this)); 
    …… 
    206255} 
    207256 
    208 template <class DescT,  
    209           enum FieldType::Cardinality FieldCardE> inline 
    210 void FieldDescription<DescT, 
    211                       FieldCardE>::beginEdit(Field              *pField, 
     257template <class DescTypeT, 
     258          enum  FieldType::Cardinality FieldCardE, 
     259          enum  FieldType::Class       FieldClassE> 
     260inline void 
     261    FieldDescription<DescTypeT, 
     262                     FieldCardE, 
     263                     FieldClassE>::beginEdit(Field              *pField, 
    212264                                             UInt32              uiAspect, 
    213265                                             AspectOffsetStore  &oOffsets) 
    214266{ 
    215     HandledField *pTypedField = dcast(pField); 
     267    HandledFieldType *pTypedField = dcast(pField); 
    216268     
    217269    FieldFunctions::beginEdit(pTypedField, uiAspect, oOffsets); 
    218270} 
    219271 
    220 template <class DescT,  
    221           enum FieldType::Cardinality FieldCardE> inline 
    222 bool FieldDescription<DescT, 
    223                       FieldCardE>::isShared(Field *pField) 
    224 { 
    225     HandledField *pTypedField = dcast(pField); 
     272template <class DescTypeT, 
     273          enum  FieldType::Cardinality FieldCardE, 
     274          enum  FieldType::Class       FieldClassE> 
     275inline bool 
     276    FieldDescription<DescTypeT, 
     277                     FieldCardE, 
     278                     FieldClassE>::isShared(Field *pField) 
     279{ 
     280    HandledFieldType *pTypedField = dcast(pField); 
    226281     
    227282    return FieldFunctions::isShared(pTypedField);