Release 1.51.0

[SVN r80098]

include/boost/detail/sp_typeinfo.hpp

@@ -74,7 +74,13 @@ template<class T> struct sp_typeid_
     }
 };
 
-template<class T> sp_typeinfo sp_typeid_< T >::ti_( sp_typeid_< T >::name() );
+#if defined(__SUNPRO_CC)
+// see #4199, the Sun Studio compiler gets confused about static initialization 
+// constructor arguments. But an assignment works just fine. 
+template<class T> sp_typeinfo sp_typeid_< T >::ti_ = sp_typeid_< T >::name();
+#else
+template<class T> sp_typeinfo sp_typeid_< T >::ti_(sp_typeid_< T >::name());
+#endif
 
 template<class T> struct sp_typeid_< T & >: sp_typeid_< T >
 {

include/boost/smart_ptr.hpp

@@ -1,3 +1,6 @@
+#ifndef BOOST_SMART_PTR_HPP_INCLUDED
+#define BOOST_SMART_PTR_HPP_INCLUDED
+
 //
 //  smart_ptr.hpp
 //
@@ -22,4 +25,7 @@
 # include <boost/weak_ptr.hpp>
 # include <boost/intrusive_ptr.hpp>
 # include <boost/enable_shared_from_this.hpp>
+# include <boost/make_shared.hpp>
 #endif
+
+#endif // #ifndef BOOST_SMART_PTR_HPP_INCLUDED

include/boost/smart_ptr/detail/shared_count.hpp

@@ -52,6 +52,10 @@ int const   weak_count_id = 0x298C38A4;
 
 struct sp_nothrow_tag {};
 
+template< class D > struct sp_inplace_tag
+{
+};
+
 class weak_count;
 
 class shared_count
@@ -142,6 +146,40 @@ public:
 #endif
     }
 
+#if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
+
+    template< class P, class D > shared_count( P p, sp_inplace_tag<D> ): pi_( 0 )
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+#ifndef BOOST_NO_EXCEPTIONS
+
+        try
+        {
+            pi_ = new sp_counted_impl_pd< P, D >( p );
+        }
+        catch( ... )
+        {
+            D()( p ); // delete p
+            throw;
+        }
+
+#else
+
+        pi_ = new sp_counted_impl_pd< P, D >( p );
+
+        if( pi_ == 0 )
+        {
+            D()( p ); // delete p
+            boost::throw_exception( std::bad_alloc() );
+        }
+
+#endif // #ifndef BOOST_NO_EXCEPTIONS
+    }
+
+#endif // !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
+
     template<class P, class D, class A> shared_count( P p, D d, A a ): pi_( 0 )
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
@@ -188,6 +226,56 @@ public:
 #endif
     }
 
+#if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
+
+    template< class P, class D, class A > shared_count( P p, sp_inplace_tag< D >, A a ): pi_( 0 )
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+        typedef sp_counted_impl_pda< P, D, A > impl_type;
+        typedef typename A::template rebind< impl_type >::other A2;
+
+        A2 a2( a );
+
+#ifndef BOOST_NO_EXCEPTIONS
+
+        try
+        {
+            pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
+            new( static_cast< void* >( pi_ ) ) impl_type( p, a );
+        }
+        catch(...)
+        {
+            D()( p );
+
+            if( pi_ != 0 )
+            {
+                a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
+            }
+
+            throw;
+        }
+
+#else
+
+        pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
+
+        if( pi_ != 0 )
+        {
+            new( static_cast< void* >( pi_ ) ) impl_type( p, a );
+        }
+        else
+        {
+            D()( p );
+            boost::throw_exception( std::bad_alloc() );
+        }
+
+#endif // #ifndef BOOST_NO_EXCEPTIONS
+    }
+
+#endif // !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
+
 #ifndef BOOST_NO_AUTO_PTR
 
     // auto_ptr<Y> is special cased to provide the strong guarantee

include/boost/smart_ptr/detail/sp_convertible.hpp

@@ -45,7 +45,7 @@ template< class Y, class T > struct sp_convertible
     static yes f( T* );
     static no  f( ... );
 
-    enum _vt { value = sizeof( f( static_cast<Y*>(0) ) ) == sizeof(yes) };
+    enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
 };
 
 struct sp_empty

include/boost/smart_ptr/detail/sp_counted_base.hpp

@@ -41,6 +41,9 @@
 #elif defined(__HP_aCC) && defined(__ia64)
 # include <boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp>
 
+#elif defined( __IBMCPP__ ) && defined( __powerpc )
+# include <boost/smart_ptr/detail/sp_counted_base_vacpp_ppc.hpp>
+
 #elif defined( __MWERKS__ ) && defined( __POWERPC__ )
 # include <boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp>
 

include/boost/smart_ptr/detail/sp_counted_base_aix.hpp

@@ -0,0 +1,142 @@
+#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_AIX_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_AIX_HPP_INCLUDED
+
+//
+//  detail/sp_counted_base_aix.hpp
+//   based on: detail/sp_counted_base_w32.hpp
+//
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
+//  Copyright 2004-2005 Peter Dimov
+//  Copyright 2006 Michael van der Westhuizen
+//
+//  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)
+//
+//
+//  Lock-free algorithm by Alexander Terekhov
+//
+//  Thanks to Ben Hitchings for the #weak + (#shared != 0)
+//  formulation
+//
+
+#include <boost/detail/sp_typeinfo.hpp>
+#include <builtins.h>
+#include <sys/atomic_op.h>
+
+namespace boost
+{
+
+namespace detail
+{
+
+inline void atomic_increment( int32_t* pw )
+{
+    // ++*pw;
+
+    fetch_and_add( pw, 1 );
+}
+
+inline int32_t atomic_decrement( int32_t * pw )
+{
+    // return --*pw;
+
+    int32_t originalValue;
+
+    __lwsync();
+    originalValue = fetch_and_add( pw, -1 );
+    __isync();
+
+    return (originalValue - 1);
+}
+
+inline int32_t atomic_conditional_increment( int32_t * pw )
+{
+    // if( *pw != 0 ) ++*pw;
+    // return *pw;
+
+    int32_t tmp = fetch_and_add( pw, 0 );
+    for( ;; )
+    {
+        if( tmp == 0 ) return 0;
+        if( compare_and_swap( pw, &tmp, tmp + 1 ) ) return (tmp + 1);
+    }
+}
+
+class sp_counted_base
+{
+private:
+
+    sp_counted_base( sp_counted_base const & );
+    sp_counted_base & operator= ( sp_counted_base const & );
+
+    int32_t use_count_;        // #shared
+    int32_t weak_count_;       // #weak + (#shared != 0)
+
+public:
+
+    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
+    {
+    }
+
+    virtual ~sp_counted_base() // nothrow
+    {
+    }
+
+    // dispose() is called when use_count_ drops to zero, to release
+    // the resources managed by *this.
+
+    virtual void dispose() = 0; // nothrow
+
+    // destroy() is called when weak_count_ drops to zero.
+
+    virtual void destroy() // nothrow
+    {
+        delete this;
+    }
+
+    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+
+    void add_ref_copy()
+    {
+        atomic_increment( &use_count_ );
+    }
+
+    bool add_ref_lock() // true on success
+    {
+        return atomic_conditional_increment( &use_count_ ) != 0;
+    }
+
+    void release() // nothrow
+    {
+        if( atomic_decrement( &use_count_ ) == 0 )
+        {
+            dispose();
+            weak_release();
+        }
+    }
+
+    void weak_add_ref() // nothrow
+    {
+        atomic_increment( &weak_count_ );
+    }
+
+    void weak_release() // nothrow
+    {
+        if( atomic_decrement( &weak_count_ ) == 0 )
+        {
+            destroy();
+        }
+    }
+
+    long use_count() const // nothrow
+    {
+        return fetch_and_add( const_cast<int32_t*>(&use_count_), 0 );
+    }
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_AIX_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp

@@ -37,9 +37,12 @@ inline void atomic_increment( int * pw )
     __asm__ __volatile__
     (
         "0:\n\t"
+        ".set push\n\t"
+        ".set mips2\n\t"
         "ll %0, %1\n\t"
         "addiu %0, 1\n\t"
         "sc %0, %1\n\t"
+        ".set pop\n\t"
         "beqz %0, 0b":
         "=&r"( tmp ), "=m"( *pw ):
         "m"( *pw )
@@ -55,9 +58,12 @@ inline int atomic_decrement( int * pw )
     __asm__ __volatile__
     (
         "0:\n\t"
+        ".set push\n\t"
+        ".set mips2\n\t"
         "ll %1, %2\n\t"
         "addiu %0, %1, -1\n\t"
         "sc %0, %2\n\t"
+        ".set pop\n\t"
         "beqz %0, 0b\n\t"
         "addiu %0, %1, -1":
         "=&r"( rv ), "=&r"( tmp ), "=m"( *pw ):
@@ -78,10 +84,13 @@ inline int atomic_conditional_increment( int * pw )
     __asm__ __volatile__
     (
         "0:\n\t"
+        ".set push\n\t"
+        ".set mips2\n\t"
         "ll %0, %2\n\t"
         "beqz %0, 1f\n\t"
         "addiu %1, %0, 1\n\t"
         "sc %1, %2\n\t"
+        ".set pop\n\t"
         "beqz %1, 0b\n\t"
         "addiu %0, %0, 1\n\t"
         "1:":

include/boost/smart_ptr/detail/sp_counted_base_vacpp_ppc.hpp

@@ -0,0 +1,150 @@
+#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_VACPP_PPC_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_VACPP_PPC_HPP_INCLUDED
+
+//
+//  detail/sp_counted_base_vacpp_ppc.hpp - xlC(vacpp) on POWER
+//   based on: detail/sp_counted_base_w32.hpp
+//
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
+//  Copyright 2004-2005 Peter Dimov
+//  Copyright 2006 Michael van der Westhuizen
+//  Copyright 2012 IBM Corp.
+//
+//  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)
+//
+//
+//  Lock-free algorithm by Alexander Terekhov
+//
+//  Thanks to Ben Hitchings for the #weak + (#shared != 0)
+//  formulation
+//
+
+#include <boost/detail/sp_typeinfo.hpp>
+
+extern "builtin" void __lwsync(void);
+extern "builtin" void __isync(void);
+extern "builtin" int __fetch_and_add(volatile int* addr, int val);
+extern "builtin" int __compare_and_swap(volatile int*, int*, int);
+
+namespace boost
+{
+
+namespace detail
+{
+
+inline void atomic_increment( int *pw )
+{
+   // ++*pw;
+   __lwsync();
+   __fetch_and_add(pw, 1);
+   __isync();
+} 
+
+inline int atomic_decrement( int *pw )
+{
+   // return --*pw;
+   __lwsync();
+   int originalValue = __fetch_and_add(pw, -1);
+   __isync();
+
+   return (originalValue - 1);
+}
+
+inline int atomic_conditional_increment( int *pw )
+{
+   // if( *pw != 0 ) ++*pw;
+   // return *pw;
+
+   __lwsync();
+   int v = *const_cast<volatile int*>(pw);
+   for (;;)
+   // loop until state is known
+   {
+      if (v == 0) return 0;
+      if (__compare_and_swap(pw, &v, v + 1))
+      {
+         __isync(); return (v + 1);
+      }
+   }
+}
+
+class sp_counted_base
+{
+private:
+
+    sp_counted_base( sp_counted_base const & );
+    sp_counted_base & operator= ( sp_counted_base const & );
+
+    int use_count_;        // #shared
+    int weak_count_;       // #weak + (#shared != 0)
+    char pad[64] __attribute__((__aligned__(64)));
+            // pad to prevent false sharing
+public:
+
+    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
+    {
+    }
+
+    virtual ~sp_counted_base() // nothrow
+    {
+    }
+
+    // dispose() is called when use_count_ drops to zero, to release
+    // the resources managed by *this.
+
+    virtual void dispose() = 0; // nothrow
+
+    // destroy() is called when weak_count_ drops to zero.
+
+    virtual void destroy() // nothrow
+    {
+        delete this;
+    }
+
+    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+
+    void add_ref_copy()
+    {
+        atomic_increment( &use_count_ );
+    }
+
+    bool add_ref_lock() // true on success
+    {
+        return atomic_conditional_increment( &use_count_ ) != 0;
+    }
+
+    void release() // nothrow
+    {
+        if( atomic_decrement( &use_count_ ) == 0 )
+        {
+            dispose();
+            weak_release();
+        }
+    }
+
+    void weak_add_ref() // nothrow
+    {
+        atomic_increment( &weak_count_ );
+    }
+
+    void weak_release() // nothrow
+    {
+        if( atomic_decrement( &weak_count_ ) == 0 )
+        {
+            destroy();
+        }
+    }
+
+    long use_count() const // nothrow
+    {
+        return *const_cast<volatile int*>(&use_count_); 
+    }
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_VACPP_PPC_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_counted_impl.hpp

@@ -135,7 +135,11 @@ public:
 
     // pre: d(p) must not throw
 
-    sp_counted_impl_pd( P p, D d ): ptr(p), del(d)
+    sp_counted_impl_pd( P p, D & d ): ptr( p ), del( d )
+    {
+    }
+
+    sp_counted_impl_pd( P p ): ptr( p ), del()
     {
     }
 
@@ -195,7 +199,11 @@ public:
 
     // pre: d( p ) must not throw
 
-    sp_counted_impl_pda( P p, D d, A a ): p_( p ), d_( d ), a_( a )
+    sp_counted_impl_pda( P p, D & d, A a ): p_( p ), d_( d ), a_( a )
+    {
+    }
+
+    sp_counted_impl_pda( P p, A a ): p_( p ), d_(), a_( a )
     {
     }
 

include/boost/smart_ptr/detail/sp_has_sync.hpp

@@ -20,7 +20,7 @@
 //  are available.
 //
 
-#if defined(__GNUC__) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
+#if defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 ) && !defined( BOOST_SP_NO_SYNC )
 
 #define BOOST_SP_HAS_SYNC
 
@@ -36,6 +36,10 @@
 #undef BOOST_SP_HAS_SYNC
 #endif
 
+#if defined( __sh__ )
+#undef BOOST_SP_HAS_SYNC
+#endif
+
 #if defined( __sparc__ )
 #undef BOOST_SP_HAS_SYNC
 #endif

include/boost/smart_ptr/detail/spinlock.hpp

@@ -31,7 +31,10 @@
 #include <boost/config.hpp>
 #include <boost/smart_ptr/detail/sp_has_sync.hpp>
 
-#if defined(__GNUC__) && defined( __arm__ ) && !defined( __thumb__ )
+#if defined( BOOST_SP_USE_PTHREADS )
+#  include <boost/smart_ptr/detail/spinlock_pt.hpp>
+
+#elif defined(__GNUC__) && defined( __arm__ ) && !defined( __thumb__ )
 #  include <boost/smart_ptr/detail/spinlock_gcc_arm.hpp>
 
 #elif defined( BOOST_SP_HAS_SYNC )

include/boost/smart_ptr/detail/spinlock_gcc_arm.hpp

@@ -2,7 +2,7 @@
 #define BOOST_SMART_PTR_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED
 
 //
-//  Copyright (c) 2008 Peter Dimov
+//  Copyright (c) 2008, 2011 Peter Dimov
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -11,6 +11,20 @@
 
 #include <boost/smart_ptr/detail/yield_k.hpp>
 
+#if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__)
+
+# define BOOST_SP_ARM_BARRIER "dmb"
+
+#elif defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__)
+
+# define BOOST_SP_ARM_BARRIER "mcr p15, 0, r0, c7, c10, 5"
+
+#else
+
+# define BOOST_SP_ARM_BARRIER ""
+
+#endif
+
 namespace boost
 {
 
@@ -29,12 +43,38 @@ public:
     {
         int r;
 
+#if defined(__ARM_ARCH_6__) \
+    || defined(__ARM_ARCH_6J__) \
+    || defined(__ARM_ARCH_6K__) \
+    || defined(__ARM_ARCH_6Z__) \
+    || defined(__ARM_ARCH_6ZK__) \
+    || defined(__ARM_ARCH_6T2__) \
+    || defined(__ARM_ARCH_7__) \
+    || defined(__ARM_ARCH_7A__) \
+    || defined(__ARM_ARCH_7R__) \
+    || defined(__ARM_ARCH_7M__) \
+    || defined(__ARM_ARCH_7EM__)
+
         __asm__ __volatile__(
-            "swp %0, %1, [%2]":
+            "ldrex %0, [%2]; \n"
+            "cmp %0, %1; \n"
+            "strexne %0, %1, [%2]; \n"
+            BOOST_SP_ARM_BARRIER :
             "=&r"( r ): // outputs
             "r"( 1 ), "r"( &v_ ): // inputs
             "memory", "cc" );
 
+#else
+
+        __asm__ __volatile__(
+            "swp %0, %1, [%2];\n"
+            BOOST_SP_ARM_BARRIER :
+            "=&r"( r ): // outputs
+            "r"( 1 ), "r"( &v_ ): // inputs
+            "memory", "cc" );
+
+#endif
+
         return r == 0;
     }
 
@@ -48,7 +88,7 @@ public:
 
     void unlock()
     {
-        __asm__ __volatile__( "" ::: "memory" );
+        __asm__ __volatile__( BOOST_SP_ARM_BARRIER ::: "memory" );
         *const_cast< int volatile* >( &v_ ) = 0;
     }
 
@@ -82,4 +122,6 @@ public:
 
 #define BOOST_DETAIL_SPINLOCK_INIT {0}
 
+#undef BOOST_SP_ARM_BARRIER
+
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED

include/boost/smart_ptr/detail/spinlock_pool.hpp

@@ -41,7 +41,11 @@ public:
 
     static spinlock & spinlock_for( void const * pv )
     {
+#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64  
+        std::size_t i = reinterpret_cast< unsigned long long >( pv ) % 41;
+#else  
         std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41;
+#endif  
         return pool_[ i ];
     }
 

include/boost/smart_ptr/detail/yield_k.hpp

@@ -55,7 +55,7 @@ namespace detail
 {
 
 #if !defined( BOOST_USE_WINDOWS_H )
-  extern "C" void __stdcall Sleep( unsigned ms );
+  extern "C" void __stdcall Sleep( unsigned long ms );
 #endif
 
 inline void yield( unsigned k )

include/boost/smart_ptr/intrusive_ptr.hpp

@@ -15,11 +15,6 @@
 
 #include <boost/config.hpp>
 
-#ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
-# pragma warning(push)
-# pragma warning(disable:4284) // odd return type for operator->
-#endif
-
 #include <boost/assert.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/smart_ptr/detail/sp_convertible.hpp>
@@ -290,10 +285,15 @@ template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
+// hash_value
+
+template< class T > struct hash;
+
+template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p )
+{
+    return boost::hash< T* >()( p.get() );
+}
+
 } // namespace boost
 
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif    
-
 #endif  // #ifndef BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED

include/boost/smart_ptr/make_shared.hpp

@@ -49,7 +49,18 @@ private:
     {
         if( initialized_ )
         {
+#if defined( __GNUC__ )
+
+            // fixes incorrect aliasing warning
+            T * p = reinterpret_cast< T* >( storage_.data_ );
+            p->~T();
+
+#else
+
             reinterpret_cast< T* >( storage_.data_ )->~T();
+
+#endif
+
             initialized_ = false;
         }
     }
@@ -87,23 +98,31 @@ public:
 };
 
 #if defined( BOOST_HAS_RVALUE_REFS )
-template< class T > T&& forward( T &&t )
+
+template< class T > T&& sp_forward( T & t )
 {
-    return t;
+    return static_cast< T&& >( t );
 }
+
 #endif
 
 } // namespace detail
 
+#if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
+# define BOOST_SP_MSD( T ) boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >()
+#else
+# define BOOST_SP_MSD( T ) boost::detail::sp_ms_deleter< T >()
+#endif
+
 // Zero-argument versions
 //
 // Used even when variadic templates are available because of the new T() vs new T issue
 
 template< class T > boost::shared_ptr< T > make_shared()
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -118,9 +137,9 @@ template< class T > boost::shared_ptr< T > make_shared()
 
 template< class T, class A > boost::shared_ptr< T > allocate_shared( A const & a )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -137,15 +156,15 @@ template< class T, class A > boost::shared_ptr< T > allocate_shared( A const & a
 
 // Variadic templates, rvalue reference
 
-template< class T, class... Args > boost::shared_ptr< T > make_shared( Args && ... args )
+template< class T, class Arg1, class... Args > boost::shared_ptr< T > make_shared( Arg1 && arg1, Args && ... args )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
-    ::new( pv ) T( detail::forward<Args>( args )... );
+    ::new( pv ) T( boost::detail::sp_forward<Arg1>( arg1 ), boost::detail::sp_forward<Args>( args )... );
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -154,15 +173,469 @@ template< class T, class... Args > boost::shared_ptr< T > make_shared( Args && .
     return boost::shared_ptr< T >( pt, pt2 );
 }
 
-template< class T, class A, class... Args > boost::shared_ptr< T > allocate_shared( A const & a, Args && ... args )
+template< class T, class A, class Arg1, class... Args > boost::shared_ptr< T > allocate_shared( A const & a, Arg1 && arg1, Args && ... args )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
-    ::new( pv ) T( detail::forward<Args>( args )... );
+    ::new( pv ) T( boost::detail::sp_forward<Arg1>( arg1 ), boost::detail::sp_forward<Args>( args )... );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+#elif defined( BOOST_HAS_RVALUE_REFS )
+
+// For example MSVC 10.0
+
+template< class T, class A1 >
+boost::shared_ptr< T > make_shared( A1 && a1 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::detail::sp_forward<A1>( a1 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( 
+        boost::detail::sp_forward<A1>( a1 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2 >
+boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( 
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3 >
+boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 ), 
+        boost::detail::sp_forward<A3>( a3 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( 
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 ), 
+        boost::detail::sp_forward<A3>( a3 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4 >
+boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 ), 
+        boost::detail::sp_forward<A3>( a3 ), 
+        boost::detail::sp_forward<A4>( a4 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( 
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 ), 
+        boost::detail::sp_forward<A3>( a3 ), 
+        boost::detail::sp_forward<A4>( a4 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5 >
+boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 ), 
+        boost::detail::sp_forward<A3>( a3 ), 
+        boost::detail::sp_forward<A4>( a4 ), 
+        boost::detail::sp_forward<A5>( a5 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( 
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 ), 
+        boost::detail::sp_forward<A3>( a3 ), 
+        boost::detail::sp_forward<A4>( a4 ), 
+        boost::detail::sp_forward<A5>( a5 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
+boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 ), 
+        boost::detail::sp_forward<A3>( a3 ), 
+        boost::detail::sp_forward<A4>( a4 ), 
+        boost::detail::sp_forward<A5>( a5 ), 
+        boost::detail::sp_forward<A6>( a6 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( 
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 ), 
+        boost::detail::sp_forward<A3>( a3 ), 
+        boost::detail::sp_forward<A4>( a4 ), 
+        boost::detail::sp_forward<A5>( a5 ), 
+        boost::detail::sp_forward<A6>( a6 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
+boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 ), 
+        boost::detail::sp_forward<A3>( a3 ), 
+        boost::detail::sp_forward<A4>( a4 ), 
+        boost::detail::sp_forward<A5>( a5 ), 
+        boost::detail::sp_forward<A6>( a6 ), 
+        boost::detail::sp_forward<A7>( a7 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( 
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 ), 
+        boost::detail::sp_forward<A3>( a3 ), 
+        boost::detail::sp_forward<A4>( a4 ), 
+        boost::detail::sp_forward<A5>( a5 ), 
+        boost::detail::sp_forward<A6>( a6 ), 
+        boost::detail::sp_forward<A7>( a7 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
+boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 ), 
+        boost::detail::sp_forward<A3>( a3 ), 
+        boost::detail::sp_forward<A4>( a4 ), 
+        boost::detail::sp_forward<A5>( a5 ), 
+        boost::detail::sp_forward<A6>( a6 ), 
+        boost::detail::sp_forward<A7>( a7 ), 
+        boost::detail::sp_forward<A8>( a8 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( 
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 ), 
+        boost::detail::sp_forward<A3>( a3 ), 
+        boost::detail::sp_forward<A4>( a4 ), 
+        boost::detail::sp_forward<A5>( a5 ), 
+        boost::detail::sp_forward<A6>( a6 ), 
+        boost::detail::sp_forward<A7>( a7 ), 
+        boost::detail::sp_forward<A8>( a8 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
+boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 ), 
+        boost::detail::sp_forward<A3>( a3 ), 
+        boost::detail::sp_forward<A4>( a4 ), 
+        boost::detail::sp_forward<A5>( a5 ), 
+        boost::detail::sp_forward<A6>( a6 ), 
+        boost::detail::sp_forward<A7>( a7 ), 
+        boost::detail::sp_forward<A8>( a8 ), 
+        boost::detail::sp_forward<A9>( a9 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( 
+        boost::detail::sp_forward<A1>( a1 ), 
+        boost::detail::sp_forward<A2>( a2 ), 
+        boost::detail::sp_forward<A3>( a3 ), 
+        boost::detail::sp_forward<A4>( a4 ), 
+        boost::detail::sp_forward<A5>( a5 ), 
+        boost::detail::sp_forward<A6>( a6 ), 
+        boost::detail::sp_forward<A7>( a7 ), 
+        boost::detail::sp_forward<A8>( a8 ), 
+        boost::detail::sp_forward<A9>( a9 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -178,9 +651,9 @@ template< class T, class A, class... Args > boost::shared_ptr< T > allocate_shar
 template< class T, class A1 >
 boost::shared_ptr< T > make_shared( A1 const & a1 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -196,9 +669,9 @@ boost::shared_ptr< T > make_shared( A1 const & a1 )
 template< class T, class A, class A1 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -214,9 +687,9 @@ boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1 )
 template< class T, class A1, class A2 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -232,9 +705,9 @@ boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2 )
 template< class T, class A, class A1, class A2 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -250,9 +723,9 @@ boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a
 template< class T, class A1, class A2, class A3 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -268,9 +741,9 @@ boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3
 template< class T, class A, class A1, class A2, class A3 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -286,9 +759,9 @@ boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a
 template< class T, class A1, class A2, class A3, class A4 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -304,9 +777,9 @@ boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3,
 template< class T, class A, class A1, class A2, class A3, class A4 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -322,9 +795,9 @@ boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a
 template< class T, class A1, class A2, class A3, class A4, class A5 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -340,9 +813,9 @@ boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3,
 template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -358,9 +831,9 @@ boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -376,9 +849,9 @@ boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3,
 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -394,9 +867,9 @@ boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -412,9 +885,9 @@ boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3,
 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -430,9 +903,9 @@ boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -448,9 +921,9 @@ boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3,
 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -466,9 +939,9 @@ boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -484,9 +957,9 @@ boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3,
 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
 {
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
-    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
 
     void * pv = pd->address();
 
@@ -501,6 +974,8 @@ boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a
 
 #endif
 
+#undef BOOST_SP_MSD
+
 } // namespace boost
 
 #endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED

include/boost/smart_ptr/owner_less.hpp

@@ -0,0 +1,57 @@
+#ifndef BOOST_SMART_PTR_OWNER_LESS_HPP_INCLUDED
+#define BOOST_SMART_PTR_OWNER_LESS_HPP_INCLUDED
+
+//
+//  owner_less.hpp
+//
+//  Copyright (c) 2008 Frank Mori Hess
+//
+//  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/smart_ptr.htm for documentation.
+//
+
+#include <functional>
+
+namespace boost
+{
+  template<typename T> class shared_ptr;
+  template<typename T> class weak_ptr;
+
+  namespace detail
+  {
+    template<typename T, typename U>
+      struct generic_owner_less : public std::binary_function<T, T, bool>
+    {
+      bool operator()(const T &lhs, const T &rhs) const
+      {
+        return lhs.owner_before(rhs);
+      }
+      bool operator()(const T &lhs, const U &rhs) const
+      {
+        return lhs.owner_before(rhs);
+      }
+      bool operator()(const U &lhs, const T &rhs) const
+      {
+        return lhs.owner_before(rhs);
+      }
+    };
+  } // namespace detail
+
+  template<typename T> struct owner_less;
+
+  template<typename T>
+    struct owner_less<shared_ptr<T> >:
+    public detail::generic_owner_less<shared_ptr<T>, weak_ptr<T> >
+  {};
+
+  template<typename T>
+    struct owner_less<weak_ptr<T> >:
+    public detail::generic_owner_less<weak_ptr<T>, shared_ptr<T> >
+  {};
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_OWNER_LESS_HPP_INCLUDED

include/boost/smart_ptr/shared_array.hpp

@@ -69,7 +69,25 @@ public:
     {
     }
 
-//  generated copy constructor, assignment, destructor are fine
+//  generated copy constructor, destructor are fine...
+
+#if defined( BOOST_HAS_RVALUE_REFS )
+
+// ... except in C++0x, move disables the implicit copy
+
+    shared_array( shared_array const & r ): px( r.px ), pn( r.pn ) // never throws
+    {
+    }
+
+#endif
+
+    // assignment
+
+    shared_array & operator=( shared_array const & r ) // never throws
+    {
+        this_type( r ).swap( *this );
+        return *this;
+    }
 
     void reset(T * p = 0)
     {
@@ -113,6 +131,11 @@ public:
         pn.swap(other.pn);
     }
 
+    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const
+    {
+        return pn.get_deleter( ti );
+    }
+
 private:
 
     T * px;                     // contained pointer
@@ -140,6 +163,11 @@ template<class T> void swap(shared_array<T> & a, shared_array<T> & b) // never t
     a.swap(b);
 }
 
+template< class D, class T > D * get_deleter( shared_array<T> const & p )
+{
+    return static_cast< D * >( p._internal_get_deleter( BOOST_SP_TYPEID(D) ) );
+}
+
 } // namespace boost
 
 #endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)

include/boost/smart_ptr/shared_ptr.hpp

@@ -41,6 +41,7 @@
 #include <algorithm>            // for std::swap
 #include <functional>           // for std::less
 #include <typeinfo>             // for std::bad_cast
+#include <cstddef>              // for std::size_t
 
 #if !defined(BOOST_NO_IOSTREAM)
 #if !defined(BOOST_NO_IOSFWD)
@@ -50,11 +51,6 @@
 #endif
 #endif
 
-#ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
-# pragma warning(push)
-# pragma warning(disable:4284) // odd return type for operator->
-#endif
-
 namespace boost
 {
 
@@ -207,7 +203,17 @@ public:
         boost::detail::sp_enable_shared_from_this( this, p, p );
     }
 
-//  generated copy constructor, destructor are fine
+//  generated copy constructor, destructor are fine...
+
+#if defined( BOOST_HAS_RVALUE_REFS )
+
+// ... except in C++0x, move disables the implicit copy
+
+    shared_ptr( shared_ptr const & r ): px( r.px ), pn( r.pn ) // never throws
+    {
+    }
+
+#endif
 
     template<class Y>
     explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
@@ -443,7 +449,12 @@ public:
         pn.swap(other.pn);
     }
 
-    template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
+    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const
+    {
+        return pn < rhs.pn;
+    }
+
+    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const
     {
         return pn < rhs.pn;
     }
@@ -499,7 +510,7 @@ template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T>
 
 template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
 {
-    return a._internal_less(b);
+    return a.owner_before( b );
 }
 
 template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
@@ -688,14 +699,19 @@ template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> *
     return atomic_compare_exchange( p, v, w ); // std::move( w )
 }
 
-#endif
+#endif // !defined(BOOST_SP_NO_ATOMIC_ACCESS)
+
+// hash_value
+
+template< class T > struct hash;
+
+template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p )
+{
+    return boost::hash< T* >()( p.get() );
+}
 
 } // namespace boost
 
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif
-
 #endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
 
 #endif  // #ifndef BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED

include/boost/smart_ptr/weak_ptr.hpp

@@ -17,11 +17,6 @@
 #include <boost/smart_ptr/detail/shared_count.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
 
-#ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
-# pragma warning(push)
-# pragma warning(disable:4284) // odd return type for operator->
-#endif
-
 namespace boost
 {
 
@@ -40,8 +35,24 @@ public:
     {
     }
 
-//  generated copy constructor, assignment, destructor are fine
+//  generated copy constructor, assignment, destructor are fine...
 
+#if defined( BOOST_HAS_RVALUE_REFS )
+
+// ... except in C++0x, move disables the implicit copy
+
+    weak_ptr( weak_ptr const & r ): px( r.px ), pn( r.pn ) // never throws
+    {
+    }
+
+    weak_ptr & operator=( weak_ptr const & r ) // never throws
+    {
+        px = r.px;
+        pn = r.pn;
+        return *this;
+    }
+
+#endif
 
 //
 //  The "obvious" converting constructor implementation:
@@ -189,7 +200,12 @@ public:
         pn = pn2;
     }
 
-    template<class Y> bool _internal_less(weak_ptr<Y> const & rhs) const
+    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const
+    {
+        return pn < rhs.pn;
+    }
+
+    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const
     {
         return pn < rhs.pn;
     }
@@ -213,7 +229,7 @@ private:
 
 template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b)
 {
-    return a._internal_less(b);
+    return a.owner_before( b );
 }
 
 template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
@@ -223,8 +239,4 @@ template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
 
 } // namespace boost
 
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif    
-
 #endif  // #ifndef BOOST_SMART_PTR_WEAK_PTR_HPP_INCLUDED

test/Jamfile.v2

@@ -63,5 +63,10 @@ import testing ;
           [ compile-fail auto_ptr_lv_fail.cpp ]
           [ run atomic_count_test2.cpp ]
           [ run sp_typeinfo_test.cpp ]
+          [ compile make_shared_fp_test.cpp ]
+          [ run sp_hash_test.cpp ]
+          [ run get_deleter_array_test.cpp ]
+          [ run ip_hash_test.cpp ]
+          [ run owner_less_test.cpp ]
         ;
 }

test/get_deleter_array_test.cpp

@@ -0,0 +1,95 @@
+//
+//  get_deleter_array_test.cpp
+//
+//  Copyright (c) 2002, 2011 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)
+//
+
+#include <boost/shared_array.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+struct deleter
+{
+    int data;
+
+    deleter(): data(0)
+    {
+    }
+
+    void operator()(void *)
+    {
+        BOOST_TEST(data == 17041);
+    }
+};
+
+struct deleter2
+{
+};
+
+struct X
+{
+};
+
+int main()
+{
+    {
+        boost::shared_array<X> p;
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+    }
+
+    {
+        boost::shared_array<X> p(new X[1]);
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+    }
+
+    {
+        X x[1];
+        boost::shared_array<X> p(x, deleter());
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+
+        deleter * q = boost::get_deleter<deleter>(p);
+
+        BOOST_TEST(q != 0);
+        BOOST_TEST(q->data == 0);
+
+        q->data = 17041;
+
+        deleter const * r = boost::get_deleter<deleter const>(p);
+
+        BOOST_TEST(r == q);
+        BOOST_TEST(r->data == 17041);
+    }
+
+    return boost::report_errors();
+}

test/intrusive_ptr_move_test.cpp

@@ -30,8 +30,7 @@
 #include <boost/intrusive_ptr.hpp>
 #include <boost/detail/atomic_count.hpp>
 #include <boost/config.hpp>
-#include <algorithm>
-#include <functional>
+#include <utility>
 
 #if defined( BOOST_HAS_RVALUE_REFS )
 

test/ip_hash_test.cpp

@@ -0,0 +1,75 @@
+//
+// ip_hash_test.cpp
+//
+// Copyright 2011 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
+//
+
+#include <boost/intrusive_ptr.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+class base
+{
+private:
+
+    int use_count_;
+
+    base(base const &);
+    base & operator=(base const &);
+
+protected:
+
+    base(): use_count_(0)
+    {
+    }
+
+    virtual ~base()
+    {
+    }
+
+public:
+
+    long use_count() const
+    {
+        return use_count_;
+    }
+
+    inline friend void intrusive_ptr_add_ref(base * p)
+    {
+        ++p->use_count_;
+    }
+
+    inline friend void intrusive_ptr_release(base * p)
+    {
+        if(--p->use_count_ == 0) delete p;
+    }
+};
+
+struct X: public base
+{
+};
+
+int main()
+{
+    boost::hash< boost::intrusive_ptr<X> > hasher;
+
+    boost::intrusive_ptr<X> p1, p2( p1 ), p3( new X ), p4( p3 ), p5( new X );
+
+    BOOST_TEST_EQ( p1, p2 );
+    BOOST_TEST_EQ( hasher( p1 ), hasher( p2 ) );
+
+    BOOST_TEST_NE( p1, p3 );
+    BOOST_TEST_NE( hasher( p1 ), hasher( p3 ) );
+
+    BOOST_TEST_EQ( p3, p4 );
+    BOOST_TEST_EQ( hasher( p3 ), hasher( p4 ) );
+
+    BOOST_TEST_NE( p3, p5 );
+    BOOST_TEST_NE( hasher( p3 ), hasher( p5 ) );
+
+    return boost::report_errors();
+}

test/make_shared_fp_test.cpp

@@ -0,0 +1,19 @@
+//
+//  make_shared_fp_test.cpp
+//
+//  Copyright 2010 Georg Fritzsche
+//
+//  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
+//
+
+
+#include <boost/shared_ptr.hpp>
+#include <boost/make_shared.hpp>
+
+int main()
+{
+    typedef boost::shared_ptr<int>(*FP)(); 
+    FP fp = boost::make_shared<int>;
+}

test/make_shared_perfect_forwarding_test.cpp

@@ -12,7 +12,7 @@
 #include <boost/make_shared.hpp>
 #include <boost/shared_ptr.hpp>
 
-#ifndef BOOST_HAS_RVALUE_REFS
+#if !defined( BOOST_HAS_RVALUE_REFS )
 
 int main()
 {

test/owner_less_test.cpp

@@ -0,0 +1,67 @@
+//
+//  owner_less_test.cpp
+//
+//  A regression test for owner_less
+//
+//  Copyright (c) 2008 Frank Mori Hess
+//
+//  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)
+//
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/smart_ptr/owner_less.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+
+int main()
+{
+  boost::owner_less<boost::shared_ptr<int> > comp;
+  {
+    boost::shared_ptr<int> x;
+    boost::shared_ptr<int> y;
+    boost::weak_ptr<int> w;
+    BOOST_TEST(!(comp(x, w) || comp(w, x)));
+  }
+  {
+    boost::shared_ptr<int> z((int*)0);
+    boost::weak_ptr<int> w;
+    BOOST_TEST(comp(z, w) || comp(w, z));
+    {
+      boost::shared_ptr<int> zz(z);
+      w = boost::weak_ptr<int>(zz);
+      BOOST_TEST(!(comp(z, zz) || comp(z, zz)));
+      BOOST_TEST(!(comp(z, w) || comp(z, w)));
+    }
+    BOOST_TEST(!(comp(z, w) || comp(w, z)));
+  }
+  {
+    boost::shared_ptr<int> x;
+    boost::shared_ptr<int> z((int*)0);
+    BOOST_TEST(comp(x, z) || comp(z, x));
+  }
+  {
+    boost::shared_ptr<int> a((int*)0);
+    boost::shared_ptr<int> b((int*)0);
+    BOOST_TEST(comp(a, b) || comp(b, a));
+    boost::weak_ptr<int> w(a);
+    BOOST_TEST(!(comp(a, w) || comp(w, a)));
+    BOOST_TEST(comp(b, w) || comp(w, b));
+  }
+
+  boost::owner_less<boost::weak_ptr<int> > weak_comp;
+  {
+    boost::shared_ptr<int> a((int*)0);
+    boost::weak_ptr<int> wa(a);
+    boost::shared_ptr<int> b((int*)0);
+    boost::weak_ptr<int> wb(b);
+    BOOST_TEST(!(weak_comp(a, wa) || weak_comp(wa, a)));
+    BOOST_TEST(!(weak_comp(b, wb) || weak_comp(wb, b)));
+    BOOST_TEST(weak_comp(wa, wb) || weak_comp(wb, wa));
+    BOOST_TEST(weak_comp(wa, b) || weak_comp(b, wa));
+  }
+
+  return boost::report_errors();
+}

test/shared_ptr_move_test.cpp

@@ -10,6 +10,7 @@
 
 #include <boost/shared_ptr.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include <utility>
 
 #if defined( BOOST_HAS_RVALUE_REFS )
 

test/smart_ptr_test.cpp

@@ -33,10 +33,7 @@
 # pragma warn -8092 // template argument passed to 'find' is not an iterator
 #endif
 
-#include <boost/scoped_ptr.hpp>
-#include <boost/scoped_array.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/shared_array.hpp>
+#include <boost/smart_ptr.hpp>
 
 #include <boost/detail/lightweight_test.hpp>
 

test/sp_hash_test.cpp

@@ -0,0 +1,34 @@
+//
+// sp_hash_test.cpp
+//
+// Copyright 2011 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
+//
+
+#include <boost/shared_ptr.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+int main()
+{
+    boost::hash< boost::shared_ptr<int> > hasher;
+
+    boost::shared_ptr< int > p1, p2( p1 ), p3( new int ), p4( p3 ), p5( new int );
+
+    BOOST_TEST_EQ( p1, p2 );
+    BOOST_TEST_EQ( hasher( p1 ), hasher( p2 ) );
+
+    BOOST_TEST_NE( p1, p3 );
+    BOOST_TEST_NE( hasher( p1 ), hasher( p3 ) );
+
+    BOOST_TEST_EQ( p3, p4 );
+    BOOST_TEST_EQ( hasher( p3 ), hasher( p4 ) );
+
+    BOOST_TEST_NE( p3, p5 );
+    BOOST_TEST_NE( hasher( p3 ), hasher( p5 ) );
+
+    return boost::report_errors();
+}

test/weak_ptr_move_test.cpp

@@ -10,6 +10,7 @@
 
 #include <boost/weak_ptr.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include <utility>
 
 #if defined( BOOST_HAS_RVALUE_REFS )
 

test/weak_ptr_test.cpp

@@ -914,7 +914,6 @@ void test()
         BOOST_TEST(wp2.use_count() == 0);
         BOOST_TEST(!(wp < wp3 || wp3 < wp));
 
-        using std::swap;
         swap(wp, wp2);
 
         BOOST_TEST(wp.use_count() == 0);
@@ -950,7 +949,6 @@ void test()
         BOOST_TEST(wp2.use_count() == 0);
         BOOST_TEST(!(wp < wp3 || wp3 < wp));
 
-        using std::swap;
         swap(wp, wp2);
 
         BOOST_TEST(wp.use_count() == 0);
@@ -965,7 +963,6 @@ void test()
         BOOST_TEST(wp2.use_count() == 0);
         BOOST_TEST(!(wp < wp3 || wp3 < wp));
 
-        using std::swap;
         swap(wp, wp2);
 
         BOOST_TEST(wp.use_count() == 0);