Merge branch 'develop'

Add .travis.yml
2025-11-03 01:01:54 +01:00 · 2016-05-21 22:45:34 +03:00 · 2016-05-21 22:07:23 +03:00 · 2016-05-21 20:48:54 +03:00 · 2016-05-21 19:34:15 +03:00 · 2016-05-21 18:55:46 +03:00
64 changed files with 1848 additions and 644 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,48 @@
+# Copyright 2016 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+os:
+  - linux
+  - osx
+
+branches:
+  only:
+    - master
+    - develop
+
+install:
+  - git clone -b $TRAVIS_BRANCH https://github.com/boostorg/boost.git boost
+  - cd boost
+  - git submodule init libs/align
+  - git submodule init libs/assert
+  - git submodule init libs/atomic
+  - git submodule init libs/config
+  - git submodule init libs/core
+  - git submodule init libs/detail
+  - git submodule init libs/functional
+  - git submodule init libs/integer
+  - git submodule init libs/move
+  - git submodule init libs/predef
+  - git submodule init libs/preprocessor
+  - git submodule init libs/smart_ptr
+  - git submodule init libs/static_assert
+  - git submodule init libs/throw_exception
+  - git submodule init libs/type_traits
+  - git submodule init tools/build
+  - git submodule init tools/inspect
+  - git submodule update
+  - cd libs/smart_ptr
+  - git checkout -q $TRAVIS_COMMIT
+  - cd ../..
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - TOOLSET=gcc,clang
+  - if [ $TRAVIS_OS_NAME == osx ]; then TOOLSET=clang; fi
+  - ./b2 libs/smart_ptr/test toolset=$TOOLSET
--- a/README.md
+++ b/README.md
@@ -0,0 +1,6 @@
+# Boost.SmartPtr
+
+Branch   | Travis | Appveyor
+---------|--------|---------
+Develop  | [![Build Status](https://travis-ci.org/boostorg/smart_ptr.svg?branch=develop)](https://travis-ci.org/boostorg/smart_ptr) | [![Build Status](https://ci.appveyor.com/api/projects/status/github/boostorg/smart_ptr?branch=develop&svg=true)](https://ci.appveyor.com/project/pdimov/smart_ptr)
+Master   | [![Build Status](https://travis-ci.org/boostorg/smart_ptr.svg?branch=master)](https://travis-ci.org/boostorg/smart_ptr) | [![Build Status](https://ci.appveyor.com/api/projects/status/github/boostorg/smart_ptr?branch=master&svg=true)](https://ci.appveyor.com/project/pdimov/smart_ptr)
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -0,0 +1,44 @@
+# Copyright 2016 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+
+install:
+  - git clone -b %APPVEYOR_REPO_BRANCH% https://github.com/boostorg/boost.git boost
+  - cd boost
+  - git submodule init libs/align
+  - git submodule init libs/assert
+  - git submodule init libs/atomic
+  - git submodule init libs/config
+  - git submodule init libs/core
+  - git submodule init libs/detail
+  - git submodule init libs/functional
+  - git submodule init libs/integer
+  - git submodule init libs/move
+  - git submodule init libs/predef
+  - git submodule init libs/preprocessor
+  - git submodule init libs/smart_ptr
+  - git submodule init libs/static_assert
+  - git submodule init libs/throw_exception
+  - git submodule init libs/type_traits
+  - git submodule init tools/build
+  - git submodule init tools/inspect
+  - git submodule update
+  - cd libs\smart_ptr
+  - git checkout -q %APPVEYOR_REPO_COMMIT%
+  - cd ..\..
+  - bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - b2 libs/smart_ptr/test toolset=msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0
--- a/enable_shared_from_this.html
+++ b/enable_shared_from_this.html
@@ -2,21 +2,25 @@
 <html>
    <head>
        <title>enable_shared_from_this</title>
-        <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+        <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
    </head>
    <body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
-        <h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png" 
-            width="277" align="middle" border="0">enable_shared_from_this</h1>
+        <h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png"
+            width="277" align="middle" border="0" />enable_shared_from_this</h1>
        <h2><a name="Purpose">Purpose</a></h2>
        <p>
-            The header <STRONG>&lt;boost/enable_shared_from_this.hpp&gt;</STRONG> defines 
-            the class template <STRONG>enable_shared_from_this</STRONG>. It is used as a 
-            base class that allows a <A href="shared_ptr.htm">shared_ptr</A> to the current 
-            object to be obtained from within a member function.
+            The header <code>&lt;boost/enable_shared_from_this.hpp&gt;</code> defines
+            the class template <code>enable_shared_from_this</code>. It is used as a
+            base class that allows a <a href="shared_ptr.htm">shared_ptr</a> or
+            a <a href="weak_ptr.htm">weak_ptr</a> to the current object to be obtained
+            from within a member function.
+        </p>
+        <p><code>enable_shared_from_this&lt;T&gt;</code> defines two member functions
+            called <code>shared_from_this</code> that return a <code>shared_ptr&lt;T&gt;</code>
+            and <code>shared_ptr&lt;T const&gt;</code>, depending on constness, to <code>this</code>.
+            It also defines two member functions called <code>weak_from_this</code> that return
+            a corresponding <code>weak_ptr</code>.
        </p>
-        <P><STRONG>enable_shared_from_this&lt;T&gt;</STRONG> defines two member functions 
-            called <STRONG>shared_from_this</STRONG> that return a <STRONG>shared_ptr&lt;T&gt;</STRONG>
-            and <STRONG>shared_ptr&lt;T const&gt;</STRONG>, depending on constness, to <STRONG>this</STRONG>.</P>
        <h2><a name="Example">Example</a></h2>
        <pre>
 #include &lt;boost/enable_shared_from_this.hpp&gt;
@@ -41,7 +45,7 @@ int main()
    assert(!(p &lt; q || q &lt; p)); // p and q must share ownership
 }
 </pre>
-        <h3><a name="Synopsis">Synopsis</a></h3>
+        <h2><a name="Synopsis">Synopsis</a></h2>
        <pre>
 namespace boost
 {
@@ -52,34 +56,55 @@ public:

    shared_ptr&lt;T&gt; shared_from_this();
    shared_ptr&lt;T const&gt; shared_from_this() const;
+
+    weak_ptr&lt;T&gt; weak_from_this() noexcept;
+    weak_ptr&lt;T const&gt; weak_from_this() const noexcept;
 }

 }
 </pre>
-        <h4>template&lt;class T&gt; shared_ptr&lt;T&gt; 
-            enable_shared_from_this&lt;T&gt;::shared_from_this();</h4>
-        <h4>template&lt;class T&gt; shared_ptr&lt;T const&gt; 
-            enable_shared_from_this&lt;T&gt;::shared_from_this() const;</h4>
+        <h4><code>template&lt;class T&gt; shared_ptr&lt;T&gt;
+            enable_shared_from_this&lt;T&gt;::shared_from_this();</code></h4>
+        <h4><code>template&lt;class T&gt; shared_ptr&lt;T const&gt;
+            enable_shared_from_this&lt;T&gt;::shared_from_this() const;</code></h4>
        <blockquote>
            <p>
-                <b>Requires:</b> <STRONG>enable_shared_from_this&lt;T&gt;</STRONG> must be an 
-                accessible base class of <b>T</b>. <STRONG>*this</STRONG> must be a subobject 
-                of an instance <STRONG>t</STRONG> of type <STRONG>T</STRONG> . There must exist 
-                at least one <STRONG>shared_ptr</STRONG> instance <STRONG>p</STRONG> that <EM>owns</EM>
-                <STRONG>t</STRONG>.
+                <b>Requires:</b> <code>enable_shared_from_this&lt;T&gt;</code> must be an 
+                accessible base class of <code>T</code>. <code>*this</code> must be a subobject 
+                of an instance <code>t</code> of type <code>T</code>.
            </p>
            <p>
-                <b>Returns:</b> A <b>shared_ptr&lt;T&gt;</b> instance <b>r</b> that shares 
-                ownership with <b>p</b>.
+                <b>Returns:</b> If a <code>shared_ptr</code> instance <code>p</code> that <em>owns</em>
+                <code>t</code> exists, a <code>shared_ptr&lt;T&gt;</code> instance <code>r</code> that shares 
+                ownership with <code>p</code>.
            </p>
            <p>
-                <b>Postconditions:</b> <tt>r.get() == this</tt>.
+                <b>Postconditions:</b> <code>r.get() == this</code>.
+            </p>
+            <p>
+                <b>Throws:</b> <code>bad_weak_ptr</code> when no <code>shared_ptr</code> <em>owns</em> <code>*this</code>.
            </p>
        </blockquote>
-        <p>$Date$</p>
+        <h4><code>template&lt;class T&gt; weak_ptr&lt;T&gt;
+            enable_shared_from_this&lt;T&gt;::weak_from_this() noexcept;</code></h4>
+        <h4><code>template&lt;class T&gt; weak_ptr&lt;T const&gt;
+            enable_shared_from_this&lt;T&gt;::weak_from_this() const noexcept;</code></h4>
+        <blockquote>
+            <p>
+                <b>Requires:</b> <code>enable_shared_from_this&lt;T&gt;</code> must be an 
+                accessible base class of <code>T</code>. <code>*this</code> must be a subobject 
+                of an instance <code>t</code> of type <code>T</code>.
+            </p>
+            <p>
+                <b>Returns:</b> If a <code>shared_ptr</code> instance <code>p</code> that <em>owns</em>
+                <code>t</code> exists or has existed in the past, a <code>weak_ptr&lt;T&gt;</code> instance
+                <code>r</code> that shares ownership with <code>p</code>. Otherwise, an empty <code>weak_ptr</code>.
+            </p>
+        </blockquote>
+        <hr />
        <p>
-            <small>Copyright &copy; 2002, 2003 by Peter Dimov. Distributed under the Boost Software License, Version 
-                1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
-                copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
+            <small>Copyright &copy; 2002, 2003, 2015 by Peter Dimov. Distributed under the Boost Software License, Version 
+                1.0. See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or 
+                copy at <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>.</small></p>
    </body>
 </html>
--- a/include/boost/make_unique.hpp
+++ b/include/boost/make_unique.hpp
@@ -1,11 +1,11 @@
 /*
- * Copyright (c) 2014 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
+(c) 2014 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
 #ifndef BOOST_MAKE_UNIQUE_HPP_INCLUDED
 #define BOOST_MAKE_UNIQUE_HPP_INCLUDED

--- a/include/boost/smart_ptr/detail/array_allocator.hpp
+++ b/include/boost/smart_ptr/detail/array_allocator.hpp
@@ -213,7 +213,7 @@ namespace boost {
            typedef Y* pointer;
            typedef const Y* const_pointer;
            typedef std::size_t size_type;
-            typedef ptrdiff_t difference_type;
+            typedef std::ptrdiff_t difference_type;
            typedef Y& reference;
            typedef const Y& const_reference;

--- a/include/boost/smart_ptr/detail/operator_bool.hpp
+++ b/include/boost/smart_ptr/detail/operator_bool.hpp
@@ -6,7 +6,8 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt

-#if !defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS ) && !defined( BOOST_NO_CXX11_NULLPTR )
+#if !defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS ) && !defined( BOOST_NO_CXX11_NULLPTR )\
+    && !(defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5130))

    explicit operator bool () const BOOST_NOEXCEPT
    {
--- a/include/boost/smart_ptr/detail/shared_count.hpp
+++ b/include/boost/smart_ptr/detail/shared_count.hpp
@@ -28,6 +28,7 @@
 #include <boost/smart_ptr/bad_weak_ptr.hpp>
 #include <boost/smart_ptr/detail/sp_counted_base.hpp>
 #include <boost/smart_ptr/detail/sp_counted_impl.hpp>
+#include <boost/smart_ptr/detail/sp_disable_deprecated.hpp>
 #include <boost/detail/workaround.hpp>
 // In order to avoid circular dependencies with Boost.TR1
 // we make sure that our include of <memory> doesn't try to
@@ -40,13 +41,23 @@
 # include <new>              // std::bad_alloc
 #endif

-#if !defined( BOOST_NO_CXX11_SMART_PTR )
-# include <boost/utility/addressof.hpp>
+#include <boost/core/addressof.hpp>
+
+#if defined( BOOST_SP_DISABLE_DEPRECATED )
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif

 namespace boost
 {

+namespace movelib
+{
+
+    template< class T, class D > class unique_ptr;
+
+} // namespace movelib
+
 namespace detail
 {

@@ -63,8 +74,6 @@ template< class D > struct sp_inplace_tag
 {
 };

-#if !defined( BOOST_NO_CXX11_SMART_PTR )
-
 template< class T > class sp_reference_wrapper
 { 
 public:
@@ -93,8 +102,6 @@ template< class D > struct sp_convert_reference< D& >
    typedef sp_reference_wrapper< D > type;
 };

-#endif
-
 class weak_count;

 class shared_count
@@ -438,6 +445,29 @@ public:

 #endif

+    template<class Y, class D>
+    explicit shared_count( boost::movelib::unique_ptr<Y, D> & r ): pi_( 0 )
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+        typedef typename sp_convert_reference<D>::type D2;
+
+        D2 d2( r.get_deleter() );
+        pi_ = new sp_counted_impl_pd< typename boost::movelib::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 );
+
+#ifdef BOOST_NO_EXCEPTIONS
+
+        if( pi_ == 0 )
+        {
+            boost::throw_exception( std::bad_alloc() );
+        }
+
+#endif
+
+        r.release();
+    }
+
    ~shared_count() // nothrow
    {
        if( pi_ != 0 ) pi_->release();
@@ -668,6 +698,10 @@ inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_(

 } // namespace boost

+#if defined( BOOST_SP_DISABLE_DEPRECATED )
+#pragma GCC diagnostic pop
+#endif
+
 #ifdef __BORLANDC__
 # pragma warn .8027     // Functions containing try are not expanded inline
 #endif
--- a/include/boost/smart_ptr/detail/sp_convertible.hpp
+++ b/include/boost/smart_ptr/detail/sp_convertible.hpp
@@ -16,6 +16,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt

 #include <boost/config.hpp>
+#include <cstddef>

 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( BOOST_NO_SFINAE )
 # define BOOST_SP_NO_SP_CONVERTIBLE
--- a/include/boost/smart_ptr/detail/sp_counted_base.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base.hpp
@@ -20,6 +20,12 @@
 #include <boost/config.hpp>
 #include <boost/smart_ptr/detail/sp_has_sync.hpp>

+#if defined( __clang__ ) && defined( __has_extension )
+# if __has_extension( __c_atomic__ )
+#   define BOOST_SP_HAS_CLANG_C11_ATOMICS
+# endif
+#endif
+
 #if defined( BOOST_SP_DISABLE_THREADS )
 # include <boost/smart_ptr/detail/sp_counted_base_nt.hpp>

@@ -35,6 +41,9 @@
 #elif defined( BOOST_DISABLE_THREADS ) && !defined( BOOST_SP_ENABLE_THREADS ) && !defined( BOOST_DISABLE_WIN32 )
 # include <boost/smart_ptr/detail/sp_counted_base_nt.hpp>

+#elif defined( BOOST_SP_HAS_CLANG_C11_ATOMICS )
+# include <boost/smart_ptr/detail/sp_counted_base_clang.hpp>
+
 #elif defined( __SNC__ )
 # include <boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp>

@@ -79,4 +88,6 @@

 #endif

+#undef BOOST_SP_HAS_CLANG_C11_ATOMICS
+
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_base_clang.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_base_clang.hpp
@@ -0,0 +1,140 @@
+#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  detail/sp_counted_base_clang.hpp - __c11 clang intrinsics
+//
+//  Copyright (c) 2007, 2013, 2015 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/detail/sp_typeinfo.hpp>
+#include <boost/cstdint.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+typedef _Atomic( boost::int_least32_t ) atomic_int_least32_t;
+
+inline void atomic_increment( atomic_int_least32_t * pw )
+{
+    __c11_atomic_fetch_add( pw, 1, __ATOMIC_RELAXED );
+}
+
+inline boost::int_least32_t atomic_decrement( atomic_int_least32_t * pw )
+{
+    return __c11_atomic_fetch_sub( pw, 1, __ATOMIC_ACQ_REL );
+}
+
+inline boost::int_least32_t atomic_conditional_increment( atomic_int_least32_t * pw )
+{
+    // long r = *pw;
+    // if( r != 0 ) ++*pw;
+    // return r;
+
+    boost::int_least32_t r = __c11_atomic_load( pw, __ATOMIC_RELAXED );
+
+    for( ;; )
+    {
+        if( r == 0 )
+        {
+            return r;
+        }
+
+        if( __c11_atomic_compare_exchange_weak( pw, &r, r + 1, __ATOMIC_RELAXED, __ATOMIC_RELAXED ) )
+        {
+            return r;
+        }
+    }    
+}
+
+class sp_counted_base
+{
+private:
+
+    sp_counted_base( sp_counted_base const & );
+    sp_counted_base & operator= ( sp_counted_base const & );
+
+    atomic_int_least32_t use_count_;	// #shared
+    atomic_int_least32_t weak_count_;	// #weak + (#shared != 0)
+
+public:
+
+    sp_counted_base()
+    {
+        __c11_atomic_init( &use_count_, 1 );
+        __c11_atomic_init( &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;
+    virtual void * get_untyped_deleter() = 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_ ) == 1 )
+        {
+            dispose();
+            weak_release();
+        }
+    }
+
+    void weak_add_ref() // nothrow
+    {
+        atomic_increment( &weak_count_ );
+    }
+
+    void weak_release() // nothrow
+    {
+        if( atomic_decrement( &weak_count_ ) == 1 )
+        {
+            destroy();
+        }
+    }
+
+    long use_count() const // nothrow
+    {
+        return __c11_atomic_load( const_cast< atomic_int_least32_t* >( &use_count_ ), __ATOMIC_ACQUIRE );
+    }
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_counted_impl.hpp
+++ b/include/boost/smart_ptr/detail/sp_counted_impl.hpp
@@ -78,7 +78,7 @@ public:
        boost::checked_delete( px_ );
    }

-    virtual void * get_deleter( detail::sp_typeinfo const & )
+    virtual void * get_deleter( sp_typeinfo const & )
    {
        return 0;
    }
@@ -153,7 +153,7 @@ public:
        del( ptr );
    }

-    virtual void * get_deleter( detail::sp_typeinfo const & ti )
+    virtual void * get_deleter( sp_typeinfo const & ti )
    {
        return ti == BOOST_SP_TYPEID(D)? &reinterpret_cast<char&>( del ): 0;
    }
@@ -249,7 +249,7 @@ public:
        a2.deallocate( this, 1 );
    }

-    virtual void * get_deleter( detail::sp_typeinfo const & ti )
+    virtual void * get_deleter( sp_typeinfo const & ti )
    {
        return ti == BOOST_SP_TYPEID( D )? &reinterpret_cast<char&>( d_ ): 0;
    }
--- a/include/boost/smart_ptr/detail/sp_disable_deprecated.hpp
+++ b/include/boost/smart_ptr/detail/sp_disable_deprecated.hpp
@@ -0,0 +1,40 @@
+#ifndef BOOST_SMART_PTR_DETAIL_SP_DISABLE_DEPRECATED_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SP_DISABLE_DEPRECATED_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/smart_ptr/detail/sp_disable_deprecated.hpp
+//
+//  Copyright 2015 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/config.hpp>
+
+#if defined( __GNUC__ ) && ( defined( __GXX_EXPERIMENTAL_CXX0X__ ) || ( __cplusplus >= 201103L ) )
+
+# if defined( BOOST_GCC )
+
+#  if BOOST_GCC >= 40600
+#   define BOOST_SP_DISABLE_DEPRECATED
+#  endif
+
+# elif defined( __clang__ ) && defined( __has_warning )
+
+#  if __has_warning( "-Wdeprecated-declarations" )
+#   define BOOST_SP_DISABLE_DEPRECATED
+#  endif
+
+# endif
+
+#endif
+
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_DISABLE_DEPRECATED_HPP_INCLUDED
--- a/include/boost/smart_ptr/detail/sp_interlocked.hpp
+++ b/include/boost/smart_ptr/detail/sp_interlocked.hpp
@@ -111,6 +111,17 @@ extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long
 extern "C" long __cdecl _InterlockedExchange( long volatile *, long );
 extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long );

+# if defined( BOOST_MSVC ) && BOOST_MSVC == 1310
+//From MSDN, Visual Studio .NET 2003 spedific: To declare one of the interlocked functions
+//for use as an intrinsic, the function must be declared with the leading underscore and
+//the new function must appear in a #pragma intrinsic statement.
+#  pragma intrinsic( _InterlockedIncrement )
+#  pragma intrinsic( _InterlockedDecrement )
+#  pragma intrinsic( _InterlockedCompareExchange )
+#  pragma intrinsic( _InterlockedExchange )
+#  pragma intrinsic( _InterlockedExchangeAdd )
+# endif
+
 #endif

 # define BOOST_SP_INTERLOCKED_INCREMENT _InterlockedIncrement
--- a/include/boost/smart_ptr/detail/spinlock_gcc_arm.hpp
+++ b/include/boost/smart_ptr/detail/spinlock_gcc_arm.hpp
@@ -82,6 +82,7 @@ public:
    {
        __asm__ __volatile__( BOOST_SP_ARM_BARRIER ::: "memory" );
        *const_cast< int volatile* >( &v_ ) = 0;
+        __asm__ __volatile__( BOOST_SP_ARM_BARRIER ::: "memory" );
    }

 public:
--- a/include/boost/smart_ptr/detail/spinlock_pool.hpp
+++ b/include/boost/smart_ptr/detail/spinlock_pool.hpp
@@ -31,7 +31,7 @@ namespace boost
 namespace detail
 {

-template< int I > class spinlock_pool
+template< int M > class spinlock_pool
 {
 private:

@@ -72,7 +72,7 @@ public:
    };
 };

-template< int I > spinlock spinlock_pool< I >::pool_[ 41 ] =
+template< int M > spinlock spinlock_pool< M >::pool_[ 41 ] =
 {
    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
--- a/include/boost/smart_ptr/detail/up_if_array.hpp
+++ b/include/boost/smart_ptr/detail/up_if_array.hpp
@@ -1,26 +0,0 @@
-/*
- * Copyright (c) 2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_UP_IF_ARRAY_HPP
-#define BOOST_SMART_PTR_DETAIL_UP_IF_ARRAY_HPP
-
-#include <memory>
-
-namespace boost {
-    namespace detail {
-        template<class T>
-        struct up_if_array;
-
-        template<class T>
-        struct up_if_array<T[]> {
-            typedef std::unique_ptr<T[]> type;
-        };
-    }
-}
-
-#endif
--- a/include/boost/smart_ptr/detail/up_if_not_array.hpp
+++ b/include/boost/smart_ptr/detail/up_if_not_array.hpp
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_UP_IF_NOT_ARRAY_HPP
-#define BOOST_SMART_PTR_DETAIL_UP_IF_NOT_ARRAY_HPP
-
-#include <memory>
-
-namespace boost {
-    namespace detail {
-        template<class T> 
-        struct up_if_not_array {
-            typedef std::unique_ptr<T> type;
-        };
-
-        template<class T>
-        struct up_if_not_array<T[]> {
-        };
-
-        template<class T, std::size_t N>
-        struct up_if_not_array<T[N]> {
-        };
-    }
-}
-
-#endif
--- a/include/boost/smart_ptr/detail/yield_k.hpp
+++ b/include/boost/smart_ptr/detail/yield_k.hpp
@@ -60,7 +60,16 @@ namespace detail
 {

 #if !defined( BOOST_USE_WINDOWS_H ) && !BOOST_PLAT_WINDOWS_RUNTIME
+#if !BOOST_COMP_CLANG || !defined __MINGW32__
  extern "C" void __stdcall Sleep( unsigned long ms );
+#else
+#include <_mingw.h>
+#if !defined __MINGW64_VERSION_MAJOR
+  extern "C" void __stdcall Sleep( unsigned long ms );
+#else
+  extern "C" __declspec(dllimport) void __stdcall Sleep( unsigned long ms );
+#endif
+#endif
 #endif

 inline void yield( unsigned k )
--- a/include/boost/smart_ptr/enable_shared_from_raw.hpp
+++ b/include/boost/smart_ptr/enable_shared_from_raw.hpp
@@ -53,7 +53,7 @@ protected:

 private:

-    void init_weak_once() const
+    void init_if_expired() const
    {
        if( weak_this_.expired() )
        {
@@ -62,6 +62,15 @@ private:
        }
    }

+    void init_if_empty() const
+    {
+        if( weak_this_._empty() )
+        {
+            shared_this_.reset( static_cast<void*>(0), detail::esft2_deleter_wrapper() );
+            weak_this_ = shared_this_;
+        }
+    }
+
 #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 public:
 #else
@@ -74,7 +83,7 @@ private:

    shared_ptr<void const volatile> shared_from_this() const
    {
-        init_weak_once();
+        init_if_expired();
        return shared_ptr<void const volatile>( weak_this_ );
    }

@@ -83,8 +92,19 @@ private:
        return const_cast< enable_shared_from_raw const * >( this )->shared_from_this();
    }

+    weak_ptr<void const volatile> weak_from_this() const
+    {
+        init_if_empty();
+        return weak_this_;
+    }
+
+    weak_ptr<void const volatile> weak_from_this() const volatile
+    {
+        return const_cast< enable_shared_from_raw const * >( this )->weak_from_this();
+    }
+
    // Note: invoked automatically by shared_ptr; do not call
-    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> * ppx, Y * py ) const
+    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> * ppx, Y * ) const
    {
        BOOST_ASSERT( ppx != 0 );

@@ -125,7 +145,7 @@ boost::weak_ptr<T> weak_from_raw(T *p)
 {
    BOOST_ASSERT(p != 0);
    boost::weak_ptr<T> result;
-    result._internal_aliasing_assign(p->enable_shared_from_raw::weak_this_, p);
+    result._internal_aliasing_assign(p->enable_shared_from_raw::weak_from_this(), p);
    return result;
 }

--- a/include/boost/smart_ptr/enable_shared_from_this.hpp
+++ b/include/boost/smart_ptr/enable_shared_from_this.hpp
@@ -58,6 +58,16 @@ public:
        return p;
    }

+    weak_ptr<T> weak_from_this() BOOST_NOEXCEPT
+    {
+        return weak_this_;
+    }
+
+    weak_ptr<T const> weak_from_this() const BOOST_NOEXCEPT
+    {
+        return weak_this_;
+    }
+
 public: // actually private, but avoids compiler template friendship issues

    // Note: invoked automatically by shared_ptr; do not call
--- a/include/boost/smart_ptr/intrusive_ptr.hpp
+++ b/include/boost/smart_ptr/intrusive_ptr.hpp
@@ -59,7 +59,7 @@ public:

    typedef T element_type;

-    intrusive_ptr() BOOST_NOEXCEPT : px( 0 )
+    BOOST_CONSTEXPR intrusive_ptr() BOOST_NOEXCEPT : px( 0 )
    {
    }

@@ -122,6 +122,30 @@ public:
        return *this;
    }

+    template<class U> friend class intrusive_ptr;
+
+    template<class U>
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
+
+    intrusive_ptr(intrusive_ptr<U> && rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty())
+
+#else
+
+    intrusive_ptr(intrusive_ptr<U> && rhs)
+
+#endif        
+    : px( rhs.px )
+    {
+        rhs.px = 0;
+    }
+
+    template<class U>
+    intrusive_ptr & operator=(intrusive_ptr<U> && rhs) BOOST_NOEXCEPT
+    {
+        this_type( static_cast< intrusive_ptr<U> && >( rhs ) ).swap(*this);
+        return *this;
+    }
+
 #endif

    intrusive_ptr & operator=(intrusive_ptr const & rhs)
--- a/include/boost/smart_ptr/intrusive_ref_counter.hpp
+++ b/include/boost/smart_ptr/intrusive_ref_counter.hpp
@@ -83,7 +83,7 @@ struct thread_safe_counter

    static unsigned int decrement(boost::detail::atomic_count& counter) BOOST_NOEXCEPT
    {
-        return --counter;
+        return static_cast< unsigned int >(--counter);
    }
 };

--- a/include/boost/smart_ptr/make_unique.hpp
+++ b/include/boost/smart_ptr/make_unique.hpp
@@ -1,15 +1,105 @@
 /*
- * Copyright (c) 2014 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
+(c) 2014-2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
 #ifndef BOOST_SMART_PTR_MAKE_UNIQUE_HPP
 #define BOOST_SMART_PTR_MAKE_UNIQUE_HPP

-#include <boost/smart_ptr/make_unique_array.hpp>
-#include <boost/smart_ptr/make_unique_object.hpp>
+#include <boost/config.hpp>
+#include <memory>
+#include <utility>
+
+namespace boost {
+namespace detail {
+template<class T>
+struct up_if_object {
+    typedef std::unique_ptr<T> type;
+};
+
+template<class T>
+struct up_if_object<T[]> { };
+
+template<class T, std::size_t N>
+struct up_if_object<T[N]> { };
+
+template<class T>
+struct up_if_array { };
+
+template<class T>
+struct up_if_array<T[]> {
+    typedef std::unique_ptr<T[]> type;
+};
+
+template<class T>
+struct up_remove_reference {
+    typedef T type;
+};
+
+template<class T>
+struct up_remove_reference<T&> {
+    typedef T type;
+};
+
+template<class T>
+struct up_remove_reference<T&&> {
+    typedef T type;
+};
+
+template<class T>
+struct up_element { };
+
+template<class T>
+struct up_element<T[]> {
+    typedef T type;
+};
+} /* detail */
+
+template<class T>
+inline typename detail::up_if_object<T>::type make_unique()
+{
+    return std::unique_ptr<T>(new T());
+}
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+template<class T, class... Args>
+inline typename detail::up_if_object<T>::type
+    make_unique(Args&&... args)
+{
+    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+#endif
+
+template<class T>
+inline typename detail::up_if_object<T>::type
+    make_unique(typename detail::up_remove_reference<T>::type&& value)
+{
+    return std::unique_ptr<T>(new T(std::move(value)));
+}
+
+template<class T>
+inline typename detail::up_if_object<T>::type make_unique_noinit()
+{
+    return std::unique_ptr<T>(new T);
+}
+
+template<class T>
+inline typename detail::up_if_array<T>::type make_unique(std::size_t n)
+{
+    return std::unique_ptr<T>(new
+        typename detail::up_element<T>::type[n]());
+}
+
+template<class T>
+inline typename detail::up_if_array<T>::type
+    make_unique_noinit(std::size_t n)
+{
+    return std::unique_ptr<T>(new
+        typename detail::up_element<T>::type[n]);
+}
+} /* boost */

 #endif
--- a/include/boost/smart_ptr/make_unique_array.hpp
+++ b/include/boost/smart_ptr/make_unique_array.hpp
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2014 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_MAKE_UNIQUE_ARRAY_HPP
-#define BOOST_SMART_PTR_MAKE_UNIQUE_ARRAY_HPP
-
-#include <boost/smart_ptr/detail/up_if_array.hpp>
-#include <boost/smart_ptr/detail/array_traits.hpp>
-
-namespace boost {
-    template<class T>
-    inline typename boost::detail::up_if_array<T>::type
-    make_unique(std::size_t size) {
-        typedef typename boost::detail::array_inner<T>::type U;
-        return std::unique_ptr<T>(new U[size]());
-    }
-    
-    template<class T>
-    inline typename boost::detail::up_if_array<T>::type
-    make_unique_noinit(std::size_t size) {
-        typedef typename boost::detail::array_inner<T>::type U;
-        return std::unique_ptr<T>(new U[size]);
-    }
-}
-
-#endif
--- a/include/boost/smart_ptr/make_unique_object.hpp
+++ b/include/boost/smart_ptr/make_unique_object.hpp
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) 2014 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_MAKE_UNIQUE_OBJECT_HPP
-#define BOOST_SMART_PTR_MAKE_UNIQUE_OBJECT_HPP
-
-#include <boost/config.hpp>
-#include <boost/smart_ptr/detail/up_if_not_array.hpp>
-#include <boost/type_traits/add_rvalue_reference.hpp>
-#include <utility>
-
-namespace boost {
-    template<class T>
-    inline typename boost::detail::up_if_not_array<T>::type
-    make_unique() {
-        return std::unique_ptr<T>(new T());
-    }
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template<class T, class... Args>
-    inline typename boost::detail::up_if_not_array<T>::type
-    make_unique(Args&&... args) {
-        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-    }
-#endif
-    
-    template<class T>
-    inline typename boost::detail::up_if_not_array<T>::type
-    make_unique(typename add_rvalue_reference<T>::type value) {
-        return std::unique_ptr<T>(new T(std::move(value)));
-    }
-
-    template<class T>
-    inline typename boost::detail::up_if_not_array<T>::type
-    make_unique_noinit() {
-        return std::unique_ptr<T>(new T);
-    }
-}
-
-#endif
--- a/include/boost/smart_ptr/scoped_ptr.hpp
+++ b/include/boost/smart_ptr/scoped_ptr.hpp
@@ -15,12 +15,18 @@
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
+#include <boost/smart_ptr/detail/sp_disable_deprecated.hpp>
 #include <boost/detail/workaround.hpp>

 #ifndef BOOST_NO_AUTO_PTR
 # include <memory>          // for std::auto_ptr
 #endif

+#if defined( BOOST_SP_DISABLE_DEPRECATED )
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 namespace boost
 {

@@ -154,4 +160,8 @@ template<class T> inline T * get_pointer(scoped_ptr<T> const & p) BOOST_NOEXCEPT

 } // namespace boost

+#if defined( BOOST_SP_DISABLE_DEPRECATED )
+#pragma GCC diagnostic pop
+#endif
+
 #endif // #ifndef BOOST_SMART_PTR_SCOPED_PTR_HPP_INCLUDED
--- a/include/boost/smart_ptr/shared_ptr.hpp
+++ b/include/boost/smart_ptr/shared_ptr.hpp
@@ -29,6 +29,7 @@
 #include <boost/detail/workaround.hpp>
 #include <boost/smart_ptr/detail/sp_convertible.hpp>
 #include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
+#include <boost/smart_ptr/detail/sp_disable_deprecated.hpp>

 #if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
 #include <boost/smart_ptr/detail/spinlock_pool.hpp>
@@ -47,6 +48,11 @@
 #endif
 #endif

+#if defined( BOOST_SP_DISABLE_DEPRECATED )
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 namespace boost
 {

@@ -55,6 +61,13 @@ template<class T> class weak_ptr;
 template<class T> class enable_shared_from_this;
 class enable_shared_from_raw;

+namespace movelib
+{
+
+    template< class T, class D > class unique_ptr;
+
+} // namespace movelib
+
 namespace detail
 {

@@ -495,6 +508,17 @@ public:

 #endif

+    template< class Y, class D >
+    shared_ptr( boost::movelib::unique_ptr< Y, D > r ): px( r.get() ), pn()
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        typename boost::movelib::unique_ptr< Y, D >::pointer tmp = r.get();
+        pn = boost::detail::shared_count( r );
+
+        boost::detail::sp_deleter_construct( this, tmp );
+    }
+
    // assignment

    shared_ptr & operator=( shared_ptr const & r ) BOOST_NOEXCEPT
@@ -556,6 +580,27 @@ public:

 #endif

+    template<class Y, class D>
+    shared_ptr & operator=( boost::movelib::unique_ptr<Y, D> r )
+    {
+        // this_type( static_cast< unique_ptr<Y, D> && >( r ) ).swap( *this );
+
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        typename boost::movelib::unique_ptr< Y, D >::pointer p = r.get();
+
+        shared_ptr tmp;
+
+        tmp.px = p;
+        tmp.pn = boost::detail::shared_count( r );
+
+        boost::detail::sp_deleter_construct( &tmp, p );
+
+        tmp.swap( *this );
+
+        return *this;
+    }
+
 // Move support

 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
@@ -597,6 +642,14 @@ public:
        return *this;
    }

+    // aliasing move
+    template<class Y>
+    shared_ptr( shared_ptr<Y> && r, element_type * p ) BOOST_NOEXCEPT : px( p ), pn()
+    {
+        pn.swap( r.pn );
+        r.px = 0;
+    }
+
 #endif

 #if !defined( BOOST_NO_CXX11_NULLPTR )
@@ -634,7 +687,16 @@ public:
    {
        this_type( r, p ).swap( *this );
    }
-    
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class Y> void reset( shared_ptr<Y> && r, element_type * p )
+    {
+        this_type( static_cast< shared_ptr<Y> && >( r ), p ).swap( *this );
+    }
+
+#endif
+
    // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
    typename boost::detail::sp_dereference< T >::type operator* () const
    {
@@ -655,7 +717,7 @@ public:
        BOOST_ASSERT( px != 0 );
        BOOST_ASSERT( i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 ) );

-        return px[ i ];
+        return static_cast< typename boost::detail::sp_array_access< T >::type >( px[ i ] );
    }

    element_type * get() const BOOST_NOEXCEPT
@@ -1020,9 +1082,13 @@ template< class T > struct hash;

 template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) BOOST_NOEXCEPT
 {
-    return boost::hash< T* >()( p.get() );
+    return boost::hash< typename boost::shared_ptr<T>::element_type* >()( p.get() );
 }

 } // namespace boost

+#if defined( BOOST_SP_DISABLE_DEPRECATED )
+#pragma GCC diagnostic pop
+#endif
+
 #endif  // #ifndef BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED
--- a/shared_ptr.htm
+++ b/shared_ptr.htm
@@ -139,6 +139,8 @@ void bad()

      template&lt;class Y&gt; <a href="#aliasing_constructor" >shared_ptr</a>(shared_ptr&lt;Y&gt; const &amp; r, element_type * p); // never throws

+      template&lt;class Y&gt; <a href="#aliasing_move_constructor" >shared_ptr</a>(shared_ptr&lt;Y&gt; &amp;&amp; r, element_type * p); // never throws
+
      template&lt;class Y&gt; explicit <a href="#weak_ptr_constructor" >shared_ptr</a>(<a href="weak_ptr.htm" >weak_ptr</a>&lt;Y&gt; const &amp; r);

      template&lt;class Y&gt; explicit <a href="#auto_ptr_constructor" >shared_ptr</a>(std::auto_ptr&lt;Y&gt; &amp; r);
@@ -352,6 +354,16 @@ template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; &amp;&amp; r); // never t
            <p><b>Postconditions:</b> <code>get() == p &amp;&amp; use_count() == r.use_count()</code>.</p>
            <p><b>Throws:</b> nothing.</p>
        </blockquote>
+        <h3 id="aliasing_move_constructor">aliasing move constructor</h3>
+        <pre>template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; &amp;&amp; r, element_type * p); // never throws</pre>
+        <blockquote>
+            <p>
+                <b>Effects:</b> Move-constructs a <code>shared_ptr</code> from <code>r</code>, while
+                storing <code>p</code> instead.
+            </p>
+            <p><b>Postconditions:</b> <code>get() == p</code> and <code>use_count()</code> equals the old count of <code>r</code>. <code>r</code> is <em>empty</em> and <code>r.get() == 0</code>.</p>
+            <p><b>Throws:</b> nothing.</p>
+        </blockquote>
        <h3 id="weak_ptr_constructor">weak_ptr constructor</h3>
        <pre>template&lt;class Y&gt; explicit shared_ptr(<a href="weak_ptr.htm" >weak_ptr</a>&lt;Y&gt; const &amp; r);</pre>
        <blockquote>
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -34,6 +34,7 @@ import testing ;
          [ run shared_ptr_alias_test.cpp ]
          [ run shared_ptr_rv_test.cpp ]
          [ run shared_ptr_move_test.cpp ]
+          [ run shared_ptr_alias_move_test.cpp ]
          [ compile-fail shared_ptr_pv_fail.cpp ]
          [ run sp_unary_addr_test.cpp ]
          [ compile-fail scoped_ptr_eq_fail.cpp ]
@@ -171,5 +172,18 @@ import testing ;

          [ run weak_from_raw_test.cpp ]
          [ run weak_from_raw_test2.cpp ]
+          [ run weak_from_raw_test3.cpp ]
+          [ run weak_from_raw_test4.cpp ]
+          [ run weak_from_raw_test5.cpp ]
+
+          [ compile sp_explicit_inst_test.cpp ]
+
+          [ run weak_from_this_test.cpp ]
+          [ run weak_from_this_test2.cpp ]
+
+          [ run sp_bml_unique_ptr_test.cpp ]
+
+          [ run sp_hash_test2.cpp ]
+          [ run sp_hash_test3.cpp ]
        ;
 }
--- a/test/allocate_shared_array_construct_test.cpp
+++ b/test/allocate_shared_array_construct_test.cpp
@@ -1,43 +1,38 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-#include <boost/smart_ptr/allocate_shared_array.hpp>
+(c) 2012-2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
+struct tag { };

 template<typename T>
 class creator {
 public:
    typedef T value_type;
-
    creator() {
    }
-
    template<typename U>
    creator(const creator<U>&) {
    }
-
    T* allocate(std::size_t size) {
-        void* p1 = ::operator new(size * sizeof(T));
-        return static_cast<T*>(p1);
+        void* p = ::operator new(size * sizeof(T));
+        return static_cast<T*>(p);
    }
-
    void deallocate(T* memory, std::size_t) {
-        void* p1 = memory;
-        ::operator delete(p1);
+        void* p = memory;
+        ::operator delete(p);
    }
-
    template<typename U>
    void construct(U* memory) {
-        void* p1 = memory;
-        ::new(p1) U();
+        void* p = memory;
+        ::new(p) U(tag());
    }
-
    template<typename U>
    void destroy(U* memory) {
        memory->~U();
@@ -45,116 +40,88 @@ public:
 };

 class type {
-    friend class creator<type>;
-
 public:
    static unsigned int instances;
-    static const type object;
-
-protected:
-    explicit type() {
+    explicit type(tag) {
        instances++;
    }
-
    type(const type&) {
        instances++;
    }
-
    ~type() {
        instances--;
    }
 };

-unsigned int type::instances;
-const type type::object;
+unsigned int type::instances = 0;

-int main() {
-    BOOST_TEST(type::instances == 1);
+int main()
+{
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
    {
        boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(creator<void>(), 3);
        BOOST_TEST(a1.use_count() == 1);
        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(type::instances == 4);
+        BOOST_TEST(type::instances == 3);
        a1.reset();
-        BOOST_TEST(type::instances == 1);
+        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 1);
    {
        boost::shared_ptr<type[3]> a1 = boost::allocate_shared<type[3]>(creator<void>());
        BOOST_TEST(a1.use_count() == 1);
        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(type::instances == 4);
+        BOOST_TEST(type::instances == 3);
        a1.reset();
-        BOOST_TEST(type::instances == 1);
+        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 1);
    {
        boost::shared_ptr<type[][2]> a1 = boost::allocate_shared<type[][2]>(creator<void>(), 2);
        BOOST_TEST(a1.get() != 0);
        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 5);
+        BOOST_TEST(type::instances == 4);
        a1.reset();
-        BOOST_TEST(type::instances == 1);
+        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 1);
    {
        boost::shared_ptr<type[2][2]> a1 = boost::allocate_shared<type[2][2]>(creator<void>());
        BOOST_TEST(a1.get() != 0);
        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 5);
+        BOOST_TEST(type::instances == 4);
        a1.reset();
-        BOOST_TEST(type::instances == 1);
+        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 1);
    {
        boost::shared_ptr<const type[]> a1 = boost::allocate_shared<const type[]>(creator<void>(), 3);
        BOOST_TEST(a1.get() != 0);
        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 4);
+        BOOST_TEST(type::instances == 3);
        a1.reset();
-        BOOST_TEST(type::instances == 1);
+        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 1);
    {
        boost::shared_ptr<const type[3]> a1 = boost::allocate_shared<const type[3]>(creator<void>());
        BOOST_TEST(a1.get() != 0);
        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 4);
+        BOOST_TEST(type::instances == 3);
        a1.reset();
-        BOOST_TEST(type::instances == 1);
+        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 1);
    {
        boost::shared_ptr<const type[][2]> a1 = boost::allocate_shared<const type[][2]>(creator<void>(), 2);
        BOOST_TEST(a1.get() != 0);
        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 5);
+        BOOST_TEST(type::instances == 4);
        a1.reset();
-        BOOST_TEST(type::instances == 1);
+        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 1);
    {
        boost::shared_ptr<const type[2][2]> a1 = boost::allocate_shared<const type[2][2]>(creator<void>());
        BOOST_TEST(a1.get() != 0);
        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 5);
+        BOOST_TEST(type::instances == 4);
        a1.reset();
-        BOOST_TEST(type::instances == 1);
+        BOOST_TEST(type::instances == 0);
    }
-
+#endif
    return boost::report_errors();
 }
-#else
-
-int main() {
-    return 0;
-}
-
-#endif
--- a/test/allocate_shared_array_esft_test.cpp
+++ b/test/allocate_shared_array_esft_test.cpp
@@ -1,28 +1,25 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/allocate_shared_array.hpp>
+(c) 2012-2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/enable_shared_from_this.hpp>
+#include <boost/smart_ptr/make_shared.hpp>

 class type 
    : public boost::enable_shared_from_this<type> {
 public:
    static unsigned int instances;
-
    explicit type() {
        instances++;
    }
-
    ~type() {
        instances--;
    }
-
 private:
    type(const type&);
    type& operator=(const type&);
@@ -30,7 +27,8 @@ private:

 unsigned int type::instances = 0;

-int main() {
+int main()
+{
    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(std::allocator<type>(), 3);
@@ -41,7 +39,6 @@ int main() {
            BOOST_TEST(type::instances == 3);
        }
    }
-
    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[]> a1 = boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 3);
@@ -52,6 +49,5 @@ int main() {
            BOOST_TEST(type::instances == 3);
        }
    }
-
    return boost::report_errors();
 }
--- a/test/allocate_shared_array_noinit_test.cpp
+++ b/test/allocate_shared_array_noinit_test.cpp
@@ -1,28 +1,25 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/allocate_shared_array.hpp>
+(c) 2012-2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
 #include <boost/type_traits/alignment_of.hpp>

 class type {
 public:
    static unsigned int instances;
-
    explicit type() {
        instances++;
    }
-
    ~type() {
        instances--;
    }
-
 private:
    type(const type&);
    type& operator=(const type&);
@@ -30,7 +27,8 @@ private:

 unsigned int type::instances = 0;

-int main() {
+int main()
+{
    {
        boost::shared_ptr<int[]> a1 = boost::allocate_shared_noinit<int[]>(std::allocator<int>(), 3);
        int* a2 = a1.get();
@@ -38,7 +36,6 @@ int main() {
        BOOST_TEST(a2 != 0);
        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
    }
-
    {
        boost::shared_ptr<int[3]> a1 = boost::allocate_shared_noinit<int[3]>(std::allocator<int>());
        int* a2 = a1.get();
@@ -46,19 +43,16 @@ int main() {
        BOOST_TEST(a2 != 0);
        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
    }
-
    {
        boost::shared_ptr<int[][2]> a1 = boost::allocate_shared_noinit<int[][2]>(std::allocator<int>(), 2);
        BOOST_TEST(a1.get() != 0);
        BOOST_TEST(a1.use_count() == 1);
    }
-
    {
        boost::shared_ptr<int[2][2]> a1 = boost::allocate_shared_noinit<int[2][2]>(std::allocator<int>());
        BOOST_TEST(a1.get() != 0);
        BOOST_TEST(a1.use_count() == 1);
    }
-
    {
        boost::shared_ptr<const int[]> a1 = boost::allocate_shared_noinit<const int[]>(std::allocator<int>(), 3);
        const int* a2 = a1.get();
@@ -66,7 +60,6 @@ int main() {
        BOOST_TEST(a2 != 0);
        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
    }
-
    {
        boost::shared_ptr<const int[3]> a1 = boost::allocate_shared_noinit<const int[3]>(std::allocator<int>());
        const int* a2 = a1.get();
@@ -74,20 +67,16 @@ int main() {
        BOOST_TEST(a2 != 0);
        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
    }
-
    {
        boost::shared_ptr<const int[][2]> a1 = boost::allocate_shared_noinit<const int[][2]>(std::allocator<int>(), 2);
        BOOST_TEST(a1.get() != 0);
        BOOST_TEST(a1.use_count() == 1);
    }
-
    {
        boost::shared_ptr<const int[2][2]> a1 = boost::allocate_shared_noinit<const int[2][2]>(std::allocator<int>());
        BOOST_TEST(a1.get() != 0);
        BOOST_TEST(a1.use_count() == 1);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[]> a1 = boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 3);
        type* a2 = a1.get();
@@ -99,8 +88,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[3]> a1 = boost::allocate_shared_noinit<type[3]>(std::allocator<type>());
        type* a2 = a1.get();
@@ -112,8 +99,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[][2]> a1 = boost::allocate_shared_noinit<type[][2]>(std::allocator<type>(), 2);
        BOOST_TEST(a1.get() != 0);
@@ -122,8 +107,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[2][2]> a1 = boost::allocate_shared_noinit<type[2][2]>(std::allocator<type>());
        BOOST_TEST(a1.get() != 0);
@@ -132,8 +115,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[]> a1 = boost::allocate_shared_noinit<const type[]>(std::allocator<type>(), 3);
        const type* a2 = a1.get();
@@ -144,8 +125,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[3]> a1 = boost::allocate_shared_noinit<const type[3]>(std::allocator<type>());
        const type* a2 = a1.get();
@@ -156,8 +135,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[][2]> a1 = boost::allocate_shared_noinit<const type[][2]>(std::allocator<type>(), 2);
        BOOST_TEST(a1.get() != 0);
@@ -166,8 +143,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[2][2]> a1 = boost::allocate_shared_noinit<const type[2][2]>(std::allocator<type>());
        BOOST_TEST(a1.get() != 0);
@@ -176,6 +151,5 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
    return boost::report_errors();
 }
--- a/test/allocate_shared_array_test.cpp
+++ b/test/allocate_shared_array_test.cpp
@@ -1,28 +1,25 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/allocate_shared_array.hpp>
+(c) 2012-2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
 #include <boost/type_traits/alignment_of.hpp>

 class type {
 public:
    static unsigned int instances;
-
    explicit type() {
        instances++;
    }
-
    ~type() {
        instances--;
    }
-
 private:
    type(const type&);
    type& operator=(const type&);
@@ -30,7 +27,8 @@ private:

 unsigned int type::instances = 0;

-int main() {
+int main()
+{
    {
        boost::shared_ptr<int[]> a1 = boost::allocate_shared<int[]>(std::allocator<int>(), 3);
        int* a2 = a1.get();
@@ -41,7 +39,6 @@ int main() {
        BOOST_TEST(a1[1] == 0);
        BOOST_TEST(a1[2] == 0);
    }
-
    {
        boost::shared_ptr<int[3]> a1 = boost::allocate_shared<int[3]>(std::allocator<int>());
        int* a2 = a1.get();
@@ -52,7 +49,6 @@ int main() {
        BOOST_TEST(a1[1] == 0);
        BOOST_TEST(a1[2] == 0);
    }
-
    {
        boost::shared_ptr<int[][2]> a1 = boost::allocate_shared<int[][2]>(std::allocator<int>(), 2);
        BOOST_TEST(a1.get() != 0);
@@ -62,7 +58,6 @@ int main() {
        BOOST_TEST(a1[1][0] == 0);
        BOOST_TEST(a1[1][1] == 0);
    }
-
    {
        boost::shared_ptr<int[2][2]> a1 = boost::allocate_shared<int[2][2]>(std::allocator<int>());
        BOOST_TEST(a1.get() != 0);
@@ -72,7 +67,6 @@ int main() {
        BOOST_TEST(a1[1][0] == 0);
        BOOST_TEST(a1[1][1] == 0);
    }
-
    {
        boost::shared_ptr<const int[]> a1 = boost::allocate_shared<const int[]>(std::allocator<int>(), 3);
        const int* a2 = a1.get();
@@ -83,7 +77,6 @@ int main() {
        BOOST_TEST(a1[1] == 0);
        BOOST_TEST(a1[2] == 0);
    }
-
    {
        boost::shared_ptr<const int[3]> a1 = boost::allocate_shared<const int[3]>(std::allocator<int>());
        const int* a2 = a1.get();
@@ -94,7 +87,6 @@ int main() {
        BOOST_TEST(a1[1] == 0);
        BOOST_TEST(a1[2] == 0);
    }
-
    {
        boost::shared_ptr<const int[][2]> a1 = boost::allocate_shared<const int[][2]>(std::allocator<int>(), 2);
        BOOST_TEST(a1.get() != 0);
@@ -104,7 +96,6 @@ int main() {
        BOOST_TEST(a1[1][0] == 0);
        BOOST_TEST(a1[1][1] == 0);
    }
-
    {
        boost::shared_ptr<const int[2][2]> a1 = boost::allocate_shared<const int[2][2]>(std::allocator<int>());
        BOOST_TEST(a1.get() != 0);
@@ -114,8 +105,6 @@ int main() {
        BOOST_TEST(a1[1][0] == 0);
        BOOST_TEST(a1[1][1] == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(std::allocator<type>(), 3);
        type* a2 = a1.get();
@@ -127,8 +116,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[3]> a1 = boost::allocate_shared<type[3]>(std::allocator<type>());
        type* a2 = a1.get();
@@ -140,8 +127,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[][2]> a1 = boost::allocate_shared<type[][2]>(std::allocator<type>(), 2);
        BOOST_TEST(a1.get() != 0);
@@ -150,8 +135,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[2][2]> a1 = boost::allocate_shared<type[2][2]>(std::allocator<type>());
        BOOST_TEST(a1.get() != 0);
@@ -160,8 +143,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[]> a1 = boost::allocate_shared<const type[]>(std::allocator<type>(), 3);
        const type* a2 = a1.get();
@@ -172,8 +153,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[3]> a1 = boost::allocate_shared<const type[3]>(std::allocator<type>());
        const type* a2 = a1.get();
@@ -184,8 +163,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[][2]> a1 = boost::allocate_shared<const type[][2]>(std::allocator<type>(), 2);
        BOOST_TEST(a1.get() != 0);
@@ -194,8 +171,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[2][2]> a1 = boost::allocate_shared<const type[2][2]>(std::allocator<type>());
        BOOST_TEST(a1.get() != 0);
@@ -204,6 +179,5 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
    return boost::report_errors();
 }
--- a/test/allocate_shared_array_throws_test.cpp
+++ b/test/allocate_shared_array_throws_test.cpp
@@ -1,29 +1,26 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/allocate_shared_array.hpp>
+(c) 2012-2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared.hpp>

 class type {
 public:
    static unsigned int instances;
-
    explicit type() {
        if (instances == 5) {
            throw true;
        }
        instances++;
    }
-
    ~type() {
        instances--;
    }
-
 private:
    type(const type&);
    type& operator=(const type&);
@@ -31,70 +28,55 @@ private:

 unsigned int type::instances = 0;

-int main() {
-    BOOST_TEST(type::instances == 0);
+int main()
+{
    try {
        boost::allocate_shared<type[]>(std::allocator<type>(), 6);
        BOOST_ERROR("allocate_shared did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    try {
        boost::allocate_shared<type[][2]>(std::allocator<type>(), 3);
        BOOST_ERROR("allocate_shared did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    try {
        boost::allocate_shared<type[6]>(std::allocator<type>());
        BOOST_ERROR("allocate_shared did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    try {
        boost::allocate_shared<type[3][2]>(std::allocator<type>());
        BOOST_ERROR("allocate_shared did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    try {
        boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 6);
        BOOST_ERROR("allocate_shared_noinit did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    try {
        boost::allocate_shared_noinit<type[][2]>(std::allocator<type>(), 3);
        BOOST_ERROR("allocate_shared_noinit did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    try {
        boost::allocate_shared_noinit<type[6]>(std::allocator<type>());
        BOOST_ERROR("allocate_shared_noinit did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    try {
        boost::allocate_shared_noinit<type[3][2]>(std::allocator<type>());
        BOOST_ERROR("allocate_shared_noinit did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
    return boost::report_errors();
 }
--- a/test/allocate_shared_array_value_test.cpp
+++ b/test/allocate_shared_array_value_test.cpp
@@ -1,15 +1,16 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/allocate_shared_array.hpp>
+(c) 2012-2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>

-int main() {
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
+int main()
+{
    {
        boost::shared_ptr<int[]> a1 = boost::allocate_shared<int[]>(std::allocator<int>(), 4, 1);
        BOOST_TEST(a1[0] == 1);
@@ -17,7 +18,6 @@ int main() {
        BOOST_TEST(a1[2] == 1);
        BOOST_TEST(a1[3] == 1);
    }
-
    {
        boost::shared_ptr<int[4]> a1 = boost::allocate_shared<int[4]>(std::allocator<int>(), 1);
        BOOST_TEST(a1[0] == 1);
@@ -25,7 +25,6 @@ int main() {
        BOOST_TEST(a1[2] == 1);
        BOOST_TEST(a1[3] == 1);
    }
-
    {
        boost::shared_ptr<const int[]> a1 = boost::allocate_shared<const int[]>(std::allocator<int>(), 4, 1);
        BOOST_TEST(a1[0] == 1);
@@ -33,7 +32,6 @@ int main() {
        BOOST_TEST(a1[2] == 1);
        BOOST_TEST(a1[3] == 1);
    }
-
    {
        boost::shared_ptr<const int[4]> a1 = boost::allocate_shared<const int[4]>(std::allocator<int>(), 1);
        BOOST_TEST(a1[0] == 1);
@@ -41,6 +39,5 @@ int main() {
        BOOST_TEST(a1[2] == 1);
        BOOST_TEST(a1[3] == 1);
    }
-
    return boost::report_errors();
 }
--- a/test/allocate_shared_arrays_test.cpp
+++ b/test/allocate_shared_arrays_test.cpp
@@ -1,15 +1,16 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/allocate_shared_array.hpp>
+(c) 2012-2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>

-int main() {
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
+int main()
+{
 #if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
    {
        boost::shared_ptr<int[][2]> a1 = boost::allocate_shared<int[][2]>(std::allocator<int>(), 2, {0, 1});
@@ -18,7 +19,6 @@ int main() {
        BOOST_TEST(a1[1][0] == 0);
        BOOST_TEST(a1[1][1] == 1);
    }
-
    {
        boost::shared_ptr<int[2][2]> a1 = boost::allocate_shared<int[2][2]>(std::allocator<int>(), { 0, 1 });
        BOOST_TEST(a1[0][0] == 0);
@@ -26,7 +26,6 @@ int main() {
        BOOST_TEST(a1[1][0] == 0);
        BOOST_TEST(a1[1][1] == 1);
    }
-
    {
        boost::shared_ptr<const int[][2]> a1 = boost::allocate_shared<const int[][2]>(std::allocator<int>(), 2, { 0, 1 });
        BOOST_TEST(a1[0][0] == 0);
@@ -34,7 +33,6 @@ int main() {
        BOOST_TEST(a1[1][0] == 0);
        BOOST_TEST(a1[1][1] == 1);
    }
-
    {
        boost::shared_ptr<const int[2][2]> a1 = boost::allocate_shared<const int[2][2]>(std::allocator<int>(), { 0, 1 });
        BOOST_TEST(a1[0][0] == 0);
@@ -43,6 +41,5 @@ int main() {
        BOOST_TEST(a1[1][1] == 1);
    }
 #endif
-
    return boost::report_errors();
 }
--- a/test/array_fail_array_access.cpp
+++ b/test/array_fail_array_access.cpp
@@ -12,8 +12,12 @@ struct X
 {
 };

+template<class T> void f( T & /*t*/ )
+{
+}
+
 int main()
 {
    boost::shared_ptr<X> px( new X );
-    px[ 0 ];
+    f( px[ 0 ] );
 }
--- a/test/intrusive_ptr_move_test.cpp
+++ b/test/intrusive_ptr_move_test.cpp
@@ -143,6 +143,18 @@ int main()
        BOOST_TEST( N::base::instances == 0 );
    }

+    {
+        boost::intrusive_ptr<Y> p( new Y );
+        BOOST_TEST( N::base::instances == 1 );
+
+        boost::intrusive_ptr<X> p2( std::move( p ) );
+        BOOST_TEST( N::base::instances == 1 );
+        BOOST_TEST( p.get() == 0 );
+
+        p2.reset();
+        BOOST_TEST( N::base::instances == 0 );
+    }
+
    {
        boost::intrusive_ptr<X> p( new X );
        BOOST_TEST( N::base::instances == 1 );
@@ -170,6 +182,33 @@ int main()
        BOOST_TEST( N::base::instances == 0 );
    }

+    {
+        boost::intrusive_ptr<Y> p( new Y );
+        BOOST_TEST( N::base::instances == 1 );
+
+        boost::intrusive_ptr<X> p2;
+        p2 = std::move( p );
+        BOOST_TEST( N::base::instances == 1 );
+        BOOST_TEST( p.get() == 0 );
+
+        p2.reset();
+        BOOST_TEST( N::base::instances == 0 );
+    }
+
+    {
+        boost::intrusive_ptr<Y> p( new Y );
+        BOOST_TEST( N::base::instances == 1 );
+
+        boost::intrusive_ptr<X> p2( new X );
+        BOOST_TEST( N::base::instances == 2 );
+        p2 = std::move( p );
+        BOOST_TEST( N::base::instances == 1 );
+        BOOST_TEST( p.get() == 0 );
+
+        p2.reset();
+        BOOST_TEST( N::base::instances == 0 );
+    }
+
    return boost::report_errors();
 }

--- a/test/make_shared_array_esft_test.cpp
+++ b/test/make_shared_array_esft_test.cpp
@@ -1,28 +1,25 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
+(c) 2012-2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/enable_shared_from_this.hpp>
-#include <boost/smart_ptr/make_shared_array.hpp>
+#include <boost/smart_ptr/make_shared.hpp>

 class type
    : public boost::enable_shared_from_this<type> {
 public:
    static unsigned int instances;
-
    explicit type() {
        instances++;
    }
-
    ~type() {
        instances--;
    }
-
 private:
    type(const type&);
    type& operator=(const type&);
@@ -30,7 +27,8 @@ private:

 unsigned int type::instances = 0;

-int main() {
+int main()
+{
    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>(3);
@@ -41,7 +39,6 @@ int main() {
            BOOST_TEST(type::instances == 3);
        }
    }
-
    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[]> a1 = boost::make_shared_noinit<type[]>(3);
@@ -52,6 +49,5 @@ int main() {
            BOOST_TEST(type::instances == 3);
        }
    }
-
    return boost::report_errors();
 }
--- a/test/make_shared_array_noinit_test.cpp
+++ b/test/make_shared_array_noinit_test.cpp
@@ -1,28 +1,25 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_shared_array.hpp>
+(c) 2012-2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
 #include <boost/type_traits/alignment_of.hpp>

 class type {
 public:
    static unsigned int instances;
-
    explicit type() {
        instances++;
    }
-
    ~type() {
        instances--;
    }
-
 private:
    type(const type&);
    type& operator=(const type&);
@@ -30,7 +27,8 @@ private:

 unsigned int type::instances = 0;

-int main() {
+int main()
+{
    {
        boost::shared_ptr<int[]> a1 = boost::make_shared_noinit<int[]>(3);
        int* a2 = a1.get();
@@ -38,7 +36,6 @@ int main() {
        BOOST_TEST(a2 != 0);
        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
    }
-
    {
        boost::shared_ptr<int[3]> a1 = boost::make_shared_noinit<int[3]>();
        int* a2 = a1.get();
@@ -46,19 +43,16 @@ int main() {
        BOOST_TEST(a2 != 0);
        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
    }
-
    {
        boost::shared_ptr<int[][2]> a1 = boost::make_shared_noinit<int[][2]>(2);
        BOOST_TEST(a1.get() != 0);
        BOOST_TEST(a1.use_count() == 1);
    }
-
    {
        boost::shared_ptr<int[2][2]> a1 = boost::make_shared_noinit<int[2][2]>();
        BOOST_TEST(a1.get() != 0);
        BOOST_TEST(a1.use_count() == 1);
    }
-
    {
        boost::shared_ptr<const int[]> a1 = boost::make_shared_noinit<const int[]>(3);
        const int* a2 = a1.get();
@@ -66,7 +60,6 @@ int main() {
        BOOST_TEST(a2 != 0);
        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
    }
-
    {
        boost::shared_ptr<const int[3]> a1 = boost::make_shared_noinit<const int[3]>();
        const int* a2 = a1.get();
@@ -74,20 +67,16 @@ int main() {
        BOOST_TEST(a2 != 0);
        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
    }
-
    {
        boost::shared_ptr<const int[][2]> a1 = boost::make_shared_noinit<const int[][2]>(2);
        BOOST_TEST(a1.get() != 0);
        BOOST_TEST(a1.use_count() == 1);
    }
-
    {
        boost::shared_ptr<const int[2][2]> a1 = boost::make_shared_noinit<const int[2][2]>();
        BOOST_TEST(a1.get() != 0);
        BOOST_TEST(a1.use_count() == 1);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[]> a1 = boost::make_shared_noinit<type[]>(3);
        type* a2 = a1.get();
@@ -99,8 +88,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[3]> a1 = boost::make_shared_noinit<type[3]>();
        type* a2 = a1.get();
@@ -112,8 +99,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[][2]> a1 = boost::make_shared_noinit<type[][2]>(2);
        BOOST_TEST(a1.get() != 0);
@@ -122,8 +107,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[2][2]> a1 = boost::make_shared_noinit<type[2][2]>();
        BOOST_TEST(a1.get() != 0);
@@ -132,8 +115,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[]> a1 = boost::make_shared_noinit<const type[]>(3);
        const type* a2 = a1.get();
@@ -144,8 +125,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[3]> a1 = boost::make_shared_noinit<const type[3]>();
        const type* a2 = a1.get();
@@ -156,8 +135,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[][2]> a1 = boost::make_shared_noinit<const type[][2]>(2);
        BOOST_TEST(a1.get() != 0);
@@ -166,8 +143,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[2][2]> a1 = boost::make_shared_noinit<const type[2][2]>();
        BOOST_TEST(a1.get() != 0);
@@ -176,6 +151,5 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
    return boost::report_errors();
 }
--- a/test/make_shared_array_test.cpp
+++ b/test/make_shared_array_test.cpp
@@ -1,28 +1,25 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_shared_array.hpp>
+(c) 2012-2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
 #include <boost/type_traits/alignment_of.hpp>

 class type {
 public:
    static unsigned int instances;
-
    explicit type() {
        instances++;
    }
-
    ~type() {
        instances--;
    }
-
 private:
    type(const type&);
    type& operator=(const type&);
@@ -30,7 +27,8 @@ private:

 unsigned int type::instances = 0;

-int main() {
+int main()
+{
    {
        boost::shared_ptr<int[]> a1 = boost::make_shared<int[]>(3);
        int* a2 = a1.get();
@@ -41,7 +39,6 @@ int main() {
        BOOST_TEST(a1[1] == 0);
        BOOST_TEST(a1[2] == 0);
    }
-
    {
        boost::shared_ptr<int[3]> a1 = boost::make_shared<int[3]>();
        int* a2 = a1.get();
@@ -52,7 +49,6 @@ int main() {
        BOOST_TEST(a1[1] == 0);
        BOOST_TEST(a1[2] == 0);
    }
-
    {
        boost::shared_ptr<int[][2]> a1 = boost::make_shared<int[][2]>(2);
        BOOST_TEST(a1.get() != 0);
@@ -62,7 +58,6 @@ int main() {
        BOOST_TEST(a1[1][0] == 0);
        BOOST_TEST(a1[1][1] == 0);
    }
-
    {
        boost::shared_ptr<int[2][2]> a1 = boost::make_shared<int[2][2]>();
        BOOST_TEST(a1.get() != 0);
@@ -72,7 +67,6 @@ int main() {
        BOOST_TEST(a1[1][0] == 0);
        BOOST_TEST(a1[1][1] == 0);
    }
-
    {
        boost::shared_ptr<const int[]> a1 = boost::make_shared<const int[]>(3);
        const int* a2 = a1.get();
@@ -83,7 +77,6 @@ int main() {
        BOOST_TEST(a1[1] == 0);
        BOOST_TEST(a1[2] == 0);
    }
-
    {
        boost::shared_ptr<const int[3]> a1 = boost::make_shared<const int[3]>();
        const int* a2 = a1.get();
@@ -94,7 +87,6 @@ int main() {
        BOOST_TEST(a1[1] == 0);
        BOOST_TEST(a1[2] == 0);
    }
-
    {
        boost::shared_ptr<const int[][2]> a1 = boost::make_shared<const int[][2]>(2);
        BOOST_TEST(a1.get() != 0);
@@ -104,7 +96,6 @@ int main() {
        BOOST_TEST(a1[1][0] == 0);
        BOOST_TEST(a1[1][1] == 0);
    }
-
    {
        boost::shared_ptr<const int[2][2]> a1 = boost::make_shared<const int[2][2]>();
        BOOST_TEST(a1.get() != 0);
@@ -114,8 +105,6 @@ int main() {
        BOOST_TEST(a1[1][0] == 0);
        BOOST_TEST(a1[1][1] == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>(3);
        type* a2 = a1.get();
@@ -127,8 +116,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[3]> a1 = boost::make_shared<type[3]>();
        type* a2 = a1.get();
@@ -140,8 +127,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[][2]> a1 = boost::make_shared<type[][2]>(2);
        BOOST_TEST(a1.get() != 0);
@@ -150,8 +135,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<type[2][2]> a1 = boost::make_shared<type[2][2]>();
        BOOST_TEST(a1.get() != 0);
@@ -160,8 +143,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[]> a1 = boost::make_shared<const type[]>(3);
        const type* a2 = a1.get();
@@ -172,8 +153,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[3]> a1 = boost::make_shared<const type[3]>();
        const type* a2 = a1.get();
@@ -184,8 +163,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[][2]> a1 = boost::make_shared<const type[][2]>(2);
        BOOST_TEST(a1.get() != 0);
@@ -194,8 +171,6 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    {
        boost::shared_ptr<const type[2][2]> a1 = boost::make_shared<const type[2][2]>();
        BOOST_TEST(a1.get() != 0);
@@ -204,6 +179,5 @@ int main() {
        a1.reset();
        BOOST_TEST(type::instances == 0);
    }
-
    return boost::report_errors();
 }
--- a/test/make_shared_array_throws_test.cpp
+++ b/test/make_shared_array_throws_test.cpp
@@ -1,29 +1,26 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
+(c) 2012-2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
 #include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_shared_array.hpp>
+#include <boost/smart_ptr/make_shared.hpp>

 class type {
 public:
    static unsigned int instances;
-
    explicit type() {
        if (instances == 5) {
            throw true;
        }
        instances++;
    }
-
    ~type() {
        instances--;
    }
-
 private:
    type(const type&);
    type& operator=(const type&);
@@ -31,70 +28,55 @@ private:

 unsigned int type::instances = 0;

-int main() {
-    BOOST_TEST(type::instances == 0);
+int main()
+{
    try {
        boost::make_shared<type[]>(6);
        BOOST_ERROR("make_shared did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    try {
        boost::make_shared<type[][2]>(3);
        BOOST_ERROR("make_shared did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    try {
        boost::make_shared<type[6]>();
        BOOST_ERROR("make_shared did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    try {
        boost::make_shared<type[3][2]>();
        BOOST_ERROR("make_shared did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    try {
        boost::make_shared_noinit<type[]>(6);
        BOOST_ERROR("make_shared_noinit did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    try {
        boost::make_shared_noinit<type[][2]>(3);
        BOOST_ERROR("make_shared_noinit did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    try {
        boost::make_shared_noinit<type[6]>();
        BOOST_ERROR("make_shared_noinit did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
-    BOOST_TEST(type::instances == 0);
    try {
        boost::make_shared_noinit<type[3][2]>();
        BOOST_ERROR("make_shared_noinit did not throw");
    } catch (...) {
        BOOST_TEST(type::instances == 0);
    }
-
    return boost::report_errors();
 }
--- a/test/make_shared_array_value_test.cpp
+++ b/test/make_shared_array_value_test.cpp
@@ -1,15 +1,16 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_shared_array.hpp>
+(c) 2012-2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>

-int main() {
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
+int main()
+{
    {
        boost::shared_ptr<int[]> a1 = boost::make_shared<int[]>(4, 1);
        BOOST_TEST(a1[0] == 1);
@@ -17,7 +18,6 @@ int main() {
        BOOST_TEST(a1[2] == 1);
        BOOST_TEST(a1[3] == 1);
    }
-
    {
        boost::shared_ptr<int[4]> a1 = boost::make_shared<int[4]>(1);
        BOOST_TEST(a1[0] == 1);
@@ -25,7 +25,6 @@ int main() {
        BOOST_TEST(a1[2] == 1);
        BOOST_TEST(a1[3] == 1);
    }
-
    {
        boost::shared_ptr<const int[]> a1 = boost::make_shared<const int[]>(4, 1);
        BOOST_TEST(a1[0] == 1);
@@ -33,7 +32,6 @@ int main() {
        BOOST_TEST(a1[2] == 1);
        BOOST_TEST(a1[3] == 1);
    }
-
    {
        boost::shared_ptr<const int[4]> a1 = boost::make_shared<const int[4]>(1);
        BOOST_TEST(a1[0] == 1);
@@ -41,6 +39,5 @@ int main() {
        BOOST_TEST(a1[2] == 1);
        BOOST_TEST(a1[3] == 1);
    }
-
    return boost::report_errors();
 }
--- a/test/make_shared_arrays_test.cpp
+++ b/test/make_shared_arrays_test.cpp
@@ -1,15 +1,16 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_shared_array.hpp>
+(c) 2012-2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>

-int main() {
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
+int main()
+{
 #if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
    {
        boost::shared_ptr<int[][2]> a1 = boost::make_shared<int[][2]>(2, {0, 1});
@@ -18,7 +19,6 @@ int main() {
        BOOST_TEST(a1[1][0] == 0);
        BOOST_TEST(a1[1][1] == 1);
    }
-
    {
        boost::shared_ptr<int[2][2]> a1 = boost::make_shared<int[2][2]>({ 0, 1 });
        BOOST_TEST(a1[0][0] == 0);
@@ -26,7 +26,6 @@ int main() {
        BOOST_TEST(a1[1][0] == 0);
        BOOST_TEST(a1[1][1] == 1);
    }
-
    {
        boost::shared_ptr<const int[][2]> a1 = boost::make_shared<const int[][2]>(2, { 0, 1 });
        BOOST_TEST(a1[0][0] == 0);
@@ -34,7 +33,6 @@ int main() {
        BOOST_TEST(a1[1][0] == 0);
        BOOST_TEST(a1[1][1] == 1);
    }
-
    {
        boost::shared_ptr<const int[2][2]> a1 = boost::make_shared<const int[2][2]>({ 0, 1 });
        BOOST_TEST(a1[0][0] == 0);
@@ -43,6 +41,5 @@ int main() {
        BOOST_TEST(a1[1][1] == 1);
    }
 #endif
-
    return boost::report_errors();
 }
--- a/test/make_unique_args_test.cpp
+++ b/test/make_unique_args_test.cpp
@@ -1,15 +1,15 @@
 /*
- * Copyright (c) 2014 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
+(c) 2014 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_unique_object.hpp>
+#include <boost/smart_ptr/make_unique.hpp>

 class type {
 public:
@@ -41,7 +41,8 @@ private:

 unsigned int type::instances = 0;

-int main() {
+int main()
+{
    BOOST_TEST(type::instances == 0);
    {
        std::unique_ptr<type> a1 = boost::make_unique<type>();
@@ -139,7 +140,8 @@ int main() {
 }
 #else

-int main() {
+int main()
+{
    return 0;
 }

--- a/test/make_unique_array_noinit_test.cpp
+++ b/test/make_unique_array_noinit_test.cpp
@@ -1,15 +1,15 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
+(c) 2014 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_unique_array.hpp>
+#include <boost/smart_ptr/make_unique.hpp>

 class type {
 public:
@@ -30,7 +30,8 @@ private:

 unsigned int type::instances = 0;

-int main() {
+int main()
+{
    {
        std::unique_ptr<int[]> a1 = boost::make_unique_noinit<int[]>(3);
        BOOST_TEST(a1.get() != 0);
@@ -81,7 +82,8 @@ int main() {
 }
 #else

-int main() {
+int main()
+{
    return 0;
 }

--- a/test/make_unique_array_test.cpp
+++ b/test/make_unique_array_test.cpp
@@ -1,15 +1,15 @@
 /*
- * Copyright (c) 2014 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
+(c) 2014 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_unique_array.hpp>
+#include <boost/smart_ptr/make_unique.hpp>

 class type {
 public:
@@ -30,7 +30,8 @@ private:

 unsigned int type::instances = 0;

-int main() {
+int main()
+{
    {
        std::unique_ptr<int[]> a1 = boost::make_unique<int[]>(3);
        BOOST_TEST(a1.get() != 0);
@@ -105,7 +106,8 @@ int main() {
 }
 #else

-int main() {
+int main()
+{
    return 0;
 }

--- a/test/make_unique_array_throws_test.cpp
+++ b/test/make_unique_array_throws_test.cpp
@@ -1,15 +1,15 @@
 /*
- * Copyright (c) 2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
+(c) 2014 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_unique_array.hpp>
+#include <boost/smart_ptr/make_unique.hpp>

 class type {
 public:
@@ -33,7 +33,8 @@ private:

 unsigned int type::instances = 0;

-int main() {
+int main()
+{
    BOOST_TEST(type::instances == 0);
    try {
        boost::make_unique<type[]>(6);
@@ -70,7 +71,8 @@ int main() {
 }
 #else

-int main() {
+int main()
+{
    return 0;
 }

--- a/test/make_unique_noinit_test.cpp
+++ b/test/make_unique_noinit_test.cpp
@@ -1,15 +1,15 @@
 /*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
+(c) 2014 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_unique_object.hpp>
+#include <boost/smart_ptr/make_unique.hpp>

 class type {
 public:
@@ -30,7 +30,8 @@ private:

 unsigned int type::instances = 0;

-int main() {
+int main()
+{
    {
        std::unique_ptr<int> a1 = boost::make_unique_noinit<int>();
        BOOST_TEST(a1.get() != 0);
@@ -58,7 +59,8 @@ int main() {
 }
 #else

-int main() {
+int main()
+{
    return 0;
 }

--- a/test/make_unique_test.cpp
+++ b/test/make_unique_test.cpp
@@ -1,15 +1,15 @@
 /*
- * Copyright (c) 2014 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
+(c) 2014 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_unique_object.hpp>
+#include <boost/smart_ptr/make_unique.hpp>

 class type {
 public:
@@ -30,7 +30,8 @@ private:

 unsigned int type::instances = 0;

-int main() {
+int main()
+{
    {
        std::unique_ptr<int> a1 = boost::make_unique<int>();
        BOOST_TEST(a1.get() != 0);
@@ -65,7 +66,8 @@ int main() {
 }
 #else

-int main() {
+int main()
+{
    return 0;
 }

--- a/test/make_unique_throws_test.cpp
+++ b/test/make_unique_throws_test.cpp
@@ -1,15 +1,15 @@
 /*
- * Copyright (c) 2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
+(c) 2014 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_unique_object.hpp>
+#include <boost/smart_ptr/make_unique.hpp>

 class type {
 public:
@@ -33,7 +33,8 @@ private:

 unsigned int type::instances = 0;

-int main() {
+int main()
+{
    BOOST_TEST(type::instances == 0);
    try {
        boost::make_unique<type>();
@@ -46,7 +47,8 @@ int main() {
 }
 #else

-int main() {
+int main()
+{
    return 0;
 }

--- a/test/make_unique_value_test.cpp
+++ b/test/make_unique_value_test.cpp
@@ -1,22 +1,23 @@
 /*
- * Copyright (c) 2014 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
+(c) 2014 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_unique_object.hpp>
+#include <boost/smart_ptr/make_unique.hpp>

 struct type {
    int x;
    int y;
 };

-int main() {
+int main()
+{
    {
        std::unique_ptr<type> a1 = boost::make_unique<type>();
        BOOST_TEST(a1.get() != 0);
@@ -51,7 +52,8 @@ int main() {
 }
 #else

-int main() {
+int main()
+{
    return 0;
 }

--- a/test/shared_ptr_alias_move_test.cpp
+++ b/test/shared_ptr_alias_move_test.cpp
@@ -0,0 +1,255 @@
+#include <boost/config.hpp>
+
+//  shared_ptr_alias_move_test.cpp
+//
+//  Copyright (c) 2007 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/detail/lightweight_test.hpp>
+#include <boost/shared_ptr.hpp>
+#include <utility>
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+class incomplete;
+
+struct X
+{
+    static long instances;
+
+    int v_;
+
+    explicit X( int v ): v_( v )
+    {
+        ++instances;
+    }
+
+    ~X()
+    {
+        v_ = 0;
+        --instances;
+    }
+
+private:
+    X( X const & );
+    X & operator=( X const & );
+};
+
+long X::instances = 0;
+
+int main()
+{
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        int m = 0;
+        boost::shared_ptr< int > p;
+        boost::shared_ptr< int > p2( std::move( p ), &m );
+
+        BOOST_TEST( p2.get() == &m );
+        BOOST_TEST( p2? true: false );
+        BOOST_TEST( !!p2 );
+        BOOST_TEST( p2.use_count() == 0 );
+
+        BOOST_TEST( p.get() == 0 );
+        BOOST_TEST( p.use_count() == 0 );
+
+        p2.reset( std::move( p ), 0 );
+
+        BOOST_TEST( p2.get() == 0 );
+        BOOST_TEST( p2? false: true );
+        BOOST_TEST( !p2 );
+        BOOST_TEST( p2.use_count() == 0 );
+
+        BOOST_TEST( p.get() == 0 );
+        BOOST_TEST( p.use_count() == 0 );
+    }
+
+    {
+        int m = 0;
+        boost::shared_ptr< int > p( new int );
+        boost::shared_ptr< int const > p2( std::move( p ), &m );
+
+        BOOST_TEST( p2.get() == &m );
+        BOOST_TEST( p2? true: false );
+        BOOST_TEST( !!p2 );
+        BOOST_TEST( p2.use_count() == 1 );
+
+        BOOST_TEST( p.get() == 0 );
+        BOOST_TEST( p.use_count() == 0 );
+
+        boost::shared_ptr< int volatile > p3;
+        p2.reset( std::move( p3 ), 0 );
+
+        BOOST_TEST( p2.get() == 0 );
+        BOOST_TEST( p2? false: true );
+        BOOST_TEST( !p2 );
+        BOOST_TEST( p2.use_count() == 0 );
+
+        BOOST_TEST( p3.get() == 0 );
+        BOOST_TEST( p3.use_count() == 0 );
+
+        boost::shared_ptr< int const volatile > p4( new int );
+        p2.reset( std::move( p4 ), &m );
+
+        BOOST_TEST( p2.get() == &m );
+        BOOST_TEST( p2.use_count() == 1 );
+
+        BOOST_TEST( p4.get() == 0 );
+        BOOST_TEST( p4.use_count() == 0 );
+    }
+
+    {
+        boost::shared_ptr< int > p( new int );
+        boost::shared_ptr< void const > p2( std::move( p ), 0 );
+
+        BOOST_TEST( p2.get() == 0 );
+        BOOST_TEST( p2? false: true );
+        BOOST_TEST( !p2 );
+        BOOST_TEST( p2.use_count() == 1 );
+
+        BOOST_TEST( p.get() == 0 );
+        BOOST_TEST( p.use_count() == 0 );
+
+        int m = 0;
+        boost::shared_ptr< void volatile > p3;
+
+        p2.reset( std::move( p3 ), &m );
+
+        BOOST_TEST( p2.get() == &m );
+        BOOST_TEST( p2? true: false );
+        BOOST_TEST( !!p2 );
+        BOOST_TEST( p2.use_count() == 0 );
+
+        BOOST_TEST( p3.get() == 0 );
+        BOOST_TEST( p3.use_count() == 0 );
+
+        boost::shared_ptr< void const volatile > p4( new int );
+        p2.reset( std::move( p4 ), 0 );
+
+        BOOST_TEST( p2.get() == 0 );
+        BOOST_TEST( p2.use_count() == 1 );
+
+        BOOST_TEST( p4.get() == 0 );
+        BOOST_TEST( p4.use_count() == 0 );
+    }
+
+    {
+        boost::shared_ptr< incomplete > p;
+        boost::shared_ptr< incomplete > p2( std::move( p ), 0 );
+
+        BOOST_TEST( p2.get() == 0 );
+        BOOST_TEST( p2? false: true );
+        BOOST_TEST( !p2 );
+        BOOST_TEST( p2.use_count() == 0 );
+
+        BOOST_TEST( p.get() == 0 );
+        BOOST_TEST( p.use_count() == 0 );
+
+        p2.reset( std::move( p ), 0 );
+
+        BOOST_TEST( p2.get() == 0 );
+        BOOST_TEST( p2? false: true );
+        BOOST_TEST( !p2 );
+        BOOST_TEST( p2.use_count() == 0 );
+
+        BOOST_TEST( p.get() == 0 );
+        BOOST_TEST( p.use_count() == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > p( new X( 5 ) ), q( p );
+        boost::shared_ptr< int const > p2( std::move( q ), &q->v_ );
+
+        BOOST_TEST( p2.get() == &p->v_ );
+        BOOST_TEST( p2? true: false );
+        BOOST_TEST( !!p2 );
+        BOOST_TEST( p2.use_count() == p.use_count() );
+        BOOST_TEST( !( p < p2 ) && !( p2 < p ) );
+
+        BOOST_TEST( q.get() == 0 );
+        BOOST_TEST( q.use_count() == 0 );
+
+        p.reset();
+        BOOST_TEST( *p2 == 5 );
+
+        boost::shared_ptr< X const > p3( new X( 8 ) ), q3( p3 );
+        p2.reset( std::move( q3 ), &q3->v_ );
+
+        BOOST_TEST( p2.get() == &p3->v_ );
+        BOOST_TEST( p2? true: false );
+        BOOST_TEST( !!p2 );
+        BOOST_TEST( p2.use_count() == p3.use_count() );
+        BOOST_TEST( !( p3 < p2 ) && !( p2 < p3 ) );
+
+        BOOST_TEST( q3.get() == 0 );
+        BOOST_TEST( q3.use_count() == 0 );
+
+        p3.reset();
+        BOOST_TEST( *p2 == 8 );
+    }
+
+    {
+        boost::shared_ptr< X > p( new X( 5 ) );
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( p.unique() );
+        BOOST_TEST( p->v_ == 5 );
+
+        boost::shared_ptr< X > p2( std::move( p ), p.get() );
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( p.get() == 0 );
+        BOOST_TEST( p2.unique() );
+        BOOST_TEST( p2->v_ == 5 );
+
+        boost::shared_ptr< int const > p3( std::move( p2 ), &p2->v_ );
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( p2.get() == 0 );
+        BOOST_TEST( p3.unique() );
+        BOOST_TEST( *p3 == 5 );
+
+        p3.reset();
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > p( new X( 5 ) );
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( p.unique() );
+        BOOST_TEST( p->v_ == 5 );
+
+        {
+            boost::shared_ptr< X > p2(p);
+            BOOST_TEST( X::instances == 1 );
+            BOOST_TEST( p.get() == p2.get() );
+            BOOST_TEST( p.use_count() == 2 );
+            BOOST_TEST( p2.use_count() == 2 );
+
+            boost::shared_ptr< int const > p3( std::move( p2 ), &p2->v_ );
+            BOOST_TEST( X::instances == 1 );
+            BOOST_TEST( p.use_count() == 2 );
+            BOOST_TEST( p2.use_count() == 0 );
+            BOOST_TEST( p2.get() == 0 );
+            BOOST_TEST( p3.use_count() == 2 );
+            BOOST_TEST( p3.get() == &p->v_ );
+        }
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( p.unique() );
+        BOOST_TEST( p->v_ == 5 );
+    }
+
+    return boost::report_errors();
+}
+
+#else // defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+int main()
+{
+    return 0;
+}
+
+#endif
--- a/test/sp_bml_unique_ptr_test.cpp
+++ b/test/sp_bml_unique_ptr_test.cpp
@@ -0,0 +1,239 @@
+//
+//  sp_bml_unique_ptr_test.cpp
+//
+//  Copyright (c) 2012, 2015 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/enable_shared_from_this.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/move/unique_ptr.hpp>
+#include <memory>
+#include <utility>
+
+struct X: public boost::enable_shared_from_this< X >
+{
+    static int instances;
+
+    X()
+    {
+        ++instances;
+    }
+
+    ~X()
+    {
+        --instances;
+    }
+
+private:
+
+    X( X const & );
+    X & operator=( X const & );
+};
+
+int X::instances = 0;
+
+struct Y
+{
+    static int instances;
+
+    bool deleted_;
+
+    Y(): deleted_( false )
+    {
+        ++instances;
+    }
+
+    ~Y()
+    {
+        BOOST_TEST( deleted_ );
+        --instances;
+    }
+
+private:
+
+    Y( Y const & );
+    Y & operator=( Y const & );
+};
+
+int Y::instances = 0;
+
+struct YD
+{
+    void operator()( Y* p ) const
+    {
+        p->deleted_ = true;
+        delete p;
+    }
+};
+
+int main()
+{
+    {
+        BOOST_TEST( X::instances == 0 );
+
+        boost::movelib::unique_ptr<X> p( new X );
+        BOOST_TEST( X::instances == 1 );
+
+        boost::shared_ptr<X> p2( boost::move( p ) );
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( p.get() == 0 );
+
+        boost::shared_ptr<X> p3 = p2->shared_from_this();
+        BOOST_TEST( p2 == p3 );
+        BOOST_TEST( !(p2 < p3) && !(p3 < p2) );
+
+        p2.reset();
+        p3.reset();
+        BOOST_TEST( X::instances == 0 );
+
+        p2 = boost::movelib::unique_ptr<X>( new X );
+        BOOST_TEST( X::instances == 1 );
+
+        p2 = boost::movelib::unique_ptr<X>( new X );
+        BOOST_TEST( X::instances == 1 );
+
+        p3 = p2->shared_from_this();
+        BOOST_TEST( p2 == p3 );
+        BOOST_TEST( !(p2 < p3) && !(p3 < p2) );
+
+        p2.reset();
+        p3.reset();
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        BOOST_TEST( X::instances == 0 );
+
+        boost::movelib::unique_ptr<X> p( new X );
+        BOOST_TEST( X::instances == 1 );
+
+        boost::shared_ptr<X const> p2( boost::move( p ) );
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( p.get() == 0 );
+
+        boost::shared_ptr<X const> p3 = p2->shared_from_this();
+        BOOST_TEST( p2 == p3 );
+        BOOST_TEST( !(p2 < p3) && !(p3 < p2) );
+
+        p2.reset();
+        p3.reset();
+        BOOST_TEST( X::instances == 0 );
+
+        p2 = boost::movelib::unique_ptr<X>( new X );
+        BOOST_TEST( X::instances == 1 );
+
+        p2 = boost::movelib::unique_ptr<X>( new X );
+        BOOST_TEST( X::instances == 1 );
+
+        p3 = p2->shared_from_this();
+        BOOST_TEST( p2 == p3 );
+        BOOST_TEST( !(p2 < p3) && !(p3 < p2) );
+
+        p2.reset();
+        p3.reset();
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        BOOST_TEST( X::instances == 0 );
+
+        boost::movelib::unique_ptr<X> p( new X );
+        BOOST_TEST( X::instances == 1 );
+
+        boost::shared_ptr<void> p2( boost::move( p ) );
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( p.get() == 0 );
+
+        p2.reset();
+        BOOST_TEST( X::instances == 0 );
+
+        p2 = boost::movelib::unique_ptr<X>( new X );
+        BOOST_TEST( X::instances == 1 );
+
+        p2 = boost::movelib::unique_ptr<X>( new X );
+        BOOST_TEST( X::instances == 1 );
+
+        p2.reset();
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        BOOST_TEST( Y::instances == 0 );
+
+        boost::movelib::unique_ptr<Y, YD> p( new Y, YD() );
+        BOOST_TEST( Y::instances == 1 );
+
+        boost::shared_ptr<Y> p2( boost::move( p ) );
+        BOOST_TEST( Y::instances == 1 );
+        BOOST_TEST( p.get() == 0 );
+
+        p2.reset();
+        BOOST_TEST( Y::instances == 0 );
+
+        p2 = boost::movelib::unique_ptr<Y, YD>( new Y, YD() );
+        BOOST_TEST( Y::instances == 1 );
+
+        p2 = boost::movelib::unique_ptr<Y, YD>( new Y, YD() );
+        BOOST_TEST( Y::instances == 1 );
+
+        p2.reset();
+        BOOST_TEST( Y::instances == 0 );
+    }
+
+    {
+        BOOST_TEST( Y::instances == 0 );
+
+        YD yd;
+
+        boost::movelib::unique_ptr<Y, YD&> p( new Y, yd );
+        BOOST_TEST( Y::instances == 1 );
+
+        boost::shared_ptr<Y> p2( boost::move( p ) );
+        BOOST_TEST( Y::instances == 1 );
+        BOOST_TEST( p.get() == 0 );
+
+        p2.reset();
+        BOOST_TEST( Y::instances == 0 );
+
+        p2 = boost::movelib::unique_ptr<Y, YD&>( new Y, yd );
+        BOOST_TEST( Y::instances == 1 );
+
+        p2 = boost::movelib::unique_ptr<Y, YD&>( new Y, yd );
+        BOOST_TEST( Y::instances == 1 );
+
+        p2.reset();
+        BOOST_TEST( Y::instances == 0 );
+    }
+
+    {
+        BOOST_TEST( Y::instances == 0 );
+
+        YD yd;
+
+        boost::movelib::unique_ptr<Y, YD const&> p( new Y, yd );
+        BOOST_TEST( Y::instances == 1 );
+
+        boost::shared_ptr<Y> p2( boost::move( p ) );
+        BOOST_TEST( Y::instances == 1 );
+        BOOST_TEST( p.get() == 0 );
+
+        p2.reset();
+        BOOST_TEST( Y::instances == 0 );
+
+        p2 = boost::movelib::unique_ptr<Y, YD const&>( new Y, yd );
+        BOOST_TEST( Y::instances == 1 );
+
+        p2 = boost::movelib::unique_ptr<Y, YD const&>( new Y, yd );
+        BOOST_TEST( Y::instances == 1 );
+
+        p2.reset();
+        BOOST_TEST( Y::instances == 0 );
+    }
+
+    return boost::report_errors();
+}
--- a/test/sp_explicit_inst_test.cpp
+++ b/test/sp_explicit_inst_test.cpp
@@ -0,0 +1,23 @@
+//
+// Explicit instantiations are reported to exist in user code
+//
+// Copyright (c) 2014 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>
+
+template class boost::shared_ptr< int >;
+
+struct X
+{
+};
+
+template class boost::shared_ptr< X >;
+
+int main()
+{
+}
--- a/test/sp_hash_test2.cpp
+++ b/test/sp_hash_test2.cpp
@@ -0,0 +1,34 @@
+//
+// sp_hash_test2.cpp
+//
+// Copyright 2011, 2015 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[1] ), p4( p3 ), p5( new int[1] );
+
+    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();
+}
--- a/test/sp_hash_test3.cpp
+++ b/test/sp_hash_test3.cpp
@@ -0,0 +1,34 @@
+//
+// sp_hash_test3.cpp
+//
+// Copyright 2011, 2015 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[1]> > hasher;
+
+    boost::shared_ptr< int[1] > p1, p2( p1 ), p3( new int[1] ), p4( p3 ), p5( new int[1] );
+
+    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();
+}
--- a/test/weak_from_raw_test.cpp
+++ b/test/weak_from_raw_test.cpp
@@ -12,7 +12,6 @@


 #include <boost/smart_ptr/enable_shared_from_raw.hpp>
-
 #include <boost/detail/lightweight_test.hpp>


@@ -23,7 +22,7 @@ void basic_weak_from_raw_test()
 {
    X *p(new X);
    boost::weak_ptr<X> weak = boost::weak_from_raw(p);
-    BOOST_TEST(weak.expired());
+    BOOST_TEST(!weak.expired());
    boost::shared_ptr<X> shared(p);
    weak = boost::weak_from_raw(p);
    BOOST_TEST(weak.expired() == false);
--- a/test/weak_from_raw_test3.cpp
+++ b/test/weak_from_raw_test3.cpp
@@ -0,0 +1,46 @@
+//
+//  weak_from_raw_test3.cpp
+//
+//  Test that weak_from_raw and shared_from_raw
+//  return consistent values from a constructor
+//
+//  Copyright (c) 2015 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/smart_ptr/enable_shared_from_raw.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+class X: public boost::enable_shared_from_raw
+{
+public:
+
+    X()
+    {
+        boost::weak_ptr<X> p1 = boost::weak_from_raw( this );
+        BOOST_TEST( !p1.expired() );
+
+        boost::weak_ptr<X> p2 = boost::weak_from_raw( this );
+        BOOST_TEST( !p2.expired() );
+        BOOST_TEST( !( p1 < p2 ) && !( p2 < p1 ) );
+
+        boost::weak_ptr<X> p3 = boost::shared_from_raw( this );
+        BOOST_TEST( !( p1 < p3 ) && !( p3 < p1 ) );
+
+        boost::weak_ptr<X> p4 = boost::weak_from_raw( this );
+        BOOST_TEST( !p4.expired() );
+        BOOST_TEST( !( p3 < p4 ) && !( p4 < p3 ) );
+        BOOST_TEST( !( p1 < p4 ) && !( p4 < p1 ) );
+    }
+};
+
+int main()
+{
+    boost::shared_ptr< X > px( new X );
+    return boost::report_errors();
+}
--- a/test/weak_from_raw_test4.cpp
+++ b/test/weak_from_raw_test4.cpp
@@ -0,0 +1,67 @@
+//
+//  weak_from_raw_test4.cpp
+//
+//  As weak_from_raw_test2.cpp, but uses weak_from_raw
+//  in the constructor
+//
+//  Copyright (c) 2014, 2015 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/smart_ptr/enable_shared_from_raw.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+class X;
+
+static boost::weak_ptr< X > r_;
+
+void register_( boost::weak_ptr< X > const & r )
+{
+    r_ = r;
+}
+
+void check_( boost::weak_ptr< X > const & r )
+{
+    BOOST_TEST( !( r < r_ ) && !( r_ < r ) );
+}
+
+void unregister_( boost::weak_ptr< X > const & r )
+{
+    BOOST_TEST( !( r < r_ ) && !( r_ < r ) );
+    r_.reset();
+}
+
+class X: public boost::enable_shared_from_raw
+{
+public:
+
+    X()
+    {
+        register_( boost::weak_from_raw( this ) );
+    }
+
+    ~X()
+    {
+        unregister_( boost::weak_from_raw( this ) );
+    }
+
+    void check()
+    {
+        check_( boost::weak_from_raw( this ) );
+    }
+};
+
+int main()
+{
+    {
+        boost::shared_ptr< X > px( new X );
+        px->check();
+    }
+
+    return boost::report_errors();
+}
--- a/test/weak_from_raw_test5.cpp
+++ b/test/weak_from_raw_test5.cpp
@@ -0,0 +1,45 @@
+//
+//  weak_from_raw_test5.cpp
+//
+//  Tests whether pointers returned from weak_from_raw
+//  expire properly
+//
+//  Copyright 2015 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/smart_ptr/enable_shared_from_raw.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+class X: public boost::enable_shared_from_raw
+{
+public:
+
+    explicit X( boost::weak_ptr< X > & r )
+    {
+        r = boost::weak_from_raw( this );
+    }
+};
+
+int main()
+{
+    boost::weak_ptr<X> p1, p2;
+
+    {
+        boost::shared_ptr< X > px( new X( p1 ) );
+        p2 = boost::weak_from_raw( px.get() );
+
+        BOOST_TEST( !p1.expired() );
+        BOOST_TEST( !p2.expired() );
+    }
+
+    BOOST_TEST( p1.expired() );
+    BOOST_TEST( p2.expired() );
+
+    return boost::report_errors();
+}
--- a/test/weak_from_this_test.cpp
+++ b/test/weak_from_this_test.cpp
@@ -0,0 +1,52 @@
+#include <boost/config.hpp>
+
+//
+//  weak_from_this_test.cpp
+//
+//  Copyright (c) 2002, 2003, 2015 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/enable_shared_from_this.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+class V: public boost::enable_shared_from_this<V>
+{
+};
+
+void test()
+{
+    boost::shared_ptr<V> p( new V );
+
+    boost::weak_ptr<V> q = p;
+    BOOST_TEST( !q.expired() );
+
+    boost::weak_ptr<V> q2 = p->weak_from_this();
+    BOOST_TEST( !q2.expired() );
+    BOOST_TEST( !(q < q2) && !(q2 < q) );
+
+    V v2( *p );
+
+    boost::weak_ptr<V> q3 = v2.weak_from_this();
+    BOOST_TEST( q3.expired() );
+
+    *p = V();
+
+    boost::weak_ptr<V> q4 = p->shared_from_this();
+    BOOST_TEST( !q4.expired() );
+    BOOST_TEST( !(q < q4) && !(q4 < q) );
+    BOOST_TEST( !(q2 < q4) && !(q4 < q2) );
+}
+
+int main()
+{
+    test();
+    return boost::report_errors();
+}
--- a/test/weak_from_this_test2.cpp
+++ b/test/weak_from_this_test2.cpp
@@ -0,0 +1,60 @@
+//
+//  weak_from_this_test2.cpp
+//
+//  Tests weak_from_this in a destructor
+//
+//  Copyright (c) 2014, 2015 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/smart_ptr/enable_shared_from_this.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+class X: public boost::enable_shared_from_this< X >
+{
+private:
+
+    boost::weak_ptr<X> px_;
+
+public:
+
+    X()
+    {
+        boost::weak_ptr<X> p1 = weak_from_this();
+        BOOST_TEST( p1._empty() );
+        BOOST_TEST( p1.expired() );
+    }
+
+    void check()
+    {
+        boost::weak_ptr<X> p2 = weak_from_this();
+        BOOST_TEST( !p2.expired() );
+
+        BOOST_TEST( p2.lock().get() == this );
+
+        px_ = p2;
+    }
+
+    ~X()
+    {
+        boost::weak_ptr<X> p3 = weak_from_this();
+        BOOST_TEST( p3.expired() );
+
+        BOOST_TEST( !(px_ < p3) && !(p3 < px_) );
+    }
+};
+
+int main()
+{
+    {
+        boost::shared_ptr< X > px( new X );
+        px->check();
+    }
+
+    return boost::report_errors();
+}
Author	SHA1	Message	Date
Peter Dimov	f3279d24b4	Merge branch 'develop'	2016-05-21 22:45:34 +03:00
Peter Dimov	c87b6e8af8	Add .travis.yml	2016-05-21 22:07:23 +03:00
Peter Dimov	aaded4f85c	Merge branch 'develop'	2016-05-21 20:48:54 +03:00
Peter Dimov	eb1a002e34	Create README.md	2016-05-21 19:34:15 +03:00
Peter Dimov	3304a56101	Merge branch 'develop'	2016-05-21 18:55:46 +03:00
Peter Dimov	181f38682f	Add appveyor.yml.	2016-05-21 18:23:41 +03:00
Peter Dimov	5b1a8412c3	Merge branch 'develop'	2016-05-21 01:11:22 +03:00
Peter Dimov	e52905cf3c	Add intrusive_ptr converting move assignment.	2016-05-17 18:43:41 +03:00
Peter Dimov	b7f99ceba6	Update intrusive_ptr_move_test with converting move construction.	2016-05-17 18:36:50 +03:00
Peter Dimov	a7ade6f062	Remove unnecessary #ifdef	2016-05-17 18:34:18 +03:00
Peter Dimov	097d2e9bf9	Merge branch 'intrusive_ptr_move' of https://github.com/jtwang83/smart_ptr into develop	2016-05-17 18:29:29 +03:00
Peter Dimov	d44a78d671	Merge branch 'develop'	2016-05-17 18:10:45 +03:00
Peter Dimov	582eb63cb3	Merge pull request #18 from joachim-faulhaber/smart_ptr_patches_1_59_0 Warning fixes: Conversion and unused parameter warnings	2016-05-17 18:07:32 +03:00
Peter Dimov	181b449a57	Merge branch 'develop'	2016-05-17 18:01:36 +03:00
Peter Dimov	da8de3e95b	Merge pull request #19 from Lastique/patch-4 Make the default intrusive_ptr constructor constexpr	2016-05-17 17:59:10 +03:00
Peter Dimov	6c27833099	Merge branch 'develop'	2016-05-17 17:46:15 +03:00
Glen Fernandes	83e6e00456	Merge branch 'develop'	2016-04-13 08:01:21 -04:00
Peter Dimov	522f6c1869	Add more aliasing move test cases, add alias move reset	2016-04-13 14:31:43 +03:00
Peter Dimov	cd8de9d4a6	Merge branch 'move-alias' of https://github.com/uecasm/smart_ptr into develop	2016-04-13 13:29:50 +03:00
Glen Fernandes	e26542272d	Use remove_reference in make_unique implementation	2016-02-19 08:14:02 -05:00
Glen Fernandes	e13beef5df	Fix formatting in headers and tests	2016-02-19 08:13:54 -05:00
Glen Fernandes	8298952a12	Update unit tests for make_shared/allocate_shared for arrays Before pending refactor of make_shared and allocate_shared for arrays.	2016-02-19 08:13:41 -05:00
Glen Fernandes	821925c536	Refactor make_unique implementations Before the pending refactor of make_shared/allocate_shared for arrays.	2016-02-19 08:13:27 -05:00
Glen Fernandes	427124543b	Use remove_reference in make_unique implementation	2016-02-19 08:09:25 -05:00
Peter Dimov	46f00ea993	Fix hash support for shared_ptr<T[]>, <T[N]>	2016-02-08 20:47:52 +02:00
Peter Dimov	4473bf8ec2	Fix hash support for shared_ptr<T[]>, <T[N]>	2015-12-15 19:13:20 +02:00
Glen Fernandes	7a7ac4512e	Fix formatting in headers and tests	2015-11-11 01:26:15 -05:00
Glen Fernandes	38b6334e36	Update unit tests for make_shared/allocate_shared for arrays Before pending refactor of make_shared and allocate_shared for arrays.	2015-11-09 22:35:34 -05:00
Glen Fernandes	7af503d3bb	Refactor make_unique implementations Before the pending refactor of make_shared/allocate_shared for arrays.	2015-11-08 11:02:06 -05:00
Peter Dimov	4db7219c32	Merge branch 'develop'	2015-10-27 20:12:16 +02:00
Ion Gaztañaga	3f17244225	Removed the intrin.h-related part Removed the commented part as the comment clearly says that VC9 has problems when intrin.h is included.	2015-10-18 19:44:17 +02:00
Ion Gaztañaga	ca93749614	Support MSVC-7.1/ intrin.h available >= MSVC-8.0 -> MSVC 7.1 has no intrin.h and needs to use "#pragma intrinsic". -> intrin.h available since Visual 2005	2015-10-18 12:51:13 +02:00
Gavin Lambert	05d5a4e9a0	Added shared_ptr aliasing move constructor. Signed-off-by: Gavin Lambert <github@mirality.co.nz>	2015-10-12 18:19:22 +13:00
Andrey Semashev	970a179ac2	Make the default constructor constexpr	2015-10-05 18:24:52 +03:00
Peter Dimov	a06123eb87	Merge branch 'develop'	2015-09-28 15:51:01 +03:00
Joachim Faulhaber	fd543d3292	Warning fixes: Conversion and unused parameter warnings	2015-09-24 14:53:40 +02:00
Peter Dimov	df90496583	Disable deprecation warnings on g++/clang	2015-09-10 23:45:47 +03:00
Peter Dimov	20ead68473	Merge branch 'develop'	2015-08-18 21:09:05 +03:00
Peter Dimov	79cde147c9	Merge pull request #17 from jzmaddock/patch-1 Disable explicit operator bool on Oracle C++	2015-08-18 20:54:50 +03:00
jzmaddock	abbe975e8f	Disable explicit operator bool on Oracle C++ Although Oracle supports this syntax, advanced usage such as: if(my_shared_ptr && x) Fail. Attempts to wokaround by adding additional operator overloads have so far failed.	2015-08-18 18:14:50 +01:00
Peter Dimov	8ba0730686	Merge pull request #16 from eldiener/sleep_fix_2 Change to Sleep declaration for clang on Windows to match Windows imp…	2015-07-23 01:52:03 +03:00
Edward Diener	686efe100b	Updated Sleep declaration only includes _mingw.h when needed.	2015-07-22 18:23:43 -04:00
Edward Diener	acb880d8c2	Change to Sleep declaration for clang on Windows to match Windows implementation being used	2015-07-22 06:51:49 -04:00
Edward Diener	1712b87cb6	Added __declspec(dllimport) for Sleep using clang on Windows.	2015-07-21 15:41:35 -04:00
Peter Dimov	f8943703f8	Merge branch 'develop'	2015-06-06 01:40:42 +03:00
Peter Dimov	a42dda0af4	Apply fix for errata 754327 for ARM Cortex-A9 suggested in ticket #11362	2015-06-06 01:40:01 +03:00
Peter Dimov	9b9b6d3ca6	Merge branch 'develop'	2015-05-12 20:13:50 +03:00
Peter Dimov	d875a68ceb	Add constructor/assignment taking boost::movelib::unique_ptr	2015-05-04 01:06:42 +03:00
Peter Dimov	8cb2c56556	Merge branch 'develop'	2015-03-20 15:04:59 +02:00
Peter Dimov	290fe82a43	Merge pull request #14 from Bjoe/changes Fix bug ticket 11131	2015-03-20 03:02:09 +02:00
Jörg Böhme	94824c807f	Add missing std:: namespace	2015-03-20 00:23:58 +01:00
Jonathan Wang	334654de06	intrusive_ptr: add converting ctor for intrusive_ptr<U> with move semantics. Analagous to template <class U> intrusive_ptr(intrusive_ptr<U> const&)	2015-03-15 20:17:55 -04:00
Peter Dimov	0ab0e6eecc	Merge branch 'develop'	2015-03-02 16:11:06 +02:00
Peter Dimov	effc9f73d6	Merge pull request #12 from Theodor/size_t_fix_11066 Add <cstddef> include. fixes #11066	2015-03-02 15:53:36 +02:00
Fedor Sergeev	99762e7dde	Add <cstddef> include. fixes #11066	2015-03-01 23:14:28 +04:00
Peter Dimov	add539142b	Merge branch 'develop'	2015-01-28 13:03:43 +02:00
Peter Dimov	e067fd2cfd	Fix comment.	2015-01-28 13:03:23 +02:00
Peter Dimov	212528860a	Merge branch 'develop'	2015-01-28 12:52:40 +02:00
Peter Dimov	711c36958a	Add an additional weak_from_raw test.	2015-01-28 12:52:10 +02:00
Peter Dimov	7104e7dc7e	Add weak_from_this.	2015-01-25 20:10:57 +02:00
Peter Dimov	254bda34b7	Merge branch 'develop'	2015-01-25 18:26:07 +02:00
Peter Dimov	3fd53ced83	Make shared_from_raw and weak_from_raw return consistent values in a constructor, regardless of order, as suggested by Gavin Lambert in #8 .	2015-01-22 20:47:01 +02:00
Peter Dimov	75de3dbcf1	Add clang-specific sp_counted_base.	2015-01-22 05:13:27 +02:00
Peter Dimov	7faec4265b	Fix conflicts with the I macro in <complex.h>.	2015-01-21 19:55:42 +02:00
Peter Dimov	c81d0806e4	Merge branch 'develop'	2015-01-16 20:53:48 +02:00
Peter Dimov	a74329794c	Fix ambiguous 'detail' errors under msvc-8.0.	2015-01-16 20:53:27 +02:00
Peter Dimov	71756350d9	Merge branch 'develop'	2015-01-15 22:00:17 +02:00
Peter Dimov	f65c57d9d2	Fix explicit instantiation regression	2014-11-12 19:04:29 +02:00