Files

711 lines
19 KiB
C++

#ifndef ACTIV_BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED
#define ACTIV_BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED
// local_shared_ptr.hpp
//
// Copyright 2017 Peter Dimov
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/smart_ptr/ for documentation.
#include <ActivBoost/smart_ptr/shared_ptr.hpp>
namespace Boost
{
template<class T> class local_shared_ptr;
namespace detail
{
template< class E, class Y > inline void lsp_pointer_construct( Boost::local_shared_ptr< E > * /*ppx*/, Y * p, Boost::detail::local_counted_base * & pn )
{
Boost::detail::sp_assert_convertible< Y, E >();
typedef Boost::detail::local_sp_deleter< Boost::checked_deleter<Y> > D;
Boost::shared_ptr<E> p2( p, D() );
D * pd = static_cast< D * >( p2._internal_get_untyped_deleter() );
pd->pn_ = p2._internal_count();
pn = pd;
}
template< class E, class Y > inline void lsp_pointer_construct( Boost::local_shared_ptr< E[] > * /*ppx*/, Y * p, Boost::detail::local_counted_base * & pn )
{
Boost::detail::sp_assert_convertible< Y[], E[] >();
typedef Boost::detail::local_sp_deleter< Boost::checked_array_deleter<E> > D;
Boost::shared_ptr<E[]> p2( p, D() );
D * pd = static_cast< D * >( p2._internal_get_untyped_deleter() );
pd->pn_ = p2._internal_count();
pn = pd;
}
template< class E, std::size_t N, class Y > inline void lsp_pointer_construct( Boost::local_shared_ptr< E[N] > * /*ppx*/, Y * p, Boost::detail::local_counted_base * & pn )
{
Boost::detail::sp_assert_convertible< Y[N], E[N] >();
typedef Boost::detail::local_sp_deleter< Boost::checked_array_deleter<E> > D;
Boost::shared_ptr<E[N]> p2( p, D() );
D * pd = static_cast< D * >( p2._internal_get_untyped_deleter() );
pd->pn_ = p2._internal_count();
pn = pd;
}
template< class E, class P, class D > inline void lsp_deleter_construct( Boost::local_shared_ptr< E > * /*ppx*/, P p, D const& d, Boost::detail::local_counted_base * & pn )
{
typedef Boost::detail::local_sp_deleter<D> D2;
Boost::shared_ptr<E> p2( p, D2( d ) );
D2 * pd = static_cast< D2 * >( p2._internal_get_untyped_deleter() );
pd->pn_ = p2._internal_count();
pn = pd;
}
template< class E, class P, class D, class A > inline void lsp_allocator_construct( Boost::local_shared_ptr< E > * /*ppx*/, P p, D const& d, A const& a, Boost::detail::local_counted_base * & pn )
{
typedef Boost::detail::local_sp_deleter<D> D2;
Boost::shared_ptr<E> p2( p, D2( d ), a );
D2 * pd = static_cast< D2 * >( p2._internal_get_untyped_deleter() );
pd->pn_ = p2._internal_count();
pn = pd;
}
struct lsp_internal_constructor_tag
{
};
} // namespace detail
//
// local_shared_ptr
//
// as shared_ptr, but local to a thread.
// reference count manipulations are non-atomic.
//
template<class T> class local_shared_ptr
{
private:
typedef local_shared_ptr this_type;
public:
typedef typename Boost::detail::sp_element<T>::type element_type;
private:
element_type * px;
Boost::detail::local_counted_base * pn;
template<class Y> friend class local_shared_ptr;
public:
// destructor
~local_shared_ptr() ACTIV_BOOST_SP_NOEXCEPT
{
if( pn )
{
pn->release();
}
}
// constructors
ACTIV_BOOST_CONSTEXPR local_shared_ptr() ACTIV_BOOST_SP_NOEXCEPT : px( 0 ), pn( 0 )
{
}
#if !defined( ACTIV_BOOST_NO_CXX11_NULLPTR )
ACTIV_BOOST_CONSTEXPR local_shared_ptr( Boost::detail::sp_nullptr_t ) ACTIV_BOOST_SP_NOEXCEPT : px( 0 ), pn( 0 )
{
}
#endif
// internal constructor, used by make_shared
ACTIV_BOOST_CONSTEXPR local_shared_ptr( Boost::detail::lsp_internal_constructor_tag, element_type * px_, Boost::detail::local_counted_base * pn_ ) ACTIV_BOOST_SP_NOEXCEPT : px( px_ ), pn( pn_ )
{
}
template<class Y>
explicit local_shared_ptr( Y * p ): px( p ), pn( 0 )
{
Boost::detail::lsp_pointer_construct( this, p, pn );
}
template<class Y, class D> local_shared_ptr( Y * p, D d ): px( p ), pn( 0 )
{
Boost::detail::lsp_deleter_construct( this, p, d, pn );
}
#if !defined( ACTIV_BOOST_NO_CXX11_NULLPTR )
template<class D> local_shared_ptr( Boost::detail::sp_nullptr_t p, D d ): px( p ), pn( 0 )
{
Boost::detail::lsp_deleter_construct( this, p, d, pn );
}
#endif
template<class Y, class D, class A> local_shared_ptr( Y * p, D d, A a ): px( p ), pn( 0 )
{
Boost::detail::lsp_allocator_construct( this, p, d, a, pn );
}
#if !defined( ACTIV_BOOST_NO_CXX11_NULLPTR )
template<class D, class A> local_shared_ptr( Boost::detail::sp_nullptr_t p, D d, A a ): px( p ), pn( 0 )
{
Boost::detail::lsp_allocator_construct( this, p, d, a, pn );
}
#endif
// construction from shared_ptr
template<class Y> local_shared_ptr( shared_ptr<Y> const & r,
typename Boost::detail::sp_enable_if_convertible<Y, T>::type = Boost::detail::sp_empty() )
: px( r.get() ), pn( 0 )
{
Boost::detail::sp_assert_convertible< Y, T >();
if( r.use_count() != 0 )
{
pn = new Boost::detail::local_counted_impl( r._internal_count() );
}
}
#if !defined( ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES )
template<class Y> local_shared_ptr( shared_ptr<Y> && r,
typename Boost::detail::sp_enable_if_convertible<Y, T>::type = Boost::detail::sp_empty() )
: px( r.get() ), pn( 0 )
{
Boost::detail::sp_assert_convertible< Y, T >();
if( r.use_count() != 0 )
{
pn = new Boost::detail::local_counted_impl( r._internal_count() );
r.reset();
}
}
#endif
// construction from unique_ptr
#if !defined( ACTIV_BOOST_NO_CXX11_SMART_PTR ) && !defined( ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES )
template< class Y, class D >
local_shared_ptr( std::unique_ptr< Y, D > && r,
typename Boost::detail::sp_enable_if_convertible<Y, T>::type = Boost::detail::sp_empty() )
: px( r.get() ), pn( 0 )
{
Boost::detail::sp_assert_convertible< Y, T >();
if( px )
{
pn = new Boost::detail::local_counted_impl( shared_ptr<T>( std::move(r) )._internal_count() );
}
}
#endif
template< class Y, class D >
local_shared_ptr( Boost::movelib::unique_ptr< Y, D > r ); // !
// : px( r.get() ), pn( new Boost::detail::local_counted_impl( shared_ptr<T>( std::move(r) ) ) )
//{
// Boost::detail::sp_assert_convertible< Y, T >();
//}
// copy constructor
local_shared_ptr( local_shared_ptr const & r ) ACTIV_BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
{
if( pn )
{
pn->add_ref();
}
}
// move constructor
#if !defined( ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES )
local_shared_ptr( local_shared_ptr && r ) ACTIV_BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
{
r.px = 0;
r.pn = 0;
}
#endif
// converting copy constructor
template<class Y> local_shared_ptr( local_shared_ptr<Y> const & r,
typename Boost::detail::sp_enable_if_convertible<Y, T>::type = Boost::detail::sp_empty() ) ACTIV_BOOST_SP_NOEXCEPT
: px( r.px ), pn( r.pn )
{
Boost::detail::sp_assert_convertible< Y, T >();
if( pn )
{
pn->add_ref();
}
}
// converting move constructor
#if !defined( ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES )
template<class Y> local_shared_ptr( local_shared_ptr<Y> && r,
typename Boost::detail::sp_enable_if_convertible<Y, T>::type = Boost::detail::sp_empty() ) ACTIV_BOOST_SP_NOEXCEPT
: px( r.px ), pn( r.pn )
{
Boost::detail::sp_assert_convertible< Y, T >();
r.px = 0;
r.pn = 0;
}
#endif
// aliasing
template<class Y>
local_shared_ptr( local_shared_ptr<Y> const & r, element_type * p ) ACTIV_BOOST_SP_NOEXCEPT : px( p ), pn( r.pn )
{
if( pn )
{
pn->add_ref();
}
}
#if !defined( ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES )
template<class Y>
local_shared_ptr( local_shared_ptr<Y> && r, element_type * p ) ACTIV_BOOST_SP_NOEXCEPT : px( p ), pn( r.pn )
{
r.px = 0;
r.pn = 0;
}
#endif
// assignment
local_shared_ptr & operator=( local_shared_ptr const & r ) ACTIV_BOOST_SP_NOEXCEPT
{
local_shared_ptr( r ).swap( *this );
return *this;
}
template<class Y> local_shared_ptr & operator=( local_shared_ptr<Y> const & r ) ACTIV_BOOST_SP_NOEXCEPT
{
local_shared_ptr( r ).swap( *this );
return *this;
}
#if !defined( ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES )
local_shared_ptr & operator=( local_shared_ptr && r ) ACTIV_BOOST_SP_NOEXCEPT
{
local_shared_ptr( std::move( r ) ).swap( *this );
return *this;
}
template<class Y>
local_shared_ptr & operator=( local_shared_ptr<Y> && r ) ACTIV_BOOST_SP_NOEXCEPT
{
local_shared_ptr( std::move( r ) ).swap( *this );
return *this;
}
#endif
#if !defined( ACTIV_BOOST_NO_CXX11_NULLPTR )
local_shared_ptr & operator=( Boost::detail::sp_nullptr_t ) ACTIV_BOOST_SP_NOEXCEPT
{
local_shared_ptr().swap(*this);
return *this;
}
#endif
#if !defined( ACTIV_BOOST_NO_CXX11_SMART_PTR ) && !defined( ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES )
template<class Y, class D>
local_shared_ptr & operator=( std::unique_ptr<Y, D> && r )
{
local_shared_ptr( std::move(r) ).swap( *this );
return *this;
}
#endif
template<class Y, class D>
local_shared_ptr & operator=( Boost::movelib::unique_ptr<Y, D> r ); // !
// reset
void reset() ACTIV_BOOST_SP_NOEXCEPT
{
local_shared_ptr().swap( *this );
}
template<class Y> void reset( Y * p ) // Y must be complete
{
local_shared_ptr( p ).swap( *this );
}
template<class Y, class D> void reset( Y * p, D d )
{
local_shared_ptr( p, d ).swap( *this );
}
template<class Y, class D, class A> void reset( Y * p, D d, A a )
{
local_shared_ptr( p, d, a ).swap( *this );
}
template<class Y> void reset( local_shared_ptr<Y> const & r, element_type * p ) ACTIV_BOOST_SP_NOEXCEPT
{
local_shared_ptr( r, p ).swap( *this );
}
#if !defined( ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES )
template<class Y> void reset( local_shared_ptr<Y> && r, element_type * p ) ACTIV_BOOST_SP_NOEXCEPT
{
local_shared_ptr( std::move( r ), p ).swap( *this );
}
#endif
// accessors
typename Boost::detail::sp_dereference< T >::type operator* () const ACTIV_BOOST_SP_NOEXCEPT
{
return *px;
}
typename Boost::detail::sp_member_access< T >::type operator-> () const ACTIV_BOOST_SP_NOEXCEPT
{
return px;
}
typename Boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const ACTIV_BOOST_SP_NOEXCEPT_WITH_ASSERT
{
ACTIV_BOOST_ASSERT( px != 0 );
ACTIV_BOOST_ASSERT( i >= 0 && ( i < Boost::detail::sp_extent< T >::value || Boost::detail::sp_extent< T >::value == 0 ) );
return static_cast< typename Boost::detail::sp_array_access< T >::type >( px[ i ] );
}
element_type * get() const ACTIV_BOOST_SP_NOEXCEPT
{
return px;
}
// implicit conversion to "bool"
#include <ActivBoost/smart_ptr/detail/operator_bool.hpp>
long local_use_count() const ACTIV_BOOST_SP_NOEXCEPT
{
return pn? pn->local_use_count(): 0;
}
// conversions to shared_ptr, weak_ptr
#if !defined( ACTIV_BOOST_SP_NO_SP_CONVERTIBLE ) && !defined(ACTIV_BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
template<class Y, class E = typename Boost::detail::sp_enable_if_convertible<T,Y>::type> operator shared_ptr<Y>() const ACTIV_BOOST_SP_NOEXCEPT
#else
template<class Y> operator shared_ptr<Y>() const ACTIV_BOOST_SP_NOEXCEPT
#endif
{
Boost::detail::sp_assert_convertible<T, Y>();
if( pn )
{
return shared_ptr<Y>( Boost::detail::sp_internal_constructor_tag(), px, pn->local_cb_get_shared_count() );
}
else
{
return shared_ptr<Y>();
}
}
#if !defined( ACTIV_BOOST_SP_NO_SP_CONVERTIBLE ) && !defined(ACTIV_BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
template<class Y, class E = typename Boost::detail::sp_enable_if_convertible<T,Y>::type> operator weak_ptr<Y>() const ACTIV_BOOST_SP_NOEXCEPT
#else
template<class Y> operator weak_ptr<Y>() const ACTIV_BOOST_SP_NOEXCEPT
#endif
{
Boost::detail::sp_assert_convertible<T, Y>();
if( pn )
{
return shared_ptr<Y>( Boost::detail::sp_internal_constructor_tag(), px, pn->local_cb_get_shared_count() );
}
else
{
return weak_ptr<Y>();
}
}
// swap
void swap( local_shared_ptr & r ) ACTIV_BOOST_SP_NOEXCEPT
{
std::swap( px, r.px );
std::swap( pn, r.pn );
}
// owner_before
template<class Y> bool owner_before( local_shared_ptr<Y> const & r ) const ACTIV_BOOST_SP_NOEXCEPT
{
return std::less< Boost::detail::local_counted_base* >()( pn, r.pn );
}
// owner_equals
template<class Y> bool owner_equals( local_shared_ptr<Y> const & r ) const ACTIV_BOOST_SP_NOEXCEPT
{
return pn == r.pn;
}
};
template<class T, class U> inline bool operator==( local_shared_ptr<T> const & a, local_shared_ptr<U> const & b ) ACTIV_BOOST_SP_NOEXCEPT
{
return a.get() == b.get();
}
template<class T, class U> inline bool operator!=( local_shared_ptr<T> const & a, local_shared_ptr<U> const & b ) ACTIV_BOOST_SP_NOEXCEPT
{
return a.get() != b.get();
}
#if !defined( ACTIV_BOOST_NO_CXX11_NULLPTR )
template<class T> inline bool operator==( local_shared_ptr<T> const & p, Boost::detail::sp_nullptr_t ) ACTIV_BOOST_SP_NOEXCEPT
{
return p.get() == 0;
}
template<class T> inline bool operator==( Boost::detail::sp_nullptr_t, local_shared_ptr<T> const & p ) ACTIV_BOOST_SP_NOEXCEPT
{
return p.get() == 0;
}
template<class T> inline bool operator!=( local_shared_ptr<T> const & p, Boost::detail::sp_nullptr_t ) ACTIV_BOOST_SP_NOEXCEPT
{
return p.get() != 0;
}
template<class T> inline bool operator!=( Boost::detail::sp_nullptr_t, local_shared_ptr<T> const & p ) ACTIV_BOOST_SP_NOEXCEPT
{
return p.get() != 0;
}
#endif
template<class T, class U> inline bool operator==( local_shared_ptr<T> const & a, shared_ptr<U> const & b ) ACTIV_BOOST_SP_NOEXCEPT
{
return a.get() == b.get();
}
template<class T, class U> inline bool operator!=( local_shared_ptr<T> const & a, shared_ptr<U> const & b ) ACTIV_BOOST_SP_NOEXCEPT
{
return a.get() != b.get();
}
template<class T, class U> inline bool operator==( shared_ptr<T> const & a, local_shared_ptr<U> const & b ) ACTIV_BOOST_SP_NOEXCEPT
{
return a.get() == b.get();
}
template<class T, class U> inline bool operator!=( shared_ptr<T> const & a, local_shared_ptr<U> const & b ) ACTIV_BOOST_SP_NOEXCEPT
{
return a.get() != b.get();
}
template<class T, class U> inline bool operator<(local_shared_ptr<T> const & a, local_shared_ptr<U> const & b) ACTIV_BOOST_SP_NOEXCEPT
{
return a.owner_before( b );
}
template<class T> inline void swap( local_shared_ptr<T> & a, local_shared_ptr<T> & b ) ACTIV_BOOST_SP_NOEXCEPT
{
a.swap( b );
}
template<class T, class U> local_shared_ptr<T> static_pointer_cast( local_shared_ptr<U> const & r ) ACTIV_BOOST_SP_NOEXCEPT
{
(void) static_cast< T* >( static_cast< U* >( 0 ) );
typedef typename local_shared_ptr<T>::element_type E;
E * p = static_cast< E* >( r.get() );
return local_shared_ptr<T>( r, p );
}
template<class T, class U> local_shared_ptr<T> const_pointer_cast( local_shared_ptr<U> const & r ) ACTIV_BOOST_SP_NOEXCEPT
{
(void) const_cast< T* >( static_cast< U* >( 0 ) );
typedef typename local_shared_ptr<T>::element_type E;
E * p = const_cast< E* >( r.get() );
return local_shared_ptr<T>( r, p );
}
template<class T, class U> local_shared_ptr<T> dynamic_pointer_cast( local_shared_ptr<U> const & r ) ACTIV_BOOST_SP_NOEXCEPT
{
(void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
typedef typename local_shared_ptr<T>::element_type E;
E * p = dynamic_cast< E* >( r.get() );
return p? local_shared_ptr<T>( r, p ): local_shared_ptr<T>();
}
template<class T, class U> local_shared_ptr<T> reinterpret_pointer_cast( local_shared_ptr<U> const & r ) ACTIV_BOOST_SP_NOEXCEPT
{
(void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
typedef typename local_shared_ptr<T>::element_type E;
E * p = reinterpret_cast< E* >( r.get() );
return local_shared_ptr<T>( r, p );
}
#if !defined( ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES )
template<class T, class U> local_shared_ptr<T> static_pointer_cast( local_shared_ptr<U> && r ) ACTIV_BOOST_SP_NOEXCEPT
{
(void) static_cast< T* >( static_cast< U* >( 0 ) );
typedef typename local_shared_ptr<T>::element_type E;
E * p = static_cast< E* >( r.get() );
return local_shared_ptr<T>( std::move(r), p );
}
template<class T, class U> local_shared_ptr<T> const_pointer_cast( local_shared_ptr<U> && r ) ACTIV_BOOST_SP_NOEXCEPT
{
(void) const_cast< T* >( static_cast< U* >( 0 ) );
typedef typename local_shared_ptr<T>::element_type E;
E * p = const_cast< E* >( r.get() );
return local_shared_ptr<T>( std::move(r), p );
}
template<class T, class U> local_shared_ptr<T> dynamic_pointer_cast( local_shared_ptr<U> && r ) ACTIV_BOOST_SP_NOEXCEPT
{
(void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
typedef typename local_shared_ptr<T>::element_type E;
E * p = dynamic_cast< E* >( r.get() );
return p? local_shared_ptr<T>( std::move(r), p ): local_shared_ptr<T>();
}
template<class T, class U> local_shared_ptr<T> reinterpret_pointer_cast( local_shared_ptr<U> && r ) ACTIV_BOOST_SP_NOEXCEPT
{
(void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
typedef typename local_shared_ptr<T>::element_type E;
E * p = reinterpret_cast< E* >( r.get() );
return local_shared_ptr<T>( std::move(r), p );
}
#endif // !defined( ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES )
// get_pointer() enables Boost::mem_fn to recognize local_shared_ptr
template<class T> inline typename local_shared_ptr<T>::element_type * get_pointer( local_shared_ptr<T> const & p ) ACTIV_BOOST_SP_NOEXCEPT
{
return p.get();
}
// operator<<
#if !defined(ACTIV_BOOST_NO_IOSTREAM)
template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< ( std::basic_ostream<E, T> & os, local_shared_ptr<Y> const & p )
{
os << p.get();
return os;
}
#endif // !defined(ACTIV_BOOST_NO_IOSTREAM)
// get_deleter
template<class D, class T> D * get_deleter( local_shared_ptr<T> const & p ) ACTIV_BOOST_SP_NOEXCEPT
{
return get_deleter<D>( shared_ptr<T>( p ) );
}
// hash_value
template< class T > struct hash;
template< class T > std::size_t hash_value( local_shared_ptr<T> const & p ) ACTIV_BOOST_SP_NOEXCEPT
{
return Boost::hash< typename local_shared_ptr<T>::element_type* >()( p.get() );
}
} // namespace Boost
// std::hash
#if !defined(ACTIV_BOOST_NO_CXX11_HDR_FUNCTIONAL)
namespace std
{
template<class T> struct hash< ::Boost::local_shared_ptr<T> >
{
std::size_t operator()( ::Boost::local_shared_ptr<T> const & p ) const ACTIV_BOOST_SP_NOEXCEPT
{
return std::hash< typename ::Boost::local_shared_ptr<T>::element_type* >()( p.get() );
}
};
} // namespace std
#endif // #if !defined(ACTIV_BOOST_NO_CXX11_HDR_FUNCTIONAL)
#endif // #ifndef ACTIV_BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED