Show
Ignore:
Timestamp:
12/12/07 18:00:42 (9 months ago)
Author:
cneumann
Message:

added: generic interface
changed: factory functions return RefPtr?

The unittests don't pass right now, because of the change
to the factory functions, which leads to containers
being immediately destroyed as they are not assigned to
a RefPtr?.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

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

    r1030 r1032  
    4040 
    4141template <class DescT,  
    42           enum FieldCardinality FieldCardE, 
    43           enum FieldCategory    FieldCatE  > inline 
    44 FieldDescription<DescT, 
    45                  FieldCardE, 
    46                  FieldCatE  >::FieldDescription( 
     42          enum FieldType::Cardinality FieldCardE> inline 
     43FieldDescription<DescT, 
     44                 FieldCardE>::FieldDescription( 
    4745    const FieldType       &elementType, 
    4846    const Char8           *szName, 
    49           std::string      documentation, 
     47    const std::string     &documentation, 
    5048    const UInt32           uiFieldId, 
    5149    const BitVector        vFieldMask, 
    …… 
    5351    const UInt32           uiFieldFlags, 
    5452          FieldEditMethod  fEditMethod, 
    55           FieldGetMethod   fGetMethod, 
    56     const Char8           *defaultValue) : 
     53          FieldGetMethod   fGetMethod   ) : 
    5754 
    5855    Inherited(elementType, 
    …… 
    6461              uiFieldFlags, 
    6562              fEditMethod, 
    66               fGetMethod, 
    67               defaultValue) 
    68 { 
    69 } 
    70  
    71 template <class DescT,  
    72           enum FieldCardinality FieldCardE, 
    73           enum FieldCategory    FieldCatE  > inline 
    74 FieldDescription<DescT, 
    75                  FieldCardE, 
    76                  FieldCatE  >::FieldDescription( 
     63              fGetMethod   ) 
     64{ 
     65} 
     66 
     67template <class DescT,  
     68          enum FieldType::Cardinality FieldCardE> inline 
     69FieldDescription<DescT, 
     70                 FieldCardE>::FieldDescription( 
    7771    const FieldType            &elementType, 
    7872    const Char8                *szName, 
    79     std::string                 documentation, 
     73    const std::string          &documentation, 
    8074    const UInt32                uiFieldId, 
    8175    const BitVector             vFieldMask, 
    …… 
    8377    const UInt32                uiFieldFlags, 
    8478          FieldIndexEditMethod  fIndexedEditMethod, 
    85           FieldIndexGetMethod   fIndexedGetMethod, 
    86     const Char8                *defaultValue      ) : 
     79          FieldIndexGetMethod   fIndexedGetMethod  ) : 
    8780 
    8881    Inherited(elementType, 
    …… 
    9487              uiFieldFlags, 
    9588              fIndexedEditMethod, 
    96               fIndexedGetMethod, 
    97               defaultValue) 
    98 { 
    99 } 
    100  
    101 template <class DescT,  
    102           enum FieldCardinality FieldCardE, 
    103           enum FieldCategory    FieldCatE  > inline 
    104 FieldDescription<DescT, 
    105                  FieldCardE, 
    106                  FieldCatE  >::FieldDescription( 
     89              fIndexedGetMethod  ) 
     90{ 
     91} 
     92 
     93template <class DescT,  
     94          enum FieldType::Cardinality FieldCardE> inline 
     95FieldDescription<DescT, 
     96                 FieldCardE>::FieldDescription( 
    10797    const FieldDescription &source) : 
    10898 
    …… 
    112102 
    113103template <class DescT,  
    114           enum FieldCardinality FieldCardE, 
    115           enum FieldCategory    FieldCatE  > inline 
    116 FieldDescription<DescT, 
    117                  FieldCardE, 
    118                  FieldCatE  >::~FieldDescription(void) 
    119 { 
    120 } 
    121  
    122 template <class DescT,  
    123           enum FieldCardinality FieldCardE, 
    124           enum FieldCategory    FieldCatE  > inline 
     104          enum FieldType::Cardinality FieldCardE> inline 
     105FieldDescription<DescT, 
     106                 FieldCardE>::~FieldDescription(void) 
     107{ 
     108} 
     109 
     110template <class DescT,  
     111          enum FieldType::Cardinality FieldCardE> inline 
    125112typename FieldDescription<DescT, 
    126                           FieldCardE, 
    127                           FieldCatE  >::HandledField const * 
     113                          FieldCardE>::HandledField const * 
    128114    FieldDescription<DescT, 
    129                      FieldCardE, 
    130                      FieldCatE  >::dcast_const(const Field *pField) const 
     115                     FieldCardE>::dcast_const(const Field *pField) const 
    131116{ 
    132117    return static_cast<const HandledField *>(pField); 
    …… 
    134119 
    135120template <class DescT,  
    136           enum FieldCardinality FieldCardE, 
    137           enum FieldCategory    FieldCatE  > inline 
     121          enum FieldType::Cardinality FieldCardE> inline 
    138122typename FieldDescription<DescT, 
    139                           FieldCardE, 
    140                           FieldCatE  >::HandledField * 
     123                          FieldCardE>::HandledField * 
    141124    FieldDescription<DescT, 
    142                      FieldCardE, 
    143                      FieldCatE  >::dcast(Field *pField) const 
     125                     FieldCardE>::dcast(Field *pField) const 
    144126{ 
    145127    return static_cast<HandledField *>(pField); 
    …… 
    147129 
    148130template <class DescT,  
    149           enum FieldCardinality FieldCardE, 
    150           enum FieldCategory    FieldCatE  > inline 
     131          enum FieldType::Cardinality FieldCardE> inline 
    151132Field *FieldDescription<DescT, 
    152                         FieldCardE, 
    153                         FieldCatE  >::createField(void) const 
    154 { 
    155 //     return new HandledField(); 
    156  
    157     FFATAL(("FieldDescription<>::createField: DISABLED - cneumann\n")); 
    158     return NULL; 
    159 } 
    160  
    161 template <class DescT,  
    162           enum FieldCardinality FieldCardE, 
    163           enum FieldCategory    FieldCatE  > inline 
     133                        FieldCardE>::createField(void) const 
     134{ 
     135    return new HandledField(); 
     136} 
     137 
     138template <class DescT,  
     139          enum FieldType::Cardinality FieldCardE> inline 
    164140void FieldDescription<DescT, 
    165                       FieldCardE, 
    166                       FieldCatE  >::destroyField(Field *pField) const 
     141                      FieldCardE>::destroyField(Field *pField) const 
    167142{ 
    168143    HandledField *pDelField = dcast(pField); 
    …… 
    172147 
    173148template <class DescT,  
    174           enum FieldCardinality FieldCardE, 
    175           enum FieldCategory    FieldCatE  > inline 
     149          enum FieldType::Cardinality FieldCardE> inline 
    176150FieldDescriptionBase *FieldDescription<DescT, 
    177                                        FieldCardE, 
    178                                        FieldCatE  >::clone(void) const 
     151                                       FieldCardE>::clone(void) const 
    179152{ 
    180153    return new Self(*this); 
    …… 
    182155 
    183156template <class DescT,  
    184           enum FieldCardinality FieldCardE, 
    185           enum FieldCategory    FieldCatE  > inline 
    186 GetFieldHandlePtr  
    187     FieldDescription<DescT, 
    188                      FieldCardE, 
    189                      FieldCatE  >::createGetHandler(const Field *pField) 
    190 { 
    191     const HandledField *pTypedField = dcast_const(pField); 
    192  
    193     GetHandlePtr returnValue(new GetHandle(pTypedField, this)); 
    194  
    195     return returnValue; 
    196 } 
    197  
    198 template <class DescT,  
    199           enum FieldCardinality FieldCardE, 
    200           enum FieldCategory    FieldCatE  > inline 
     157          enum FieldType::Cardinality FieldCardE> 
     158inline GetFieldHandlePtr  
     159FieldDescription<DescT, 
     160                 FieldCardE>::createGetHandler(Field const *pField) const 
     161{ 
     162    HandledField const *pTypedField = dcast_const(pField); 
     163     
     164    GetHandlePtr retVal(new GetHandle(pTypedField, this)); 
     165     
     166    return retVal; 
     167} 
     168 
     169template <class DescT,  
     170          enum FieldType::Cardinality FieldCardE> inline 
    201171EditFieldHandlePtr  
    202172    FieldDescription<DescT, 
    203                      FieldCardE, 
    204                      FieldCatE  >::createEditHandler(Field *pField) 
     173                     FieldCardE>::createEditHandler(Field *pField) const 
    205174{ 
    206175    HandledField *pTypedField = dcast(pField); 
    207  
    208     EditHandlePtr returnValue(new EditHandle(pTypedField, this)); 
    209  
    210     return returnValue; 
    211 } 
    212  
    213  
    214 template <class DescT,  
    215           enum FieldCardinality FieldCardE, 
    216           enum FieldCategory    FieldCatE  > inline 
     176     
     177    EditHandlePtr retVal(new EditHandle(pTypedField, this)); 
     178     
     179    return retVal; 
     180} 
     181 
     182 
     183template <class DescT,  
     184          enum FieldType::Cardinality FieldCardE> inline 
    217185void FieldDescription<DescT, 
    218                       FieldCardE, 
    219                       FieldCatE  >::SFieldFunctions::beginEdit( 
    220                           HandledField       *, 
    221                           UInt32              , 
    222                           AspectOffsetStore  &) 
    223 { 
    224 } 
    225  
    226 template <class DescT,  
    227           enum FieldCardinality FieldCardE, 
    228           enum FieldCategory    FieldCatE  > inline 
    229 void FieldDescription<DescT, 
    230                       FieldCardE, 
    231                       FieldCatE  >::MFieldFunctions::beginEdit( 
    232                           HandledField       *pField, 
    233                           UInt32              uiAspect, 
    234                           AspectOffsetStore  &oOffsets) 
    235 { 
    236     pField->beginEdit(uiAspect, oOffsets); 
    237 } 
    238  
    239  
    240 template <class DescT,  
    241           enum FieldCardinality FieldCardE, 
    242           enum FieldCategory    FieldCatE  > inline 
     186                      FieldCardE>::beginEdit(Field              *pField, 
     187                                             UInt32              uiAspect, 
     188                                             AspectOffsetStore  &oOffsets) 
     189{ 
     190    HandledField *pTypedField = dcast(pField); 
     191     
     192    FieldFunctions::beginEdit(pTypedField, uiAspect, oOffsets); 
     193} 
     194 
     195template <class DescT,  
     196          enum FieldType::Cardinality FieldCardE> inline 
    243197bool FieldDescription<DescT, 
    244                       FieldCardE, 
    245                       FieldCatE  >::SFieldFunctions::isShared( 
    246                           HandledField *) 
    247 { 
    248     return false; 
    249 } 
    250  
    251 template <class DescT,  
    252           enum FieldCardinality FieldCardE, 
    253           enum FieldCategory    FieldCatE  > inline 
    254 bool FieldDescription<DescT, 
    255                       FieldCardE, 
    256                       FieldCatE  >::MFieldFunctions::isShared( 
    257                           HandledField *pField) 
    258 { 
    259     return pField->isShared(); 
    260 } 
    261  
    262  
    263  
    264 template <class DescT,  
    265           enum FieldCardinality FieldCardE, 
    266           enum FieldCategory    FieldCatE  > inline 
    267 void FieldDescription<DescT, 
    268                       FieldCardE, 
    269                       FieldCatE  >::beginEdit(Field              *pField, 
    270                                               UInt32              uiAspect, 
    271                                               AspectOffsetStore  &oOffsets) 
     198                      FieldCardE>::isShared(Field *pField) 
    272199{ 
    273200    HandledField *pTypedField = dcast(pField); 
    274201     
    275     FieldFunctions::beginEdit(pTypedField, uiAspect, oOffsets); 
    276 } 
    277  
    278 template <class DescT,  
    279           enum FieldCardinality FieldCardE, 
    280           enum FieldCategory    FieldCatE  > inline 
    281 bool FieldDescription<DescT, 
    282                       FieldCardE, 
    283                       FieldCatE  >::isShared(Field *pField) 
    284 { 
    285     HandledField *pTypedField = dcast(pField); 
    286      
    287202    return FieldFunctions::isShared(pTypedField); 
    288203}