From ddfcc5f4170f8d0c89bfbba29ebac5994c9061a9 Mon Sep 17 00:00:00 2001
From: Glen Fernandes <glenfe@live.com>
Date: Sun, 18 Nov 2012 02:51:06 +0000
Subject: [PATCH] Make make_shared_array.hpp and allocate_shared_array.hpp
 consistent with namespace qualification in rest of smart_ptr.

[SVN r81409]
---
 .../boost/smart_ptr/allocate_shared_array.hpp | 160 +++++++-------
 .../detail/allocate_array_helper.hpp          |   4 +-
 .../smart_ptr/detail/make_array_helper.hpp    |   2 +-
 include/boost/smart_ptr/make_shared_array.hpp | 200 +++++++++---------
 4 files changed, 183 insertions(+), 183 deletions(-)

diff --git a/include/boost/smart_ptr/allocate_shared_array.hpp b/include/boost/smart_ptr/allocate_shared_array.hpp
index cc894e7..e6fa081 100644
--- a/include/boost/smart_ptr/allocate_shared_array.hpp
+++ b/include/boost/smart_ptr/allocate_shared_array.hpp
@@ -13,154 +13,154 @@
 #include <boost/smart_ptr/detail/allocate_array_helper.hpp>
 #include <boost/smart_ptr/detail/array_deleter.hpp>
 #include <boost/smart_ptr/detail/array_traits.hpp>
-#include <boost/smart_ptr/detail/sp_if_array.hpp>
 #include <boost/smart_ptr/detail/sp_forward.hpp>
+#include <boost/smart_ptr/detail/sp_if_array.hpp>
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>
 #endif
 
 namespace boost {
     template<typename T, typename A>
-    inline typename detail::sp_if_array<T>::type 
+    inline typename boost::detail::sp_if_array<T>::type 
     allocate_shared(const A& allocator, std::size_t size) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         T1* p1 = 0;
         T2* p2 = 0;
-        std::size_t n1 = size * detail::array_total<T1>::size;
-        detail::allocate_array_helper<A, T2> a1(allocator, n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;
+        std::size_t n1 = size * boost::detail::array_total<T1>::size;
+        boost::detail::allocate_array_helper<A, T2> a1(allocator, n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
         d2->construct(p2, n1);
-        return shared_ptr<T>(s1, p1);
+        return boost::shared_ptr<T>(s1, p1);
     }
 #if defined(BOOST_HAS_VARIADIC_TMPL) && defined(BOOST_HAS_RVALUE_REFS)
     template<typename T, typename A, typename... Args>
-    inline typename detail::sp_if_array<T>::type
+    inline typename boost::detail::sp_if_array<T>::type
     allocate_shared(const A& allocator, std::size_t size, Args&&... args) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         T1* p1 = 0;
         T2* p2 = 0;
-        std::size_t n1 = size * detail::array_total<T1>::size;
-        detail::allocate_array_helper<A, T2> a1(allocator, n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;
+        std::size_t n1 = size * boost::detail::array_total<T1>::size;
+        boost::detail::allocate_array_helper<A, T2> a1(allocator, n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
-        d2->construct(p2, n1, detail::sp_forward<Args>(args)...);
-        return shared_ptr<T>(s1, p1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
+        d2->construct(p2, n1, boost::detail::sp_forward<Args>(args)...);
+        return boost::shared_ptr<T>(s1, p1);
     }
     template<typename T, typename A, typename... Args>
-    inline typename detail::sp_if_size_array<T>::type
+    inline typename boost::detail::sp_if_size_array<T>::type
     allocate_shared(const A& allocator, Args&&... args) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         T1* p1 = 0;
         T2* p2 = 0;
-        std::size_t n1 = detail::array_total<T>::size;
-        detail::allocate_array_helper<A, T2> a1(allocator, n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;
+        std::size_t n1 = boost::detail::array_total<T>::size;
+        boost::detail::allocate_array_helper<A, T2> a1(allocator, n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
-        d2->construct(p2, n1, detail::sp_forward<Args>(args)...);
-        return shared_ptr<T>(s1, p1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
+        d2->construct(p2, n1, boost::detail::sp_forward<Args>(args)...);
+        return boost::shared_ptr<T>(s1, p1);
     }
 #endif
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
     template<typename T, typename A>
-    inline typename detail::sp_if_array<T>::type
+    inline typename boost::detail::sp_if_array<T>::type
     allocate_shared(const A& allocator, 
-        std::initializer_list<typename detail::array_inner<T>::type> list) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+        std::initializer_list<typename boost::detail::array_inner<T>::type> list) {
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         typedef const T2 T3;
         T1* p1 = 0;
         T2* p2 = 0;
         T3* p3 = 0;
-        std::size_t n1 = list.size() * detail::array_total<T1>::size;
-        detail::allocate_array_helper<A, T2> a1(allocator, n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;
+        std::size_t n1 = list.size() * boost::detail::array_total<T1>::size;
+        boost::detail::allocate_array_helper<A, T2> a1(allocator, n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;
         p3 = reinterpret_cast<T3*>(list.begin());
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
         d2->construct_list(p2, n1, p3);
-        return shared_ptr<T>(s1, p1);
+        return boost::shared_ptr<T>(s1, p1);
     }
     template<typename T, typename A>
-    inline typename detail::sp_if_size_array<T>::type
+    inline typename boost::detail::sp_if_size_array<T>::type
     allocate_shared(const A& allocator, 
-        std::initializer_list<typename detail::array_inner<T>::type> list) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+        std::initializer_list<typename boost::detail::array_inner<T>::type> list) {
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         typedef const T2 T3;
-        BOOST_ASSERT(list.size() == detail::array_size<T>::size);
+        BOOST_ASSERT(list.size() == boost::detail::array_size<T>::size);
         T1* p1 = 0;
         T2* p2 = 0;
         T3* p3 = 0;
-        std::size_t n1 = detail::array_total<T>::size;
-        detail::allocate_array_helper<A, T2> a1(allocator, n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;
+        std::size_t n1 = boost::detail::array_total<T>::size;
+        boost::detail::allocate_array_helper<A, T2> a1(allocator, n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;
         p3 = reinterpret_cast<T3*>(list.begin());
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
         d2->construct_list(p2, n1, p3);
-        return shared_ptr<T>(s1, p1);
+        return boost::shared_ptr<T>(s1, p1);
     }
     template<typename T, typename A>
-    inline typename detail::sp_if_array<T>::type
+    inline typename boost::detail::sp_if_array<T>::type
     allocate_shared(const A& allocator, std::size_t size, 
-        std::initializer_list<typename detail::arrays_inner<T>::type> list) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+        std::initializer_list<typename boost::detail::arrays_inner<T>::type> list) {
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         typedef const T2 T3;
         T1* p1 = 0;
         T2* p2 = 0;
         T3* p3 = 0;
-        std::size_t n0 = detail::array_total<T1>::size;
+        std::size_t n0 = boost::detail::array_total<T1>::size;
         std::size_t n1 = n0 * list.size();
-        detail::allocate_array_helper<A, T2> a1(allocator, n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;
+        boost::detail::allocate_array_helper<A, T2> a1(allocator, n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;
         p3 = reinterpret_cast<T3*>(list.begin());
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
         d2->construct_list(p2, n1, p3, n0);
-        return shared_ptr<T>(s1, p1);
+        return boost::shared_ptr<T>(s1, p1);
     }
     template<typename T, typename A>
-    inline typename detail::sp_if_size_array<T>::type
+    inline typename boost::detail::sp_if_size_array<T>::type
     allocate_shared(const A& allocator, 
-        std::initializer_list<typename detail::arrays_inner<T>::type> list) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+        std::initializer_list<typename boost::detail::arrays_inner<T>::type> list) {
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         typedef const T2 T3;
-        BOOST_ASSERT(list.size() == detail::array_size<T1>::size);
+        BOOST_ASSERT(list.size() == boost::detail::array_size<T1>::size);
         T1* p1 = 0;
         T2* p2 = 0;
         T3* p3 = 0;
-        std::size_t n0 = detail::array_total<T1>::size;
-        std::size_t n1 = detail::array_total<T>::size;
-        detail::allocate_array_helper<A, T2> a1(allocator, n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;
+        std::size_t n0 = boost::detail::array_total<T1>::size;
+        std::size_t n1 = boost::detail::array_total<T>::size;
+        boost::detail::allocate_array_helper<A, T2> a1(allocator, n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;
         p3 = reinterpret_cast<T3*>(list.begin());
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
         d2->construct_list(p2, n1, p3, n0);
-        return shared_ptr<T>(s1, p1);
+        return boost::shared_ptr<T>(s1, p1);
     }
 #endif
 }
diff --git a/include/boost/smart_ptr/detail/allocate_array_helper.hpp b/include/boost/smart_ptr/detail/allocate_array_helper.hpp
index bfb4dec..dee34ad 100644
--- a/include/boost/smart_ptr/detail/allocate_array_helper.hpp
+++ b/include/boost/smart_ptr/detail/allocate_array_helper.hpp
@@ -57,7 +57,7 @@ namespace boost {
                 return allocator.max_size();
             }
             pointer allocate(size_type count, const void* value = 0) {
-                std::size_t a1 = alignment_of<T>::value;
+                std::size_t a1 = boost::alignment_of<T>::value;
                 std::size_t n1 = count * sizeof(Y) + a1 - 1;
                 char*  p1 = A3(allocator).allocate(n1 + size, value);
                 char*  p2 = p1 + n1;
@@ -68,7 +68,7 @@ namespace boost {
                 return  reinterpret_cast<Y*>(p1);
             }
             void deallocate(pointer memory, size_type count) {
-                std::size_t a1 = alignment_of<T>::value;
+                std::size_t a1 = boost::alignment_of<T>::value;
                 std::size_t n1 = count * sizeof(Y) + a1 - 1;
                 char*  p1 = reinterpret_cast<char*>(memory);
                 A3(allocator).deallocate(p1, n1 + size);
diff --git a/include/boost/smart_ptr/detail/make_array_helper.hpp b/include/boost/smart_ptr/detail/make_array_helper.hpp
index 96fa3f9..4d92be3 100644
--- a/include/boost/smart_ptr/detail/make_array_helper.hpp
+++ b/include/boost/smart_ptr/detail/make_array_helper.hpp
@@ -52,7 +52,7 @@ namespace boost {
                 return static_cast<std::size_t>(-1) / sizeof(Y);
             }
             pointer allocate(size_type count, const void* = 0) {
-                std::size_t a1 = alignment_of<T>::value;
+                std::size_t a1 = boost::alignment_of<T>::value;
                 std::size_t n1 = count * sizeof(Y) + a1 - 1;
                 void*  p1 = ::operator new(n1 + size);
                 char*  p2 = static_cast<char*>(p1) + n1;
diff --git a/include/boost/smart_ptr/make_shared_array.hpp b/include/boost/smart_ptr/make_shared_array.hpp
index 8422150..36e0ddd 100644
--- a/include/boost/smart_ptr/make_shared_array.hpp
+++ b/include/boost/smart_ptr/make_shared_array.hpp
@@ -13,186 +13,186 @@
 #include <boost/smart_ptr/detail/array_deleter.hpp>
 #include <boost/smart_ptr/detail/array_traits.hpp>
 #include <boost/smart_ptr/detail/make_array_helper.hpp>
-#include <boost/smart_ptr/detail/sp_if_array.hpp>
 #include <boost/smart_ptr/detail/sp_forward.hpp>
+#include <boost/smart_ptr/detail/sp_if_array.hpp>
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>
 #endif
 
 namespace boost {
     template<typename T>
-    inline typename detail::sp_if_array<T>::type
+    inline typename boost::detail::sp_if_array<T>::type
     make_shared(std::size_t size) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         T1* p1 = 0;
         T2* p2 = 0;
-        std::size_t n1 = size * detail::array_total<T1>::size;
-        detail::make_array_helper<T2> a1(n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;
+        std::size_t n1 = size * boost::detail::array_total<T1>::size;
+        boost::detail::make_array_helper<T2> a1(n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;
         p1 = reinterpret_cast<T1*>(p2);        
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
         d2->construct(p2, n1);
-        return shared_ptr<T>(s1, p1);
+        return boost::shared_ptr<T>(s1, p1);
     }
 #if defined(BOOST_HAS_VARIADIC_TMPL) && defined(BOOST_HAS_RVALUE_REFS)
     template<typename T, typename... Args>
-    inline typename detail::sp_if_array<T>::type
+    inline typename boost::detail::sp_if_array<T>::type
     make_shared(std::size_t size, Args&&... args) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         T1* p1 = 0;
         T2* p2 = 0;
-        std::size_t n1 = size * detail::array_total<T1>::size;
-        detail::make_array_helper<T2> a1(n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;
+        std::size_t n1 = size * boost::detail::array_total<T1>::size;
+        boost::detail::make_array_helper<T2> a1(n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;
         p1 = reinterpret_cast<T1*>(p2);        
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
-        d2->construct(p2, n1, detail::sp_forward<Args>(args)...);
-        return shared_ptr<T>(s1, p1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
+        d2->construct(p2, n1, boost::detail::sp_forward<Args>(args)...);
+        return boost::shared_ptr<T>(s1, p1);
     }
     template<typename T, typename... Args>
-    inline typename detail::sp_if_size_array<T>::type
+    inline typename boost::detail::sp_if_size_array<T>::type
     make_shared(Args&&... args) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         T1* p1 = 0;
         T2* p2 = 0;
-        std::size_t n1 = detail::array_total<T>::size;
-        detail::make_array_helper<T2> a1(n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;
+        std::size_t n1 = boost::detail::array_total<T>::size;
+        boost::detail::make_array_helper<T2> a1(n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;
         p1 = reinterpret_cast<T1*>(p2);        
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
-        d2->construct(p2, n1, detail::sp_forward<Args>(args)...);
-        return shared_ptr<T>(s1, p1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
+        d2->construct(p2, n1, boost::detail::sp_forward<Args>(args)...);
+        return boost::shared_ptr<T>(s1, p1);
     }
 #endif
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
     template<typename T>
-    inline typename detail::sp_if_array<T>::type
-    make_shared(std::initializer_list<typename detail::array_inner<T>::type> list) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+    inline typename boost::detail::sp_if_array<T>::type
+    make_shared(std::initializer_list<typename boost::detail::array_inner<T>::type> list) {
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         typedef const T2 T3;
         T1* p1 = 0;
         T2* p2 = 0;
         T3* p3 = 0;
-        std::size_t n1 = list.size() * detail::array_total<T1>::size;
-        detail::make_array_helper<T2> a1(n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;        
+        std::size_t n1 = list.size() * boost::detail::array_total<T1>::size;
+        boost::detail::make_array_helper<T2> a1(n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;        
         p3 = reinterpret_cast<T3*>(list.begin());
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
         d2->construct_list(p2, n1, p3);
-        return shared_ptr<T>(s1, p1);
+        return boost::shared_ptr<T>(s1, p1);
     }
     template<typename T>
-    inline typename detail::sp_if_size_array<T>::type
-    make_shared(std::initializer_list<typename detail::array_inner<T>::type> list) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+    inline typename boost::detail::sp_if_size_array<T>::type
+    make_shared(std::initializer_list<typename boost::detail::array_inner<T>::type> list) {
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         typedef const T2 T3;
-        BOOST_ASSERT(list.size() == detail::array_size<T>::size);
+        BOOST_ASSERT(list.size() == boost::detail::array_size<T>::size);
         T1* p1 = 0;
         T2* p2 = 0;
         T3* p3 = 0;
-        std::size_t n1 = detail::array_total<T>::size;
-        detail::make_array_helper<T2> a1(n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;        
+        std::size_t n1 = boost::detail::array_total<T>::size;
+        boost::detail::make_array_helper<T2> a1(n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;        
         p3 = reinterpret_cast<T3*>(list.begin());
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
         d2->construct_list(p2, n1, p3);
-        return shared_ptr<T>(s1, p1);
+        return boost::shared_ptr<T>(s1, p1);
     }
     template<typename T>
-    inline typename detail::sp_if_array<T>::type
+    inline typename boost::detail::sp_if_array<T>::type
     make_shared(std::size_t size, 
-        std::initializer_list<typename detail::arrays_inner<T>::type> list) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+        std::initializer_list<typename boost::detail::arrays_inner<T>::type> list) {
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         typedef const T2 T3;
         T1* p1 = 0;
         T2* p2 = 0;
         T3* p3 = 0;
-        std::size_t n0 = detail::array_total<T1>::size;
+        std::size_t n0 = boost::detail::array_total<T1>::size;
         std::size_t n1 = n0 * size;
-        detail::make_array_helper<T2> a1(n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;        
+        boost::detail::make_array_helper<T2> a1(n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;        
         p3 = reinterpret_cast<T3*>(list.begin());
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
         d2->construct_list(p2, n1, p3, n0);
-        return shared_ptr<T>(s1, p1);
+        return boost::shared_ptr<T>(s1, p1);
     }
     template<typename T>
-    inline typename detail::sp_if_size_array<T>::type
-    make_shared(std::initializer_list<typename detail::arrays_inner<T>::type> list) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+    inline typename boost::detail::sp_if_size_array<T>::type
+    make_shared(std::initializer_list<typename boost::detail::arrays_inner<T>::type> list) {
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         typedef const T2 T3;
-        BOOST_ASSERT(list.size() == detail::array_size<T1>::size);
+        BOOST_ASSERT(list.size() == boost::detail::array_size<T1>::size);
         T1* p1 = 0;
         T2* p2 = 0;
         T3* p3 = 0;
-        std::size_t n0 = detail::array_total<T1>::size;
-        std::size_t n1 = detail::array_total<T>::size;
-        detail::make_array_helper<T2> a1(n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;        
+        std::size_t n0 = boost::detail::array_total<T1>::size;
+        std::size_t n1 = boost::detail::array_total<T>::size;
+        boost::detail::make_array_helper<T2> a1(n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;        
         p3 = reinterpret_cast<T3*>(list.begin());
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
         d2->construct_list(p2, n1, p3, n0);
-        return shared_ptr<T>(s1, p1);
+        return boost::shared_ptr<T>(s1, p1);
     }
 #endif
     template<typename T>
-    inline typename detail::sp_if_array<T>::type
+    inline typename boost::detail::sp_if_array<T>::type
     make_shared_noinit(std::size_t size) {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         T1* p1 = 0;
         T2* p2 = 0;
-        std::size_t n1 = size * detail::array_total<T1>::size;
-        detail::make_array_helper<T2> a1(n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;
+        std::size_t n1 = size * boost::detail::array_total<T1>::size;
+        boost::detail::make_array_helper<T2> a1(n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;
         p1 = reinterpret_cast<T1*>(p2);        
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
         d2->construct_noinit(p2, n1);
-        return shared_ptr<T>(s1, p1);
+        return boost::shared_ptr<T>(s1, p1);
     }
     template<typename T>
-    inline typename detail::sp_if_size_array<T>::type
+    inline typename boost::detail::sp_if_size_array<T>::type
     make_shared_noinit() {
-        typedef typename detail::array_inner<T>::type T1;
-        typedef typename detail::array_base<T1>::type T2;
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
         T1* p1 = 0;
         T2* p2 = 0;
-        std::size_t n1 = detail::array_total<T>::size;
-        detail::make_array_helper<T2> a1(n1, &p2);
-        detail::array_deleter<T2> d1;
-        shared_ptr<T> s1(p1, d1, a1);
-        detail::array_deleter<T2>* d2;
+        std::size_t n1 = boost::detail::array_total<T>::size;
+        boost::detail::make_array_helper<T2> a1(n1, &p2);
+        boost::detail::array_deleter<T2> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        boost::detail::array_deleter<T2>* d2;
         p1 = reinterpret_cast<T1*>(p2);        
-        d2 = get_deleter<detail::array_deleter<T2> >(s1);
+        d2 = get_deleter<boost::detail::array_deleter<T2> >(s1);
         d2->construct_noinit(p2, n1);
-        return shared_ptr<T>(s1, p1);
+        return boost::shared_ptr<T>(s1, p1);
     }
 }