Show
Ignore:
Timestamp:
10/20/07 18:11:52 (1 year ago)
Author:
cneumann
Message:

added: RootObjectT template paremter for ReferenceCountPointer?

and ParentPointer? templates - allows use for FieldBundles?

compile fixes - but still not done

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/Carsten_PtrWork/Source/System/FieldContainer/Base/OSGReferenceCountPointer.inl

    r973 r976  
    5454/*-------------------------------------------------------------------------*/ 
    5555 
    56 inline void 
    57 InternalRefCountPolicy::addRef(FieldContainerPtrConstArg pContainer) 
    58 { 
    59     addInternalRef(pContainer); 
    60 } 
    61      
    62 inline void 
    63 InternalRefCountPolicy::subRef(FieldContainerPtrConstArg pContainer) 
    64 { 
    65     subInternalRef(pContainer); 
    66 } 
    67      
    68 inline FieldContainerPtr 
    69 InternalRefCountPolicy::deref(FieldContainerPtrConstArg pContainer) 
    70 { 
    71     return pContainer; 
     56template <class RootObjectT> 
     57inline void 
     58InternalRefCountPolicy<RootObjectT>::addRef(RootObjectPtrConstArg rootObjectPtr) 
     59{ 
     60    addInternalRef(rootObjectPtr); 
     61} 
     62 
     63template <class RootObjectT>     
     64inline void 
     65InternalRefCountPolicy<RootObjectT>::subRef(RootObjectPtrConstArg rootObjectPtr) 
     66{ 
     67    subInternalRef(rootObjectPtr); 
     68} 
     69     
     70template <class RootObjectT> 
     71inline typename InternalRefCountPolicy<RootObjectT>::RootObjectPtr 
     72InternalRefCountPolicy<RootObjectT>::deref(RootObjectPtrConstArg rootObjectPtr) 
     73{ 
     74    return rootObjectPtr; 
    7275} 
    7376 
    …… 
    7679/*-------------------------------------------------------------------------*/ 
    7780 
    78 inline void 
    79 RefCountPolicy::addRef(FieldContainerPtrConstArg pContainer) 
    80 { 
    81     addExternalRef(pContainer); 
    82 } 
    83      
    84 inline void 
    85 RefCountPolicy::subRef(FieldContainerPtrConstArg pContainer) 
    86 { 
    87     subExternalRef(pContainer); 
    88 } 
    89      
    90 inline FieldContainerPtr 
    91 RefCountPolicy::deref(FieldContainerPtrConstArg pContainer) 
    92 { 
    93     return pContainer; 
    94 } 
    95  
    96 /*-------------------------------------------------------------------------*/ 
    97 /* MTRefCountPolicy                                                        */ 
    98 /*-------------------------------------------------------------------------*/ 
    99  
    100 inline void 
    101 RefCountPolicy::addRef(FieldContainerPtrConstArg pContainer) 
    102 { 
    103     addExternalRef(pContainer); 
    104 } 
    105      
    106 inline void 
    107 RefCountPolicy::subRef(FieldContainerPtrConstArg pContainer) 
    108 { 
    109     subExternalRef(pContainer); 
    110 } 
    111      
    112 inline FieldContainerPtr 
    113 RefCountPolicy::deref(FieldContainerPtrConstArg pContainer) 
    114 { 
    115     return pContainer->getAspectPtr(Thread::getCurrentAspect()); 
     81template <class RootObjectT> 
     82inline void 
     83RefCountPolicy<RootObjectT>::addRef(RootObjectPtrConstArg rootObjectPtr) 
     84{ 
     85    addExternalRef(rootObjectPtr); 
     86} 
     87 
     88template <class RootObjectT> 
     89inline void 
     90RefCountPolicy<RootObjectT>::subRef(RootObjectPtrConstArg rootObjectPtr) 
     91{ 
     92    subExternalRef(rootObjectPtr); 
     93} 
     94 
     95template <class RootObjectT> 
     96inline typename RefCountPolicy<RootObjectT>::RootObjectPtr 
     97RefCountPolicy<RootObjectT>::deref(RootObjectPtrConstArg rootObjectPtr) 
     98{ 
     99    return rootObjectPtr; 
     100} 
     101 
     102/*-------------------------------------------------------------------------*/ 
     103/* MTRefCountPolicy<FieldContainer>                                        */ 
     104/*-------------------------------------------------------------------------*/ 
     105 
     106template <> 
     107inline void 
     108MTRefCountPolicy<FieldContainer>::addRef(RootObjectPtrConstArg rootObjectPtr) 
     109{ 
     110    addExternalRef(rootObjectPtr); 
     111} 
     112     
     113template <> 
     114inline void 
     115MTRefCountPolicy<FieldContainer>::subRef(RootObjectPtrConstArg rootObjectPtr) 
     116{ 
     117    subExternalRef(rootObjectPtr); 
     118} 
     119     
     120template <> 
     121inline typename RefCountPolicy<FieldContainer>::RootObjectPtr 
     122MTRefCountPolicy<FieldContainer>::deref(RootObjectPtrConstArg rootObjectPtr) 
     123{ 
     124    return rootObjectPtr->getAspectPtr(Thread::getCurrentAspect()); 
     125} 
     126 
     127/*-------------------------------------------------------------------------*/ 
     128/* MTRefCountPolicy<FieldBundle>                                           */ 
     129/*-------------------------------------------------------------------------*/ 
     130 
     131template <> 
     132inline void 
     133MTRefCountPolicy<FieldBundle>::addRef(RootObjectPtrConstArg rootObjectPtr) 
     134{ 
     135    addExternalRef(rootObjectPtr); 
     136} 
     137     
     138template <> 
     139inline void 
     140MTRefCountPolicy<FieldBundle>::subRef(RootObjectPtrConstArg rootObjectPtr) 
     141{ 
     142    subExternalRef(rootObjectPtr); 
     143} 
     144     
     145template <> 
     146inline typename RefCountPolicy<FieldContainer>::RootObjectPtr 
     147MTRefCountPolicy<FieldBundle>::deref(RootObjectPtrConstArg rootObjectPtr) 
     148{ 
     149    return rootObjectPtr; 
    116150} 
    117151 
    …… 
    120154/*-------------------------------------------------------------------------*/ 
    121155 
    122 inline void 
    123 WeakRefCountPolicy::addRef(FieldContainerPtrConstArg pContainer) 
    124 { 
    125     addWeakRef(pContainer); 
    126 } 
    127      
    128 inline void 
    129 WeakRefCountPolicy::subRef(FieldContainerPtrConstArg pContainer) 
    130 { 
    131     subWeakRef(pContainer); 
    132 } 
    133      
    134 inline FieldContainerPtr 
    135 WeakRefCountPolicy::deref(FieldContainerPtrConstArg pContainer) 
    136 { 
    137     return pContainer; 
     156template <class RootObjectT> 
     157inline void 
     158WeakRefCountPolicy<RootObjectT>::addRef(RootObjectPtrConstArg rootObjectPtr) 
     159{ 
     160    addWeakRef(rootObjectPtr); 
     161} 
     162 
     163template <class RootObjectT> 
     164inline void 
     165WeakRefCountPolicy<RootObjectT>::subRef(RootObjectPtrConstArg rootObjectPtr) 
     166{ 
     167    subWeakRef(rootObjectPtr); 
     168} 
     169 
     170template <class RootObjectT> 
     171inline typename RefCountPolicy<RootObjectT>::RootObjectPtr 
     172WeakRefCountPolicy<RootObjectT>::deref(RootObjectPtrConstArg rootObjectPtr) 
     173{ 
     174    return rootObjectPtr; 
    138175} 
    139176 
    …… 
    145182/* Internal Helpers                                                        */ 
    146183 
    147 template <class ContainerT, class RefCountPolicyT> 
    148 inline FieldContainerPtr 
    149 ReferenceCountPointer<ContainerT, RefCountPolicyT>::castPtrUp( 
    150     ContainerPtrConstArg pContainer) const 
    151 { 
    152     return static_cast<FieldContainerPtr>(static_cast<void *>(pContainer)); 
    153 } 
    154  
    155 template <class ContainerT, class RefCountPolicyT> 
     184template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
     185inline typename  
     186    ReferenceCountPointer<ContainerT,  
     187                          RefCountPolicyT, 
     188                          RootObjectT     >::RootObjectPtr 
     189ReferenceCountPointer<ContainerT,  
     190                      RefCountPolicyT, 
     191                      RootObjectT     >::castPtrUp(ObjectPtrConstArg objectPtr) 
     192{ 
     193    return static_cast<RootObjectPtr>(static_cast<void *>(objectPtr)); 
     194} 
     195 
     196template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
    156197inline typename 
    157     ReferenceCountPointer<ContainerT, RefCountPolicyT>::ContainerPtr 
    158 ReferenceCountPointer<ContainerT, RefCountPolicyT>::castPtrDown( 
    159     FieldContainerPtrConstArg pContainer) const 
    160 { 
    161     return static_cast<ContainerPtr>(static_cast<void *>(pContainer)); 
    162 } 
    163  
    164 template <class ContainerT, class RefCountPolicyT> 
    165 inline void 
    166 ReferenceCountPointer<ContainerT, RefCountPolicyT>::internalSet( 
    167     FieldContainerPtrConstArg pNewContainer) 
    168 { 
    169     RefCountPolicy::addRef( pNewContainer); 
    170     RefCountPolicy::subRef(_pContainer   ); 
    171      
    172     _pContainer = pNewContainer; 
     198    ReferenceCountPointer<ContainerT,  
     199                          RefCountPolicyT, 
     200                          RootObjectT     >::ObjectPtr 
     201ReferenceCountPointer<ContainerT,  
     202                      RefCountPolicyT, 
     203                      RootObjectT     >::castPtrDown( 
     204    RootObjectPtrConstArg rootObjectPtr) 
     205{ 
     206    return static_cast<ContainerPtr>(static_cast<void *>(rootObjectPtr)); 
     207} 
     208 
     209template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
     210inline void 
     211ReferenceCountPointer<ContainerT,  
     212                      RefCountPolicyT, 
     213                      RootObjectT     >::internalSet( 
     214    RootObjectPtrConstArg rootObjectPtr) 
     215{ 
     216    RefCountPolicy::addRef( rootObjectPtr); 
     217    RefCountPolicy::subRef(_rootObjectPtr); 
     218     
     219    _rootObjectPtr = rootObjectPtr; 
    173220} 
    174221 
    …… 
    176223/* Constructors                                                            */ 
    177224 
    178 template <class ContainerT, class RefCountPolicyT> 
    179 inline 
    180 ReferenceCountPointer<ContainerT, RefCountPolicyT>::ReferenceCountPointer(void) 
    181     : _pContainer(NullFC) 
    182 { 
    183 } 
    184  
    185 template <class ContainerT, class RefCountPolicyT> 
    186 inline 
    187 ReferenceCountPointer<ContainerT, RefCountPolicyT>::ReferenceCountPointer( 
     225template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
     226inline 
     227ReferenceCountPointer<ContainerT,  
     228                      RefCountPolicyT, 
     229                      RootObjectT     >::ReferenceCountPointer(void) 
     230    : _rootObjectPtr(NullFC) 
     231{ 
     232} 
     233 
     234template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
     235inline 
     236ReferenceCountPointer<ContainerT,  
     237                      RefCountPolicyT, 
     238                      RootObjectT     >::ReferenceCountPointer( 
    188239    Self const &other) 
    189     : _pContainer(NullFC) 
    190 { 
    191     internalSet(other._pContainer); 
    192 } 
    193      
    194 template <class ContainerT, class RefCountPolicyT> 
    195 inline 
    196 ReferenceCountPointer<ContainerT, RefCountPolicyT>::ReferenceCountPointer( 
    197     ContainerPtrConstArg pContainer) 
    198     : _pContainer(NullFC) 
    199 { 
    200     internalSet(Self::castPtrUp(pContainer)); 
    201 } 
    202  
    203 template <class OtherContainerT, class OtherRefCountPolicy> 
    204 inline 
    205 ReferenceCountPointer<ContainerT, RefCountPolicyT>::ReferenceCountPointer( 
    206     RefrenceCountPointer<OtherContainerT, OtherRefCountPolicy> const &refPtr) 
     240    : _rootObjectPtr(NullFC) 
     241{ 
     242    internalSet(other._rootObjectPtr); 
     243} 
     244     
     245template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
     246inline 
     247ReferenceCountPointer<ContainerT,  
     248                      RefCountPolicyT, 
     249                      RootObjectT     >::ReferenceCountPointer( 
     250    ObjectPtrConstArg objectPtr) 
     251    : _rootObjectPtr(NullFC) 
     252{ 
     253    internalSet(Self::castPtrUp(objectPtr)); 
     254} 
     255 
     256template <class ContainerT,      class RefCountPolicyT,     class RootObjectT> 
     257template <class OtherContainerT, class OtherRefCountPolicyT                  > 
     258inline 
     259ReferenceCountPointer<ContainerT,  
     260                      RefCountPolicyT, 
     261                      RootObjectT     >::ReferenceCountPointer( 
     262    ReferenceCountPointer<OtherContainerT, 
     263                          OtherRefCountPolicyT, 
     264                          RootObjectT          > const &refPtr) 
    207265    : _pContainer(NullFC) 
    208266{ 
    …… 
    221279/* Destructor                                                              */ 
    222280 
    223 template <class ContainerT, class RefCountPolicyT> 
    224 inline 
    225 ReferenceCountPointer<ContainerT, RefCountPolicyT>::~ReferenceCountPointer(void) 
     281template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
     282inline 
     283ReferenceCountPointer<ContainerT,  
     284                      RefCountPolicyT, 
     285                      RootObjectT     >::~ReferenceCountPointer(void) 
    226286{ 
    227287    internalSet(NullFC); 
    …… 
    231291/* Assignment                                                              */ 
    232292 
    233 template <class ContainerT, class RefCountPolicyT> 
     293template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
    234294inline typename ReferenceCountContainer<ContainerT, RefCountPolicyT>::Self & 
    235 ReferenceCountPointer<ContainerT, RefCountPolicyT>::operator=(Self const &other) 
    236 { 
    237     internalSet(other._pContainer); 
     295ReferenceCountPointer<ContainerT,  
     296                      RefCountPolicyT, 
     297                      RootObjectT     >::operator=(Self const &other) 
     298{ 
     299    internalSet(other._rootObjectPtr); 
    238300     
    239301    return *this; 
    240302} 
    241303 
    242 template <class ContainerT, class RefCountPolicyT> 
    243 inline typename ReferenceCountContainer<ContainerT, RefCountPolicyT>::Self & 
    244 ReferenceCountPointer<ContainerT, RefCountPolicyT>::operator=( 
    245     ContainerPtrConstArg pContainer) 
    246 { 
    247     internalSet(Self::castPtrUp(pContainer)); 
     304template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
     305inline typename  
     306    ReferenceCountPointer<ContainerT,  
     307                          RefCountPolicyT, 
     308                          RootObjectT     >::Self & 
     309ReferenceCountPointer<ContainerT,  
     310                      RefCountPolicyT, 
     311                      RootObjectT     >::operator=( 
     312    ObjectPtrConstArg objectPtr) 
     313{ 
     314    internalSet(Self::castPtrUp(objectPtr)); 
    248315     
    249316    return *this; 
    250317} 
    251318 
    252 template <class ContainerT, class RefCountPolicyT> 
    253 inline typename ReferenceCountContainer<ContainerT, RefCountPolicyT>::Self & 
    254 ReferenceCountPointer<ContainerT, RefCountPolicyT>::operator=( 
     319template <class ContainerT,      class RefCountPolicyT,     class RootObjectT> 
     320template <class OtherContainerT, class OtherRefCountPolicyT                  > 
     321inline typename  
     322    ReferenceCountPointer<ContainerT,  
     323                          RefCountPolicyT, 
     324                          RootObjectT     > 
     325ReferenceCountPointer<ContainerT,  
     326                      RefCountPolicyT, 
     327                      RootObjectT     >::operator=( 
    255328    ReferenceCountPointer<OtherContainerT, 
    256                           OtherRefCountPolicy> const &refPtr) 
     329                          OtherRefCountPolicy, 
     330                          RootObjectT         > const &refPtr) 
    257331{ 
    258332// //     This requires ContainerT and OtherContainerT to be a complete types 
    …… 
    272346/* Conversion                                                              */ 
    273347 
    274 template <class ContainerT, class RefCountPolicyT> 
    275 inline 
    276 ReferenceCountPointer<ContainerT, RefCountPolicyT>:: 
    277     operator ContainerPtr(void) const 
    278 { 
    279     return Self::castPtrDown(RefCountPolicy::deref(_pContainer)); 
     348template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
     349inline 
     350ReferenceCountPointer<ContainerT,  
     351                      RefCountPolicyT, 
     352                      RootObjectT     >::operator ObjectPtr(void) const 
     353{ 
     354    return Self::castPtrDown(RefCountPolicy::deref(_rootObjectPtr)); 
    280355} 
    281356 
    …… 
    283358/* Access                                                                  */ 
    284359 
    285 template <class ContainerT, class RefCountPolicyT> 
    286 inline typename ReferenceCountPointer<ContainerT, RefCountPolicy>::ContainerPtr 
    287 ReferenceCountPointer<ContainerT, RefCountPolicyT>::operator->(void) const 
    288 { 
    289     return Self::castPtrDown(RefCountPolicy::deref(_pContainer)); 
    290 } 
    291  
    292 template <class ContainerT, class RefCountPolicyT> 
    293 inline typename ReferenceCountPointer<ContainerT, RefCountPolicy>::Container & 
    294 ReferenceCountPointer<ContainerT, RefCountPolicyT>::operator*(void) const 
    295 { 
    296     return *(Self::castPtrDown(RefCountPolicy::deref(_pContainer))); 
    297 } 
    298  
    299 template <class ContainerT, class RefCountPolicyT> 
    300 inline typename ReferenceCountPointer<ContainerT, RefCountPolicy>::ContainerPtr 
    301 ReferenceCountPointer<ContainerT, RefCountPolicyT>::get(void) const 
    302 { 
    303     return Self::castPtrDown(RefCountPolicy::deref(_pContainer)); 
    304 } 
    305  
    306 template <class ContainerT, class RefCountPolicyT> 
    307 inline void 
    308 ReferenceCountPointer<ContainerT, RefCountPolicyT>::set( 
    309     ContainerPtrConstArg pContainer) 
    310 { 
    311     _pContainer = Self::castPtrUp(pContainer); 
    312 } 
    313  
    314 template <class ContainerT, class RefCountPolicyT> 
    315 inline void 
    316 ReferenceCountPointer<ContainerT, RefCountPolicyT>::swap(Self &other) 
    317 { 
    318     std::swap(_pContainer, other._pContainer); 
     360template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
     361inline typename 
     362    ReferenceCountPointer<ContainerT,  
     363                      RefCountPolicyT, 
     364                      RootObjectT     >::ObjectPtr 
     365ReferenceCountPointer<ContainerT,  
     366                      RefCountPolicyT, 
     367                      RootObjectT     >::operator->(void) const 
     368{ 
     369    return Self::castPtrDown(RefCountPolicy::deref(_rootObjectPtr)); 
     370} 
     371 
     372template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
     373inline typename  
     374    ReferenceCountPointer<ContainerT,  
     375                      RefCountPolicyT, 
     376                      RootObjectT     >::Object & 
     377ReferenceCountPointer<ContainerT,  
     378                      RefCountPolicyT, 
     379                      RootObjectT     >::operator*(void) const 
     380{ 
     381    return *(Self::castPtrDown(RefCountPolicy::deref(_rootObjectPtr))); 
     382} 
     383 
     384template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
     385inline typename 
     386    ReferenceCountPointer<ContainerT,  
     387                      RefCountPolicyT, 
     388                      RootObjectT     >::ObjectPtr 
     389ReferenceCountPointer<ContainerT,  
     390                      RefCountPolicyT, 
     391                      RootObjectT     >::get(void) const 
     392{ 
     393    return Self::castPtrDown(RefCountPolicy::deref(_rootObjectPtr)); 
     394} 
     395 
     396template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
     397inline void 
     398ReferenceCountPointer<ContainerT,  
     399                      RefCountPolicyT, 
     400                      RootObjectT     >::set( 
     401    ObjectPtrConstArg objectPtr) 
     402{ 
     403    _objectPtr = Self::castPtrUp(objectPtr); 
     404} 
     405 
     406template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
     407inline void 
     408ReferenceCountPointer<ContainerT,  
     409                      RefCountPolicyT, 
     410                      RootObjectT     >::swap(Self &other) 
     411{ 
     412    std::swap(_rootObjectPtr, other._rootObjectPtr); 
    319413} 
    320414 
    …… 
    322416/* Comparison                                                              */ 
    323417 
    324 template <class ContainerT, class RefCountPolicyT> 
     418template <class ContainerT, class RefCountPolicyT, class RootObjectT> 
    325419inline bool 
    326 operator!(ReferenceCountPointer<ContainerT, RefCountPolicyT> const &refPtr) 
     420operator!(ReferenceCountPointer<ContainerT,  
     421                                RefCountPolicyT, 
     422                                RootObjectT     > const &refPtr) 
    327423{ 
    328424    return (static_cast<void *>(refPtr.get()) == 0); 
    …… 
    330426 
    331427template <class LHSContainerT, class LHSRefCountPolicyT, 
    332           class RHSContainerT, class RHSRefCountPolicyT > 
     428          class RHSContainerT, class RHSRefCountPolicyT, 
     429          class RootObjectT                             > 
    333430inline bool 
    334 operator==(ReferenceCountPointer<LHSContainerT, LHSRefCountPolicyT> const &lhs, 
    335            ReferenceCountPointer<RHSContainerT, RHSRefCountPolicyT> const &rhs) 
     431operator==(ReferenceCountPointer<LHSContainerT,  
     432                                 LHSRefCountPolicyT, 
     433                                 RootObjectT        > const &lhs, 
     434           ReferenceCountPointer<RHSContainerT, 
     435                                 RHSRefCountPolicyT, 
     436                                 RootObjectT        > const &rhs) 
    336437{ 
    337438    return (static_cast<void *>(lhs.get()) == static_cast<void *>(rhs.get())); 
    …… 
    339440 
    340441template <class LHSContainerT, class LHSRefCountPolicyT, 
    341           class RHSContainerT, class RHSRefCountPolicyT > 
     442          class RHSContainerT, class RHSRefCountPolicyT, 
     443          class RootObjectT                             > 
    342444inline bool 
    343 operator!=(ReferenceCountPointer<LHSContainerT, LHSRefCountPolicyT> const &lhs, 
    344            ReferenceCountPointer<RHSContainerT, RHSRefCountPolicyT> const &rhs) 
     445operator!=(ReferenceCountPointer<LHSContainerT, 
     446                                 LHSRefCountPolicyT, 
     447                                 RootObjectT        > const &lhs, 
     448           ReferenceCountPointer<RHSContainerT, 
     449                                 RHSRefCountPolicyT, 
     450                                 RootObjectT        > const &rhs) 
    345451{ 
    346452    return (static_cast<void *>(lhs.get()) != static_cast<void *>(rhs.get())); 
    …… 
    348454 
    349455template <class LHSContainerT, class LHSRefCountPolicyT, 
    350           class RHSContainerT, class RHSRefCountPolicyT > 
     456          class RHSContainerT, class RHSRefCountPolicyT, 
     457          class RootObjectT                             > 
    351458inline bool 
    352 operator<(ReferenceCountPointer<LHSContainerT, LHSRefCountPolicyT> const &lhs, 
    353           ReferenceCountPointer<RHSContainerT, RHSRefCountPolicyT> const &rhs) 
     459operator<(ReferenceCountPointer<LHSContainerT, 
     460                                LHSRefCountPolicyT, 
     461                                RootObject         > const &lhs, 
     462          ReferenceCountPointer<RHSContainerT, 
     463                                RHSRefCountPolicyT, 
     464                                RootObjectT        > const &rhs) 
    354465{ 
    355466    return std::less(static_cast<void *>(lhs.get()),