feedc0de/boost_smart_ptr
1
0
Fork 0
forked from boostorg/smart_ptr
Code Pull Requests Activity

Refactored and optimized enable_shared_from_this

Browse Source 
[SVN r44782]
This commit is contained in:
Daniel Frey
2008-04-26 19:59:11 +00:00
parent 6f8dc5923c
commit a01e4c3f83
2 changed files with 52 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
include/boost/detail/shared_count.hpp
View File

@ -373,6 +373,11 @@ public:
return pi_ != 0? pi_->use_count(): 0;
}
bool empty() const // nothrow
{
return pi_ == 0;
}
friend inline bool operator==(weak_count const & a, weak_count const & b)
{
return a.pi_ == b.pi_;

103
include/boost/enable_shared_from_this.hpp
View File

@ -13,7 +13,6 @@
// http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
//
#include <boost/detail/shared_count.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/assert.hpp>
#include <boost/config.hpp>
@ -21,35 +20,19 @@
namespace boost
{
template<class T> class enable_shared_from_this
template< class T > class enable_shared_from_this;
template< class T, class Y > void sp_accept_owner( shared_ptr<Y> * ptr, enable_shared_from_this<T> const * pe );
template< class T, class Y > void sp_accept_owner( shared_ptr<Y> * ptr, enable_shared_from_this<T> const * pe, void * /*pd*/ );
template< class T > class enable_shared_from_this
{
void init_internal_shared_once() const
{
if( !owned() && _internal_shared_count.empty() )
{
detail::shared_count( (void*)0, detail::sp_deleter_wrapper() ).swap(_internal_shared_count);
_internal_weak_count = _internal_shared_count;
}
}
bool owned() const
{
return _owned;
}
mutable detail::shared_count _internal_shared_count;
mutable detail::weak_count _internal_weak_count;
mutable bool _owned;
protected:
enable_shared_from_this():
_owned(false)
enable_shared_from_this()
{
}
enable_shared_from_this(enable_shared_from_this const &):
_owned(false)
enable_shared_from_this(enable_shared_from_this const &)
{
}
@ -64,69 +47,77 @@ protected:
// make sure no dangling shared_ptr objects were created by the
// user calling shared_from_this() but never passing ownership of the object
// to a shared_ptr.
BOOST_ASSERT(owned() || _internal_shared_count.use_count() <= 1);
BOOST_ASSERT( _shared_count.use_count() <= 1 );
}
public:
shared_ptr<T> shared_from_this()
{
init_internal_shared_once();
T * p = dynamic_cast<T *>(this);
return shared_ptr<T>( detail::shared_count( _internal_weak_count ), p );
init_weak_once();
T * p = dynamic_cast<T *>( this );
return shared_ptr<T>( detail::shared_count( _weak_count ), p );
}
shared_ptr<T const> shared_from_this() const
{
init_internal_shared_once();
T const * p = dynamic_cast<T const *>(this);
return shared_ptr<T const>( detail::shared_count( _internal_weak_count ), p );
init_weak_once();
T const * p = dynamic_cast<T const *>( this );
return shared_ptr<T const>( detail::shared_count( _weak_count ), p );
}
private:
mutable detail::weak_count _weak_count;
mutable detail::shared_count _shared_count;
void init_weak_once() const
{
if( _weak_count.empty() )
{
detail::shared_count( (void*)0, detail::sp_deleter_wrapper() ).swap( _shared_count );
_weak_count = _shared_count;
}
}
template<typename U>
void _internal_accept_owner(shared_ptr<U> &owner) const
void sp_accept_owner( shared_ptr<U> & owner ) const
{
if( !_owned )
if( _weak_count.use_count() == 0 )
{
if( _internal_shared_count.empty() )
{
_internal_weak_count = owner.get_shared_count();
}else
{
BOOST_ASSERT(owner.unique()); // no weak_ptrs to owner should exist either, but there's no way to check that
typedef detail::sp_deleter_wrapper D;
D * pd = static_cast<D *>(_internal_shared_count.get_deleter(BOOST_SP_TYPEID(D)));
BOOST_ASSERT( pd != 0 );
pd->set_deleter(owner);
shared_ptr<U>( _internal_shared_count, owner.get() ).swap( owner );
detail::shared_count().swap(_internal_shared_count);
}
_owned = true;
_weak_count = owner.get_shared_count();
}else if( !_shared_count.empty() )
{
BOOST_ASSERT( owner.unique() ); // no weak_ptrs to owner should exist either, but there's no way to check that
typedef detail::sp_deleter_wrapper D;
D * pd = static_cast<D *>( _shared_count.get_deleter( BOOST_SP_TYPEID(D) ) );
BOOST_ASSERT( pd != 0 );
pd->set_deleter( owner );
owner.reset( _shared_count, owner.get() );
detail::shared_count().swap( _shared_count );
}
}
template< class U, class Y > friend void sp_accept_owner( shared_ptr<Y> * ptr, enable_shared_from_this<U> const * pe );
template< class U, class Y > friend void sp_accept_owner( shared_ptr<Y> * ptr, enable_shared_from_this<U> const * pe, void * /*pd*/ );
};
template< class T, class Y > inline void sp_accept_owner( boost::shared_ptr<Y> * ptr, boost::enable_shared_from_this<T> const * pe )
template< class T, class Y > inline void sp_accept_owner( shared_ptr<Y> * ptr, enable_shared_from_this<T> const * pe )
{
if( pe != 0 )
{
pe->_internal_accept_owner( *ptr );
pe->sp_accept_owner( *ptr );
}
}
template< class T, class Y > inline void sp_accept_owner( boost::shared_ptr<Y> * ptr, boost::enable_shared_from_this<T> const * pe, void * /*pd*/ )
template< class T, class Y > inline void sp_accept_owner( shared_ptr<Y> * ptr, enable_shared_from_this<T> const * pe, void * /*pd*/ )
{
if( pe != 0 )
{
pe->_internal_accept_owner( *ptr );
pe->sp_accept_owner( *ptr );
}
}
template< class T, class Y > inline void sp_accept_owner( boost::shared_ptr<Y> * /*ptr*/, boost::enable_shared_from_this<T> const * /*pe*/, boost::detail::sp_deleter_wrapper * /*pd*/ )
{
}
} // namespace boost
#endif // #ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED