Show
Ignore:
Timestamp:
12/12/07 18:00:42 (1 year 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/System/FieldContainer/Fields/OSGEditMFCPointerFieldHandle.inl

    r1017 r1032  
    1 /*---------------------------------------------------------------------------*\ 
    2  *                                OpenSG                                     * 
    3  *                                                                           * 
    4  *                                                                           * 
    5  *                       Copyright 2007 by OpenSG Forum                      * 
    6  *                                                                           * 
    7  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          * 
    8  *                                                                           * 
    9 \*---------------------------------------------------------------------------*/ 
    10 /*---------------------------------------------------------------------------*\ 
    11  *                                License                                    * 
    12  *                                                                           * 
    13  * This library is free software; you can redistribute it and/or modify it   * 
    14  * under the terms of the GNU Library General Public License as published    * 
    15  * by the Free Software Foundation, version 2.                               * 
    16  *                                                                           * 
    17  * This library is distributed in the hope that it will be useful, but       * 
    18  * WITHOUT ANY WARRANTY; without even the implied warranty of                * 
    19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         * 
    20  * Library General Public License for more details.                          * 
    21  *                                                                           * 
    22  * You should have received a copy of the GNU Library General Public         * 
    23  * License along with this library; if not, write to the Free Software       * 
    24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 * 
    25  *                                                                           * 
    26 \*---------------------------------------------------------------------------*/ 
    27 /*---------------------------------------------------------------------------*\ 
    28  *                                Changes                                    * 
    29  *                                                                           * 
    30  *                                                                           * 
    31  *                                                                           * 
    32  *                                                                           * 
    33  *                                                                           * 
    34  *                                                                           * 
    35 \*---------------------------------------------------------------------------*/ 
    36  
    371/*---------------------------------------------------------------------------*\ 
    382 *                                OpenSG                                     * 
    …… 
    10165inline 
    10266EditMFCPointerFieldBaseHandle::EditMFCPointerFieldBaseHandle( 
    103     Field                      *pField,  
     67    Field                      *pField, 
    10468    FieldDescriptionBase const *pDescription) 
    10569     
    …… 
    159123    Self const &other) 
    160124     
    161     : Inherited(other) 
     125    : Inherited           (other                     ), 
     126      _mfAddFunc          (other._mfAddFunc          ), 
     127      _mfInsertFunc       (other._mfInsertFunc       ), 
     128      _mfReplaceIndexFunc (other._mfReplaceIndexFunc ), 
     129      _mfReplaceObjectFunc(other._mfReplaceObjectFunc), 
     130      _mfSubIndexFunc     (other._mfSubIndexFunc     ), 
     131      _mfSubObjectFunc    (other._mfSubObjectFunc    ), 
     132      _mfClearFunc        (other._mfClearFunc        ) 
    162133{ 
    163134} 
    …… 
    166137inline 
    167138EditMFCPointerFieldHandle<FieldT>::EditMFCPointerFieldHandle( 
    168     Field                      *pField,  
     139    Field                      *pField, 
    169140    FieldDescriptionBase const *pDescription) 
    170141     
    171     : Inherited(pField, pDescription) 
     142    : Inherited           (pField, pDescription), 
     143      _mfAddFunc          (                    ), 
     144      _mfInsertFunc       (                    ), 
     145      _mfReplaceIndexFunc (                    ), 
     146      _mfReplaceObjectFunc(                    ), 
     147      _mfSubIndexFunc     (                    ), 
     148      _mfSubObjectFunc    (                    ), 
     149      _mfClearFunc        (                    ) 
    172150{ 
    173151} 
    …… 
    256234 
    257235/*-------------------------------------------------------------------------*/ 
     236/* Setup                                                                   */ 
     237 
     238template <class FieldT> 
     239inline void 
     240EditMFCPointerFieldHandle<FieldT>::setAddFunc(MFAddFunction const &func) 
     241{ 
     242    _mfAddFunc = func; 
     243} 
     244 
     245template <class FieldT> 
     246inline void 
     247EditMFCPointerFieldHandle<FieldT>::setInsertFunc(MFInsertFunction const &func) 
     248{ 
     249    _mfInsertFunc = func; 
     250} 
     251 
     252template <class FieldT> 
     253inline void 
     254EditMFCPointerFieldHandle<FieldT>::setReplaceIndexFunc( 
     255    MFReplaceIndexFunction const &func) 
     256{ 
     257    _mfReplaceIndexFunc = func; 
     258} 
     259 
     260template <class FieldT> 
     261inline void 
     262EditMFCPointerFieldHandle<FieldT>::setReplaceObjectFunc( 
     263    MFReplaceObjectFunction const &func) 
     264{ 
     265    _mfReplaceObjectFunc = func; 
     266} 
     267 
     268template <class FieldT> 
     269inline void 
     270EditMFCPointerFieldHandle<FieldT>::setSubIndexFunc( 
     271    MFSubIndexFunction const &func) 
     272{ 
     273    _mfSubIndexFunc = func; 
     274} 
     275 
     276template <class FieldT> 
     277inline void 
     278EditMFCPointerFieldHandle<FieldT>::setSubObjectFunc( 
     279    MFSubObjectFunction const &func) 
     280{ 
     281    _mfSubObjectFunc = func; 
     282} 
     283 
     284template <class FieldT> 
     285inline void 
     286EditMFCPointerFieldHandle<FieldT>::setClearFunc(MFClearFunction const &func) 
     287{ 
     288    _mfClearFunc = func; 
     289} 
     290 
     291/*-------------------------------------------------------------------------*/ 
    258292/* Operations                                                              */ 
    259293 
    …… 
    276310EditMFCPointerFieldHandle<FieldT>::add(FieldContainer * const pNewElement) 
    277311{ 
    278     HandledFieldValueType pCastNewElement = 
     312    HandledFieldValueType pTypedNewElement = 
    279313        dynamic_cast<HandledFieldValueType>(pNewElement); 
    280314 
    281     if(pCastNewElement != NULL) 
    282         castFieldDown()->push_back(pCastNewElement); 
     315    if(pTypedNewElement != NULL) 
     316    { 
     317        _mfAddFunc(pTypedNewElement); 
     318    } 
    283319} 
    284320 
    …… 
    287323EditMFCPointerFieldHandle<FieldT>::sub(UInt32 const uiIndex) 
    288324{ 
    289     castFieldDown()->erase(castFieldDown()->begin() + uiIndex); 
     325    _mfSubIndexFunc(uiIndex); 
    290326} 
    291327 
    …… 
    294330EditMFCPointerFieldHandle<FieldT>::sub(FieldContainer * const pOldElement) 
    295331{ 
    296     HandledFieldValueType pOldCastElement = 
     332    HandledFieldValueType pTypedOldElement = 
    297333        dynamic_cast<HandledFieldValueType>(pOldElement); 
    298334 
    299     if(pOldCastElement != NULL) 
    300     { 
    301         typename HandledFieldType::iterator vI =  
    302             castFieldDown()->find(pOldCastElement); 
    303          
    304         if(vI != castFieldDown()->end()) 
    305             castFieldDown()->erase(vI); 
     335    if(pTypedOldElement != NULL) 
     336    { 
     337        _mfSubObjectFunc(pTypedOldElement); 
    306338    } 
    307339} 
    …… 
    313345    FieldContainer * const pNewElement) 
    314346{ 
    315     HandledFieldValueType pCastNewElement = 
     347    HandledFieldValueType pTypedNewElement = 
    316348        dynamic_cast<HandledFieldValueType>(pNewElement); 
    317          
    318     if(pCastNewElement != NULL) 
    319     { 
    320         castFieldDown()->insert(castFieldDown()->begin() + uiIndex, 
    321                                 pCastNewElement                    ); 
     349 
     350    if(pTypedNewElement != NULL) 
     351    { 
     352        _mfInsertFunc(uiIndex, pTypedNewElement); 
    322353    } 
    323354} 
    …… 
    329360    FieldContainer * const pNewElement) 
    330361{ 
    331     HandledFieldValueType pCastNewElement = 
     362    HandledFieldValueType pTypedNewElement = 
    332363        dynamic_cast<HandledFieldValueType>(pNewElement); 
    333          
    334     if(pCastNewElement != NULL) 
    335     { 
    336         castFieldDown()->insert(castFieldDown()->begin() + uiIndex,  
    337                                 pCastNewElement                    ); 
     364 
     365    if(pTypedNewElement != NULL) 
     366    { 
     367        _mfReplaceIndexFunc(uiIndex, pTypedNewElement); 
    338368    } 
    339369} 
    …… 
    345375    FieldContainer * const pNewElement) 
    346376{ 
    347     HandledFieldValueType pOldCastElement = 
     377    HandledFieldValueType pTypedOldElement = 
    348378        dynamic_cast<HandledFieldValueType>(pOldElement); 
    349     HandledFieldValueType pCastNewElement = 
     379    HandledFieldValueType pTypedNewElement = 
    350380        dynamic_cast<HandledFieldValueType>(pNewElement); 
    351381 
    352     if((pOldCastElement != NULL) && (pCastNewElement != NULL)) 
    353     { 
    354         typename HandledFieldType::iterator vI =  
    355             castFieldDown()->find(pOldCastElement); 
    356          
    357         if(vI != castFieldDown()->end()) 
    358             *vI = pCastNewElement; 
     382    if((pTypedOldElement != NULL) && (pTypedNewElement != NULL)) 
     383    { 
     384        _mfReplaceObjectFunc(pTypedOldElement, pTypedNewElement); 
    359385    } 
    360386} 
    …… 
    364390EditMFCPointerFieldHandle<FieldT>::clear(void) 
    365391{ 
    366     castFieldDown()->clear(); 
     392    _mfClearFunc(); 
    367393} 
    368394 
    …… 
    402428} 
    403429 
     430 
     431/*! \class DynamicEditMFCPointerFieldHandle<FieldT> 
     432 
     433    Concrete \c EditFieldHandle for multi fields that store pointers. 
     434    This particular variant is used for dynamically added fields. 
     435     
     436    \dev 
     437    Since a dynamically added field can not be manipulated by the container 
     438    it is added to (the container lacks static type information about the 
     439    field), this EditHandle does not call back into the container, but 
     440    manipulates the field directly. 
     441    \enddev 
     442*/ 
     443 
     444/*-------------------------------------------------------------------------*/ 
     445/* DynamicEditMFCPointerFieldHandle<FieldT>                                       */ 
     446/*-------------------------------------------------------------------------*/ 
     447 
     448/*-------------------------------------------------------------------------*/ 
     449/* Helper                                                                  */ 
     450 
     451template <class FieldT> 
     452inline typename DynamicEditMFCPointerFieldHandle<FieldT>::HandledFieldType * 
     453DynamicEditMFCPointerFieldHandle<FieldT>::castFieldDown(void) const 
     454{ 
     455    return static_cast<HandledFieldType *>(_pField); 
     456} 
     457 
     458template <class FieldT> 
     459inline FieldContainer * 
     460DynamicEditMFCPointerFieldHandle<FieldT>::castPtrUp( 
     461    HandledFieldValueType ptr) const 
     462{ 
     463    return static_cast<FieldContainer *>(static_cast<void *>(ptr)); 
     464} 
     465 
     466/*-------------------------------------------------------------------------*/ 
     467/* Constructors                                                            */ 
     468 
     469template <class FieldT> 
     470inline 
     471DynamicEditMFCPointerFieldHandle<FieldT>::DynamicEditMFCPointerFieldHandle( 
     472    Self const &other) 
     473     
     474    : Inherited(other) 
     475{ 
     476} 
     477 
     478template <class FieldT> 
     479inline 
     480DynamicEditMFCPointerFieldHandle<FieldT>::DynamicEditMFCPointerFieldHandle( 
     481    Field                      *pField, 
     482    FieldDescriptionBase const *pDescription) 
     483     
     484    : Inherited(pField, pDescription) 
     485{ 
     486} 
     487 
     488/*-------------------------------------------------------------------------*/ 
     489/* Destructor                                                              */ 
     490 
     491template <class FieldT> 
     492inline 
     493DynamicEditMFCPointerFieldHandle<FieldT>::~DynamicEditMFCPointerFieldHandle(void) 
     494{ 
     495} 
     496 
     497/*-------------------------------------------------------------------------*/ 
     498/* Type Query                                                              */ 
     499 
     500template <class FieldT> 
     501inline FieldType const & 
     502DynamicEditMFCPointerFieldHandle<FieldT>::getType(void) const 
     503{ 
     504    return HandledFieldType::getClassType(); 
     505} 
     506 
     507/*-------------------------------------------------------------------------*/ 
     508/* Stream IO                                                               */ 
     509 
     510template <class FieldT> 
     511inline void 
     512DynamicEditMFCPointerFieldHandle<FieldT>::pushValueToStream( 
     513    OutStream &str) const 
     514{ 
     515    FWARNING(("DynamicEditMFCPointerFieldHandle<FieldT>::pushValueToStream(): NIY\n")); 
     516} 
     517 
     518template <class FieldT> 
     519inline void 
     520DynamicEditMFCPointerFieldHandle<FieldT>::pushSizeToStream( 
     521    OutStream &str) const 
     522{ 
     523    FWARNING(("DynamicEditMFCPointerFieldHandle<FieldT>::pushSizeToStream(): NIY\n")); 
     524} 
     525 
     526template <class FieldT> 
     527inline void 
     528DynamicEditMFCPointerFieldHandle<FieldT>::pushValueFromCString( 
     529    Char8 const *str) 
     530{ 
     531    FWARNING(("DynamicEditMFCPointerFieldHandle<FieldT>::pushValueFromCString()\n")); 
     532} 
     533 
     534/*-------------------------------------------------------------------------*/ 
     535/* Generic Operations                                                      */ 
     536 
     537template <class FieldT> 
     538inline bool 
     539DynamicEditMFCPointerFieldHandle<FieldT>::equal(EditFieldHandlePtr rhs) 
     540{ 
     541    FWARNING(("DynamicEditMFCPointerFieldHandle<FieldT>::equal(): NIY\n")); 
     542} 
     543     
     544template <class FieldT> 
     545inline void 
     546DynamicEditMFCPointerFieldHandle<FieldT>::copyValues(GetFieldHandlePtr source) 
     547{ 
     548    FWARNING(("DynamicEditMFCPointerFieldHandle<FieldT>::copyValues(): NIY\n")); 
     549} 
     550 
     551template <class FieldT> 
     552inline void 
     553DynamicEditMFCPointerFieldHandle<FieldT>::shareValues(GetFieldHandlePtr source) 
     554{ 
     555    FWARNING(("DynamicEditMFCPointerFieldHandle<FieldT>::shareValues(): NIY\n")); 
     556} 
     557 
     558template <class FieldT> 
     559inline void 
     560DynamicEditMFCPointerFieldHandle<FieldT>::cloneValues( 
     561    GetFieldHandlePtr        pSrc, 
     562    TypePtrVector     const &shareTypes, 
     563    TypePtrVector     const &ignoreTypes, 
     564    TypeIdVector      const &shareGroupIds, 
     565    TypeIdVector      const &ignoreGroupIds) const 
     566{ 
     567    FWARNING(("DynamicEditMFCPointerFieldHandle<FieldT>::cloneValues(): NIY\n")); 
     568} 
     569 
     570/*-------------------------------------------------------------------------*/ 
     571/* Operations                                                              */ 
     572 
     573template <class FieldT> 
     574inline UInt32 
     575DynamicEditMFCPointerFieldHandle<FieldT>::size(void) const 
     576{ 
     577    return castFieldDown()->size(); 
     578} 
     579 
     580template <class FieldT> 
     581inline FieldContainer  * 
     582DynamicEditMFCPointerFieldHandle<FieldT>::get(UInt32 const uiIndex) const 
     583{ 
     584    return castPtrUp((*castFieldDown())[uiIndex]); 
     585} 
     586     
     587template <class FieldT> 
     588inline void 
     589DynamicEditMFCPointerFieldHandle<FieldT>::add(FieldContainer * const pNewElement) 
     590{ 
     591    HandledFieldValueType pTypedNewElement = 
     592        dynamic_cast<HandledFieldValueType>(pNewElement); 
     593 
     594    if(pTypedNewElement != NULL) 
     595    { 
     596        castFieldDown()->push_back(pTypedNewElement); 
     597    } 
     598} 
     599 
     600template <class FieldT> 
     601inline void 
     602DynamicEditMFCPointerFieldHandle<FieldT>::sub(UInt32 const uiIndex) 
     603{ 
     604    if(uiIndex < castFieldDown()->size()) 
     605    { 
     606        typename HandledFieldType::iterator vI = 
     607            castFieldDown()->begin() + index; 
     608             
     609        castFieldDown()->erase(vI); 
     610    } 
     611} 
     612 
     613template <class FieldT> 
     614inline void 
     615DynamicEditMFCPointerFieldHandle<FieldT>::sub(FieldContainer * const pOldElement) 
     616{ 
     617    HandledFieldValueType pTypedOldElement = 
     618        dynamic_cast<HandledFieldValueType>(pOldElement); 
     619 
     620    if(pTypedOldElement != NULL) 
     621    { 
     622        typename HandledFieldType::iterator vI = 
     623            castFieldDown()->find(pTypedOldElement); 
     624             
     625        if(vI != castFieldDown()->end()) 
     626        { 
     627            castFieldDown()->erase(vI); 
     628        } 
     629    } 
     630} 
     631 
     632template <class FieldT> 
     633inline void 
     634DynamicEditMFCPointerFieldHandle<FieldT>::insert( 
     635    UInt32           const uiIndex,  
     636    FieldContainer * const pNewElement) 
     637{ 
     638    HandledFieldValueType pTypedNewElement = 
     639        dynamic_cast<HandledFieldValueType>(pNewElement); 
     640 
     641    if((pTypedNewElement != NULL) && (uiIndex < castFieldDown()->size)) 
     642    { 
     643        typename HandledFieldType::iterator vI = 
     644            castFieldDown()->begin() + uiIndex; 
     645             
     646        castFieldDown()->insert(vI, pTypedNewElement); 
     647    } 
     648} 
     649  
     650template <class FieldT> 
     651inline void 
     652DynamicEditMFCPointerFieldHandle<FieldT>::replace( 
     653    UInt32           const uiIndex, 
     654    FieldContainer * const pNewElement) 
     655{ 
     656    HandledFieldValueType pTypedNewElement = 
     657        dynamic_cast<HandledFieldValueType>(pNewElement); 
     658 
     659    if((pTypedNewElement != NULL) && (uiIndex < castFieldDown()->size)) 
     660    { 
     661        typename HandledFieldType::iterator vI = 
     662            castFieldDown()->begin() + uiIndex; 
     663             
     664        *vI = pTypedNewElement; 
     665    } 
     666} 
     667                                
     668template <class FieldT> 
     669inline void 
     670DynamicEditMFCPointerFieldHandle<FieldT>::replace( 
     671    FieldContainer * const pOldElement, 
     672    FieldContainer * const pNewElement) 
     673{ 
     674    HandledFieldValueType pTypedOldElement = 
     675        dynamic_cast<HandledFieldValueType>(pOldElement); 
     676    HandledFieldValueType pTypedNewElement = 
     677        dynamic_cast<HandledFieldValueType>(pNewElement); 
     678 
     679    if((pTypedOldElement != NULL) && (pTypedNewElement != NULL)) 
     680    { 
     681        typename HandledFieldType::iterator vI = 
     682            castFieldDown()->find(pTypedOldElement); 
     683             
     684        if(vI != castFieldDown()->end()) 
     685        { 
     686            *vI = pTypedNewElement; 
     687        } 
     688    } 
     689} 
     690                                  
     691template <class FieldT> 
     692inline void 
     693DynamicEditMFCPointerFieldHandle<FieldT>::clear(void) 
     694{ 
     695    castFieldDown()->clear(); 
     696} 
     697 
     698/*-------------------------------------------------------------------------*/ 
     699/* Typed Operations                                                        */ 
     700 
     701template <class FieldT> 
     702inline typename 
     703    DynamicEditMFCPointerFieldHandle<FieldT>::HandledFieldType * 
     704DynamicEditMFCPointerFieldHandle<FieldT>::operator->(void) const 
     705{ 
     706    return castFieldDown(); 
     707} 
     708 
     709template <class FieldT> 
     710inline typename 
     711    DynamicEditMFCPointerFieldHandle<FieldT>::HandledFieldType & 
     712DynamicEditMFCPointerFieldHandle<FieldT>::operator*(void) const 
     713{ 
     714    return *castFieldDown(); 
     715} 
     716 
     717template <class FieldT> 
     718inline typename 
     719    DynamicEditMFCPointerFieldHandle<FieldT>::HandledFieldType const * 
     720DynamicEditMFCPointerFieldHandle<FieldT>::getField(void) const 
     721{ 
     722    return castFieldDown(); 
     723} 
     724 
     725template <class FieldT> 
     726inline typename 
     727    DynamicEditMFCPointerFieldHandle<FieldT>::HandledFieldType * 
     728DynamicEditMFCPointerFieldHandle<FieldT>::editField(void) 
     729{ 
     730    return castFieldDown(); 
     731} 
     732 
     733 
     734 
    404735OSG_END_NAMESPACE 
    405736