Changeset 980

Show
Ignore:
Timestamp:
10/22/07 18:52:36 (9 months ago)
Author:
cneumann
Message:

fixed: compile errors - not done yet

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/Carsten_PtrWork/Source/System/Action/Base/OSGRenderTraversalActionBase.h

    r741 r980  
    6666struct RenderTravDataSlotDesc 
    6767{ 
    68     typedef Action         ParentT; 
    69     typedef MFFieldBundleP DataStore; 
     68    typedef Action                      ParentT; 
     69    typedef MFFieldBundleInternalRefPtr DataStore; 
    7070}; 
    7171 

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Fields/OSGAttachmentContainerFieldTraits.h

    r976 r980  
    5353 
    5454#if !defined(OSG_DO_DOC) || (OSG_DOC_LEVEL >= 3) 
     55 
     56class AttachmentContainer; 
     57 
     58OSG_GEN_CONTAINERPTR(AttachmentContainer); 
     59 
     60typedef RefCountPtrBuilder<AttachmentContainer>::Ptr         AttachmentContainerRefPtr; 
     61typedef MTRefCountPtrBuilder<AttachmentContainer>::Ptr       AttachmentContainerMTRefPtr; 
     62typedef WeakRefCountPtrBuilder<AttachmentContainer>::Ptr     AttachmentContainerWeakRefPtr; 
     63typedef InternalRefCountPtrBuilder<AttachmentContainer>::Ptr AttachmentContainerInternalRefPtr; 
     64 
     65typedef ParentPtrBuilder<AttachmentContainer>::Ptr           AttachmentContainerParentPtr; 
    5566 
    5667#ifdef OSG_DOC_FILES_IN_MODULE 
    …… 
    155166    static const bool bIsParentPointerField = true; 
    156167 
    157     typedef FieldTraits<NodeParentPtr> Self; 
     168    typedef FieldTraits<AttachmentContainerParentPtr> Self; 
    158169 
    159170 

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Fields/OSGAttachmentContainerMFields.h

    r976 r980  
    4747#include "OSGMPointerFieldAdapter.h" 
    4848#include "OSGFieldContainerMFields.h" 
     49#include "OSGAttachmentContainerFieldTraits.h" 
    4950 
    5051OSG_BEGIN_NAMESPACE 

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Fields/OSGAttachmentContainerSFields.h

    r976 r980  
    4747#include "OSGSPointerFieldAdapter.h" 
    4848#include "OSGFieldContainerSFields.h" 
     49#include "OSGAttachmentContainerFieldTraits.h" 
    4950 
    5051OSG_BEGIN_NAMESPACE 

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Fields/OSGContainerTypeInst.cpp

    r976 r980  
    7575OSG_BEGIN_NAMESPACE 
    7676 
    77 OSG_SFIELDTYPE_SPEZ_INST(FieldContainerPtr, 0); 
    78 OSG_MFIELDTYPE_SPEZ_INST(FieldContainerPtr, 0); 
     77OSG_SFIELDTYPE_SPEZ_INST(FieldContainerInternalRefPtr, 0); 
     78OSG_MFIELDTYPE_SPEZ_INST(FieldContainerInternalRefPtr, 0); 
    7979 
    80 OSG_SFIELDTYPE_SPEZ_INST(ParentFieldContainerPtr, 0); 
    81 OSG_MFIELDTYPE_SPEZ_INST(ParentFieldContainerPtr, 0); 
     80OSG_SFIELDTYPE_SPEZ_INST(FieldContainerWeakRefPtr, 0); 
     81OSG_MFIELDTYPE_SPEZ_INST(FieldContainerWeakRefPtr, 0); 
     82 
     83OSG_SFIELDTYPE_SPEZ_INST(FieldContainerParentPtr, 0); 
     84OSG_MFIELDTYPE_SPEZ_INST(FieldContainerParentPtr, 0); 
     85 
     86// OSG_SFIELDTYPE_SPEZ_INST(FieldContainerPtr, 0); 
     87// OSG_MFIELDTYPE_SPEZ_INST(FieldContainerPtr, 0); 
     88//  
     89// OSG_SFIELDTYPE_SPEZ_INST(ParentFieldContainerPtr, 0); 
     90// OSG_MFIELDTYPE_SPEZ_INST(ParentFieldContainerPtr, 0); 
    8291 
    8392#if !defined(OSG_DO_DOC) || (OSG_DOC_LEVEL >= 3) 

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Fields/OSGFieldBundleMFields.h

    r976 r980  
    5252 
    5353// typedef MField<FieldBundleP> MFFieldBundleP; 
    54 typedef MField<FieldBundleInternalRefPtr> MFFieldBundleInternalRefPtr; 
     54typedef MField< 
     55    ReferenceCountPointer< 
     56        FieldBundle, 
     57        InternalRefCountPolicy<FieldContainer>, 
     58        FieldBundle                             > > MFFieldBundleInternalRefPtr; 
     59 
     60typedef MField< 
     61    ReferenceCountPointer< 
     62        FieldBundle, 
     63        WeakRefCountPolicy<FieldContainer>, 
     64        FieldBundle                             > > MFFieldBundleWeakRefPtr; 
     65         
     66typedef MField< 
     67    ParentPointer        <FieldBundle, 
     68                          FieldBundle           > > MFFieldBundleParentPtr; 
    5569 
    5670#endif 
    …… 
    93107 
    94108// typedef MField<ParentFieldBundleP, 1> MFParentFieldBundleP; 
    95 typedef MField<FieldBundleParentPtr> MFFieldBundleParentPtr; 
    96109 
    97110#endif 

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Fields/OSGFieldBundleSFields.h

    r976 r980  
    5252 
    5353// typedef SField<FieldBundleP> SFFieldBundleP; 
    54 typedef SField<FieldBundleInternalRefPtr> SFFieldBundleInternalRefPtr; 
     54typedef SField< 
     55    ReferenceCountPointer< 
     56        FieldBundle, 
     57        InternalRefCountPolicy<FieldContainer>, 
     58        FieldBundle                             > > SFFieldBundleInternalRefPtr; 
     59 
     60typedef SField< 
     61    ReferenceCountPointer< 
     62        FieldBundle, 
     63        WeakRefCountPolicy<FieldContainer>, 
     64        FieldBundle                             > > SFFieldBundleWeakRefPtr; 
     65         
     66typedef SField< 
     67    ParentPointer        <FieldBundle, 
     68                          FieldBundle           > > SFFieldBundleParentPtr; 
    5569#endif 
    5670 
    …… 
    95109//     1                 > SFParentFieldBundleP; 
    96110 
    97 typedef SField<FieldBundleParentPtr> SFFieldBundleParentPtr; 
    98  
    99111#endif 
    100112 

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Fields/OSGNodeFieldTraits.h

    r976 r980  
    109109}; 
    110110 
     111/*! \ingroup  
     112 */ 
     113#if !defined(OSG_DOC_DEV_TRAITS) 
     114/*! \hideinhierarchy */ 
     115#endif 
     116 
     117template <> 
     118struct FieldTraits<NodeWeakRefPtr> :  
     119    public FieldTraitsFCReferenceCountPointerBase<NodeWeakRefPtr> 
     120{ 
     121  private: 
     122 
     123    static  DataType _type; 
     124 
     125  public: 
     126    static const bool bIsPointerField       = true; 
     127    static const bool bIsParentPointerField = false; 
     128 
     129    typedef FieldTraits<NodeWeakRefPtr> Self; 
     130 
     131 
     132    enum { Convertible = Self::NotConvertible }; 
     133     
     134    static OSG_SYSTEM_DLLMAPPING 
     135                 DataType &getType (void); 
     136 
     137    static const Char8    *getSName(void)  
     138    { 
     139        return "SFNodeWeakRefPtr";  
     140    } 
     141 
     142    static const Char8    *getMName(void)  
     143    {  
     144        return "MFNodeWeakRefPtr";  
     145    } 
     146}; 
    111147 
    112148/*! \ingroup  

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Fields/OSGParentPointerEditMFieldHandle.h

    r979 r980  
    5353OSG_BEGIN_NAMESPACE 
    5454 
    55 template <class ContainerT, class RootObjectT> 
     55template <class ObjectT, class RootObjectT> 
    5656class OSG_SYSTEM_DLLMAPPING  
    57     EditMFieldHandle<MField<ParentPointer<ContainerT, RootObjectT> > > 
     57    EditMFieldHandle<MField<ParentPointer<ObjectT, RootObjectT> > > 
    5858    : public EditFieldHandle 
    5959{ 
    …… 
    6767    typedef boost::shared_ptr<EditMFieldHandle>     Ptr; 
    6868     
    69     typedef MField<ParentPointer<ContainerT, 
     69    typedef MField<ParentPointer<ObjectT, 
    7070                                 RootObjectT> >     HandledFieldType; 
    7171    typedef typename HandledFieldType::StoredType   HandledFieldStoredType; 

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Fields/OSGParentPointerEditMFieldHandle.inl

    r979 r980  
    5151/*-------------------------------------------------------------------------*/ 
    5252/* EditMFieldHandle<                                                       */ 
    53 /*     MField< ParentPointer< ContainerT,                                  */ 
     53/*     MField< ParentPointer< ObjectT,                                     */ 
    5454/*                             RootObjectT > > >                           */ 
    5555/*-------------------------------------------------------------------------*/ 
    …… 
    5858/* Constructors                                                            */ 
    5959 
    60 template <class ContainerT, class RootObjectT> 
     60template <class ObjectT, class RootObjectT> 
    6161inline 
    62 EditMFieldHandle<MField<ParentPointer<ContainerT, 
     62EditMFieldHandle<MField<ParentPointer<ObjectT, 
    6363                                      RootObjectT> > >::EditMFieldHandle( 
    6464    EditMFieldHandle const &source) 
    …… 
    6767} 
    6868 
    69 template <class ContainerT, class RootObjectT> 
     69template <class ObjectT, class RootObjectT> 
    7070inline 
    71 EditMFieldHandle<MField<ParentPointer<ContainerT, 
     71EditMFieldHandle<MField<ParentPointer<ObjectT, 
    7272                                      RootObjectT> > >::EditMFieldHandle( 
    7373    HandledFieldType           *pField,  
    …… 
    8080/* Desctructor                                                             */ 
    8181 
    82 template <class ContainerT, class RootObjectT> 
     82template <class ObjectT, class RootObjectT> 
    8383inline 
    84 EditMFieldHandle<MField<ParentPointer<ContainerT, 
     84EditMFieldHandle<MField<ParentPointer<ObjectT, 
    8585                                      RootObjectT> > >::~EditMFieldHandle(void) 
    8686{ 
    …… 
    9090/* Type Information                                                        */ 
    9191 
    92 template <class ContainerT, class RootObjectT> 
     92template <class ObjectT, class RootObjectT> 
    9393inline FieldType const & 
    94 EditMFieldHandle<MField<ParentPointer<ContainerT, 
     94EditMFieldHandle<MField<ParentPointer<ObjectT, 
    9595                                      RootObjectT> > >::getType(void) const 
    9696{ 
    …… 
    9898} 
    9999                                                      
    100 template <class ContainerT, class RootObjectT> 
     100template <class ObjectT, class RootObjectT> 
    101101inline bool 
    102 EditMFieldHandle<MField<ParentPointer<ContainerT, 
     102EditMFieldHandle<MField<ParentPointer<ObjectT, 
    103103                                      RootObjectT> > >::isPointerField(void) const 
    104104{ 
    …… 
    106106} 
    107107 
    108 template <class ContainerT, class RootObjectT> 
     108template <class ObjectT, class RootObjectT> 
    109109inline bool 
    110 EditMFieldHandle<MField<ParentPointer<ContainerT, 
     110EditMFieldHandle<MField<ParentPointer<ObjectT, 
    111111                                      RootObjectT> > >::isParentPointerField(void) const 
    112112{ 
    …… 
    117117/* Stream IO                                                               */ 
    118118 
    119 template <class ContainerT, class RootObjectT> 
    120 inline void 
    121 EditMFieldHandle<MField<ParentPointer<ContainerT, 
     119template <class ObjectT, class RootObjectT> 
     120inline void 
     121EditMFieldHandle<MField<ParentPointer<ObjectT, 
    122122                                      RootObjectT> > >::pushValueToStream( 
    123123    OutStream &str) const 
    …… 
    130130} 
    131131        
    132 template <class ContainerT, class RootObjectT> 
    133 inline void 
    134 EditMFieldHandle<MField<ParentPointer<ContainerT, 
     132template <class ObjectT, class RootObjectT> 
     133inline void 
     134EditMFieldHandle<MField<ParentPointer<ObjectT, 
    135135                                      RootObjectT> > >::pushSizeToStream( 
    136136    OutStream &str) const 
    …… 
    143143} 
    144144 
    145 template <class ContainerT, class RootObjectT> 
     145template <class ObjectT, class RootObjectT> 
    146146inline void 
    147147EditMFieldHandle<MField<ParentPointer<Container, 
    …… 
    156156/* Generic Operations                                                      */ 
    157157 
    158 template <class ContainerT, class RootObjectT> 
     158template <class ObjectT, class RootObjectT> 
    159159inline bool 
    160 EditMFieldHandle<MField<ParentPointer<ContainerT, 
     160EditMFieldHandle<MField<ParentPointer<ObjectT, 
    161161                                      RootObjectT> > >::equal(Inherited::Ptr rhs) 
    162162{ 
    …… 
    174174} 
    175175     
    176 template <class ContainerT, class RootObjectT> 
    177 inline void 
    178 EditMFieldHandle<MField<ParentPointer<ContainerT, 
     176template <class ObjectT, class RootObjectT> 
     177inline void 
     178EditMFieldHandle<MField<ParentPointer<ObjectT, 
    179179                                      RootObjectT> > >::copyValues( 
    180180    GetFieldHandlePtr source) 
    181181{ 
    182     FWARNING(("Illegal EditMFieldHandle<MField<ParentPointer<ContainerT> > >" 
     182    FWARNING(("Illegal EditMFieldHandle<MField<ParentPointer<ObjectT> > >" 
    183183              "::copyValues() called for %s\n",  
    184184              this->getName().c_str())); 
    …… 
    186186}                                
    187187                                  
    188 template <class ContainerT, class RootObjectT> 
    189 inline void 
    190 EditMFieldHandle<MField<ParentPointer<ContainerT, 
     188template <class ObjectT, class RootObjectT> 
     189inline void 
     190EditMFieldHandle<MField<ParentPointer<ObjectT, 
    191191                                      RootObjectT> > >::shareValues( 
    192192    GetFieldHandlePtr source) 
    193193{ 
    194     FWARNING(("Illegal EditMFieldHandle<MField<ParentPointer<ContainerT> > >" 
     194    FWARNING(("Illegal EditMFieldHandle<MField<ParentPointer<ObjectT> > >" 
    195195              "::shareValues() called for %s\n",  
    196196              this->getName().c_str())); 
    …… 
    198198} 
    199199 
    200 template <class ContainerT, class RootObjectT> 
    201 inline void 
    202 EditMFieldHandle<MField<ParentPointer<ContainerT, 
     200template <class ObjectT, class RootObjectT> 
     201inline void 
     202EditMFieldHandle<MField<ParentPointer<ObjectT, 
    203203                                      RootObjectT> > >::cloneValues( 
    204204    GetFieldHandlePtr        pSrc, 
    …… 
    208208    TypeIdVector      const &ignoreGroupIds = TypeIdVector ()) const 
    209209{ 
    210     FWARNING(("Illegal EditMFieldHandle<MField<ParentPointer<ContainerT> > >" 
     210    FWARNING(("Illegal EditMFieldHandle<MField<ParentPointer<ObjectT> > >" 
    211211              "::cloneValues() called for %s\n",  
    212212              this->getName().c_str())); 
    …… 
    217217/* Access                                                                  */ 
    218218 
    219 template <class ContainerT, class RootObjectT> 
     219template <class ObjectT, class RootObjectT> 
    220220inline typename  
    221     EditMFieldHandle<MField<ParentPointer<ContainerT, 
     221    EditMFieldHandle<MField<ParentPointer<ObjectT, 
    222222                                          RootObjectT> > >::HandledFieldType * 
    223 EditMFieldHandle<MField<ParentPointer<ContainerT, 
     223EditMFieldHandle<MField<ParentPointer<ObjectT, 
    224224                                      RootObjectT> > >::operator->(void) 
    225225{ 
    …… 
    227227} 
    228228 
    229 template <class ContainerT, class RootObjectT> 
     229template <class ObjectT, class RootObjectT> 
    230230inline typename  
    231     EditMFieldHandle<MField<ParentPointer<ContainerT, 
     231    EditMFieldHandle<MField<ParentPointer<ObjectT, 
    232232                                          RootObjectT> > >::HandledFieldType & 
    233 EditMFieldHandle<MField<ParentPointer<ContainerT, 
     233EditMFieldHandle<MField<ParentPointer<ObjectT, 
    234234                                      RootObjectT> > >::operator*(void) 
    235235{ 

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Fields/OSGParentPointerEditSFieldHandle.h

    r979 r980  
    5353OSG_BEGIN_NAMESPACE 
    5454 
    55 template <class ContainerT, class RootObjectT> 
     55template <class ObjectT, class RootObjectT> 
    5656class OSG_SYSTEM_DLLMAPPING  
    57     EditSFieldHandle<SField<ParentPointer<ContainerT, RootObjectT> > > 
     57    EditSFieldHandle<SField<ParentPointer<ObjectT, RootObjectT> > > 
    5858    : public EditFieldHandle 
    5959{ 
    …… 
    6767    typedef boost::shared_ptr<EditSFieldHandle>     Ptr; 
    6868     
    69     typedef SField<ParentPointer<ContainerT, 
     69    typedef SField<ParentPointer<ObjectT, 
    7070                                 RootObjectT> >     HandledFieldType; 
    7171    typedef typename HandledFieldType::StoredType   HandledFieldStoredType; 

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Fields/OSGParentPointerEditSFieldHandle.inl

    r979 r980  
    5050 
    5151/*-------------------------------------------------------------------------*/ 
    52 /* EditSFieldHandle< SField< ParentPointer< ContainerT                     */ 
     52/* EditSFieldHandle< SField< ParentPointer< ObjectT                        */ 
    5353/*                                          RootObjectT > > >              */ 
    5454/*-------------------------------------------------------------------------*/ 
    …… 
    5757/* Constructors                                                            */ 
    5858 
    59 template <class ContainerT, class RootObjectT> 
     59template <class ObjectT, class RootObjectT> 
    6060inline 
    61 EditSFieldHandle<SField<ParentPointer<ContainerT, 
     61EditSFieldHandle<SField<ParentPointer<ObjectT, 
    6262                                      RootObjectT> > >::EditSFieldHandle( 
    6363    EditSFieldHandle const &source) 
    …… 
    6666} 
    6767 
    68 template <class ContainerT, class RootObjectT> 
     68template <class ObjectT, class RootObjectT> 
    6969inline 
    70 EditSFieldHandle<SField<ParentPointer<ContainerT, 
     70EditSFieldHandle<SField<ParentPointer<ObjectT, 
    7171                                      RootObjectT> > >::EditSFieldHandle( 
    7272    HandledFieldType           *pField,  
    …… 
    7979/* Desctructor                                                             */ 
    8080 
    81 template <class ContainerT, class RootObjectT> 
     81template <class ObjectT, class RootObjectT> 
    8282inline 
    83 EditSFieldHandle<SField<ParentPointer<ContainerT, 
     83EditSFieldHandle<SField<ParentPointer<ObjectT, 
    8484                                      RootObjectT> > >::~EditSFieldHandle(void) 
    8585{ 
    …… 
    8989/* Type Information                                                        */ 
    9090 
    91 template <class ContainerT, class RootObjectT> 
     91template <class ObjectT, class RootObjectT> 
    9292inline FieldType const & 
    93 EditSFieldHandle<SField<ParentPointer<ContainerT, 
     93EditSFieldHandle<SField<ParentPointer<ObjectT, 
    9494                                      RootObjectT> > >::getType(void) const 
    9595{ 
    …… 
    9797} 
    9898                                                      
    99 template <class ContainerT, class RootObjectT> 
     99template <class ObjectT, class RootObjectT> 
    100100inline bool 
    101 EditSFieldHandle<SField<ParentPointer<ContainerT, 
     101EditSFieldHandle<SField<ParentPointer<ObjectT, 
    102102                                      RootObjectT> > >::isPointerField(void) const 
    103103{ 
    …… 
    105105} 
    106106 
    107 template <class ContainerT, class RootObjectT> 
     107template <class ObjectT, class RootObjectT> 
    108108inline bool 
    109 EditSFieldHandle<SField<ParentPointer<ContainerT, 
     109EditSFieldHandle<SField<ParentPointer<ObjectT, 
    110110                                      RootObjectT> > >::isParentPointerField(void) const 
    111111{ 
    …… 
    116116/* Stream IO                                                               */ 
    117117 
    118 template <class ContainerT, class RootObjectT> 
    119 inline void 
    120 EditSFieldHandle<SField<ParentPointer<ContainerT, 
     118template <class ObjectT, class RootObjectT> 
     119inline void 
     120EditSFieldHandle<SField<ParentPointer<ObjectT, 
    121121                                      RootObjectT> > >::pushValueToStream( 
    122122    OutStream &str) const 
    …… 
    129129} 
    130130        
    131 template <class ContainerT, class RootObjectT> 
    132 inline void 
    133 EditSFieldHandle<SField<ParentPointer<ContainerT, 
     131template <class ObjectT, class RootObjectT> 
     132inline void 
     133EditSFieldHandle<SField<ParentPointer<ObjectT, 
    134134                                      RootObjectT> > >::pushSizeToStream( 
    135135    OutStream &str) const 
    …… 
    142142} 
    143143 
    144 template <class ContainerT, class RootObjectT> 
     144template <class ObjectT, class RootObjectT> 
    145145inline void 
    146146EditSFieldHandle<SField<ParentPointer<Container, 
    …… 
    155155/* Generic Operations                                                      */ 
    156156 
    157 template <class ContainerT, class RootObjectT> 
     157template <class ObjectT, class RootObjectT> 
    158158inline bool 
    159 EditSFieldHandle<SField<ParentPointer<ContainerT, 
     159EditSFieldHandle<SField<ParentPointer<ObjectT, 
    160160                                      RootObjectT> > >::equal(Inherited::Ptr rhs) 
    161161{ 
    …… 
    173173} 
    174174     
    175 template <class ContainerT, class RootObjectT> 
    176 inline void 
    177 EditSFieldHandle<SField<ParentPointer<ContainerT, 
     175template <class ObjectT, class RootObjectT> 
     176inline void 
     177EditSFieldHandle<SField<ParentPointer<ObjectT, 
    178178                                      RootObjectT> > >::copyValues( 
    179179    GetFieldHandlePtr source) 
    180180{ 
    181     FWARNING(("Illegal EditSFieldHandle<SField<ParentPointer<ContainerT> > >" 
     181    FWARNING(("Illegal EditSFieldHandle<SField<ParentPointer<ObjectT> > >" 
    182182              "::copyValues() called for %s\n",  
    183183              this->getName().c_str())); 
    …… 
    185185}                                
    186186                                  
    187 template <class ContainerT, class RootObjectT> 
    188 inline void 
    189 EditSFieldHandle<SField<ParentPointer<ContainerT, 
     187template <class ObjectT, class RootObjectT> 
     188inline void 
     189EditSFieldHandle<SField<ParentPointer<ObjectT, 
    190190                                      RootObjectT> > >::shareValues( 
    191191    GetFieldHandlePtr source) 
    192192{ 
    193     FWARNING(("Illegal EditSFieldHandle<SField<ParentPointer<ContainerT> > >" 
     193    FWARNING(("Illegal EditSFieldHandle<SField<ParentPointer<ObjectT> > >" 
    194194              "::shareValues() called for %s\n",  
    195195              this->getName().c_str())); 
    …… 
    197197} 
    198198 
    199 template <class ContainerT, class RootObjectT> 
    200 inline void 
    201 EditSFieldHandle<SField<ParentPointer<ContainerT, 
     199template <class ObjectT, class RootObjectT> 
     200inline void 
     201EditSFieldHandle<SField<ParentPointer<ObjectT, 
    202202                                      RootObjectT> > >::cloneValues( 
    203203    GetFieldHandlePtr        pSrc, 
    …… 
    207207    TypeIdVector      const &ignoreGroupIds = TypeIdVector ()) const 
    208208{ 
    209     FWARNING(("Illegal EditSFieldHandle<SField<ParentPointer<ContainerT> > >" 
     209    FWARNING(("Illegal EditSFieldHandle<SField<ParentPointer<ObjectT> > >" 
    210210              "::cloneValues() called for %s\n",  
    211211              this->getName().c_str())); 
    …… 
    216216/* Access                                                                  */ 
    217217 
    218 template <class ContainerT, class RootObjectT> 
     218template <class ObjectT, class RootObjectT> 
    219219inline typename  
    220     EditSFieldHandle<SField<ParentPointer<ContainerT, 
     220    EditSFieldHandle<SField<ParentPointer<ObjectT, 
    221221                                          RootObjectT> > >:HandledFieldType * 
    222 EditSFieldHandle<SField<ParentPointer<ContainerT, 
     222EditSFieldHandle<SField<ParentPointer<ObjectT, 
    223223                                      RootObjectT> > >::operator->(void) 
    224224{ 
    …… 
    226226} 
    227227 
    228 template <class ContainerT, class RootObjectT> 
     228template <class ObjectT, class RootObjectT> 
    229229inline typename  
    230     EditSFieldHandle<SField<ParentPointer<ContainerT, 
     230    EditSFieldHandle<SField<ParentPointer<ObjectT, 
    231231                                          RootObjectT> > >::HandledFieldType & 
    232 EditSFieldHandle<SField<ParentPointer<ContainerT, 
     232EditSFieldHandle<SField<ParentPointer<ObjectT, 
    233233                                      RootObjectT> > >::operator*(void) 
    234234{ 

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Fields/OSGParentPointerGetMFieldHandle.h

    r976 r980  
    5353OSG_BEGIN_NAMESPACE 
    5454 
    55 template <class ContainerT, class RootObjectT> 
     55template <class ObjectT, class RootObjectT> 
    5656class OSG_SYSTEM_DLLMAPPING 
    57     GetMFieldHandle<MField<ParentPointer<ContainerT, RootObjectT> > > 
     57    GetMFieldHandle<MField<ParentPointer<ObjectT, RootObjectT> > > 
    5858    : public GetFieldHandle 
    5959{ 
    …… 
    6767    typedef boost::shared_ptr<GetMFieldHandle>     Ptr; 
    6868     
    69     typedef MField<ParentPointer<ContainerT, 
     69    typedef MField<ParentPointer<ObjectT, 
    7070                                 RootObjectT> >    HandledFieldType; 
    7171    typedef typename HandledFieldType::StoredType  HandledFieldStoredType; 

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Fields/OSGParentPointerGetMFieldHandle.inl

    r976 r980  
    5050 
    5151/*-------------------------------------------------------------------------*/ 
    52 /* GetMFieldHandle<MField<ParentPointer<ContainerT,                        */ 
     52/* GetMFieldHandle<MField<ParentPointer<ObjectT,                           */ 
    5353/*                                      RootObjectT> > >                   */ 
    5454/*-------------------------------------------------------------------------*/ 
    …… 
    5757/* Constructors                                                            */ 
    5858 
    59 template <class ContainerT, class RootObjectT> 
     59template <class ObjectT, class RootObjectT> 
    6060inline 
    61 GetMFieldHandle<MField<ParentPointer<ContainerT, 
     61GetMFieldHandle<MField<ParentPointer<ObjectT, 
    6262                                     RootObjectT> > >::GetMFieldHandle( 
    6363    GetMFieldHandle const &source) 
    …… 
    6666} 
    6767 
    68 template <class ContainerT, class RootObjectT> 
     68template <class ObjectT, class RootObjectT> 
    6969inline 
    70 GetMFieldHandle<MField<ParentPointer<ContainerT, 
     70GetMFieldHandle<MField<ParentPointer<ObjectT, 
    7171                                     RootObjectT> > >::GetMFieldHandle( 
    7272    HandledFieldType     const *pField,  
    …… 
    7979/* Desctructor                                                             */ 
    8080 
    81 template <class ContainerT, class RootObjectT> 
     81template <class ObjectT, class RootObjectT> 
    8282inline 
    83 GetMFieldHandle<MField<ParentPointer<Container</