sp_counted_impl_p added for the pointer constructor

[SVN r27727]

include/boost/detail/shared_count.hpp

@@ -19,21 +19,12 @@
 //
 
 #include <boost/config.hpp>
-
-#if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.
-#endif
-
 #include <boost/checked_delete.hpp>
 #include <boost/throw_exception.hpp>
 #include <boost/detail/bad_weak_ptr.hpp>
 #include <boost/detail/sp_counted_base.hpp>
 #include <boost/detail/sp_counted_impl.hpp>
 
-#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-#include <boost/detail/quick_allocator.hpp>
-#endif
-
 #include <memory>           // std::auto_ptr, std::allocator
 #include <functional>       // std::less
 #include <new>              // std::bad_alloc
@@ -79,6 +70,36 @@ public:
     {
     }
 
+    template<class Y> explicit shared_count( Y * p ): pi_( 0 )
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+#ifndef BOOST_NO_EXCEPTIONS
+
+        try
+        {
+            pi_ = new sp_counted_impl_p<Y>( p );
+        }
+        catch(...)
+        {
+            boost::checked_delete( p );
+            throw;
+        }
+
+#else
+
+        pi_ = new sp_counted_impl_p<Y>( p );
+
+        if( pi_ == 0 )
+        {
+            boost::checked_delete( p );
+            boost::throw_exception( std::bad_alloc() );
+        }
+
+#endif
+    }
+
     template<class P, class D> shared_count(P p, D d): pi_(0)
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
@@ -114,11 +135,20 @@ public:
     // auto_ptr<Y> is special cased to provide the strong guarantee
 
     template<class Y>
-    explicit shared_count(std::auto_ptr<Y> & r): pi_(new sp_counted_impl_pd< Y *, checked_deleter<Y> >(r.get(), checked_deleter<Y>()))
+    explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) )
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
 #endif
     {
+#ifdef BOOST_NO_EXCEPTIONS
+
+        if( pi_ == 0 )
+        {
+            boost::throw_exception(std::bad_alloc());
+        }
+
+#endif
+
         r.release();
     }
 

include/boost/detail/sp_counted_impl.hpp

@@ -38,52 +38,78 @@
 namespace boost
 {
 
-// Debug hooks
-
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
 
 void sp_scalar_constructor_hook( void * px, std::size_t size, void * pn );
-void sp_array_constructor_hook(void * px);
 void sp_scalar_destructor_hook( void * px, std::size_t size, void * pn );
-void sp_array_destructor_hook(void * px);
 
 #endif
 
 namespace detail
 {
 
+template<class X> class sp_counted_impl_p: public sp_counted_base
+{
+private:
+
+    X * px_;
+
+    sp_counted_impl_p( sp_counted_impl_p const & );
+    sp_counted_impl_p & operator= ( sp_counted_impl_p const & );
+
+    typedef sp_counted_impl_p<X> this_type;
+
+public:
+
+    explicit sp_counted_impl_p( X * px ): px_( px )
+    {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-template<class T> void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
-{
-    boost::sp_scalar_constructor_hook(px, sizeof(T), pn);
+        boost::sp_scalar_constructor_hook( px, sizeof(X), this );
+#endif
     }
 
-template<class T> void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
+    virtual void dispose() // nothrow
     {
-    boost::sp_array_constructor_hook(px);
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        boost::sp_scalar_destructor_hook( px_, sizeof(X), this );
+#endif
+        boost::checked_delete( px_ );
     }
 
-template<class P, class D> void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long)
+    virtual void * get_deleter( std::type_info const & )
     {
+        return 0;
     }
 
-template<class T> void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
+#if defined(BOOST_SP_USE_STD_ALLOCATOR)
+
+    void * operator new( std::size_t )
     {
-    boost::sp_scalar_destructor_hook(px, sizeof(T), pn);
+        return std::allocator<this_type>().allocate( 1, static_cast<this_type *>(0) );
     }
 
-template<class T> void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
-{
-    boost::sp_array_destructor_hook(px);
-}
-
-template<class P, class D> void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long)
+    void operator delete( void * p )
     {
+        std::allocator<this_type>().deallocate( static_cast<this_type *>(p), 1 );
     }
 
 #endif
 
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+
+    void * operator new( std::size_t )
+    {
+        return quick_allocator<this_type>::alloc();
+    }
+
+    void operator delete( void * p )
+    {
+        quick_allocator<this_type>::dealloc( p );
+    }
+
+#endif
+};
+
 //
 // Borland's Codeguard trips up over the -Vx- option here:
 //
@@ -109,16 +135,10 @@ public:
 
     sp_counted_impl_pd( P p, D d ): ptr(p), del(d)
     {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        detail::cbi_call_constructor_hook(this, p, d, 0);
-#endif
     }
 
     virtual void dispose() // nothrow
     {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        detail::cbi_call_destructor_hook(this, ptr, del, 0);
-#endif
         del( ptr );
     }
 

include/boost/shared_ptr.hpp

@@ -121,7 +121,7 @@ public:
     }
 
     template<class Y>
-    explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>()) // Y must be complete
+    explicit shared_ptr( Y * p ): px( p ), pn( p ) // Y must be complete
     {
         detail::sp_enable_shared_from_this( pn, p, p );
     }