Merge branch 'develop'

Add examples back to documentation

.travis.yml

@@ -0,0 +1,274 @@
+# 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
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=c++03
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++14
+
+install:
+  - cd ..
+  - git clone -b $TRAVIS_BRANCH https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - 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/static_assert
+  - git submodule init libs/throw_exception
+  - git submodule init libs/type_traits
+  - git submodule init tools/build
+  - git submodule update
+  - cp -r $TRAVIS_BUILD_DIR/* libs/smart_ptr
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
+  - ./b2 libs/smart_ptr/test toolset=$TOOLSET
+
+notifications:
+  email:
+    on_success: always

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)

appveyor.yml

@@ -0,0 +1,41 @@
+# 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:
+  - cd ..
+  - git clone -b %APPVEYOR_REPO_BRANCH% https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - 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/static_assert
+  - git submodule init libs/throw_exception
+  - git submodule init libs/type_traits
+  - git submodule init tools/build
+  - git submodule update
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\smart_ptr
+  - bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - b2 libs/smart_ptr/test toolset=msvc-9.0,msvc-10.0,msvc-11.0,msvc-14.0

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>

include/boost/make_unique.hpp

@@ -1,11 +1,10 @@
 /*
- * 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)
- */
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
 #ifndef BOOST_MAKE_UNIQUE_HPP_INCLUDED
 #define BOOST_MAKE_UNIQUE_HPP_INCLUDED
 

include/boost/pointer_cast.hpp

@@ -10,6 +10,8 @@
 #ifndef BOOST_POINTER_CAST_HPP
 #define BOOST_POINTER_CAST_HPP
 
+#include <boost/config.hpp>
+
 namespace boost { 
 
 //static_pointer_cast overload for raw pointers
@@ -42,4 +44,78 @@ inline T* reinterpret_pointer_cast(U *ptr)
 
 } // namespace boost
 
+#if !defined( BOOST_NO_CXX11_SMART_PTR )
+
+#include <boost/type_traits/has_virtual_destructor.hpp>
+#include <boost/static_assert.hpp>
+#include <memory>
+
+namespace boost {
+
+//static_pointer_cast overload for std::shared_ptr
+using std::static_pointer_cast;
+
+//dynamic_pointer_cast overload for std::shared_ptr
+using std::dynamic_pointer_cast;
+
+//const_pointer_cast overload for std::shared_ptr
+using std::const_pointer_cast;
+
+//reinterpret_pointer_cast overload for std::shared_ptr
+template<class T, class U> std::shared_ptr<T> reinterpret_pointer_cast(const std::shared_ptr<U> & r ) BOOST_NOEXCEPT
+{
+    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename std::shared_ptr<T>::element_type E;
+
+    E * p = reinterpret_cast< E* >( r.get() );
+    return std::shared_ptr<T>( r, p );
+}
+
+//static_pointer_cast overload for std::unique_ptr
+template<class T, class U> std::unique_ptr<T> static_pointer_cast( std::unique_ptr<U> && r ) BOOST_NOEXCEPT
+{
+    (void) static_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename std::unique_ptr<T>::element_type E;
+
+    return std::unique_ptr<T>( static_cast<E*>( r.release() ) );
+}
+
+//dynamic_pointer_cast overload for std::unique_ptr
+template<class T, class U> std::unique_ptr<T> dynamic_pointer_cast( std::unique_ptr<U> && r ) BOOST_NOEXCEPT
+{
+    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
+
+    BOOST_STATIC_ASSERT_MSG( boost::has_virtual_destructor<T>::value, "The target of dynamic_pointer_cast must have a virtual destructor." );
+
+    T * p = dynamic_cast<T*>( r.get() );
+    if( p ) r.release();
+    return std::unique_ptr<T>( p );
+}
+
+//const_pointer_cast overload for std::unique_ptr
+template<class T, class U> std::unique_ptr<T> const_pointer_cast( std::unique_ptr<U> && r ) BOOST_NOEXCEPT
+{
+    (void) const_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename std::unique_ptr<T>::element_type E;
+
+    return std::unique_ptr<T>( const_cast<E*>( r.release() ) );
+}
+
+//reinterpret_pointer_cast overload for std::unique_ptr
+template<class T, class U> std::unique_ptr<T> reinterpret_pointer_cast( std::unique_ptr<U> && r ) BOOST_NOEXCEPT
+{
+    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename std::unique_ptr<T>::element_type E;
+
+    return std::unique_ptr<T>( reinterpret_cast<E*>( r.release() ) );
+}
+
+} // namespace boost
+
+#endif // #if !defined( BOOST_NO_CXX11_SMART_PTR )
+
 #endif   //BOOST_POINTER_CAST_HPP

include/boost/smart_ptr/bad_weak_ptr.hpp

@@ -36,6 +36,11 @@ namespace boost
 # pragma option push -pc
 #endif
 
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
 class bad_weak_ptr: public std::exception
 {
 public:
@@ -46,6 +51,10 @@ public:
     }
 };
 
+#if defined(__clang__)
+# pragma clang diagnostic pop
+#endif
+
 #if defined(__BORLANDC__) && __BORLANDC__ <= 0x564
 # pragma option pop
 #endif

include/boost/smart_ptr/detail/array_allocator.hpp

@@ -1,318 +0,0 @@
-/*
- * 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)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_ALLOCATOR_HPP
-#define BOOST_SMART_PTR_DETAIL_ARRAY_ALLOCATOR_HPP
-
-#include <boost/align/align.hpp>
-#include <boost/smart_ptr/detail/array_traits.hpp>
-#include <boost/smart_ptr/detail/array_utility.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-
-namespace boost {
-    namespace detail {
-        struct ms_init_tag   { };
-        struct ms_noinit_tag { };
-
-        template<class T>
-        struct ms_allocator_state;
-
-        template<class T>
-        struct ms_allocator_state<T[]> {
-            typedef typename array_base<T>::type type;
-
-            ms_allocator_state(std::size_t size_,
-                type** result_)
-                : size(size_ * array_total<T>::size),
-                  result(result_) {
-            }
-
-            std::size_t size;
-
-            union {
-                type** result;
-                type* object;
-            };
-        };
-
-        template<class T, std::size_t N>
-        struct ms_allocator_state<T[N]> {
-            typedef typename array_base<T>::type type;
-
-            ms_allocator_state(type** result_)
-                : result(result_) {
-            }
-
-            enum {
-                size = array_total<T[N]>::size
-            };
-
-            union {
-                type** result;
-                type* object;
-            };
-        };
-
-        template<class A, class T, class R>
-        class as_allocator
-            : public A {
-            template<class A_, class T_, class R_>
-            friend class as_allocator;
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-            typedef std::allocator_traits<A> AT;
-            typedef typename AT::template rebind_alloc<char> CA;
-            typedef typename AT::template rebind_traits<char> CT;
-#else
-            typedef typename A::template rebind<char>::other CA;
-#endif
-
-        public:
-            typedef A allocator_type;
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-            typedef typename AT::value_type value_type;
-            typedef typename AT::pointer pointer;
-            typedef typename AT::const_pointer const_pointer;
-            typedef typename AT::void_pointer void_pointer;
-            typedef typename AT::const_void_pointer const_void_pointer;
-            typedef typename AT::size_type size_type;
-            typedef typename AT::difference_type difference_type;
-#else
-            typedef typename A::value_type value_type;
-            typedef typename A::pointer pointer;
-            typedef typename A::const_pointer const_pointer;
-            typedef typename A::size_type size_type;
-            typedef typename A::difference_type difference_type;
-            typedef typename A::reference reference;
-            typedef typename A::const_reference const_reference;
-            typedef void* void_pointer;
-            typedef const void* const_void_pointer;
-#endif
-
-            template<class U>
-            struct rebind {
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                typedef as_allocator<typename AT::
-                    template rebind_alloc<U>, T, R> other;
-#else
-                typedef as_allocator<typename A::
-                    template rebind<U>::other, T, R> other;
-#endif
-            };
-
-            typedef typename array_base<T>::type type;
-
-            as_allocator(const A& allocator_, type** result)
-                : A(allocator_),
-                  data(result) {
-            }
-
-            as_allocator(const A& allocator_, std::size_t size,
-                type** result)
-                : A(allocator_),
-                  data(size, result) {
-            }
-
-            template<class U>
-            as_allocator(const as_allocator<U, T, R>& other)
-                : A(other.allocator()),
-                  data(other.data) {
-            }
-
-            pointer allocate(size_type count, const_void_pointer = 0) {
-                enum {
-                    M = boost::alignment_of<type>::value
-                };
-                std::size_t n1 = count * sizeof(value_type);
-                std::size_t n2 = data.size * sizeof(type);
-                std::size_t n3 = n2 + M;
-                CA ca(allocator());
-                void* p1 = ca.allocate(n1 + n3);
-                void* p2 = static_cast<char*>(p1) + n1;
-                (void)boost::alignment::align(M, n2, p2, n3);
-                *data.result = static_cast<type*>(p2);
-                return static_cast<value_type*>(p1);
-            }
-
-            void deallocate(pointer memory, size_type count) {
-                enum {
-                    M = boost::alignment_of<type>::value
-                };
-                std::size_t n1 = count * sizeof(value_type);
-                std::size_t n2 = data.size * sizeof(type) + M;
-                char* p1 = reinterpret_cast<char*>(memory);
-                CA ca(allocator());
-                ca.deallocate(p1, n1 + n2);
-            }
-
-            const A& allocator() const {
-                return static_cast<const A&>(*this);
-            }
-
-            A& allocator() {
-                return static_cast<A&>(*this);
-            }
-
-            void set(type* memory) {
-                data.object = memory;
-            }
-
-            void operator()() {
-                if (data.object) {
-                    R tag;
-                    release(tag);
-                }
-            }
-
-        private:
-            void release(ms_init_tag) {
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                as_destroy(allocator(), data.object, data.size);
-#else
-                ms_destroy(data.object, data.size);
-#endif
-            }
-
-            void release(ms_noinit_tag) {
-                ms_destroy(data.object, data.size);
-            }
-
-            ms_allocator_state<T> data;
-        };
-
-        template<class A1, class A2, class T, class R>
-        bool operator==(const as_allocator<A1, T, R>& a1,
-            const as_allocator<A2, T, R>& a2) {
-            return a1.allocator() == a2.allocator();
-        }
-
-        template<class A1, class A2, class T, class R>
-        bool operator!=(const as_allocator<A1, T, R>& a1,
-            const as_allocator<A2, T, R>& a2) {
-            return a1.allocator() != a2.allocator();
-        }
-
-        template<class T, class Y = char>
-        class ms_allocator;
-
-        template<class T, class Y>
-        class ms_allocator {
-            template<class T_, class Y_>
-            friend class ms_allocator;
-
-        public:
-            typedef typename array_base<T>::type type;
-
-            typedef Y value_type;
-            typedef Y* pointer;
-            typedef const Y* const_pointer;
-            typedef std::size_t size_type;
-            typedef ptrdiff_t difference_type;
-            typedef Y& reference;
-            typedef const Y& const_reference;
-
-            template<class U>
-            struct rebind {
-                typedef ms_allocator<T, U> other;
-            };
-
-            ms_allocator(type** result)
-                : data(result) {
-            }
-
-            ms_allocator(std::size_t size, type** result)
-                : data(size, result) {
-            }
-
-            template<class U>
-            ms_allocator(const ms_allocator<T, U>& other)
-                : data(other.data) {
-            }
-
-            pointer allocate(size_type count, const void* = 0) {
-                enum {
-                    M = boost::alignment_of<type>::value
-                };
-                std::size_t n1 = count * sizeof(Y);
-                std::size_t n2 = data.size * sizeof(type);
-                std::size_t n3 = n2 + M;
-                void* p1 = ::operator new(n1 + n3);
-                void* p2 = static_cast<char*>(p1) + n1;
-                (void)boost::alignment::align(M, n2, p2, n3);
-                *data.result = static_cast<type*>(p2);
-                return static_cast<Y*>(p1);
-            }
-
-            void deallocate(pointer memory, size_type) {
-                void* p1 = memory;
-                ::operator delete(p1);
-            }
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-            pointer address(reference value) const {
-                return &value;
-            }
-
-            const_pointer address(const_reference value) const {
-                return &value;
-            }
-
-            size_type max_size() const {
-                enum {
-                    N = static_cast<std::size_t>(-1) / sizeof(Y)
-                };
-                return N;
-            }
-
-            void construct(pointer memory, const_reference value) {
-                void* p1 = memory;
-                ::new(p1) Y(value);
-            }
-
-            void destroy(pointer memory) {
-                (void)memory;
-                memory->~Y();
-            }
-#endif
-
-            void set(type* memory) {
-                data.object = memory;
-            }
-
-            void operator()() {
-                if (data.object) {
-                    ms_destroy(data.object, data.size);
-                }
-            }
-
-        private:
-            ms_allocator_state<T> data;
-        };
-
-        template<class T, class Y1, class Y2>
-        bool operator==(const ms_allocator<T, Y1>&,
-            const ms_allocator<T, Y2>&) {
-            return true;
-        }
-
-        template<class T, class Y1, class Y2>
-        bool operator!=(const ms_allocator<T, Y1>&,
-            const ms_allocator<T, Y2>&) {
-            return false;
-        }
-
-        class ms_in_allocator_tag {
-        public:
-            void operator()(const void*) {
-            }
-        };
-    }
-}
-
-#endif

include/boost/smart_ptr/detail/array_count_impl.hpp

@@ -1,67 +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_ARRAY_COUNT_IMPL_HPP
-#define BOOST_SMART_PTR_DETAIL_ARRAY_COUNT_IMPL_HPP
-
-#include <boost/smart_ptr/detail/array_allocator.hpp>
-#include <boost/smart_ptr/detail/sp_counted_impl.hpp>
-
-namespace boost {
-    namespace detail {
-        template<class P, class A>
-        class sp_counted_impl_pda<P, ms_in_allocator_tag, A>
-            : public sp_counted_base {
-            typedef ms_in_allocator_tag D;
-            typedef sp_counted_impl_pda<P, D, A> Y;
-        public:
-            sp_counted_impl_pda(P, D, const A& allocator_)
-                : allocator(allocator_) {
-            }
-
-            virtual void dispose() {
-                allocator();
-            }
-
-            virtual void destroy() {
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                typedef typename std::allocator_traits<A>::
-                    template rebind_alloc<Y> YA;
-                typedef typename std::allocator_traits<A>::
-                    template rebind_traits<Y> YT;
-#else
-                typedef typename A::template rebind<Y>::other YA;
-#endif
-                YA a1(allocator);
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                YT::destroy(a1, this);
-                YT::deallocate(a1, this, 1);
-#else
-                this->~Y();
-                a1.deallocate(this, 1);
-#endif                
-            }
-
-            virtual void* get_deleter(const sp_typeinfo&) {
-                return &reinterpret_cast<char&>(allocator);
-            }
-
-            virtual void* get_untyped_deleter() {
-                return &reinterpret_cast<char&>(allocator);
-            }
-
-        private:
-            sp_counted_impl_pda(const sp_counted_impl_pda&);
-            sp_counted_impl_pda& operator=(const sp_counted_impl_pda&);
-
-            A allocator;
-        };
-    }
-}
-
-#endif

include/boost/smart_ptr/detail/array_traits.hpp

@@ -1,60 +0,0 @@
-/*
- * 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)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_TRAITS_HPP
-#define BOOST_SMART_PTR_DETAIL_ARRAY_TRAITS_HPP
-
-#include <boost/type_traits/remove_cv.hpp>
-
-namespace boost {
-    namespace detail {
-        template<class T>
-        struct array_base {
-            typedef typename boost::remove_cv<T>::type type;
-        };
-
-        template<class T>
-        struct array_base<T[]> {
-            typedef typename array_base<T>::type type;
-        };
-
-        template<class T, std::size_t N>
-        struct array_base<T[N]> {
-            typedef typename array_base<T>::type type;
-        };
-
-        template<class T>
-        struct array_total {
-            enum {
-                size = 1
-            };
-        };
-
-        template<class T, std::size_t N>
-        struct array_total<T[N]> {
-            enum {
-                size = N * array_total<T>::size
-            };
-        };
-
-        template<class T>
-        struct array_inner;
-
-        template<class T>
-        struct array_inner<T[]> {
-            typedef T type;
-        };
-
-        template<class T, std::size_t N>
-        struct array_inner<T[N]> {
-            typedef T type;
-        };
-    }
-}
-
-#endif

include/boost/smart_ptr/detail/array_utility.hpp

@@ -1,214 +0,0 @@
-/*
- * 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)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_UTILITY_HPP
-#define BOOST_SMART_PTR_DETAIL_ARRAY_UTILITY_HPP
-
-#include <boost/config.hpp>
-#include <boost/type_traits/has_trivial_constructor.hpp>
-#include <boost/type_traits/has_trivial_destructor.hpp>
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-#include <memory>
-#endif
-
-namespace boost {
-    namespace detail {
-        typedef boost::true_type  ms_is_trivial;
-        typedef boost::false_type ms_no_trivial;
-
-        template<class T>
-        inline void ms_destroy(T*, std::size_t, ms_is_trivial) {
-        }
-
-        template<class T>
-        inline void ms_destroy(T* memory, std::size_t size, ms_no_trivial) {
-            for (std::size_t i = size; i > 0;) {
-                memory[--i].~T();
-            }
-        }
-
-        template<class T>
-        inline void ms_destroy(T* memory, std::size_t size) {
-            boost::has_trivial_destructor<T> trivial;
-            ms_destroy(memory, size, trivial);
-        }
-
-        template<class T>
-        inline void ms_init(T* memory, std::size_t size, ms_is_trivial) {
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T();
-            }
-        }
-
-        template<class T>
-        inline void ms_init(T* memory, std::size_t size, ms_no_trivial) {
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    void* p1 = memory + i;
-                    ::new(p1) T();
-                }
-            } catch (...) {
-                ms_destroy(memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T();
-            }
-#endif
-        }
-
-        template<class T>
-        inline void ms_init(T* memory, std::size_t size) {
-            boost::has_trivial_default_constructor<T> trivial;
-            ms_init(memory, size, trivial);
-        }
-
-        template<class T, std::size_t N>
-        inline void ms_init(T* memory, std::size_t size, const T* list) {
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    void* p1 = memory + i;
-                    ::new(p1) T(list[i % N]);
-                }
-            } catch (...) {
-                ms_destroy(memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T(list[i % N]);
-            }
-#endif
-        }
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-        template<class T, class A>
-        inline void as_destroy(const A& allocator, T* memory,
-            std::size_t size) {
-            typedef typename std::allocator_traits<A>::
-                template rebind_alloc<T> TA;
-            typedef typename std::allocator_traits<A>::
-                template rebind_traits<T> TT;
-            TA a2(allocator);
-            for (std::size_t i = size; i > 0;) {
-                TT::destroy(a2, &memory[--i]);
-            }
-        }
-
-        template<class T, class A>
-        inline void as_init(const A& allocator, T* memory, std::size_t size,
-            ms_is_trivial) {
-            typedef typename std::allocator_traits<A>::
-                template rebind_alloc<T> TA;
-            typedef typename std::allocator_traits<A>::
-                template rebind_traits<T> TT;
-            TA a2(allocator);
-            for (std::size_t i = 0; i < size; i++) {
-                TT::construct(a2, memory + i);
-            }
-        }
-
-        template<class T, class A>
-        inline void as_init(const A& allocator, T* memory, std::size_t size,
-            ms_no_trivial) {
-            typedef typename std::allocator_traits<A>::
-                template rebind_alloc<T> TA;
-            typedef typename std::allocator_traits<A>::
-                template rebind_traits<T> TT;
-            TA a2(allocator);
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    TT::construct(a2, memory + i);
-                }
-            } catch (...) {
-                as_destroy(a2, memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                TT::construct(a2, memory + i);
-            }
-#endif
-        }
-
-        template<class T, class A>
-        inline void as_init(const A& allocator, T* memory, std::size_t size) {
-            boost::has_trivial_default_constructor<T> trivial;
-            as_init(allocator, memory, size, trivial);
-        }
-
-        template<class T, class A, std::size_t N>
-        inline void as_init(const A& allocator, T* memory, std::size_t size,
-            const T* list) {
-            typedef typename std::allocator_traits<A>::
-                template rebind_alloc<T> TA;
-            typedef typename std::allocator_traits<A>::
-                template rebind_traits<T> TT;
-            TA a2(allocator);
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    TT::construct(a2, memory + i, list[i % N]);
-                }
-            } catch (...) {
-                as_destroy(a2, memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                TT::construct(a2, memory + i, list[i % N]);
-            }
-#endif
-        }
-#endif
-
-        template<class T>
-        inline void ms_noinit(T*, std::size_t, ms_is_trivial) {
-        }
-
-        template<class T>
-        inline void ms_noinit(T* memory, std::size_t size, ms_no_trivial) {
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    void* p1 = memory + i;
-                    ::new(p1) T;
-                }
-            } catch (...) {
-                ms_destroy(memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T;
-            }
-#endif
-        }
-
-        template<class T>
-        inline void ms_noinit(T* memory, std::size_t size) {
-            boost::has_trivial_default_constructor<T> trivial;
-            ms_noinit(memory, size, trivial);
-        }
-    }
-}
-
-#endif

include/boost/smart_ptr/detail/atomic_count.hpp

@@ -73,6 +73,9 @@
 #elif defined( BOOST_DISABLE_THREADS ) && !defined( BOOST_SP_ENABLE_THREADS ) && !defined( BOOST_DISABLE_WIN32 )
 # include <boost/smart_ptr/detail/atomic_count_nt.hpp>
 
+#elif !defined( BOOST_NO_CXX11_HDR_ATOMIC )
+# include <boost/smart_ptr/detail/atomic_count_std_atomic.hpp>
+
 #elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) ) && !defined( __PATHSCALE__ )
 # include <boost/smart_ptr/detail/atomic_count_gcc_x86.hpp>
 

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
     {

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
@@ -242,18 +249,8 @@ public:
 
         try
         {
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-            impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
-            pi_ = pi;
-            std::allocator_traits<A2>::construct( a2, pi, p, d, a );
-
-#else
-
-            pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
+            pi_ = a2.allocate( 1 );
             ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
-
-#endif
         }
         catch(...)
         {
@@ -269,28 +266,11 @@ public:
 
 #else
 
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-        impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
-        pi_ = pi;
-
-#else
-
-        pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
-
-#endif
+        pi_ = a2.allocate( 1 );
 
         if( pi_ != 0 )
         {
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-            std::allocator_traits<A2>::construct( a2, pi, p, d, a );
-
-#else
-
             ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
-
-#endif
         }
         else
         {
@@ -326,18 +306,8 @@ public:
 
         try
         {
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-            impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
-            pi_ = pi;
-            std::allocator_traits<A2>::construct( a2, pi, p, a );
-
-#else
-
-            pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
+            pi_ = a2.allocate( 1 );
             ::new( static_cast< void* >( pi_ ) ) impl_type( p, a );
-
-#endif
         }
         catch(...)
         {
@@ -353,28 +323,11 @@ public:
 
 #else
 
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-        impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
-        pi_ = pi;
-
-#else
-
-        pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
-
-#endif
+        pi_ = a2.allocate( 1 );
 
         if( pi_ != 0 )
         {
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-            std::allocator_traits<A2>::construct( a2, pi, p, a );
-
-#else
-
             ::new( static_cast< void* >( pi_ ) ) impl_type( p, a );
-
-#endif
         }
         else
         {
@@ -438,6 +391,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 +644,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

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

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( __c2__ ) && 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,12 @@
 #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( BOOST_NO_CXX11_HDR_ATOMIC )
+# include <boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp>
+
 #elif defined( __SNC__ )
 # include <boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp>
 
@@ -56,7 +68,7 @@
 #elif defined( __GNUC__ ) && ( defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc ) ) && !defined(__PATHSCALE__) && !defined( _AIX )
 # include <boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp>
 
-#elif defined( __GNUC__ ) && ( defined( __mips__ ) || defined( _mips ) ) && !defined(__PATHSCALE__)
+#elif defined( __GNUC__ ) && ( defined( __mips__ ) || defined( _mips ) ) && !defined(__PATHSCALE__) && !defined( __mips16 )
 # include <boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp>
 
 #elif defined( BOOST_SP_HAS_SYNC )
@@ -79,4 +91,6 @@
 
 #endif
 
+#undef BOOST_SP_HAS_CLANG_C11_ATOMICS
+
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_counted_base_clang.hpp

@@ -0,0 +1,149 @@
+#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;
+        }
+    }    
+}
+
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+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 );
+    }
+};
+
+#if defined(__clang__)
+# pragma clang diagnostic pop
+#endif
+
+} // namespace detail
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED

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;
     }
@@ -236,20 +236,12 @@ public:
 
         A2 a2( a_ );
 
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-        std::allocator_traits<A2>::destroy( a2, this );
-
-#else
-
         this->~this_type();
 
-#endif
-
         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;
     }

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

include/boost/smart_ptr/detail/sp_forward.hpp

@@ -25,6 +25,17 @@ namespace detail
 
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
+#if defined( BOOST_GCC ) && __GNUC__ * 100 + __GNUC_MINOR__ <= 404
+
+// GCC 4.4 supports an outdated version of rvalue references and creates a copy of the forwarded object.
+// This results in warnings 'returning reference to temporary'. Therefore we use a special version similar to std::forward.
+template< class T > T&& sp_forward( T && t ) BOOST_NOEXCEPT
+{
+    return t;
+}
+
+#else
+
 template< class T > T&& sp_forward( T & t ) BOOST_NOEXCEPT
 {
     return static_cast< T&& >( t );
@@ -32,6 +43,8 @@ template< class T > T&& sp_forward( T & t ) BOOST_NOEXCEPT
 
 #endif
 
+#endif
+
 } // namespace detail
 
 } // namespace boost

include/boost/smart_ptr/detail/sp_has_sync.hpp

@@ -22,15 +22,15 @@
 
 #ifndef BOOST_SP_NO_SYNC
 
-#if defined( __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 )
+#if !defined( __c2__ ) && defined( __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 )
 
 # define BOOST_SP_HAS_SYNC
 
-#elif defined( __IBMCPP__ ) && ( __IBMCPP__ >= 1210 )
+#elif defined( __IBMCPP__ ) && ( __IBMCPP__ >= 1210 ) && !defined( __COMPILER_VER__ )
 
 # define BOOST_SP_HAS_SYNC
 
-#elif defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
+#elif !defined( __c2__ ) && defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
 
 #define BOOST_SP_HAS_SYNC
 

include/boost/smart_ptr/detail/sp_if_array.hpp

@@ -1,34 +0,0 @@
-/*
- * 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)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_SP_IF_ARRAY_HPP
-#define BOOST_SMART_PTR_DETAIL_SP_IF_ARRAY_HPP
-
-#include <boost/smart_ptr/shared_ptr.hpp>
-
-namespace boost {
-    namespace detail {
-        template<class T>
-        struct sp_if_array;
-
-        template<class T>
-        struct sp_if_array<T[]> {
-            typedef boost::shared_ptr<T[]> type;
-        };
-
-        template<class T>
-        struct sp_if_size_array;
-
-        template<class T, std::size_t N>
-        struct sp_if_size_array<T[N]> {
-            typedef boost::shared_ptr<T[N]> type;
-        };
-    }
-}
-
-#endif

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

include/boost/smart_ptr/detail/sp_noexcept.hpp

@@ -0,0 +1,30 @@
+#ifndef BOOST_SMART_PTR_DETAIL_SP_NOEXCEPT_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SP_NOEXCEPT_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  detail/sp_noexcept.hpp
+//
+//  Copyright 2016 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( BOOST_MSVC ) && BOOST_MSVC >= 1700 && BOOST_MSVC < 1900
+
+#define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT_OR_NOTHROW
+
+#else
+
+#define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT
+
+#endif
+
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_NOEXCEPT_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_nullptr_t.hpp

@@ -26,7 +26,7 @@ namespace boost
 namespace detail
 {
 
-#if defined( __clang__ ) && !defined( _LIBCPP_VERSION ) && !defined( BOOST_NO_CXX11_DECLTYPE )
+#if !defined( BOOST_NO_CXX11_DECLTYPE ) && ( ( defined( __clang__ ) && !defined( _LIBCPP_VERSION ) ) || defined( __INTEL_COMPILER ) )
 
     typedef decltype(nullptr) sp_nullptr_t;
 

include/boost/smart_ptr/detail/spinlock.hpp

@@ -43,6 +43,9 @@
 #elif defined( BOOST_SP_USE_PTHREADS )
 #  include <boost/smart_ptr/detail/spinlock_pt.hpp>
 
+#elif !defined( BOOST_NO_CXX11_HDR_ATOMIC )
+#  include <boost/smart_ptr/detail/spinlock_std_atomic.hpp>
+
 #elif defined(__GNUC__) && defined( __arm__ ) && !defined( __thumb__ )
 #  include <boost/smart_ptr/detail/spinlock_gcc_arm.hpp>
 

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:

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, 

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

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

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 )
@@ -98,7 +107,13 @@ inline void yield( unsigned k )
 
 #elif defined( BOOST_HAS_PTHREADS )
 
+#ifndef _AIX
 #include <sched.h>
+#else
+   // AIX's sched.h defines ::var which sometimes conflicts with Lambda's var
+       extern "C" int sched_yield(void);
+#endif
+
 #include <time.h>
 
 namespace boost

include/boost/smart_ptr/enable_shared_from_raw.hpp

@@ -4,7 +4,7 @@
 //
 //  enable_shared_from_raw.hpp
 //
-//  Copyright 2002, 2009 Peter Dimov
+//  Copyright 2002, 2009, 2014 Peter Dimov
 //  Copyright 2008-2009 Frank Mori Hess
 //
 //  Distributed under the Boost Software License, Version 1.0.
@@ -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
@@ -72,20 +81,30 @@ private:
     template< class X, class Y > friend inline void detail::sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe );
 #endif
 
-    shared_ptr<void> shared_from_this()
+    shared_ptr<void const volatile> shared_from_this() const
     {
-        init_weak_once();
-        return shared_ptr<void>( weak_this_ );
+        init_if_expired();
+        return shared_ptr<void const volatile>( weak_this_ );
     }
 
-    shared_ptr<const void> shared_from_this() const
+    shared_ptr<void const volatile> shared_from_this() const volatile
     {
-        init_weak_once();
-        return shared_ptr<const void>( weak_this_ );
+        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 );
 
@@ -107,9 +126,11 @@ private:
         }
     }
 
-    mutable weak_ptr<void> weak_this_;
+    mutable weak_ptr<void const volatile> weak_this_;
+
 private:
-    mutable shared_ptr<void> shared_this_;
+
+    mutable shared_ptr<void const volatile> shared_this_;
 };
 
 template<typename T>
@@ -124,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;
 }
 

include/boost/smart_ptr/enable_shared_from_this.hpp

@@ -15,6 +15,7 @@
 
 #include <boost/smart_ptr/weak_ptr.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
 
@@ -25,20 +26,20 @@ template<class T> class enable_shared_from_this
 {
 protected:
 
-    enable_shared_from_this() BOOST_NOEXCEPT
+    enable_shared_from_this() BOOST_SP_NOEXCEPT
     {
     }
 
-    enable_shared_from_this(enable_shared_from_this const &) BOOST_NOEXCEPT
+    enable_shared_from_this(enable_shared_from_this const &) BOOST_SP_NOEXCEPT
     {
     }
 
-    enable_shared_from_this & operator=(enable_shared_from_this const &) BOOST_NOEXCEPT
+    enable_shared_from_this & operator=(enable_shared_from_this const &) BOOST_SP_NOEXCEPT
     {
         return *this;
     }
 
-    ~enable_shared_from_this() BOOST_NOEXCEPT // ~weak_ptr<T> newer throws, so this call also must not throw
+    ~enable_shared_from_this() BOOST_SP_NOEXCEPT // ~weak_ptr<T> newer throws, so this call also must not throw
     {
     }
 
@@ -58,6 +59,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

include/boost/smart_ptr/intrusive_ptr.hpp

@@ -19,6 +19,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_noexcept.hpp>
 
 #include <boost/config/no_tr1/functional.hpp>           // for std::less
 
@@ -59,7 +60,7 @@ public:
 
     typedef T element_type;
 
-    intrusive_ptr() BOOST_NOEXCEPT : px( 0 )
+    BOOST_CONSTEXPR intrusive_ptr() BOOST_SP_NOEXCEPT : px( 0 )
     {
     }
 
@@ -111,17 +112,41 @@ public:
 
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
-    intrusive_ptr(intrusive_ptr && rhs) BOOST_NOEXCEPT : px( rhs.px )
+    intrusive_ptr(intrusive_ptr && rhs) BOOST_SP_NOEXCEPT : px( rhs.px )
     {
         rhs.px = 0;
     }
 
-    intrusive_ptr & operator=(intrusive_ptr && rhs) BOOST_NOEXCEPT
+    intrusive_ptr & operator=(intrusive_ptr && rhs) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< intrusive_ptr && >( rhs ) ).swap(*this);
         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)

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);
     }
 };
 

include/boost/smart_ptr/make_shared_array.hpp

@@ -1,158 +1,66 @@
 /*
- * 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)
- */
+Copyright 2012-2017 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
 #ifndef BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
 #define BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
 
-#include <boost/smart_ptr/detail/array_count_impl.hpp>
-#include <boost/smart_ptr/detail/sp_if_array.hpp>
+#include <boost/smart_ptr/allocate_shared_array.hpp>
 
 namespace boost {
-    template<class T>
-    inline typename boost::detail::sp_if_array<T>::type
-    make_shared(std::size_t size) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef boost::detail::ms_allocator<T> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        std::size_t n1 = size * boost::detail::array_total<T1>::size;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        D1 d1;
-        A1 a1(size, &p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-        boost::detail::ms_init(p2, n1);
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
 
-    template<class T>
-    inline typename boost::detail::sp_if_size_array<T>::type
-    make_shared() {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef boost::detail::ms_allocator<T> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        enum {
-            N = boost::detail::array_total<T>::size
-        };
-        T1* p1 = 0;
-        T2* p2 = 0;
-        D1 d1;
-        A1 a1(&p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-        boost::detail::ms_init(p2, N);
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-
-    template<class T>
-    inline typename boost::detail::sp_if_array<T>::type
-    make_shared(std::size_t size,
-        const typename boost::detail::array_inner<T>::type& value) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef const T2 T3;
-        typedef boost::detail::ms_allocator<T> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        enum {
-            M = boost::detail::array_total<T1>::size
-        };
-        std::size_t n1 = M * size;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        T3* p3 = reinterpret_cast<T3*>(&value);
-        D1 d1;
-        A1 a1(size, &p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-        boost::detail::ms_init<T2, M>(p2, n1, p3);
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-
-    template<class T>
-    inline typename boost::detail::sp_if_size_array<T>::type
-    make_shared(const typename boost::detail::array_inner<T>::type& value) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef const T2 T3;
-        typedef boost::detail::ms_allocator<T> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        enum {
-            M = boost::detail::array_total<T1>::size,
-            N = boost::detail::array_total<T>::size
-        };
-        T1* p1 = 0;
-        T2* p2 = 0;
-        T3* p3 = reinterpret_cast<T3*>(&value);
-        D1 d1;
-        A1 a1(&p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-        boost::detail::ms_init<T2, M>(p2, N, p3);
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-
-    template<class T>
-    inline typename boost::detail::sp_if_array<T>::type
-    make_shared_noinit(std::size_t size) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef boost::detail::ms_allocator<T> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        std::size_t n1 = size * boost::detail::array_total<T1>::size;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        D1 d1;
-        A1 a1(size, &p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-        boost::detail::ms_noinit(p2, n1);
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-
-    template<class T>
-    inline typename boost::detail::sp_if_size_array<T>::type
-    make_shared_noinit() {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef boost::detail::ms_allocator<T> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        enum {
-            N = boost::detail::array_total<T>::size
-        };
-        T1* p1 = 0;
-        T2* p2 = 0;
-        D1 d1;
-        A1 a1(&p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-        boost::detail::ms_noinit(p2, N);
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
+template<class T>
+inline typename detail::sp_if_size_array<T>::type
+make_shared()
+{
+    return boost::allocate_shared<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>());
 }
 
+template<class T>
+inline typename detail::sp_if_size_array<T>::type
+make_shared(const typename detail::sp_array_element<T>::type& value)
+{
+    return boost::allocate_shared<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>(), value);
+}
+
+template<class T>
+inline typename detail::sp_if_array<T>::type
+make_shared(std::size_t size)
+{
+    return boost::allocate_shared<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>(), size);
+}
+
+template<class T>
+inline typename detail::sp_if_array<T>::type
+make_shared(std::size_t size,
+    const typename detail::sp_array_element<T>::type& value)
+{
+    return boost::allocate_shared<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>(), size, value);
+}
+
+template<class T>
+inline typename detail::sp_if_size_array<T>::type
+make_shared_noinit()
+{
+    return allocate_shared_noinit<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>());
+}
+
+template<class T>
+inline typename detail::sp_if_array<T>::type
+make_shared_noinit(std::size_t size)
+{
+    return allocate_shared_noinit<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>(), size);
+}
+
+} /* boost */
+
 #endif

include/boost/smart_ptr/make_shared_object.hpp

@@ -13,6 +13,8 @@
 //  for documentation.
 
 #include <boost/config.hpp>
+#include <boost/move/core.hpp>
+#include <boost/move/utility_core.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
 #include <boost/smart_ptr/detail/sp_forward.hpp>
 #include <boost/type_traits/type_with_alignment.hpp>
@@ -338,466 +340,10 @@ template< class T, class A > typename boost::detail::sp_if_not_array< T >::type
     return boost::shared_ptr< T >( pt, pt2 );
 }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-// For example MSVC 10.0
-
-template< class T, class A1 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 ), 
-        boost::detail::sp_forward<A7>( a7 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 ), 
-        boost::detail::sp_forward<A7>( a7 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 ), 
-        boost::detail::sp_forward<A7>( a7 ), 
-        boost::detail::sp_forward<A8>( a8 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 ), 
-        boost::detail::sp_forward<A7>( a7 ), 
-        boost::detail::sp_forward<A8>( a8 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 ), 
-        boost::detail::sp_forward<A7>( a7 ), 
-        boost::detail::sp_forward<A8>( a8 ), 
-        boost::detail::sp_forward<A9>( a9 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 ), 
-        boost::detail::sp_forward<A7>( a7 ), 
-        boost::detail::sp_forward<A8>( a8 ), 
-        boost::detail::sp_forward<A9>( a9 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-#else // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
 // C++03 version
 
 template< class T, class A1 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1 )
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
@@ -805,7 +351,10 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1 )
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -815,7 +364,7 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1 )
 }
 
 template< class T, class A, class A1 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1 )
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
@@ -823,7 +372,10 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -833,7 +385,7 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 }
 
 template< class T, class A1, class A2 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2 )
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
@@ -841,7 +393,11 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -851,7 +407,7 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 }
 
 template< class T, class A, class A1, class A2 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2 )
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
@@ -859,7 +415,11 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -869,7 +429,7 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 }
 
 template< class T, class A1, class A2, class A3 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3 )
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
@@ -877,7 +437,12 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2, a3 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -887,7 +452,7 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 }
 
 template< class T, class A, class A1, class A2, class A3 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3 )
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
@@ -895,7 +460,12 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2, a3 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -905,7 +475,7 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 }
 
 template< class T, class A1, class A2, class A3, class A4 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
@@ -913,7 +483,13 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2, a3, a4 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -923,7 +499,7 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 }
 
 template< class T, class A, class A1, class A2, class A3, class A4 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
@@ -931,7 +507,13 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2, a3, a4 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -941,7 +523,7 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 }
 
 template< class T, class A1, class A2, class A3, class A4, class A5 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
@@ -949,7 +531,14 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2, a3, a4, a5 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -959,7 +548,7 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 }
 
 template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
@@ -967,7 +556,14 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2, a3, a4, a5 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -977,7 +573,7 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 }
 
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
@@ -985,7 +581,15 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -995,7 +599,7 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 }
 
 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
@@ -1003,7 +607,15 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -1013,7 +625,7 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 }
 
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
@@ -1021,7 +633,16 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 ),
+        boost::forward<A7>( a7 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -1031,7 +652,7 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 }
 
 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
@@ -1039,7 +660,16 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 ),
+        boost::forward<A7>( a7 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -1049,7 +679,7 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 }
 
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
@@ -1057,7 +687,17 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 ),
+        boost::forward<A7>( a7 ),
+        boost::forward<A8>( a8 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -1067,7 +707,7 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 }
 
 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
@@ -1075,7 +715,17 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 ),
+        boost::forward<A7>( a7 ),
+        boost::forward<A8>( a8 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -1085,7 +735,7 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 }
 
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8, BOOST_FWD_REF(A9) a9 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 
@@ -1093,7 +743,18 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 ),
+        boost::forward<A7>( a7 ),
+        boost::forward<A8>( a8 ),
+        boost::forward<A9>( a9 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -1103,7 +764,7 @@ typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A
 }
 
 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8, BOOST_FWD_REF(A9) a9 )
 {
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 
@@ -1111,7 +772,18 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
 
     void * pv = pd->address();
 
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 ),
+        boost::forward<A7>( a7 ),
+        boost::forward<A8>( a8 ),
+        boost::forward<A9>( a9 )
+        );
+
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -1120,8 +792,6 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a,
     return boost::shared_ptr< T >( pt, pt2 );
 }
 
-#endif // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
 #endif // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
 #undef BOOST_SP_MSD

include/boost/smart_ptr/make_unique.hpp

@@ -1,15 +1,110 @@
 /*
- * 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)
- */
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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 size)
+{
+    return std::unique_ptr<T>(new typename
+        detail::up_element<T>::type[size]());
+}
+
+template<class T>
+inline typename detail::up_if_array<T>::type
+make_unique_noinit(std::size_t size)
+{
+    return std::unique_ptr<T>(new typename
+        detail::up_element<T>::type[size]);
+}
+
+} /* boost */
 
 #endif

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

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

include/boost/smart_ptr/owner_less.hpp

@@ -5,6 +5,7 @@
 //  owner_less.hpp
 //
 //  Copyright (c) 2008 Frank Mori Hess
+//  Copyright (c) 2016 Peter Dimov
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -13,44 +14,20 @@
 //  See http://www.boost.org/libs/smart_ptr/smart_ptr.htm for documentation.
 //
 
-#include <functional>
-
 namespace boost
 {
-  template<typename T> class shared_ptr;
-  template<typename T> class weak_ptr;
 
-  namespace detail
-  {
-    template<typename T, typename U>
-      struct generic_owner_less : public std::binary_function<T, T, bool>
+template<class T = void> struct owner_less
+{
+    typedef bool result_type;
+    typedef T first_argument_type;
+    typedef T second_argument_type;
+
+    template<class U, class V> bool operator()( U const & u, V const & v ) const
     {
-      bool operator()(const T &lhs, const T &rhs) const
-      {
-        return lhs.owner_before(rhs);
-      }
-      bool operator()(const T &lhs, const U &rhs) const
-      {
-        return lhs.owner_before(rhs);
-      }
-      bool operator()(const U &lhs, const T &rhs) const
-      {
-        return lhs.owner_before(rhs);
-      }
-    };
-  } // namespace detail
-
-  template<typename T> struct owner_less;
-
-  template<typename T>
-    struct owner_less<shared_ptr<T> >:
-    public detail::generic_owner_less<shared_ptr<T>, weak_ptr<T> >
-  {};
-
-  template<typename T>
-    struct owner_less<weak_ptr<T> >:
-    public detail::generic_owner_less<weak_ptr<T>, shared_ptr<T> >
-  {};
+        return u.owner_before( v );
+    }
+};
 
 } // namespace boost
 

include/boost/smart_ptr/scoped_array.hpp

@@ -15,6 +15,7 @@
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 
 #include <boost/detail/workaround.hpp>
 
@@ -54,7 +55,7 @@ public:
 
     typedef T element_type;
 
-    explicit scoped_array( T * p = 0 ) BOOST_NOEXCEPT : px( p )
+    explicit scoped_array( T * p = 0 ) BOOST_SP_NOEXCEPT : px( p )
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_array_constructor_hook( px );

include/boost/smart_ptr/scoped_ptr.hpp

@@ -15,12 +15,19 @@
 #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/smart_ptr/detail/sp_noexcept.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
 {
 
@@ -56,7 +63,7 @@ public:
 
     typedef T element_type;
 
-    explicit scoped_ptr( T * p = 0 ): px( p ) // never throws
+    explicit scoped_ptr( T * p = 0 ) BOOST_SP_NOEXCEPT : px( p ) // never throws
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_scalar_constructor_hook( px );
@@ -154,4 +161,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

include/boost/smart_ptr/shared_array.hpp

@@ -24,6 +24,7 @@
 #include <boost/smart_ptr/shared_ptr.hpp>
 #include <boost/smart_ptr/detail/shared_count.hpp>
 #include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 #include <boost/detail/workaround.hpp>
 
 #include <cstddef>            // for std::ptrdiff_t
@@ -53,13 +54,13 @@ public:
 
     typedef T element_type;
 
-    shared_array() BOOST_NOEXCEPT : px( 0 ), pn()
+    shared_array() BOOST_SP_NOEXCEPT : px( 0 ), pn()
     {
     }
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-    shared_array( boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT : px( 0 ), pn()
+    shared_array( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT : px( 0 ), pn()
     {
     }
 
@@ -95,11 +96,11 @@ public:
 
 // ... except in C++0x, move disables the implicit copy
 
-    shared_array( shared_array const & r ) BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
+    shared_array( shared_array const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
     {
     }
 
-    shared_array( shared_array && r ) BOOST_NOEXCEPT : px( r.px ), pn()
+    shared_array( shared_array && r ) BOOST_SP_NOEXCEPT : px( r.px ), pn()
     {
         pn.swap( r.pn );
         r.px = 0;
@@ -133,7 +134,7 @@ public:
 
     // assignment
 
-    shared_array & operator=( shared_array const & r ) BOOST_NOEXCEPT
+    shared_array & operator=( shared_array const & r ) BOOST_SP_NOEXCEPT
     {
         this_type( r ).swap( *this );
         return *this;
@@ -152,7 +153,7 @@ public:
 
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
-    shared_array & operator=( shared_array && r ) BOOST_NOEXCEPT
+    shared_array & operator=( shared_array && r ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< shared_array && >( r ) ).swap( *this );
         return *this;

include/boost/smart_ptr/shared_ptr.hpp

@@ -29,6 +29,8 @@
 #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>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 
 #if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
 #include <boost/smart_ptr/detail/spinlock_pool.hpp>
@@ -47,6 +49,11 @@
 #endif
 #endif
 
+#if defined( BOOST_SP_DISABLE_DEPRECATED )
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 namespace boost
 {
 
@@ -55,6 +62,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
 {
 
@@ -331,13 +345,13 @@ public:
 
     typedef typename boost::detail::sp_element< T >::type element_type;
 
-    shared_ptr() BOOST_NOEXCEPT : px( 0 ), pn() // never throws in 1.30+
+    shared_ptr() BOOST_SP_NOEXCEPT : px( 0 ), pn() // never throws in 1.30+
     {
     }
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-    shared_ptr( boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT : px( 0 ), pn() // never throws
+    shared_ptr( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT : px( 0 ), pn() // never throws
     {
     }
 
@@ -389,7 +403,7 @@ public:
 
 // ... except in C++0x, move disables the implicit copy
 
-    shared_ptr( shared_ptr const & r ) BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
+    shared_ptr( shared_ptr const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
     {
     }
 
@@ -495,9 +509,20 @@ 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
+    shared_ptr & operator=( shared_ptr const & r ) BOOST_SP_NOEXCEPT
     {
         this_type(r).swap(*this);
         return *this;
@@ -556,11 +581,32 @@ 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 )
 
-    shared_ptr( shared_ptr && r ) BOOST_NOEXCEPT : px( r.px ), pn()
+    shared_ptr( shared_ptr && r ) BOOST_SP_NOEXCEPT : px( r.px ), pn()
     {
         pn.swap( r.pn );
         r.px = 0;
@@ -584,7 +630,7 @@ public:
         r.px = 0;
     }
 
-    shared_ptr & operator=( shared_ptr && r ) BOOST_NOEXCEPT
+    shared_ptr & operator=( shared_ptr && r ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
         return *this;
@@ -597,6 +643,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 +688,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 +718,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
@@ -820,6 +883,50 @@ template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U>
     return shared_ptr<T>( r, p );
 }
 
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> && r ) BOOST_NOEXCEPT
+{
+    (void) static_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = static_cast< E* >( r.get() );
+    return shared_ptr<T>( std::move(r), p );
+}
+
+template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> && r ) BOOST_NOEXCEPT
+{
+    (void) const_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = const_cast< E* >( r.get() );
+    return shared_ptr<T>( std::move(r), p );
+}
+
+template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> && r ) BOOST_NOEXCEPT
+{
+    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = dynamic_cast< E* >( r.get() );
+    return p? shared_ptr<T>( std::move(r), p ): shared_ptr<T>();
+}
+
+template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> && r ) BOOST_NOEXCEPT
+{
+    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = reinterpret_cast< E* >( r.get() );
+    return shared_ptr<T>( std::move(r), p );
+}
+
+#endif // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
 // get_pointer() enables boost::mem_fn to recognize shared_ptr
 
 template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p) BOOST_NOEXCEPT
@@ -893,7 +1000,7 @@ class esft2_deleter_wrapper
 {
 private:
 
-    shared_ptr<void> deleter_;
+    shared_ptr<void const volatile> deleter_;
 
 public:
 
@@ -1020,9 +1127,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

include/boost/smart_ptr/weak_ptr.hpp

@@ -16,6 +16,7 @@
 #include <memory> // boost.TR1 include order fix
 #include <boost/smart_ptr/detail/shared_count.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 
 namespace boost
 {
@@ -31,7 +32,7 @@ public:
 
     typedef typename boost::detail::sp_element< T >::type element_type;
 
-    weak_ptr() BOOST_NOEXCEPT : px(0), pn() // never throws in 1.30+
+    weak_ptr() BOOST_SP_NOEXCEPT : px(0), pn() // never throws in 1.30+
     {
     }
 
@@ -41,11 +42,11 @@ public:
 
 // ... except in C++0x, move disables the implicit copy
 
-    weak_ptr( weak_ptr const & r ) BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
+    weak_ptr( weak_ptr const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
     {
     }
 
-    weak_ptr & operator=( weak_ptr const & r ) BOOST_NOEXCEPT
+    weak_ptr & operator=( weak_ptr const & r ) BOOST_SP_NOEXCEPT
     {
         px = r.px;
         pn = r.pn;
@@ -106,13 +107,13 @@ public:
 
     // for better efficiency in the T == Y case
     weak_ptr( weak_ptr && r )
-    BOOST_NOEXCEPT : px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
+    BOOST_SP_NOEXCEPT : px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
     {
         r.px = 0;
     }
 
     // for better efficiency in the T == Y case
-    weak_ptr & operator=( weak_ptr && r ) BOOST_NOEXCEPT
+    weak_ptr & operator=( weak_ptr && r ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< weak_ptr && >( r ) ).swap( *this );
         return *this;

make_shared_array.html

@@ -1,273 +1,393 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <title>make_shared and allocate_shared for arrays</title>
-    <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">make_shared and allocate_shared 
-      for arrays</h1>
-    <p><a href="#introduction">Introduction</a><br>
-      <a href="#synopsis">Synopsis</a><br>
-      <a href="#common">Common Requirements</a><br>
-      <a href="#functions">Free Functions</a><br>
-      <a href="#history">History</a><br>
-      <a href="#references">References</a></p>
-    <h2><a name="introduction">Introduction</a></h2>
-    <p>Originally the Boost function templates <code>make_shared</code> and 
-      <code>allocate_shared</code> were for efficient allocation of shared 
-      objects only. There was a need to have efficient allocation of 
-      shared arrays. One criticism of class template <code>shared_array</code> 
-      was always the lack of a <a href="make_shared.html">make_shared</a> 
-      utility which ensures only a single allocation.</p>
-    <p>The header files &lt;boost/smart_ptr/make_shared_array.hpp&gt; and 
-      &lt;boost/smart_ptr/allocate_shared_array.hpp&gt; provide function 
-      templates, overloads of <code>make_shared</code> and 
-      <code>allocate_shared</code> for array types, to address this need. 
-      <code>make_shared</code> uses the global operator <code>new</code> to 
-      allocate memory, whereas <code>allocate_shared</code> uses an 
-      user-supplied allocator, allowing finer control.</p>
-    <h2><a name="synopsis">Synopsis</a></h2>
-    <pre>namespace boost {
-    template&lt;class U&gt; // U is T[]
-    shared_ptr&lt;U&gt; <a href="#functions">make_shared</a>(size_t size);
-
-    template&lt;class U, class A&gt; // U is T[]
-    shared_ptr&lt;U&gt; <a href="#functions">allocate_shared</a>(const A&amp; allocator, size_t size);
-
-    template&lt;class U&gt; // U is T[N]
-    shared_ptr&lt;U&gt; <a href="#functions">make_shared</a>();
-
-    template&lt;class U, class A&gt; // U is T[N]
-    shared_ptr&lt;U&gt; <a href="#functions">allocate_shared</a>(const A&amp; allocator);
-
-    template&lt;class U&gt; // U is T[]
-    shared_ptr&lt;U&gt; <a href="#functions">make_shared</a>(size_t size, const T&amp; value);
-
-    template&lt;class U, class A&gt;  // U is T[]
-    shared_ptr&lt;U&gt; <a href="#functions">allocate_shared</a>(const A&amp; allocator, size_t size, const T&amp; value);
-
-    template&lt;class U&gt; // U is T[N]
-    shared_ptr&lt;U&gt; <a href="#functions">make_shared</a>(const T&amp; value);
-
-    template&lt;class U, class A&gt; // U is T[N]
-    shared_ptr&lt;U&gt; <a href="#functions">allocate_shared</a>(const A&amp; allocator, const T&amp; value);
-
-    template&lt;class U&gt; // U is T[]
-    shared_ptr&lt;U&gt; <a href="#functions">make_shared_noinit</a>(size_t size);
-
-    template&lt;class U, class A&gt; // U is T[]
-    shared_ptr&lt;U&gt; <a href="#functions">allocate_shared_noinit</a>(const A&amp; allocator, size_t size);
-
-    template&lt;class U&gt; // U is T[N]
-    shared_ptr&lt;U&gt; <a href="#functions">make_shared_noinit</a>();
-
-    template&lt;class U, class A&gt; // U is T[N]
-    shared_ptr&lt;U&gt; <a href="#functions">allocate_shared_noinit</a>(const A&amp; allocator);
-}</pre>
-    <h2><a name="common">Common Requirements</a></h2>
-    <pre>template&lt;class U&gt;
-    shared_ptr&lt;U&gt; make_shared(<em>args</em>);
-template&lt;class U, class A&gt;
-    shared_ptr&lt;U&gt; allocate_shared(const A&amp; allocator, <em>args</em>);
-template&lt;class U&gt;
-    shared_ptr&lt;U&gt; make_shared_noinit(<em>args</em>);
-template&lt;class U, class A&gt;
-    shared_ptr&lt;U&gt; allocate_shared_noinit(const A&amp; allocator, <em>args</em>);</pre>
-    <blockquote>
-      <p><b>Requires:</b> <code>U</code> is of the form <code>T[]</code> or 
-        <code>T[N]</code>. <code>A</code> shall be an <em>Allocator</em>, as 
-        described in section 17.6.3.5 [<strong>Allocator 
-        requirements</strong>] of the C++ Standard. The copy constructor and 
-        destructor of <code>A</code> shall not throw exceptions.</p>
-      <p><b>Effects:</b> Allocates memory for an object of type <code>U</code> 
-        (or <code>T[size]</code> when <code>U</code> is <code>T[]</code>, 
-        where <code>size</code> is determined from <code><em>args</em></code> 
-        as specified by the concrete overload). The object is initialized as 
-        specified by the concrete overload. The templates 
-        <code>allocate_shared</code> and <code>allocate_shared_noinit</code>
-        use a copy of <code>allocator</code> to allocate memory. If an 
-        exception is thrown, the functions have no effect.</p>
-      <p><b>Returns:</b> A <code>shared_ptr</code> instance that stores and 
-        owns the address of the newly constructed object.</p>
-      <p><b>Postconditions:</b> <code>r.get() != 0 &amp;&amp; 
-        r.use_count() == 1</code>, where <code>r</code> is the return 
-        value.</p>
-      <p><b>Throws:</b> <code>bad_alloc</code>, an exception thrown from 
-        <code>A::allocate</code>, or from the initialization of the 
-        object.</p>
-      <p><b>Remarks:</b></p>
-      <blockquote>
-        <p>This implementation performs no more than one memory 
-          allocation. This provides efficiency to equivalent to an intrusive 
-          smart pointer.</p>
-        <p>When an object of an array type <code>T</code> is specified to be 
-          initialized to a value of the same type <code>value</code>, this 
-          shall be interpreted to mean that each array element of the object 
-          is initialized to the corresponding element from 
-          <code>value</code>.</p>
-        <p>When an object of an array type is specified to be 
-          value-initialized, this shall be interpreted to mean that each 
-          array element of the object is value-initialized.</p>
-        <p>Array elements are initialized in ascending order of their 
-          addresses.</p>
-        <p>When a subobject of a non-array type <code>T</code> is specified to 
-          be initialized to a value <code>value</code>, 
-          <code>make_shared</code> shall perform this initialization via the 
-          expression <code>::new(ptr) T(value)</code>, where <code>ptr</code> 
-          has type <code>void*</code> and points to storage suitable to hold 
-          an object of type <code>T</code>.</p>
-        <p>When a subobject of non-array type <code>T</code> is specified to 
-          be initialized to a value <code>value</code>, 
-          <code>allocate_shared</code> shall perform this initialization via 
-          the expression <code>allocator_traits&lt;A2&gt;::construct(a2, ptr, 
-          value)</code>, where <code>ptr</code> points to storage suitable to 
-          hold an object of type <code>T</code> and <code>a2</code> of type A2 
-          is a rebound copy of the allocator <code>allocator</code> passed to
-          <code>allocate_shared</code> such that its <code>value_type</code> 
-          is <code>T</code>.</p>
-        <p>When a subobject of non-array type <code>T</code> is specified to 
-          be value-initialized, <code>make_shared</code> shall perform this 
-          initialization via the expression <code>::new(ptr) T()</code>, where 
-          <code>ptr</code> has type <code>void*</code> and points to storage 
-          suitable to hold an object of type <code>T</code>.</p>
-        <p>When a subobject of non-array type <code>T</code> is specified to 
-          be value-initialized, <code>allocate_shared</code> shall perform 
-          this initialization via the expression
-          <code>allocator_traits&lt;A2&gt;::construct(a2, ptr)</code>, where 
-          <code>ptr</code> points to storage suitable to hold an object 
-          of type <code>T</code> and <code>a2</code> of type A2 is a rebound 
-          copy of the allocator <code>allocator</code> passed to
-          <code>allocate_shared</code> such that its <code>value_type</code> 
-          is <code>T</code>.</p>
-        <p>When a subobject of non-array type <code>T</code> is specified to 
-          be default-initialized, <code>make_shared_noinit</code> and 
-          <code>allocate_shared_noinit</code> shall perform this 
-          initialization via the expression <code>::new(ptr) T</code>, where 
-          <code>ptr</code> has type <code>void*</code> and points to storage 
-          suitable to hold an object of type <code>T</code>.</p>
-        <p>When the lifetime of the object managed by the return value ends, 
-          or when the initialization of an array element throws an exception, 
-          the initialized elements should be destroyed in the reverse order 
-          of their construction.</p>
-      </blockquote>
-      <p><b>Notes:</b> These functions will typically allocate more memory 
-        than <code>sizeof(U)</code> to allow for internal bookkeeping 
-        structures such as the reference counts.</p>
-    </blockquote>
-    <h2><a name="functions">Free Functions</a></h2>
-    <pre>template&lt;class U&gt; 
-    shared_ptr&lt;U&gt; make_shared(size_t size);
-template&lt;class U, class A&gt; 
-    shared_ptr&lt;U&gt; allocate_shared(const A&amp; allocator, size_t size);</pre>
-    <blockquote>
-      <p><b>Returns:</b> A <code>shared_ptr</code> to a value-initialized 
-        object of type <code>T[size]</code>.</p>
-      <p><b>Remarks:</b> These overloads shall only participate in overload 
-        resolution when <code>U</code> is of the form <code>T[]</code>.</p>      
-      <p><b>Examples:</b></p>
-      <blockquote>
-        <pre>boost::shared_ptr&lt;int[]&gt; a1 = boost::make_shared&lt;int[]&gt;(size);
-boost::shared_ptr&lt;int[][2]&gt; a2 = boost::make_shared&lt;int[][2]&gt;(size);</pre>
-      </blockquote>
-    </blockquote>
-    <pre>template&lt;class U&gt; 
-    shared_ptr&lt;U&gt; make_shared();
-template&lt;class U, class A&gt; 
-    shared_ptr&lt;U&gt; allocate_shared(const A&amp; allocator);</pre>
-    <blockquote>
-      <p><b>Returns:</b> A <code>shared_ptr</code> to a value-initialized 
-        object of type <code>T[N]</code>.</p>
-      <p><b>Remarks:</b> These overloads shall only participate in overload 
-        resolution when <code>U</code> is of the form <code>T[N]</code>.</p>
-      <p><b>Examples:</b></p>
-      <blockquote>
-        <pre>boost::shared_ptr&lt;int[8]&gt; a1 = boost::make_shared&lt;int[8]&gt;();
-boost::shared_ptr&lt;int[4][2]&gt; a2 = boost::make_shared&lt;int[4][2]&gt;();</pre>
-      </blockquote>
-    </blockquote>
-    <pre>template&lt;class U&gt; 
-    shared_ptr&lt;U&gt; make_shared(size_t size, const T&amp; value);
-template&lt;class U, class A&gt; 
-    shared_ptr&lt;U&gt; allocate_shared(const A&amp; allocator, size_t size, const T&amp; value);</pre>
-    <blockquote>
-      <p><b>Returns:</b> A <code>shared_ptr</code> to an object of type 
-        <code>T[size]</code>, where each array element of type <code>T</code> 
-        is initialized to <code>value</code>.</p>
-      <p><b>Remarks:</b> These overloads shall only participate in overload 
-        resolution when <code>U</code> is of the form <code>T[]</code>.</p>
-      <p><b>Examples:</b></p>
-      <blockquote>
-        <pre>boost::shared_ptr&lt;int[]&gt; a1 = boost::make_shared&lt;int[]&gt;(size, 1);
-boost::shared_ptr&lt;int[][2]&gt; a2 = boost::make_shared&lt;int[][2]&gt;(size, {1, 2});</pre>
-      </blockquote>
-    </blockquote>
-    <pre>template&lt;class U&gt; 
-    shared_ptr&lt;U&gt; make_shared(const T&amp; value);
-template&lt;class U, class A&gt; 
-    shared_ptr&lt;U&gt; allocate_shared(const A&amp; allocator, const T&amp; value);</pre>
-    <blockquote>
-      <p><b>Returns:</b> A <code>shared_ptr</code> to an object of type 
-        <code>T[N]</code>, where each array element of type <code>T</code> is 
-        initialized to <code>value</code>.</p>
-      <p><b>Remarks:</b> These overloads shall only participate in overload 
-        resolution when <code>U</code> is of the form <code>T[N]</code>.</p>
-      <p><b>Examples:</b></p>
-      <blockquote>
-        <pre>boost::shared_ptr&lt;int[8]&gt; a1 = boost::make_shared&lt;int[8]&gt;(1);
-boost::shared_ptr&lt;int[4][2]&gt; a2 = boost::make_shared&lt;int[4][2]&gt;({1, 2});</pre>
-      </blockquote>
-    </blockquote>
-    <pre>template&lt;class U&gt; 
-    shared_ptr&lt;U&gt; make_shared_noinit(size_t size);
-template&lt;class U, class A&gt; 
-    shared_ptr&lt;U&gt; allocate_shared_noinit(const A&amp; allocator, size_t size);</pre>
-    <blockquote>
-      <p><b>Returns:</b> A <code>shared_ptr</code> to a default-initialized 
-        object of type <code>T[size]</code>.</p>
-      <p><b>Remarks:</b> These overloads shall only participate in overload 
-        resolution when <code>U</code> is of the form <code>T[]</code>.</p>
-      <p><b>Examples:</b></p>
-      <blockquote>
-        <pre>boost::shared_ptr&lt;int[]&gt; a1 = boost::make_shared_noinit&lt;int[]&gt;(size);
-boost::shared_ptr&lt;int[][2]&gt; a2 = boost::make_shared_noinit&lt;int[][2]&gt;(size);</pre>
-      </blockquote>
-    </blockquote>
-    <pre>template&lt;class U&gt; 
-    shared_ptr&lt;U&gt; make_shared_noinit();
-template&lt;class U, class A&gt; 
-    shared_ptr&lt;U&gt; allocate_shared_noinit(const A&amp; allocator);</pre>
-    <blockquote>
-      <p><b>Returns:</b> A <code>shared_ptr</code> to a default-initialized 
-        object of type <code>T[N]</code>.</p>
-      <p><b>Remarks:</b> These overloads shall only participate in overload 
-        resolution when <code>U</code> is of the form <code>T[N]</code>.</p>
-      <p><b>Examples:</b></p>
-      <blockquote>
-        <pre>boost::shared_ptr&lt;int[8]&gt; a1 = boost::make_shared_noinit&lt;int[8]&gt;();
-boost::shared_ptr&lt;int[4][2]&gt; a2 = boost::make_shared_noinit&lt;int[4][2]&gt;();</pre>
-      </blockquote>
-    </blockquote>
-    <h2><a name="history">History</a></h2>
-    <p>February 2014. Glen Fernandes updated overloads of make_shared and 
-      allocate_shared to conform to the specification in C++ standard paper 
-      <a href="#N3870">N3870</a>, including resolving C++ standard library 
-      defect report 2070, and reduced the spatial overhead of the internal
-      bookkeeping structures.</p>
-    <p>November 2012. Glen Fernandes contributed implementations of 
-      make_shared and allocate_shared for arrays.</p>
-    <h2><a name="references">References</a></h2>
-    <p><a name="N3870">N3870</a>,
-      <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3870.html">
-      Extending make_shared to Support Arrays, Revision 1</a>, Peter Dimov 
-      &amp; Glen Fernandes, January, 2014.</p>
-    <hr>
-    <p>$Date$</p>
-    <p><small>Copyright 2012-2014 Glen Fernandes. 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>
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>allocate_shared and make_shared for arrays</title>
+</head>
+<body>
+<h1>allocate_shared and make_shared for arrays</h1>
+<div id="navigation">
+<ul>
+<li><a href="#introduction">Introduction</a></li>
+<li><a href="#synopsis">Synopsis</a></li>
+<li><a href="#requirements">Common Requirements</a></li>
+<li><a href="#functions">Free Functions</a></li>
+<li><a href="#history">History</a></li>
+<li><a href="#references">References</a></li>
+</ul>
+</div>
+<div id="introduction">
+<h2>Introduction</h2>
+<p>
+Originally the Boost function templates <code>allocate_shared</code> and
+<code>make_shared</code> were for efficient allocation of shared scalar
+objects only. There was a need to have efficient allocation of shared
+arrays. One criticism of class template <code>shared_array</code>
+was always the lack of a utility like <code>make_shared</code> that
+uses only a single allocation.
+</p>
+<p>
+The header files &lt;boost/smart_ptr/allocate_shared_array.hpp&gt; and
+&lt;boost/smart_ptr/make_shared_array.hpp&gt; provide function
+templates, overloads of <code>allocate_shared</code> and
+<code>make_shared</code> for array types, to address this need.
+<code>allocate_shared</code> uses a user-supplied allocator for
+allocation, while <code>make_shared</code> uses
+ <code>allocate_shared</code> with the Default Allocator.
+</p>
+</div>
+<div id="synopsis">
+<h2>Synopsis</h2>
+<div>
+<h3>Header &lt;boost/smart_ptr/allocate_shared_array.hpp&gt;</h3>
+<code>namespace boost {</code>
+<blockquote>
+<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+<a href="#functions">allocate_shared</a>(const A&amp; a,
+std::size_t n);</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+<a href="#functions">allocate_shared</a>(const A&amp; a);</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+<a href="#functions">allocate_shared</a>(const A&amp; a, std::size_t n,
+const <em>E</em>&amp; v);</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+<a href="#functions">allocate_shared</a>(const A&amp; a,
+const <em>E</em>&amp; v);</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+<a href="#functions">allocate_shared_noinit</a>(const A&amp; a,
+std::size_t n);</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+<a href="#functions">allocate_shared_noinit</a>(const A&amp; a);</code>
+</blockquote>
+<code>}</code>
+</div>
+<div>
+<h3>Header &lt;boost/smart_ptr/make_shared_array.hpp&gt;</h3>
+<code>namespace boost {</code>
+<blockquote>
+<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+<a href="#functions">make_shared</a>(std::size_t n);</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+<a href="#functions">make_shared</a>();</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+<a href="#functions">make_shared</a>(std::size_t n,
+const <em>E</em>&amp; v);</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+<a href="#functions">make_shared</a>(const <em>E</em>&amp; v);</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+<a href="#functions">make_shared_noinit</a>(std::size_t n);</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+<a href="#functions">make_shared_noinit</a>();</code>
+</blockquote>
+<code>}</code>
+</div>
+</div>
+<div id="requirements">
+<h2>Common Requirements</h2>
+<h3><code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+allocate_shared(const A&amp; a, <em>args</em>);</code></h3>
+<dl>
+<dt><strong>Requires:</strong></dt>
+<dd><code>T</code> is of the form <code>E[N]</code> or
+<code>E[]</code>. <code>A</code> shall be an <em>Allocator</em>, as
+described in section 17.6.3.5 [Allocator requirements] of the C++
+Standard. The copy constructor and destructor of <code>A</code> shall
+not throw exceptions.</dd>
+<dt><strong>Effects:</strong></dt>
+<dd>Allocates storage for an object of type <code>E</code> (or
+<code>E[size]</code> when <code>T</code> is <code>E[]</code>, where
+<code>size</code> is determined from <code>args</code> as specified by
+the concrete overload). A copy of the allocator is used to allocate
+storage. The storage is initialized as specified by the concrete
+overload. If an exception is thrown, the functions have no effect.</dd>
+<dt><strong>Returns:</strong></dt>
+<dd>A <code>shared_ptr</code> instance that stores and owns the address
+of the newly allocated and constructed object.</dd>
+<dt><strong>Postconditions:</strong></dt>
+<dd><code>r.get() != 0</code> and <code>r.use_count() == 1</code>,
+where <code>r</code> is the return value.</dd>
+<dt><strong>Throws:</strong></dt>
+<dd>An exception thrown from <code>A::allocate()</code>, or from the
+initialization of the object.</dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>
+<ul>
+<li>This implementation performs no more than one memory allocation.
+This provides efficiency to equivalent to an intrusive smart
+pointer.</li>
+<li>When an object of an array type <code>T</code> is specified to be
+initialized to a value of the same type <code>v</code>, this shall be
+interpreted to mean that each array element of the object is initialized
+to the corresponding element from <code>v</code>.</li>
+<li>When an object of an array type <code>T</code> is specified to be
+value-initialized, this shall be interpreted to mean that each array
+element of the object is value-initialized.</li>
+<li>Array elements are initialized in ascending order of their
+addresses.</li>
+<li>When a subobject of a scalar type <code>S</code> is specified to
+be initialized to a value <code>v</code>, <code>allocate_shared</code>
+shall perform this initialization via the expression
+<code>std::allocator_traits&lt;A&gt;::construct(b, p, v)</code>, where
+<code>p</code> points to storage suitable to hold an object of type
+<code>S</code> and <code>b</code> of is a copy of the allocator
+<code>a</code> passed to <code>allocate_shared</code> such that its
+<code>value_type</code> is <code>S</code>.</li>
+<li>When a subobject of scalar type <code>S</code> is specified to be
+value-initialized, <code>allocate_shared</code> shall perform this
+initialization via the expression
+<code>std::allocator_traits&lt;A&gt;::construct(b, p)</code>, where
+<code>p</code> points to storage suitable to hold an object
+of type <code>S</code> and <code>b</code> is a copy of the allocator
+<code>a</code> passed to <code>allocate_shared</code> such that its
+<code>value_type</code> is <code>S</code>.</li>
+<li>When a subobject of scalar type <code>S</code> is specified to be
+default-initialized, <code>allocate_shared_noinit</code> shall perform
+this initialization via the expression <code>::new(p) S</code>, where
+<code>p</code> has type <code>void*</code> and points to storage
+suitable to hold an object of type <code>S</code>.</li>
+<li>When the lifetime of the object managed by the return value ends,
+or when the initialization of an array element throws an exception,
+the initialized elements should be destroyed in the reverse order
+of their construction.</li>
+</ul>
+</dd>
+<dt><strong>Notes:</strong></dt>
+<dd>These functions will typically allocate more memory than the size of
+<code>sizeof(E)</code> to allow for internal bookkeeping structures such
+as the reference counts.</dd>
+</dl>
+</div>
+<div id="functions">
+<h2>Free Functions</h2>
+<div>
+<h3><code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+allocate_shared(const A&amp; a, std::size_t n);</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd>A <code>shared_ptr</code> to a value-initialized object of type
+<code>E[size]</code>.</dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is of the form <code>E[]</code>.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::allocate_shared&lt;int[]<!--
+-->&gt;(std::allocator&lt;int&gt;(), 8);</code></dd>
+</dl>
+</div>
+<div>
+<h3><code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+allocate_shared(const A&amp; a);</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd>A <code>shared_ptr</code> to a value-initialized object of type
+<code>E[N]</code>.</dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is of the form <code>E[N]</code>.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::allocate_shared&lt;int[8]<!--
+-->&gt;(std::allocator&lt;int&gt;());</code></dd>
+</dl>
+</div>
+<div>
+<h3><code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+allocate_shared(const A&amp; a, std::size_t n,
+const <em>E</em>&amp; v);</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd>A <code>shared_ptr</code> to an object of type
+<code>E[size]</code>, where each array element of type <code>E</code> is
+initialized to <code>v</code>.</dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is of the form <code>E[]</code>.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::allocate_shared&lt;double[]<!--
+-->&gt;(std::allocator&lt;double&gt;(), 8, 1.0);</code></dd>
+</dl>
+</div>
+<div>
+<h3><code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+allocate_shared(const A&amp; a, const <em>E</em>&amp; v);</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd>A <code>shared_ptr</code> to an object of type <code>E[N]</code>,
+where each array element of type <code>E</code> is initialized to
+<code>v</code>.</dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is of the form <code>E[N]</code>.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::allocate_shared&lt;double[8]<!--
+-->&gt;(std::allocator&lt;double&gt;(), 1.0);</code></dd>
+</dl>
+</div>
+<div>
+<h3><code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+allocate_shared_noinit(const A&amp; a, std::size_t n);</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd>A <code>shared_ptr</code> to a default-initialized object of type
+<code>E[size]</code>.</dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is of the form <code>E[]</code>.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::allocate_shared_noinit&lt;int[]<!--
+-->&gt;(std::allocator&lt;int&gt;(), 8);</code></dd>
+</dl>
+</div>
+<div>
+<h3><code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
+allocate_shared_noinit(const A&amp; a);</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd>A <code>shared_ptr</code> to a default-initialized object of type
+<code>E[N]</code>.</dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is of the form <code>E[N]</code>.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::allocate_shared_noinit&lt;int[8]<!--
+-->&gt;(std::allocator&lt;int&gt;());</code></dd>
+</dl>
+</div>
+<div>
+<h3><code>template&lt;class T&gt;<br>shared_ptr&lt;T&gt;
+make_shared(std::size_t n);</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd><code>allocate_shared&lt;T&gt;(std::allocator&lt;<em>S<!--
+--></em>&gt;(), n);</code></dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is of the form <code>E[]</code>.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::make_shared&lt;int[]&gt;(8);</code></dd>
+</dl>
+</div>
+<div>
+<h3><code>template&lt;class T&gt;<br>shared_ptr&lt;T&gt;
+make_shared();</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd><code>allocate_shared&lt;T&gt;(std::allocator&lt;<em>S<!--
+--></em>&gt;());</code></dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is of the form <code>E[N]</code>.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::make_shared&lt;int[8]&gt;();</code></dd>
+</dl>
+</div>
+<div>
+<h3><code>template&lt;class T&gt;<br>shared_ptr&lt;T&gt;
+make_shared(std::size_t n, const <em>E</em>&amp; v);</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd><code>allocate_shared&lt;T&gt;(std::allocator&lt;<em>S<!--
+--></em>&gt;(), n, v);</code></dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is of the form <code>E[]</code>.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::make_shared&lt;double[]&gt;(8, 1.0);</code></dd>
+</dl>
+</div>
+<div>
+<h3><code>template&lt;class T&gt;<br>shared_ptr&lt;T&gt;
+make_shared(const <em>E</em>&amp; v);</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd><code>allocate_shared&lt;T&gt;(std::allocator&lt;<em>S<!--
+--></em>&gt;(), v);</code></dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is of the form <code>E[N].</code></dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::make_shared&lt;double[8]&gt;(1.0);</code></dd></dl>
+</div>
+<div>
+<h3><code>template&lt;class T&gt;<br>shared_ptr&lt;T&gt;
+make_shared_noinit(std::size_t n);</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd><code>allocate_shared_noinit&lt;T&gt;(std::allocator&lt;<em>S<!--
+--></em>&gt;(), n);</code></dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is of the form <code>E[]</code>.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::make_shared_noinit&lt;int[]&gt;(8);</code></dd>
+</dl>
+</div>
+<div>
+<h3><code>template&lt;class T&gt;<br>shared_ptr&lt;T&gt;
+make_shared_noinit();</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd><code>allocate_shared_noinit&lt;T&gt;(std::allocator&lt;<em>S<!--
+--></em>&gt;());</code></dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is of the form <code>E[N]</code>.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::make_shared_noinit&lt;int[8]&gt;();</code></dd>
+</dl>
+</div>
+</div>
+<div id="history">
+<h2>History</h2>
+<dl>
+<dt><strong>Boost 1.64</strong></dt>
+<dd>Glen Fernandes rewrote allocate_shared and make_shared for a more
+optimal and more maintainable implementation.</dd>
+<dt><strong>Boost 1.56</strong></dt>
+<dd>Glen Fernandes updated overloads of make_shared and allocate_shared
+to conform to the specification in C++ standard paper
+<a href="#N3870">N3870</a>, including resolving C++ standard library
+defect report <a href="#dr2070">DR 2070</a>.</dd>
+<dt><strong>Boost 1.53</strong></dt>
+<dd>Glen Fernandes contributed implementations of make_shared and
+allocate_shared for arrays.</dd>
+</dl>
+</div>
+<div id="references">
+<h2>References</h2>
+<ol>
+<li id="N3870"><strong>N3870</strong>, <a href=
+"http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3870.html">
+Extending make_shared to Support Arrays, Revision 1</a>, Peter Dimov
+&amp; Glen Fernandes, January, 2014.</li>
+<li id="dr2070"><strong>DR 2070</strong>,
+<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html">
+allocate_shared should use allocator_traits&lt;A&gt;::construct</a>,
+Jonathan Wakely, July, 2011.</li>
+</ol>
+</div>
+<hr>
+Copyright 2012-2017 Glen Fernandes. Distributed under the
+<a href="http://www.boost.org/LICENSE_1_0.txt">Boost Software License,
+Version 1.0</a>.
+</body>
 </html>

make_unique.html

@@ -1,152 +1,184 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <title>make_unique</title>
-    <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">make_unique</h1>
-    <p><a href="#introduction">Introduction</a><br>
-      <a href="#synopsis">Synopsis</a><br>
-      <a href="#common">Common Requirements</a><br>
-      <a href="#functions">Free Functions</a><br>
-      <a href="#history">History</a></p>
-    <h2><a name="introduction">Introduction</a></h2>
-    <p>The header file &lt;boost/make_unique.hpp&gt; provides overloaded 
-      function template <code>make_unique</code> for convenient creation of 
-      <code>unique_ptr</code> objects.</p>
-    <h2><a name="synopsis">Synopsis</a></h2>
-    <pre>namespace boost {
-    template&lt;class U&gt; // U is not array
-    unique_ptr&lt;U&gt; <a href="#functions">make_unique</a>();
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template&lt;class U, class... Args&gt; // U is not array
-    unique_ptr&lt;U&gt; <a href="#functions">make_unique</a>(Args&amp;&amp;... args);
-#endif
-
-    template&lt;class U&gt; // U is not array
-    unique_ptr&lt;U&gt; <a href="#functions">make_unique</a>(U&amp;&amp; value);
-
-    template&lt;class U&gt; // U is T[]
-    unique_ptr&lt;U&gt; <a href="#functions">make_unique</a>(size_t size);
-
-    template&lt;class U&gt; // U is not array
-    unique_ptr&lt;U&gt; <a href="#functions">make_unique_noinit</a>();
-
-    template&lt;class U&gt; // U is T[]
-    unique_ptr&lt;U&gt; <a href="#functions">make_unique_noinit</a>(size_t size);
-}</pre>
-    <h2><a name="common">Common Requirements</a></h2>
-    <pre>template&lt;class U&gt;
-    unique_ptr&lt;U&gt; make_unique(<em>args</em>);
-template&lt;class U&gt;
-    unique_ptr&lt;U&gt; make_unique_noinit(<em>args</em>);</pre> 
-    <blockquote>
-      <p><b>Effects:</b> Allocates memory for an object of type <code>U</code> 
-        (or <code>T[size]</code> when <code>U</code> is <code>T[]</code>, 
-        where <code>size</code> is determined from <code>args</code> as 
-        specified by the concrete overload). The object is initialized from 
-        <code>args</code> as specified by the concrete overload. If an 
-        exception is thrown, the functions have no effect.</p>
-      <p><b>Returns:</b> A <code>unique_ptr</code> instance that stores and 
-        owns the address of the newly constructed object.</p>
-      <p><b>Postconditions:</b> <code>r.get() != 0</code>, where 
-        <code>r</code> is the return value.</p>
-      <p><b>Throws:</b> <code>bad_alloc</code>, or an exception thrown from 
-        the initialization of the object.</p>
-      <p><b>Remarks:</b></p>
-      <blockquote>
-        <p>When an object of a non-array type <code>T</code> is specified to 
-          be initialized to a value <code>value</code>, or to 
-          <code>T(list...)</code>, where <code>list...</code> is a list of 
-          constructor arguments, <code>make_unique</code> shall perform this 
-          initialization via the expression <code>new T(value)</code> or 
-          <code>new T(list...)</code> respectively.</p>
-        <p>When an object of type <code>T</code> is specified to be 
-          value-initialized, <code>make_unique</code> shall perform this 
-          initialization via the expression <code>new T()</code>.</p>
-        <p>When an object of type <code>T</code> is specified to be 
-          default-initialized, <code>make_unique_noinit</code> shall perform 
-          this initialization via the expression <code>new T</code>.</p>
-      </blockquote>
-    </blockquote>
-    <h2><a name="functions">Free Functions</a></h2>
-    <pre>template&lt;class U, class... Args&gt;
-unique_ptr&lt;U&gt; make_unique(Args&amp;&amp;... args);</pre> 
-    <blockquote>
-      <p><b>Returns:</b> A unique_ptr to an object of type <code>U</code>, 
-        initialized to <code>U(forward&lt;Args&gt;(args)...)</code>.</p>
-      <p><b>Remarks:</b> This overload shall only participate in overload 
-        resolution when <code>U</code> is not an array type.</p>
-      <p><b>Examples:</b></p>
-      <blockquote>
-        <pre>unique_ptr&lt;float&gt; p1 = boost::make_unique&lt;float&gt;();
-unique_ptr&lt;point&gt; p2 = boost::make_unique&lt;point&gt;(x, y);</pre>
-      </blockquote>
-    </blockquote>
-    <pre>template&lt;class U&gt;
-unique_ptr&lt;U&gt; make_unique(U&amp;&amp; value);</pre> 
-    <blockquote>
-      <p><b>Returns:</b> A unique_ptr to an object of type <code>U</code>, 
-        initialized to <code>move(value)</code>.</p>
-      <p><b>Remarks:</b> This overload shall only participate in overload 
-        resolution when <code>U</code> is not an array type.</p>
-      <p><b>Examples:</b></p>
-      <blockquote>
-        <pre>unique_ptr&lt;string&gt; p1 = boost::make_unique&lt;string&gt;({'a', 'b'});
-unique_ptr&lt;point&gt; p2 = boost::make_unique&lt;point&gt;({-10, 25});</pre>
-      </blockquote>
-    </blockquote>
-    <pre>template&lt;class U&gt;
-unique_ptr&lt;U&gt; make_unique(size_t size);</pre> 
-    <blockquote>
-      <p><b>Returns:</b> A unique_ptr to a value-initialized object of type 
-        <code>T[size]</code>.</p>
-      <p><b>Remarks:</b> This overload shall only participate in overload 
-        resolution when <code>U</code> is of the form <code>T[]</code>.</p>
-      <p><b>Examples:</b></p>
-      <blockquote>
-        <pre>unique_ptr&lt;double[]&gt; p1 = boost::make_unique&lt;double[]&gt;(4);
-unique_ptr&lt;int[][2]&gt; p2 = boost::make_unique&lt;int[][2]&gt;(2);</pre>
-      </blockquote>
-    </blockquote>
-    <pre>template&lt;class U&gt;
-unique_ptr&lt;U&gt; make_unique_noinit();</pre> 
-    <blockquote>
-      <p><b>Returns:</b> A unique_ptr to a default-initialized object of 
-        type <code>U</code>.</p>
-      <p><b>Remarks:</b> This overload shall only participate in overload 
-        resolution when <code>U</code> is not an array type.</p>
-      <p><b>Examples:</b></p>
-      <blockquote>
-        <pre>unique_ptr&lt;float&gt; p1 = boost::make_unique_noinit&lt;float&gt;();
-unique_ptr&lt;point&gt; p2 = boost::make_unique_noinit&lt;point&gt;();</pre>
-      </blockquote>
-    </blockquote>
-    <pre>template&lt;class U&gt;
-unique_ptr&lt;U&gt; make_unique_noinit(size_t size);</pre> 
-    <blockquote>
-      <p><b>Returns:</b> A unique_ptr to a default-initialized object of 
-        type <code>T[size]</code>.</p>
-      <p><b>Remarks:</b> This overload shall only participate in overload 
-        resolution when <code>U</code> is of the form <code>T[]</code>.</p>
-      <p><b>Examples:</b></p>
-      <blockquote>
-        <pre>unique_ptr&lt;double[]&gt; p1 = boost::make_unique_noinit&lt;double[]&gt;(4);
-unique_ptr&lt;int[][2]&gt; p2 = boost::make_unique_noinit&lt;int[][2]&gt;(2);</pre>
-      </blockquote>
-    </blockquote>
-    <h2><a name="history">History</a></h2>
-    <p>January 2014. Glen Fernandes contributed implementations of 
-      make_unique for objects and arrays.</p>
-    <hr>
-    <p>$Date$</p>
-    <p><small>Copyright 2012-2014 Glen Fernandes. 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>
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>make_unique</title>
+</head>
+<body>
+<h1>make_unique</h1>
+<div id="navigation">
+<ul>
+<li><a href="#introduction">Introduction</a></li>
+<li><a href="#synopsis">Synopsis</a></li>
+<li><a href="#requirements">Common Requirements</a></li>
+<li><a href="#functions">Free Functions</a></li>
+<li><a href="#history">History</a></li>
+</ul>
+</div>
+<div id="introduction">
+<h2>Introduction</h2>
+<p>
+The header file &lt;boost/make_unique.hpp&gt; provides overloads of
+function template <code>make_unique</code> for convenient creation of
+<code>std::unique_ptr</code> objects.
+</p>
+</div>
+<div id="synopsis">
+<h2>Synopsis</h2>
+<div>
+<h3>Header &lt;boost/smart_ptr/make_unique.hpp&gt;</h3>
+<code>namespace boost {</code>
+<blockquote>
+<code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
+<a href="#functions">make_unique</a>();</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T, class... Args&gt;<br>std::unique_ptr&lt;T&gt;
+<a href="#functions">make_unique</a>(Args&amp;&amp;... args);</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
+<a href="#functions">make_unique</a>(<em>T</em>&amp;&amp; value);</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
+<a href="#functions">make_unique</a>(std::size_t size);</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
+<a href="#functions">make_unique_noinit</a>();</code>
+</blockquote>
+<blockquote>
+<code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
+<a href="#functions">make_unique_noinit</a>(std::size_t size);</code>
+</blockquote>
+<code>}</code>
+</div>
+</div>
+<div id="requirements">
+<h2>Common Requirements</h2>
+<h3><code>template&lt;class T, <em>Args</em>&gt;<br>
+std::unique_ptr&lt;T&gt; make_unique(<em>args</em>);</code></h3>
+<dl>
+<dt><strong>Effects:</strong></dt>
+<dd>Allocates storage for an object of type <code>T</code> (or
+<code>E[size]</code> when <code>T</code> is <code>E[]</code>, where
+<code>size</code> is determined from <code>args</code> as specified by
+the concrete overload). The storage is initialized from
+<code>args</code> as specified by the concrete overload. If an exception
+is thrown, the functions have no effect.</dd>
+<dt><strong>Returns:</strong></dt>
+<dd>A <code>std::unique_ptr</code> instance that stores and owns the
+address of the newly allocated and constructed object.</dd>
+<dt><strong>Postconditions:</strong></dt>
+<dd><code>r.get() != 0</code>, where <code>r</code> is the return
+value.</dd>
+<dt><strong>Throws:</strong></dt>
+<dd><code>std::bad_alloc</code>, or an exception thrown from the
+initialization of the object.</dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>
+<ul>
+<li>When an object of a scalar type T is specified to be initialized to
+a value <code>value</code>, or to <code>T(args...)</code>, where
+<code>args...</code> is a list of constructor arguments,
+<code>make_unique</code> shall perform this initialization via the
+expression <code>new T(value)</code> or <code>new T(args...)</code>
+respectively.</li>
+<li>When an object of type <code>T</code> is specified to be
+value-initialized, <code>make_unique</code> shall perform this
+initialization via the expression <code>new T()</code>.</li>
+<li>When an object of type <code>T</code> is specified to be
+default-initialized, <code>make_unique_noinit</code> shall perform this
+initialization via the expression <code>new T</code>.</li>
+</ul>
+</dd>
+</dl>
+</div>
+<div id="functions">
+<h2>Free functions</h2>
+<div>
+<h3><code>template&lt;class T, class... Args&gt;<br>
+std::unique_ptr&lt;T&gt;
+make_unique(Args&amp;&amp;... args);</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd>A <code>std::unique_ptr</code> to an object of type <code>T</code>,
+initialized to <code>std::forward&lt;Args&gt;(args)...</code>.</dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is not an array type.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::make_unique&lt;double&gt;(1.0);</code></dd>
+</dl>
+</div>
+<div>
+<h3><code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
+make_unique(<em>T</em>&amp;&amp; value);</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd>A <code>std::unique_ptr</code> to an object of type <code>T</code>,
+initialized to <code>std::move(value)</code>.</dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is not an array type.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::make_unique&lt;point&gt;({1.0, -1.0});</code></dd></dl>
+</div>
+<div>
+<h3><code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
+make_unique(std::size_t size);</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd>A <code>std::unique_ptr</code> to a value-initialized object of type
+<code>E[size]</code>.</dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is of the form <code>E[]</code>.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::make_unique&lt;int[]&gt;(8);</code></dd>
+</dl>
+</div>
+<div>
+<h3><code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
+make_unique_noinit();</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd>A <code>std::unique_ptr</code> to a default-initialized object of
+type <code>T</code>.</dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is not an array type.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::make_unique_noinit&lt;std::tm&gt;();</code></dd>
+</dl>
+</div>
+<div>
+<h3><code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
+make_unique_noinit(std::size_t size);</code></h3>
+<dl>
+<dt><strong>Returns:</strong></dt>
+<dd>A <code>std::unique_ptr</code> to a default-initialized object of
+type <code>E[size]</code>.</dd>
+<dt><strong>Remarks:</strong></dt>
+<dd>This overload shall only participate in overload resolution when
+<code>T</code> is of the form <code>E[]</code>.</dd>
+<dt><strong>Example:</strong></dt>
+<dd><code>boost::make_unique_noinit&lt;char[]&gt;(64);</code></dd>
+</dl>
+</div>
+</div>
+<div id="history">
+<h2>History</h2>
+<dl>
+<dt><strong>Boost 1.56</strong></dt>
+<dd>Glen Fernandes contributed implementations of make_unique for
+scalars and arrays</dd>
+</dl>
+</div>
+<hr>
+Copyright 2012-2014 Glen Fernandes. Distributed under the
+<a href="http://www.boost.org/LICENSE_1_0.txt">Boost Software License,
+Version 1.0</a>.
+</body>
 </html>

meta/libraries.json

@@ -0,0 +1,22 @@
+{
+    "key": "smart_ptr",
+    "name": "Smart Ptr",
+    "authors": [
+        "Greg Colvin",
+        "Beman Dawes",
+        "Peter Dimov",
+        "Darin Adler",
+        "Glen Fernandes"
+    ],
+    "description": "Smart pointer class templates.",
+    "documentation": "smart_ptr.htm",
+    "std": [
+        "tr1"
+    ],
+    "category": [
+        "Memory"
+    ],
+    "maintainers": [
+        "Peter Dimov <pdimov -at- pdimov.com>"
+    ]
+}

pointer_cast.html

@@ -2,16 +2,16 @@
 <html>
     <head>
         <title>pointer_cast</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">pointer_cast</h1>
+            width="277" align="middle" border="0" />pointer_cast</h1>
         <p>The pointer cast functions (<code>boost::static_pointer_cast</code> <code>boost::dynamic_pointer_cast</code>
             <code>boost::reinterpret_pointer_cast</code> <code>boost::const_pointer_cast</code>) 
-            provide a way to write generic pointer castings for raw pointers. The functions 
-            are defined in <CITE><A href="../../boost/pointer_cast.hpp">boost/pointer_cast.hpp</A>.</CITE></p>
-        <P>There is test/example code in <CITE><A href="test/pointer_cast_test.cpp">pointer_cast_test.cpp</A></CITE>.</p>
+            provide a way to write generic pointer castings for raw pointers, <code>std::shared_ptr</code> and <code>std::unique_ptr</code>. The functions 
+            are defined in <cite><a href="../../boost/pointer_cast.hpp">boost/pointer_cast.hpp</a>.</cite></p>
+        <p>There is test/example code in <cite><a href="test/pointer_cast_test.cpp">pointer_cast_test.cpp</a></cite>.</p>
             <h2><a name="rationale">Rationale</a></h2>
         <P>Boost smart pointers usually overload those functions to provide a mechanism to 
             emulate pointers casts. For example, <code>boost::shared_ptr&lt;...&gt;</code> implements 
@@ -20,15 +20,15 @@
 template&lt;class T, class U&gt;
     shared_ptr&lt;T&gt; static_pointer_cast(shared_ptr&lt;U&gt; const &amp;r);
 </pre>
-        <P>Pointer cast functions from <CITE><A href="../../boost/pointer_cast.hpp">boost/pointer_cast.hpp</A></CITE>
+        <p>Pointer cast functions from <cite><A href="../../boost/pointer_cast.hpp">boost/pointer_cast.hpp</A></CITE>
             are overloads of <code>boost::static_pointer_cast</code>, <code>boost::dynamic_pointer_cast</code>,
             <code>boost::reinterpret_pointer_cast</code> and <code>boost::const_pointer_cast</code>
-            for raw pointers. This way when developing pointer type independent classes, 
-            for example, memory managers or shared memory compatible classes, the same code 
-            can be used for raw and smart pointers.</p>
-            <H2><A name="synopsis">Synopsis</A></H2>
-            <BLOCKQUOTE>
-                <PRE>
+            for raw pointers, <code>std::shared_ptr</code> and <code>std::unique_ptr</code>. This way when developing
+            pointer type independent classes, for example, memory managers or shared memory compatible classes, the same
+            code can be used for raw and smart pointers.</p>
+            <h2><a name="synopsis">Synopsis</a></h2>
+            <blockquote>
+                <pre>
 namespace boost {
 
 template&lt;class T, class U&gt;
@@ -46,15 +46,93 @@ inline T* const_pointer_cast(U *ptr)
 template&lt;class T, class U&gt;
 inline T* reinterpret_pointer_cast(U *ptr)
   { return reinterpret_cast&lt;T*&gt;(ptr); }
+
+template&lt;class T, class U&gt;
+inline std::shared_ptr&lt;T&gt; static_pointer_cast(std::shared_ptr&lt;U&gt; const&amp; r);
+
+template&lt;class T, class U&gt;
+inline std::shared_ptr&lt;T&gt; dynamic_pointer_cast(std::shared_ptr&lt;U&gt; const&amp; r);
+
+template&lt;class T, class U&gt;
+inline std::shared_ptr&lt;T&gt; const_pointer_cast(std::shared_ptr&lt;U&gt; const&amp; r);
+
+template&lt;class T, class U&gt;
+inline std::shared_ptr&lt;T&gt; reinterpret_pointer_cast(std::shared_ptr&lt;U&gt; const&amp; r);
+
+template&lt;class T, class U&gt;
+inline std::unique_ptr&lt;T&gt; static_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; r);
+
+template&lt;class T, class U&gt;
+inline std::unique_ptr&lt;T&gt; dynamic_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; r);
+
+template&lt;class T, class U&gt;
+inline std::unique_ptr&lt;T&gt; const_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; r);
+
+template&lt;class T, class U&gt;
+inline std::unique_ptr&lt;T&gt; reinterpret_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; r);
   
 } // namespace boost
-</PRE>
-            </BLOCKQUOTE>
-        <P>As you can see from the above synopsis, the pointer cast functions are just 
-            wrappers around standard C++ cast operators.</P>
-        <H2><A name="example">Example</A></H2>
-        <BLOCKQUOTE>
-            <PRE>
+</pre>
+            </blockquote>
+        <p>As you can see from the above synopsis, the pointer cast functions for raw pointers are just 
+           wrappers around standard C++ cast operators.</p>
+
+        <p>The pointer casts for <code>std::shared_ptr</code> are aliases of the corresponding standard
+           functions with the same names and equivalent to <a href="shared_ptr.htm#static_pointer_cast">the
+           functions taking <code>boost::shared_ptr</code></a>.</p>
+
+        <p>The pointer casts for <code>std::unique_ptr</code> are documented below.</p>
+
+        <h3 id="static_pointer_cast">static_pointer_cast</h3>
+        <pre>template&lt;class T, class U&gt;
+  unique_ptr&lt;T&gt; static_pointer_cast(unique_ptr&lt;U&gt;&amp;&amp; r); // never throws</pre>
+        <blockquote>
+            <p><b>Requires:</b> The expression <code>static_cast&lt;T*&gt;( (U*)0 )</code>
+                must be well-formed.</p>
+            <p><b>Returns:</b> <code>unique_ptr&lt;T&gt;( static_cast&lt;typename unique_ptr&lt;T&gt;::element_type*&gt;(r.release()) )</code>.</p>
+            <p><b>Throws:</b> nothing.</p>
+            <p><b>Notes:</b> the seemingly equivalent expression
+                <code>unique_ptr&lt;T&gt;(static_cast&lt;T*&gt;(r.get()))</code>
+                will eventually result in undefined behavior, attempting to delete the same
+                object twice.</p>
+        </blockquote>
+        <h3 id="const_pointer_cast">const_pointer_cast</h3>
+        <pre>template&lt;class T, class U&gt;
+  unique_ptr&lt;T&gt; const_pointer_cast(unique_ptr&lt;U&gt;&amp;&amp; r); // never throws</pre>
+        <blockquote>
+            <p><b>Requires:</b> The expression <code>const_cast&lt;T*&gt;( (U*)0 )</code>
+                must be well-formed.</p>
+            <p><b>Returns:</b> <code>unique_ptr&lt;T&gt;( const_cast&lt;typename unique_ptr&lt;T&gt;::element_type*&gt;(r.release()) )</code>.</p>
+            <p><b>Throws:</b> nothing.</p>
+        </blockquote>
+        <h3 id="dynamic_pointer_cast">dynamic_pointer_cast</h3>
+        <pre>template&lt;class T, class U&gt;
+  unique_ptr&lt;T&gt; dynamic_pointer_cast(unique_ptr&lt;U&gt;&amp;&amp; r);</pre>
+        <blockquote>
+            <p><b>Requires:</b> The expression <code>dynamic_cast&lt;T*&gt;( (U*)0 )</code>
+                must be well-formed. <code>T</code> must have a virtual destructor.</p>
+            <p><b>Returns:</b></p>
+            <ul>
+                <li>
+                    When <code>dynamic_cast&lt;typename unique_ptr&lt;T&gt;::element_type*&gt;(r.get())</code> returns a nonzero value,
+                    <code>unique_ptr&lt;T&gt;(dynamic_cast&lt;typename unique_ptr&lt;T&gt;::element_type*&gt;(r.release()))</code>;</li>
+                <li>
+                    Otherwise, <code>unique_ptr&lt;T&gt;()</code>.</li></ul>
+            <p><b>Throws:</b> nothing.</p>
+        </blockquote>
+        <h3 id="reinterpret_pointer_cast">reinterpret_pointer_cast</h3>
+        <pre>template&lt;class T, class U&gt;
+  unique_ptr&lt;T&gt; reinterpret_pointer_cast(unique_ptr&lt;U&gt;&amp;&amp; r); // never throws</pre>
+        <blockquote>
+            <p><b>Requires:</b> The expression <code>reinterpret_cast&lt;T*&gt;( (U*)0 )</code>
+                must be well-formed.</p>
+            <p><b>Returns:</b> <code>unique_ptr&lt;T&gt;( reinterpret_cast&lt;typename unique_ptr&lt;T&gt;::element_type*&gt;(r.release()) )</code>.</p>
+            <p><b>Throws:</b> nothing.</p>
+        </blockquote>
+
+        <h2><a name="example">Example</a></h2>
+        <blockquote>
+            <pre>
 #include &lt;boost/pointer_cast.hpp&gt;
 #include &lt;boost/shared_ptr.hpp&gt;
 
@@ -79,28 +157,27 @@ void check_if_it_is_derived(const BasePtr &amp;ptr)
 
 int main()
 {
-   <I>// Create a raw and a shared_ptr</I>
+   <em>// Create a raw and a shared_ptr</em>
 
    base *ptr = new derived;
    boost::shared_ptr&lt;base&gt; sptr(new derived);
    
-   <I>// Check that base pointer points actually to derived class</I>
+   <em>// Check that base pointer points actually to derived class</em>
 
    check_if_it_is_derived(ptr);
    check_if_it_is_derived(sptr);
    
-   // <EM>Ok!</EM>
+   <em>// Ok!</em>
    
    delete ptr;
    return 0;
-}</PRE>
-        </BLOCKQUOTE>
-        <P>The example demonstrates how the generic pointer casts help us create pointer 
-            independent code.</P>
-        <hr>
-        <p>$Date$</p>
+}</pre>
+        </blockquote>
+        <p>The example demonstrates how the generic pointer casts help us create pointer 
+            independent code.</p>
+        <hr />
         <p>Copyright 2005 Ion Gazta<74>aga. Use, modification, and distribution are subject to 
-            the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt">
-            LICENSE_1_0.txt</A> or a copy at &lt;<A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>&gt;.)</p>
+            the Boost Software License, Version 1.0. (See accompanying file <a href="../../LICENSE_1_0.txt">
+            LICENSE_1_0.txt</a> or a copy at &lt;<a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
     </body>
 </html>

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);
@@ -220,7 +222,7 @@ void bad()
     shared_ptr&lt;T&gt; <a href="#dynamic_pointer_cast" >dynamic_pointer_cast</a>(shared_ptr&lt;U&gt; const &amp; r); // never throws
 
   template&lt;class T, class U&gt;
-    shared_ptr&lt;T&gt; <a href="#reinterpret_pointer_cast" >reinterpet_pointer_cast</a>(shared_ptr&lt;U&gt; const &amp; r); // never throws
+    shared_ptr&lt;T&gt; <a href="#reinterpret_pointer_cast" >reinterpret_pointer_cast</a>(shared_ptr&lt;U&gt; const &amp; r); // never throws
 
   template&lt;class E, class T, class Y&gt;
     std::basic_ostream&lt;E, T&gt; &amp; <a href="#insertion-operator" >operator&lt;&lt;</a> (std::basic_ostream&lt;E, T&gt; &amp; os, shared_ptr&lt;Y&gt; const &amp; p);
@@ -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>

smart_ptr.htm

@@ -136,6 +136,9 @@
         <p>Functions which destroy objects of the pointed to type are prohibited from
             throwing exceptions by the <a href="#common_requirements">common requirements</a>.</p>
         <h2><a name="History">History</a> and Acknowledgements</h2>
+        <p>February 2017. Glen Fernandes rewrote <b>allocate_shared</b>
+            and <b>make_shared</b> for arrays for a more optimal and more
+            maintainable implementation.</p>
         <p>February 2014. Glen Fernandes updated overloads of <b>make_shared</b> and 
             <b>allocate_shared</b> to conform to the specification in C++ standard paper 
             <a href="#D&amp;F-14">[D&amp;F-14]</a>, and implemented <b>make_unique</b> for 

test/Jamfile.v2

@@ -29,11 +29,15 @@ import testing ;
           [ compile-fail shared_ptr_compare_fail.cpp ]
           [ run shared_ptr_alloc2_test.cpp ]
           [ run pointer_cast_test.cpp ]
+          [ run cpp11_pointer_cast_test.cpp ]
           [ compile pointer_to_other_test.cpp ]
           [ run auto_ptr_rv_test.cpp ]
           [ run shared_ptr_alias_test.cpp ]
           [ run shared_ptr_rv_test.cpp ]
+          [ run shared_ptr_rv_pointer_cast_test.cpp ]
           [ run shared_ptr_move_test.cpp ]
+          [ run shared_ptr_alias_move_test.cpp ]
+          [ run shared_ptr_reinterpret_pointer_cast_test.cpp ]
           [ compile-fail shared_ptr_pv_fail.cpp ]
           [ run sp_unary_addr_test.cpp ]
           [ compile-fail scoped_ptr_eq_fail.cpp ]
@@ -46,6 +50,7 @@ import testing ;
           [ run spinlock_try_test.cpp : : : <threading>multi : spinlock_try_test.mt ]
           [ run spinlock_pool_test.cpp ]
           [ run make_shared_test.cpp ]
+          [ run make_shared_move_emulation_test.cpp ]
           [ run make_shared_perfect_forwarding_test.cpp ]
           [ run shared_ptr_convertible_test.cpp ]
           [ run wp_convertible_test.cpp ]
@@ -60,8 +65,6 @@ import testing ;
           [ run sp_recursive_assign2_test.cpp ]
           [ run sp_recursive_assign_rv_test.cpp ]
           [ run sp_recursive_assign2_rv_test.cpp ]
-          [ run esft_constructor_test.cpp ]
-          [ run enable_shared_from_raw_test.cpp ]
           [ compile-fail auto_ptr_lv_fail.cpp ]
           [ run atomic_count_test2.cpp ]
           [ run sp_typeinfo_test.cpp ]
@@ -81,6 +84,7 @@ import testing ;
           [ run sa_nullptr_test.cpp ]
           [ run shared_ptr_alloc3_test.cpp ]
           [ run shared_ptr_alloc11_test.cpp ]
+          [ run shared_ptr_alloc_construct11_test.cpp ]
           [ run allocate_shared_alloc11_test.cpp ]
           [ run allocate_shared_construct11_test.cpp ]
           [ run sp_interlocked_test.cpp ]
@@ -163,5 +167,46 @@ import testing ;
           [ run make_unique_array_test.cpp ]
           [ run make_unique_array_noinit_test.cpp ]
           [ run make_unique_array_throws_test.cpp ]
+
+          [ run shared_from_raw_test.cpp ]
+          [ run shared_from_raw_test2.cpp ]
+          [ run shared_from_raw_test3.cpp ]
+          [ run shared_from_raw_test4.cpp ]
+          [ run shared_from_raw_test5.cpp ]
+          [ run shared_from_raw_test6.cpp ]
+
+          [ 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 ]
+
+          [ run pointer_cast_test2.cpp ]
+
+          [ compile-fail pointer_cast_st_fail.cpp ]
+          [ compile-fail pointer_cast_st_fail2.cpp ]
+          [ compile-fail pointer_cast_st_fail3.cpp ]
+
+          [ compile-fail pointer_cast_co_fail.cpp ]
+          [ compile-fail pointer_cast_co_fail2.cpp ]
+          [ compile-fail pointer_cast_co_fail3.cpp ]
+
+          [ compile-fail pointer_cast_dy_fail.cpp ]
+          [ compile-fail pointer_cast_dy_fail2.cpp ]
+          [ compile-fail pointer_cast_dy_fail3.cpp ]
+
+          [ run sp_nothrow_test.cpp ]
+
+          [ compile make_shared_msvc_test.cpp ]
         ;
 }

test/allocate_shared_array_construct_test.cpp

@@ -1,160 +1,162 @@
 /*
- * 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>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-template<typename T>
-class creator {
-public:
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+struct allow { };
+
+template<class T>
+struct creator {
     typedef T value_type;
 
-    creator() {
-    }
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
 
-    template<typename U>
-    creator(const creator<U>&) {
-    }
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
 
     T* allocate(std::size_t size) {
-        void* p1 = ::operator new(size * sizeof(T));
-        return static_cast<T*>(p1);
+        return static_cast<T*>(::operator new(sizeof(T) * size));
     }
 
-    void deallocate(T* memory, std::size_t) {
-        void* p1 = memory;
-        ::operator delete(p1);
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
     }
 
-    template<typename U>
-    void construct(U* memory) {
-        void* p1 = memory;
-        ::new(p1) U();
+    template<class U>
+    void construct(U* ptr) {
+        ::new(static_cast<void*>(ptr)) U(allow());
     }
 
-    template<typename U>
-    void destroy(U* memory) {
-        memory->~U();
+    template<class U>
+    void destroy(U* ptr) {
+        ptr->~U();
     }
+
 };
 
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
+
 class type {
-    friend class creator<type>;
-
 public:
-    static unsigned int instances;
-    static const type object;
+    static unsigned instances;
 
-protected:
-    explicit type() {
-        instances++;
-    }
-
-    type(const type&) {
-        instances++;
+    explicit type(allow) {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
+
+private:
+    type(const type&);
+    type& operator=(const type&);
 };
 
-unsigned int type::instances;
-const type type::object;
+unsigned type::instances = 0;
 
-int main() {
-    BOOST_TEST(type::instances == 1);
+int main()
+{
     {
-        boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(creator<void>(), 3);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1.get() != 0);
+        boost::shared_ptr<type[]> result =
+            boost::allocate_shared<type[]>(creator<type>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(type::instances == 3);
+        result.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+    {
+        boost::shared_ptr<type[3]> result =
+            boost::allocate_shared<type[3]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(type::instances == 3);
+        result.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+    {
+        boost::shared_ptr<type[][2]> result =
+            boost::allocate_shared<type[][2]>(creator<type>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
-        BOOST_TEST(type::instances == 1);
+        result.reset();
+        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::shared_ptr<type[2][2]> result =
+            boost::allocate_shared<type[2][2]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
-        BOOST_TEST(type::instances == 1);
+        result.reset();
+        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);
-        a1.reset();
-        BOOST_TEST(type::instances == 1);
+        boost::shared_ptr<const type[]> result =
+            boost::allocate_shared<const type[]>(creator<type>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(type::instances == 3);
+        result.reset();
+        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);
-        a1.reset();
-        BOOST_TEST(type::instances == 1);
+        boost::shared_ptr<const type[3]> result =
+            boost::allocate_shared<const type[3]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(type::instances == 3);
+        result.reset();
+        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::shared_ptr<const type[][2]> result =
+            boost::allocate_shared<const type[][2]>(creator<type>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
-        BOOST_TEST(type::instances == 1);
+        result.reset();
+        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::shared_ptr<const type[2][2]> result =
+            boost::allocate_shared<const type[2][2]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
-        BOOST_TEST(type::instances == 1);
+        result.reset();
+        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);
-        a1.reset();
-        BOOST_TEST(type::instances == 1);
-    }
-
-    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);
-        a1.reset();
-        BOOST_TEST(type::instances == 1);
-    }
-
     return boost::report_errors();
 }
 #else
-
-int main() {
+int main()
+{
     return 0;
 }
-
 #endif

test/allocate_shared_array_esft_test.cpp

@@ -1,26 +1,62 @@
 /*
- * 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>
-#include <boost/smart_ptr/enable_shared_from_this.hpp>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-class type 
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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>
+
+template<class T>
+struct creator {
+    typedef T value_type;
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
+    T* allocate(std::size_t size) {
+        return static_cast<T*>(::operator new(sizeof(T) * size));
+    }
+
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
+    }
+};
+
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
+
+class type
     : public boost::enable_shared_from_this<type> {
 public:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
-        instances++;
+    type() {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -28,30 +64,31 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned 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);
+        boost::shared_ptr<type[]> result =
+            boost::allocate_shared<type[]>(creator<type>(), 3);
         try {
-            a1[0].shared_from_this();
+            result[0].shared_from_this();
             BOOST_ERROR("shared_from_this did not throw");
         } catch (...) {
             BOOST_TEST(type::instances == 3);
         }
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        boost::shared_ptr<type[]> a1 = boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 3);
+        boost::shared_ptr<type[]> result =
+            boost::allocate_shared_noinit<type[]>(creator<type>(), 3);
         try {
-            a1[0].shared_from_this();
+            result[0].shared_from_this();
             BOOST_ERROR("shared_from_this did not throw");
         } catch (...) {
             BOOST_TEST(type::instances == 3);
         }
     }
-
     return boost::report_errors();
 }

test/allocate_shared_array_noinit_test.cpp

@@ -1,181 +1,251 @@
 /*
- * 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>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/align/is_aligned.hpp>
+#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>
 
+template<class T>
+struct creator {
+    typedef T value_type;
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
+    T* allocate(std::size_t size) {
+        return static_cast<T*>(::operator new(sizeof(T) * size));
+    }
+
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
+    }
+};
+
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
+
 class type {
 public:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
-        instances++;
+    type()
+        : value_(0.0) {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
+    }
+
+    void set(long double value) {
+        value_ = value;
+    }
+
+    long double get() const {
+        return value_;
     }
 
 private:
     type(const type&);
     type& operator=(const type&);
+
+    long double value_;
 };
 
-unsigned int type::instances = 0;
+unsigned 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();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<int[]> result =
+            boost::allocate_shared_noinit<int[]>(creator<int>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
     {
-        boost::shared_ptr<int[3]> a1 = boost::allocate_shared_noinit<int[3]>(std::allocator<int>());
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<int[3]> result =
+            boost::allocate_shared_noinit<int[3]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
     {
-        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]> result =
+            boost::allocate_shared_noinit<int[][2]>(creator<int>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
     {
-        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<int[2][2]> result =
+            boost::allocate_shared_noinit<int[2][2]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
     {
-        boost::shared_ptr<const int[]> a1 = boost::allocate_shared_noinit<const int[]>(std::allocator<int>(), 3);
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<const int[]> result =
+            boost::allocate_shared_noinit<const
+                int[]>(creator<int>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
     {
-        boost::shared_ptr<const int[3]> a1 = boost::allocate_shared_noinit<const int[3]>(std::allocator<int>());
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<const int[3]> result =
+            boost::allocate_shared_noinit<const int[3]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
     {
-        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]> result =
+            boost::allocate_shared_noinit<const
+                int[][2]>(creator<int>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
     {
-        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::shared_ptr<const int[2][2]> result =
+            boost::allocate_shared_noinit<const
+                int[2][2]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
-    BOOST_TEST(type::instances == 0);
     {
-        boost::shared_ptr<type[]> a1 = boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 3);
-        type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[]> result =
+            boost::allocate_shared_noinit<type[]>(creator<type>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[]> other = result;
+        result.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();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[3]> result =
+            boost::allocate_shared_noinit<type[3]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[3]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[3]> other = result;
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[][2]> result =
+            boost::allocate_shared_noinit<type[][2]>(creator<type>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<type[][2]> other = result;
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[2][2]> result =
+            boost::allocate_shared_noinit<type[2][2]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<type[2][2]> other = result;
+        result.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();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[]> result =
+            boost::allocate_shared_noinit<const
+                type[]>(creator<type>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        boost::weak_ptr<const type[]> other = result;
+        result.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();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[3]> result =
+            boost::allocate_shared_noinit<const
+                type[3]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        boost::weak_ptr<const type[3]> other = result;
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[][2]> result =
+            boost::allocate_shared_noinit<const
+                type[][2]>(creator<type>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<const type[][2]> other = result;
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[2][2]> result =
+            boost::allocate_shared_noinit<const
+                type[2][2]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<const type[2][2]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }

test/allocate_shared_array_test.cpp

@@ -1,209 +1,266 @@
 /*
- * 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>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/align/is_aligned.hpp>
+#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>
 
+template<class T>
+struct creator {
+    typedef T value_type;
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
+    T* allocate(std::size_t size) {
+        return static_cast<T*>(::operator new(sizeof(T) * size));
+    }
+
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
+    }
+};
+
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
+
 class type {
 public:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
-        instances++;
+    type()
+        : value_(0.0) {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
+    }
+
+    void set(long double value) {
+        value_ = value;
+    }
+
+    long double get() const {
+        return value_;
     }
 
 private:
     type(const type&);
     type& operator=(const type&);
+
+    long double value_;
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
-int main() {
+int main()
+{
     {
-        boost::shared_ptr<int[]> a1 = boost::allocate_shared<int[]>(std::allocator<int>(), 3);
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<int[]> result =
+            boost::allocate_shared<int[]>(creator<int>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
-
     {
-        boost::shared_ptr<int[3]> a1 = boost::allocate_shared<int[3]>(std::allocator<int>());
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<int[3]> result =
+            boost::allocate_shared<int[3]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
-
     {
-        boost::shared_ptr<int[][2]> a1 = boost::allocate_shared<int[][2]>(std::allocator<int>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<int[][2]> result =
+            boost::allocate_shared<int[][2]>(creator<int>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
-
     {
-        boost::shared_ptr<int[2][2]> a1 = boost::allocate_shared<int[2][2]>(std::allocator<int>());
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<int[2][2]> result =
+            boost::allocate_shared<int[2][2]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
-
     {
-        boost::shared_ptr<const int[]> a1 = boost::allocate_shared<const int[]>(std::allocator<int>(), 3);
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<const int[]> result =
+            boost::allocate_shared<const int[]>(creator<int>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
-
     {
-        boost::shared_ptr<const int[3]> a1 = boost::allocate_shared<const int[3]>(std::allocator<int>());
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<const int[3]> result =
+            boost::allocate_shared<const int[3]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
-
     {
-        boost::shared_ptr<const int[][2]> a1 = boost::allocate_shared<const int[][2]>(std::allocator<int>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<const int[][2]> result =
+            boost::allocate_shared<const int[][2]>(creator<int>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[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);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<const int[2][2]> result =
+            boost::allocate_shared<const int[2][2]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[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();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[]> result =
+            boost::allocate_shared<type[]>(creator<type>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[]> w1 = result;
+        result.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();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[3]> result =
+            boost::allocate_shared<type[3]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[3]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[3]> w1 = result;
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[][2]> result =
+            boost::allocate_shared<type[][2]>(creator<type>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[2][2]> result =
+            boost::allocate_shared<type[2][2]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.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();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[]> result =
+            boost::allocate_shared<const type[]>(creator<type>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.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();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[3]> result =
+            boost::allocate_shared<const type[3]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[][2]> result =
+            boost::allocate_shared<const type[][2]>(creator<type>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[2][2]> result =
+            boost::allocate_shared<const type[2][2]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }

test/allocate_shared_array_throws_test.cpp

@@ -1,27 +1,63 @@
 /*
- * 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>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
+template<class T>
+struct creator {
+    typedef T value_type;
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
+    T* allocate(std::size_t size) {
+        return static_cast<T*>(::operator new(sizeof(T) * size));
+    }
+
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
+    }
+};
+
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
 
 class type {
 public:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
+    type() {
         if (instances == 5) {
             throw true;
         }
-        instances++;
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -29,72 +65,57 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
-int main() {
-    BOOST_TEST(type::instances == 0);
+int main()
+{
     try {
-        boost::allocate_shared<type[]>(std::allocator<type>(), 6);
+        boost::allocate_shared<type[]>(creator<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::allocate_shared<type[][2]>(creator<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::allocate_shared<type[6]>(creator<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::allocate_shared<type[3][2]>(creator<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::allocate_shared_noinit<type[]>(creator<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::allocate_shared_noinit<type[][2]>(creator<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::allocate_shared_noinit<type[6]>(creator<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::allocate_shared_noinit<type[3][2]>(creator<type>());
         BOOST_ERROR("allocate_shared_noinit did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }

test/allocate_shared_array_value_test.cpp

@@ -1,46 +1,83 @@
 /*
- * 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>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-int main() {
-    {
-        boost::shared_ptr<int[]> a1 = boost::allocate_shared<int[]>(std::allocator<int>(), 4, 1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
+template<class T>
+struct creator {
+    typedef T value_type;
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
+    T* allocate(std::size_t size) {
+        return static_cast<T*>(::operator new(sizeof(T) * size));
     }
 
-    {
-        boost::shared_ptr<int[4]> a1 = boost::allocate_shared<int[4]>(std::allocator<int>(), 1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
     }
+};
 
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
+
+int main()
+{
     {
-        boost::shared_ptr<const int[]> a1 = boost::allocate_shared<const int[]>(std::allocator<int>(), 4, 1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+        boost::shared_ptr<int[]> result =
+            boost::allocate_shared<int[]>(creator<int>(), 4, 1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
     }
-
     {
-        boost::shared_ptr<const int[4]> a1 = boost::allocate_shared<const int[4]>(std::allocator<int>(), 1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+        boost::shared_ptr<int[4]> result =
+            boost::allocate_shared<int[4]>(creator<int>(), 1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
+    }
+    {
+        boost::shared_ptr<const int[]> result =
+            boost::allocate_shared<const int[]>(creator<int>(), 4, 1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
+    }
+    {
+        boost::shared_ptr<const int[4]> result =
+            boost::allocate_shared<const int[4]>(creator<int>(), 1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
     }
-
     return boost::report_errors();
 }

test/allocate_shared_arrays_test.cpp

@@ -1,48 +1,92 @@
 /*
- * 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>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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});
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+template<class T>
+struct creator {
+    typedef T value_type;
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
+    T* allocate(std::size_t size) {
+        return static_cast<T*>(::operator new(sizeof(T) * size));
     }
 
-    {
-        boost::shared_ptr<int[2][2]> a1 = boost::allocate_shared<int[2][2]>(std::allocator<int>(), { 0, 1 });
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
     }
+};
 
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
+
+int main()
+{
     {
-        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);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+        boost::shared_ptr<int[][2]> result =
+            boost::allocate_shared<int[][2]>(creator<int>(), 2, {0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[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);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+        boost::shared_ptr<int[2][2]> result =
+            boost::allocate_shared<int[2][2]>(creator<int>(), {0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 1);
+    }
+    {
+        boost::shared_ptr<const int[][2]> result =
+            boost::allocate_shared<const
+                int[][2]>(creator<int>(), 2, {0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 1);
+    }
+    {
+        boost::shared_ptr<const int[2][2]> result =
+            boost::allocate_shared<const
+                int[2][2]>(creator<int>(), {0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 1);
     }
-#endif
-
     return boost::report_errors();
 }
+#else
+int main()
+{
+    return 0;
+}
+#endif

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 ] );
 }

test/auto_ptr_rv_test.cpp

@@ -1,3 +1,5 @@
+#include <boost/config.hpp>
+
 //
 //  auto_ptr_rv_test.cpp
 //
@@ -8,6 +10,14 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
+#if defined( BOOST_NO_AUTO_PTR )
+
+int main()
+{
+}
+
+#else
+
 #include <boost/shared_ptr.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <memory>
@@ -109,3 +119,5 @@ int main()
 
     return boost::report_errors();
 }
+
+#endif // #if defined( BOOST_NO_AUTO_PTR )

test/cpp11_pointer_cast_test.cpp

@@ -0,0 +1,224 @@
+//
+//  cpp11_pointer_cast_test.cpp - a test for boost/pointer_cast.hpp with std::shared_ptr and std::unique_ptr
+//
+//  Copyright (c) 2016 Karolin Varner
+//
+// 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/pointer_cast.hpp>
+
+#include <boost/config.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/get_pointer.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include <memory>
+#include <utility>
+#include <functional>
+
+#if defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) \
+ || defined( BOOST_NO_CXX11_HDR_FUNCTIONAL ) \
+ || defined( BOOST_NO_CXX11_HDR_UTILITY ) \
+ || defined( BOOST_NO_CXX11_LAMBDAS ) \
+ || defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+// We expect all the features or none of the features to be
+// available, since we should be on C++11
+int main() { return 0; }
+
+#else
+
+namespace
+{
+
+// Let's create these inheritance relationship:
+//
+//    base   base2
+//      |     |
+//      derived
+//         |
+//  derived_derived
+//
+
+class base
+{
+   public:
+   virtual ~base(){}
+   int filler [5];
+};
+
+class base2
+{
+public:
+
+    virtual ~base2(){}
+    int filler [5];
+};
+
+class derived
+   : public base, public base2
+{
+    int filler [5];
+};
+
+class derived_derived
+   : public derived
+{
+    int filler [5];
+};
+
+// And now some simple check functions
+
+#if !defined( BOOST_NO_RTTI )
+
+template <class BasePtr>
+bool check_dynamic_pointer_cast(const BasePtr &ptr)
+{
+   //Check that dynamic_pointer_cast versus dynamic_cast
+   return
+   //Correct cast with dynamic_pointer_cast
+   boost::get_pointer(boost::dynamic_pointer_cast<derived>(ptr)) ==
+      //Correct cast with dynamic_cast
+      dynamic_cast<derived*>(boost::get_pointer(ptr))
+   &&
+   //Incorrect cast with dynamic_pointer_cast
+   boost::get_pointer(boost::dynamic_pointer_cast<derived_derived>(ptr)) ==
+      //Incorrect cast with dynamic_cast
+      dynamic_cast<derived_derived*>(boost::get_pointer(ptr));
+}
+
+#endif
+
+template <class BasePtr>
+bool check_static_pointer_cast(const BasePtr &ptr)
+{
+   return
+   //Cast base -> derived -> base2 using static_pointer_cast
+   boost::get_pointer(
+            boost::static_pointer_cast<base2>(
+               boost::static_pointer_cast<derived>(ptr))) ==
+   //Now the same with static_cast
+   static_cast<base2*>(static_cast<derived*>(boost::get_pointer(ptr)));
+}
+
+template <class BasePtr>
+bool check_const_pointer_cast(const BasePtr &ptr)
+{
+   return
+   //Unconst and const again using const_pointer_cast
+   boost::get_pointer(
+      boost::const_pointer_cast<const base>
+         (boost::const_pointer_cast<base>(ptr))) ==
+   //Now the same with const_cast
+   const_cast<const base*>(const_cast<base*>(boost::get_pointer(ptr)));
+}
+
+template <class BasePtr>
+void check_all_copy_casts(const BasePtr &ptr)
+{
+#if !defined( BOOST_NO_RTTI )
+   BOOST_TEST( check_dynamic_pointer_cast( ptr ) );
+#endif
+   BOOST_TEST( check_static_pointer_cast( ptr ) );
+   BOOST_TEST( check_const_pointer_cast( ptr ) );
+}
+
+
+#if !defined( BOOST_NO_RTTI )
+
+template <class BasePtr>
+bool check_dynamic_moving_pointer_cast(std::function<BasePtr()> f)
+{
+   BasePtr smart1 = f(), smart2 = f();
+   derived* expect1 = dynamic_cast<derived*>(boost::get_pointer(smart1));
+   derived_derived* expect2 = dynamic_cast<derived_derived*>(boost::get_pointer(smart2));
+   //Check that dynamic_pointer_cast versus dynamic_cast
+   return
+   //Correct cast with dynamic_pointer_cast
+   boost::get_pointer(boost::dynamic_pointer_cast<derived>( std::move(smart1) )) == expect1
+   &&
+   //Incorrect cast with dynamic_pointer_cast
+   boost::get_pointer(boost::dynamic_pointer_cast<derived_derived>( std::move(smart2) )) == expect2;
+}
+
+#endif
+
+template <class BasePtr>
+bool check_static_moving_pointer_cast(std::function<BasePtr()> f)
+{
+   BasePtr smart = f();
+   base2 *expect = static_cast<base2*>(static_cast<derived*>(boost::get_pointer(smart)));
+
+   return
+   //Cast base -> derived -> base2 using static_pointer_cast
+   boost::get_pointer(
+            boost::static_pointer_cast<base2>(
+               boost::static_pointer_cast<derived>( std::move(smart) ))) ==
+   //Now the same with static_cast
+   expect;
+}
+
+template <class BasePtr>
+bool check_const_moving_pointer_cast(std::function<BasePtr()> f)
+{
+   BasePtr smart = f();
+   const base *expect = const_cast<const base*>(const_cast<base*>(boost::get_pointer(smart)));
+   return
+   //Unconst and const again using const_pointer_cast
+   boost::get_pointer(
+      boost::const_pointer_cast<const base>
+         (boost::const_pointer_cast<base>( std::move(smart) ))) ==
+   //Now the same with const_cast
+   expect;
+}
+
+template <class BasePtr>
+void check_all_moving_casts(std::function<BasePtr()> f) {
+#if !defined( BOOST_NO_RTTI )
+   BOOST_TEST( check_dynamic_moving_pointer_cast( f ) );
+#endif
+   BOOST_TEST( check_static_moving_pointer_cast( f ) );
+   BOOST_TEST( check_const_moving_pointer_cast( f ) );
+}
+
+}
+
+int main()
+{
+
+   std::shared_ptr<base> std_shared(new derived);
+   boost::shared_ptr<base> boost_shared(new derived);
+   base *plain = boost_shared.get();
+
+   // plain & boost::shared_ptr moving pointer_cast checks; there
+   // is no specific handleing for those types at the moment; this
+   // test just makes sure they won't break when std::move() is used
+   // in generic code
+
+   check_all_moving_casts<boost::shared_ptr<base>>([&boost_shared]() {
+       return boost_shared;
+   });
+
+   check_all_moving_casts<base*>([plain]() {
+       return plain;
+   });
+
+   // std::shared_ptr casts
+
+   check_all_copy_casts(std_shared);
+   check_all_moving_casts<std::shared_ptr<base>>([&std_shared]() {
+       return std_shared;
+   });
+
+   // std::unique_ptr casts
+
+   check_all_moving_casts<std::unique_ptr<base>>([]() {
+       return std::unique_ptr<base>(new derived);
+   });
+
+    return boost::report_errors();
+}
+#endif

test/esft_regtest.cpp

@@ -15,6 +15,7 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include <boost/config.hpp>
 #include <memory>
 #include <string>
 
@@ -77,11 +78,15 @@ void test()
 
     BOOST_TEST( X::instances == 0 );
 
+#if !defined( BOOST_NO_AUTO_PTR )
+
     {
         std::auto_ptr<X> px( new X( 0 ) );
         BOOST_TEST( X::instances == 1 );
     }
 
+#endif
+
     BOOST_TEST( X::instances == 0 );
 
     {

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();
 }
 

test/make_shared_array_esft_test.cpp

@@ -1,26 +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>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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;
+    static unsigned instances;
 
-    explicit type() {
-        instances++;
+    type() {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -28,30 +27,31 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
-int main() {
+int main()
+{
     BOOST_TEST(type::instances == 0);
     {
-        boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>(3);
+        boost::shared_ptr<type[]> result =
+            boost::make_shared<type[]>(3);
         try {
-            a1[0].shared_from_this();
+            result[0].shared_from_this();
             BOOST_ERROR("shared_from_this did not throw");
         } catch (...) {
             BOOST_TEST(type::instances == 3);
         }
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        boost::shared_ptr<type[]> a1 = boost::make_shared_noinit<type[]>(3);
+        boost::shared_ptr<type[3]> result =
+            boost::make_shared_noinit<type[3]>();
         try {
-            a1[0].shared_from_this();
+            result[0].shared_from_this();
             BOOST_ERROR("shared_from_this did not throw");
         } catch (...) {
             BOOST_TEST(type::instances == 3);
         }
     }
-
     return boost::report_errors();
 }

test/make_shared_array_noinit_test.cpp

@@ -1,181 +1,207 @@
 /*
- * 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>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/align/is_aligned.hpp>
+#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;
+    static unsigned instances;
 
-    explicit type() {
-        instances++;
+    type()
+        : value_(0.0) {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
+    }
+
+    void set(long double value) {
+        value_ = value;
+    }
+
+    long double get() const {
+        return value_;
     }
 
 private:
     type(const type&);
     type& operator=(const type&);
+
+    long double value_;
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
-int main() {
+int main()
+{
     {
-        boost::shared_ptr<int[]> a1 = boost::make_shared_noinit<int[]>(3);
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<int[]> result =
+            boost::make_shared_noinit<int[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
     {
-        boost::shared_ptr<int[3]> a1 = boost::make_shared_noinit<int[3]>();
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<int[3]> result =
+            boost::make_shared_noinit<int[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
     {
-        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]> result =
+            boost::make_shared_noinit<int[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
     {
-        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<int[2][2]> result =
+            boost::make_shared_noinit<int[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
     {
-        boost::shared_ptr<const int[]> a1 = boost::make_shared_noinit<const int[]>(3);
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<const int[]> result =
+            boost::make_shared_noinit<const int[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
     {
-        boost::shared_ptr<const int[3]> a1 = boost::make_shared_noinit<const int[3]>();
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<const int[3]> result =
+            boost::make_shared_noinit<const int[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
     {
-        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]> result =
+            boost::make_shared_noinit<const int[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
     {
-        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::shared_ptr<const int[2][2]> result =
+            boost::make_shared_noinit<const int[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
-
-    BOOST_TEST(type::instances == 0);
     {
-        boost::shared_ptr<type[]> a1 = boost::make_shared_noinit<type[]>(3);
-        type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[]> result =
+            boost::make_shared_noinit<type[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[]> other = result;
+        result.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();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[3]> result =
+            boost::make_shared_noinit<type[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[3]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[3]> other = result;
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[][2]> result =
+            boost::make_shared_noinit<type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<type[][2]> other = result;
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[2][2]> result =
+            boost::make_shared_noinit<type[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<type[2][2]> other = result;
+        result.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();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[]> result =
+            boost::make_shared_noinit<const type[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        boost::weak_ptr<const type[]> other = result;
+        result.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();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[3]> result =
+            boost::make_shared_noinit<const type[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        boost::weak_ptr<const type[3]> other = result;
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[][2]> result =
+            boost::make_shared_noinit<const type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<const type[][2]> other = result;
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[2][2]> result =
+            boost::make_shared_noinit<const type[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<const type[2][2]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }

test/make_shared_array_test.cpp

@@ -1,209 +1,229 @@
 /*
- * 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>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/align/is_aligned.hpp>
+#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;
+    static unsigned instances;
 
-    explicit type() {
-        instances++;
+    type()
+        : value_(0.0) {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
+    }
+
+    void set(long double value) {
+        value_ = value;
+    }
+
+    long double get() const {
+        return value_;
     }
 
 private:
     type(const type&);
     type& operator=(const type&);
+
+    long double value_;
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
-int main() {
+int main()
+{
     {
-        boost::shared_ptr<int[]> a1 = boost::make_shared<int[]>(3);
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<int[]> result =
+            boost::make_shared<int[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
-
     {
-        boost::shared_ptr<int[3]> a1 = boost::make_shared<int[3]>();
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<int[3]> result =
+            boost::make_shared<int[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
-
     {
-        boost::shared_ptr<int[][2]> a1 = boost::make_shared<int[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<int[][2]> result =
+            boost::make_shared<int[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
-
     {
-        boost::shared_ptr<int[2][2]> a1 = boost::make_shared<int[2][2]>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<int[2][2]> result =
+            boost::make_shared<int[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
-
     {
-        boost::shared_ptr<const int[]> a1 = boost::make_shared<const int[]>(3);
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<const int[]> result =
+            boost::make_shared<const int[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
-
     {
-        boost::shared_ptr<const int[3]> a1 = boost::make_shared<const int[3]>();
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<const int[3]> result =
+            boost::make_shared<const int[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
-
     {
-        boost::shared_ptr<const int[][2]> a1 = boost::make_shared<const int[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<const int[][2]> result =
+            boost::make_shared<const int[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
-
     {
-        boost::shared_ptr<const int[2][2]> a1 = boost::make_shared<const int[2][2]>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<const int[2][2]> result =
+            boost::make_shared<const int[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
-
-    BOOST_TEST(type::instances == 0);
     {
-        boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>(3);
-        type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[]> result =
+            boost::make_shared<type[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[]> w1 = result;
+        result.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();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[3]> result =
+            boost::make_shared<type[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[3]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[3]> w1 = result;
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[][2]> result =
+            boost::make_shared<type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[2][2]> result =
+            boost::make_shared<type[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.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();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[]> result =
+            boost::make_shared<const type[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.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();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[3]> result =
+            boost::make_shared<const type[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[][2]> result =
+            boost::make_shared<const type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.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);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[2][2]> result =
+            boost::make_shared<const type[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }

test/make_shared_array_throws_test.cpp

@@ -1,27 +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)
- */
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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;
+    static unsigned instances;
 
-    explicit type() {
+    type() {
         if (instances == 5) {
             throw true;
         }
-        instances++;
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -29,72 +28,57 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned 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();
 }

test/make_shared_array_value_test.cpp

@@ -1,46 +1,46 @@
 /*
- * 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)
- */
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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>
 
-int main() {
+int main()
+{
     {
-        boost::shared_ptr<int[]> a1 = boost::make_shared<int[]>(4, 1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+        boost::shared_ptr<int[]> result =
+            boost::make_shared<int[]>(4, 1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
     }
-
     {
-        boost::shared_ptr<int[4]> a1 = boost::make_shared<int[4]>(1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+        boost::shared_ptr<int[4]> result =
+            boost::make_shared<int[4]>(1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
     }
-
     {
-        boost::shared_ptr<const int[]> a1 = boost::make_shared<const int[]>(4, 1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+        boost::shared_ptr<const int[]> result =
+            boost::make_shared<const int[]>(4, 1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
     }
-
     {
-        boost::shared_ptr<const int[4]> a1 = boost::make_shared<const int[4]>(1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+        boost::shared_ptr<const int[4]> result =
+            boost::make_shared<const int[4]>(1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
     }
-
     return boost::report_errors();
 }

test/make_shared_arrays_test.cpp

@@ -1,48 +1,53 @@
 /*
- * 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>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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)
+int main()
+{
     {
-        boost::shared_ptr<int[][2]> a1 = boost::make_shared<int[][2]>(2, {0, 1});
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+        boost::shared_ptr<int[][2]> result =
+            boost::make_shared<int[][2]>(2, {0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 1);
     }
-
     {
-        boost::shared_ptr<int[2][2]> a1 = boost::make_shared<int[2][2]>({ 0, 1 });
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+        boost::shared_ptr<int[2][2]> result =
+            boost::make_shared<int[2][2]>({0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[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);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+        boost::shared_ptr<const int[][2]> result =
+            boost::make_shared<const int[][2]>(2, {0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[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);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+        boost::shared_ptr<const int[2][2]> result =
+            boost::make_shared<const int[2][2]>({0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 1);
     }
-#endif
-
     return boost::report_errors();
 }
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/make_shared_move_emulation_test.cpp

@@ -0,0 +1,81 @@
+// make_shared_move_emulation_test.cpp - a test of make_shared
+//   semi-perfect forwarding of constructor arguments when using a C++03
+//   compiler with move emulation.
+//   Note the "semi": it means moving temporaries (real r-values) doesn't work.
+//
+// Copyright 2016 Giel van Schijndel
+//
+// 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/make_shared.hpp>
+#include <boost/move/core.hpp>
+#include <boost/move/utility_core.hpp>
+#include <boost/shared_ptr.hpp>
+
+class movearg
+{
+private:
+    BOOST_MOVABLE_BUT_NOT_COPYABLE(movearg)
+public:
+    movearg()
+    {}
+    movearg(BOOST_RV_REF(movearg))
+    {}
+    movearg& operator=(BOOST_RV_REF(movearg))
+    {
+        return *this;
+    }
+};
+
+class ByVal
+{
+public:
+    ByVal(movearg) {}
+};
+
+class ByRef
+{
+public:
+    enum constructor_id
+    {
+        move_constructor,
+        const_ref_constructor
+    };
+
+    ByRef(BOOST_RV_REF(movearg)): constructed_by_(move_constructor)
+    {}
+    ByRef(const movearg &arg): constructed_by_(const_ref_constructor)
+    {}
+
+    constructor_id constructed_by_;
+};
+
+int main()
+{
+    {
+        movearg a;
+        boost::shared_ptr< ByVal > x = boost::make_shared< ByVal >(boost::move(a));
+    }
+    {
+        movearg a;
+        boost::shared_ptr< ByRef > x = boost::make_shared< ByRef >(boost::move(a));
+        BOOST_TEST( x->constructed_by_ == ByRef::move_constructor);
+    }
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+    {
+        boost::shared_ptr< ByVal > x = boost::make_shared< ByVal >(movearg());
+        boost::shared_ptr< ByRef > y = boost::make_shared< ByRef >(movearg());
+        BOOST_TEST( y->constructed_by_ == ByRef::move_constructor);
+    }
+#endif // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+    {
+        const movearg ca;
+        boost::shared_ptr< ByRef > x = boost::make_shared< ByRef >(ca);
+        BOOST_TEST( x->constructed_by_ == ByRef::const_ref_constructor);
+    }
+
+    return boost::report_errors();
+}

test/make_shared_msvc_test.cpp

@@ -0,0 +1,19 @@
+//
+//  make_shared_msvc_test.cpp
+//
+//  Copyright 2017 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+//
+
+template<class T> struct value
+{
+};
+
+#include <boost/make_shared.hpp>
+
+int main()
+{
+}

test/make_unique_args_test.cpp

@@ -1,146 +1,155 @@
 /*
- * 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)
- */
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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/core/lightweight_test.hpp>
+#include <boost/smart_ptr/make_unique.hpp>
 
 class type {
 public:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type(int v1 = 0, 
-                  int v2 = 0, 
-                  int v3 = 0, 
-                  int v4 = 0, 
-                  int v5 = 0, 
-                  int v6 = 0, 
-                  int v7 = 0, 
-                  int v8 = 0, 
-                  int v9 = 0) 
-        : sum(v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9) {
-        instances++;
+    type(int v1 = 0,
+         int v2 = 0,
+         int v3 = 0,
+         int v4 = 0,
+         int v5 = 0,
+         int v6 = 0,
+         int v7 = 0,
+         int v8 = 0,
+         int v9 = 0)
+        : sum_(v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9) {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
-    const int sum;
+    int sum() const {
+        return sum_;
+    }
 
 private:
+    int sum_;
+
     type(const type&);
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
-int main() {
+int main()
+{
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>();
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result = boost::make_unique<type>();
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 0);
-        a1.reset();
+        BOOST_TEST(result->sum() == 0);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
-#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES )
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result = boost::make_unique<type>(1);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result = boost::make_unique<type>(1, 2);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2, 3);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>(1, 2, 3);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2 + 3);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2 + 3);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2, 3, 4);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>(1, 2, 3, 4);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2 + 3 + 4);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2 + 3 + 4);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2, 3, 4, 5);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>(1, 2, 3, 4, 5);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2 + 3 + 4 + 5);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2 + 3 + 4 + 5);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2, 3, 4, 5, 6);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>(1, 2, 3, 4, 5, 6);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2 + 3 + 4 + 5 + 6);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2 + 3 + 4 + 5 + 6);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2, 3, 4, 5, 6, 7);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>(1, 2, 3, 4, 5, 6, 7);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2 + 3 + 4 + 5 + 6 + 7);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2 + 3 + 4 + 5 + 6 + 7);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2, 3, 4, 5, 6, 7, 8);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>(1, 2, 3, 4, 5, 6, 7, 8);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2, 3, 4, 5, 6, 7, 8, 9);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>(1, 2, 3, 4, 5, 6, 7, 8, 9);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 #endif
-
     return boost::report_errors();
 }
 #else
-
-int main() {
+int main()
+{
     return 0;
 }
-
 #endif

test/make_unique_array_noinit_test.cpp

@@ -1,26 +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)
- */
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
-        instances++;
+    type() {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -28,61 +27,61 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
-int main() {
+int main()
+{
     {
-        std::unique_ptr<int[]> a1 = boost::make_unique_noinit<int[]>(3);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<int[]> result =
+            boost::make_unique_noinit<int[]>(3);
+        BOOST_TEST(result.get() != 0);
     }
-
     {
-        std::unique_ptr<int[][2]> a1 = boost::make_unique_noinit<int[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<int[][2]> result =
+            boost::make_unique_noinit<int[][2]>(2);
+        BOOST_TEST(result.get() != 0);
     }
-    
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<type[]> a1 = boost::make_unique_noinit<type[]>(3);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type[]> result =
+            boost::make_unique_noinit<type[]>(3);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<type[][2]> a1 = boost::make_unique_noinit<type[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type[][2]> result =
+            boost::make_unique_noinit<type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<const type[]> a1 = boost::make_unique_noinit<const type[]>(3);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<const type[]> result =
+            boost::make_unique_noinit<const type[]>(3);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<const type[][2]> a1 = boost::make_unique_noinit<const type[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<const type[][2]> result =
+            boost::make_unique_noinit<const type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }
 #else
-
-int main() {
+int main()
+{
     return 0;
 }
-
 #endif

test/make_unique_array_test.cpp

@@ -1,26 +1,25 @@
 /*
- * 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)
- */
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
-        instances++;
+    type() {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -28,85 +27,84 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
-int main() {
+int main()
+{
     {
-        std::unique_ptr<int[]> a1 = boost::make_unique<int[]>(3);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        std::unique_ptr<int[]> result = boost::make_unique<int[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
-
     {
-        std::unique_ptr<int[][2]> a1 = boost::make_unique<int[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        std::unique_ptr<int[][2]> result =
+            boost::make_unique<int[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
-
     {
-        std::unique_ptr<const int[]> a1 = boost::make_unique<const int[]>(3);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        std::unique_ptr<const int[]> result =
+            boost::make_unique<const int[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
-
     {
-        std::unique_ptr<const int[][2]> a1 = boost::make_unique<const int[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        std::unique_ptr<const int[][2]> result =
+            boost::make_unique<const int[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<type[]> a1 = boost::make_unique<type[]>(3);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type[]> result =
+            boost::make_unique<type[]>(3);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<type[][2]> a1 = boost::make_unique<type[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type[][2]> result =
+            boost::make_unique<type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<const type[]> a1 = boost::make_unique<const type[]>(3);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<const type[]> result =
+            boost::make_unique<const type[]>(3);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<const type[][2]> a1 = boost::make_unique<const type[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<const type[][2]> result =
+            boost::make_unique<const type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }
 #else
-
-int main() {
+int main()
+{
     return 0;
 }
-
 #endif

test/make_unique_array_throws_test.cpp

@@ -1,29 +1,28 @@
 /*
- * 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)
- */
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
+    type() {
         if (instances == 5) {
             throw true;
         }
-        instances++;
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -31,9 +30,10 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
-int main() {
+int main()
+{
     BOOST_TEST(type::instances == 0);
     try {
         boost::make_unique<type[]>(6);
@@ -41,7 +41,6 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     try {
         boost::make_unique<type[][2]>(3);
@@ -49,7 +48,6 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     try {
         boost::make_unique_noinit<type[]>(6);
@@ -57,7 +55,6 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     try {
         boost::make_unique_noinit<type[][2]>(3);
@@ -65,13 +62,11 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }
 #else
-
-int main() {
+int main()
+{
     return 0;
 }
-
 #endif

test/make_unique_noinit_test.cpp

@@ -1,26 +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)
- */
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
-        instances++;
+    type() {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -28,38 +27,37 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
-int main() {
+int main()
+{
     {
-        std::unique_ptr<int> a1 = boost::make_unique_noinit<int>();
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<int> result = boost::make_unique_noinit<int>();
+        BOOST_TEST(result.get() != 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<type> a1 = boost::make_unique_noinit<type>();
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique_noinit<type>();
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<const type> a1 = boost::make_unique_noinit<const type>();
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<const type> result =
+            boost::make_unique_noinit<const type>();
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }
 #else
-
-int main() {
+int main()
+{
     return 0;
 }
-
 #endif

test/make_unique_test.cpp

@@ -1,26 +1,25 @@
 /*
- * 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)
- */
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
-        instances++;
+    type() {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -28,45 +27,44 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
-int main() {
+int main()
+{
     {
-        std::unique_ptr<int> a1 = boost::make_unique<int>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(*a1 == 0);
+        std::unique_ptr<int> result = boost::make_unique<int>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(*result == 0);
     }
-
     {
-        std::unique_ptr<const int> a1 = boost::make_unique<const int>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(*a1 == 0);
+        std::unique_ptr<const int> result =
+            boost::make_unique<const int>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(*result == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>();
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>();
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<const type> a1 = boost::make_unique<const type>();
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<const type> result =
+            boost::make_unique<const type>();
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }
 #else
-
-int main() {
+int main()
+{
     return 0;
 }
-
 #endif

test/make_unique_throws_test.cpp

@@ -1,29 +1,28 @@
 /*
- * 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)
- */
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
+    type() {
         if (instances == 0) {
             throw true;
         }
-        instances++;
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -31,9 +30,10 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
-int main() {
+int main()
+{
     BOOST_TEST(type::instances == 0);
     try {
         boost::make_unique<type>();
@@ -41,13 +41,11 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }
 #else
-
-int main() {
+int main()
+{
     return 0;
 }
-
 #endif

test/make_unique_value_test.cpp

@@ -1,58 +1,56 @@
 /*
- * 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)
- */
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.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);
-        BOOST_TEST(a1->x == 0);
-        BOOST_TEST(a1->y == 0);
+        std::unique_ptr<type> result = boost::make_unique<type>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result->x == 0);
+        BOOST_TEST(result->y == 0);
     }
-
     {
-        std::unique_ptr<const type> a1 = boost::make_unique<const type>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1->x == 0);
-        BOOST_TEST(a1->y == 0);
+        std::unique_ptr<const type> result =
+            boost::make_unique<const type>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result->x == 0);
+        BOOST_TEST(result->y == 0);
     }
-
 #if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>({ 1, 2 });
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1->x == 1);
-        BOOST_TEST(a1->y == 2);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>({ 1, 2 });
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result->x == 1);
+        BOOST_TEST(result->y == 2);
     }
-
     {
-        std::unique_ptr<const type> a1 = boost::make_unique<const type>({ 1, 2 });
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1->x == 1);
-        BOOST_TEST(a1->y == 2);
+        std::unique_ptr<const type> result =
+            boost::make_unique<const type>({ 1, 2 });
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result->x == 1);
+        BOOST_TEST(result->y == 2);
     }
 #endif
-
     return boost::report_errors();
 }
 #else
-
-int main() {
+int main()
+{
     return 0;
 }
-
 #endif

test/pointer_cast_co_fail.cpp

@@ -0,0 +1,18 @@
+//
+//  A negative test for unique_ptr const_cast
+//
+//  Copyright 2016 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/pointer_cast.hpp>
+#include <memory>
+
+int main()
+{
+    std::unique_ptr<int> p1( new int );
+    std::unique_ptr<int[]> p2 = boost::const_pointer_cast<int[]>( std::move( p1 ) );
+}

test/pointer_cast_co_fail2.cpp

@@ -0,0 +1,18 @@
+//
+//  A negative test for unique_ptr const_cast
+//
+//  Copyright 2016 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/pointer_cast.hpp>
+#include <memory>
+
+int main()
+{
+    std::unique_ptr<int[]> p1( new int[ 1 ] );
+    std::unique_ptr<int> p2 = boost::const_pointer_cast<int>( std::move( p1 ) );
+}

test/pointer_cast_co_fail3.cpp

@@ -0,0 +1,29 @@
+//
+//  A negative test for unique_ptr const_cast
+//
+//  Copyright 2016 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/pointer_cast.hpp>
+#include <memory>
+
+struct B
+{
+    virtual ~B()
+    {
+    }
+};
+
+struct D: B
+{
+};
+
+int main()
+{
+    std::unique_ptr<D[]> p1( new D[ 1 ] );
+    std::unique_ptr<B[]> p2 = boost::const_pointer_cast<B[]>( std::move( p1 ) );
+}

test/pointer_cast_dy_fail.cpp

@@ -0,0 +1,25 @@
+//
+//  A negative test for unique_ptr dynamic_cast
+//
+//  Copyright 2016 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/pointer_cast.hpp>
+#include <memory>
+
+struct B
+{
+    virtual ~B()
+    {
+    }
+};
+
+int main()
+{
+    std::unique_ptr<B> p1( new B );
+    std::unique_ptr<B[]> p2 = boost::dynamic_pointer_cast<B[]>( std::move( p1 ) );
+}

test/pointer_cast_dy_fail2.cpp

@@ -0,0 +1,25 @@
+//
+//  A negative test for unique_ptr dynamic_cast
+//
+//  Copyright 2016 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/pointer_cast.hpp>
+#include <memory>
+
+struct B
+{
+    virtual ~B()
+    {
+    }
+};
+
+int main()
+{
+    std::unique_ptr<B[]> p1( new B[ 1 ] );
+    std::unique_ptr<B> p2 = boost::dynamic_pointer_cast<B>( std::move( p1 ) );
+}

test/pointer_cast_dy_fail3.cpp

@@ -0,0 +1,29 @@
+//
+//  A negative test for unique_ptr dynamic_cast
+//
+//  Copyright 2016 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/pointer_cast.hpp>
+#include <memory>
+
+struct B
+{
+    virtual ~B()
+    {
+    }
+};
+
+struct D: B
+{
+};
+
+int main()
+{
+    std::unique_ptr<D[]> p1( new D[ 1 ] );
+    std::unique_ptr<B[]> p2 = boost::dynamic_pointer_cast<B[]>( std::move( p1 ) );
+}

test/pointer_cast_st_fail.cpp

@@ -0,0 +1,18 @@
+//
+//  A negative test for unique_ptr static_cast
+//
+//  Copyright 2016 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/pointer_cast.hpp>
+#include <memory>
+
+int main()
+{
+    std::unique_ptr<int> p1( new int );
+    std::unique_ptr<int[]> p2 = boost::static_pointer_cast<int[]>( std::move( p1 ) );
+}

test/pointer_cast_st_fail2.cpp

@@ -0,0 +1,18 @@
+//
+//  A negative test for unique_ptr static_cast
+//
+//  Copyright 2016 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/pointer_cast.hpp>
+#include <memory>
+
+int main()
+{
+    std::unique_ptr<int[]> p1( new int[ 1 ] );
+    std::unique_ptr<int> p2 = boost::static_pointer_cast<int>( std::move( p1 ) );
+}

test/pointer_cast_st_fail3.cpp

@@ -0,0 +1,29 @@
+//
+//  A negative test for unique_ptr static_cast
+//
+//  Copyright 2016 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/pointer_cast.hpp>
+#include <memory>
+
+struct B
+{
+    virtual ~B()
+    {
+    }
+};
+
+struct D: B
+{
+};
+
+int main()
+{
+    std::unique_ptr<D[]> p1( new D[ 1 ] );
+    std::unique_ptr<B[]> p2 = boost::static_pointer_cast<B[]>( std::move( p1 ) );
+}

test/pointer_cast_test.cpp

@@ -104,33 +104,25 @@ bool check_const_pointer_cast(const BasePtr &ptr)
    const_cast<const base*>(const_cast<base*>(boost::get_pointer(ptr)));
 }
 
+template <class BasePtr>
+void check_all_casts(const BasePtr &ptr)
+{
+#if !defined( BOOST_NO_RTTI )
+    BOOST_TEST( check_dynamic_pointer_cast( ptr ) );
+#endif
+    BOOST_TEST( check_static_pointer_cast( ptr ) );
+    BOOST_TEST( check_const_pointer_cast( ptr ) );
+}
+
 }
 
 int main()
 {
-    {
-        // Try casts with shared_ptr
+    boost::shared_ptr<base> boost_shared(new derived);
+    base *plain = boost_shared.get();
 
-        boost::shared_ptr<base> ptr(new derived);
-
-#if !defined( BOOST_NO_RTTI )
-        BOOST_TEST( check_dynamic_pointer_cast( ptr ) );
-#endif
-        BOOST_TEST( check_static_pointer_cast( ptr ) );
-        BOOST_TEST( check_const_pointer_cast( ptr ) );
-    }
-   
-    {
-        // Try casts with raw pointer
-
-        boost::scoped_ptr<base> ptr(new derived);
-
-#if !defined( BOOST_NO_RTTI )
-        BOOST_TEST( check_dynamic_pointer_cast( ptr.get() ) );
-#endif
-        BOOST_TEST( check_static_pointer_cast( ptr.get() ) );
-        BOOST_TEST( check_const_pointer_cast( ptr.get() ) );
-    }
+    check_all_casts(boost_shared);
+    check_all_casts(plain);
     
     return boost::report_errors();
 }