From 364ee17476d4f7138afda77c46b46182586dec29 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ion=20Gazta=C3=B1aga?= <igaztanaga@gmail.com>
Date: Wed, 27 Aug 2014 23:21:36 +0200
Subject: [PATCH] Simplified and improved unique_ptr implementation: - No array
 specialization to avoid code duplication - Constructible and assignable from
 literal zero

---
 doc/Jamfile.v2                           |   5 +
 include/boost/move/detail/meta_utils.hpp |  84 +--
 include/boost/move/detail/workaround.hpp |   4 +
 include/boost/move/unique_ptr.hpp        | 904 ++++++++---------------
 test/unique_ptr.cpp                      | 144 +++-
 test/unique_ptr_default_deleter.cpp      |   4 -
 test/unique_ptr_functions.cpp            | 121 ++-
 7 files changed, 571 insertions(+), 695 deletions(-)

diff --git a/doc/Jamfile.v2 b/doc/Jamfile.v2
index 4218cc3..29d3661 100644
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@@ -24,7 +24,12 @@ doxygen autodoc
    <doxygen:param>"PREDEFINED=\"BOOST_MOVE_DOXYGEN_INVOKED\" \\
                               \"BOOST_MOVE_SEEDOC(T)=see_documentation\" \\
                               \"BOOST_RV_REF(T)=T&&\" \\
+                              \"BOOST_RV_REF_BEG=\" \\
+                              \"BOOST_RV_REF_END=&&\" \\
                               \"BOOST_FWD_REF(T)=T&&\" \\
+                              \"BOOST_MOVE_DOC0PTR(T)=std::nullptr_t\" \\
+                              \"BOOST_MOVE_DOC1ST(T1, T2)=T1\" \\
+                              \"BOOST_MOVE_DOCIGN(T1) \"\\
                   "
    ;
 
diff --git a/include/boost/move/detail/meta_utils.hpp b/include/boost/move/detail/meta_utils.hpp
index e246ae3..6cc1763 100644
--- a/include/boost/move/detail/meta_utils.hpp
+++ b/include/boost/move/detail/meta_utils.hpp
@@ -313,6 +313,15 @@ struct add_lvalue_reference<const volatile void>
    typedef const volatile void type;
 };
 
+template<class T>
+struct add_const_lvalue_reference
+{
+   typedef typename remove_reference<T>::type         t_unreferenced;
+   typedef typename add_const<t_unreferenced>::type   t_unreferenced_const;
+   typedef typename add_lvalue_reference
+      <t_unreferenced_const>::type                    type;
+};
+
 
 //////////////////////////////////////
 //             is_same
@@ -483,7 +492,8 @@ struct pointer_type_imp<T, D, false>
 template <class T, class D>
 struct pointer_type
 {
-    typedef typename pointer_type_imp<T, typename remove_reference<D>::type>::type type;
+    typedef typename pointer_type_imp
+      <typename remove_extent<T>::type, typename remove_reference<D>::type>::type type;
 };
 
 //////////////////////////////////////
@@ -517,7 +527,7 @@ class is_convertible
 #endif
 
 //////////////////////////////////////
-//    is_unary_or_binary_function
+//    is_unary_function
 //////////////////////////////////////
 #if defined(BOOST_MSVC) || defined(__BORLANDC_)
 #define BOOST_MOVE_TT_DECL __cdecl
@@ -530,120 +540,86 @@ class is_convertible
 #endif
 
 template <typename T>
-struct is_unary_or_binary_function_impl
+struct is_unary_function_impl
 {  static const bool value = false; };
 
-// avoid duplicate definitions of is_unary_or_binary_function_impl
+// avoid duplicate definitions of is_unary_function_impl
 #ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
 
 template <typename R>
-struct is_unary_or_binary_function_impl<R (*)()>
+struct is_unary_function_impl<R (*)()>
 {  static const bool value = true;  };
 
 template <typename R>
-struct is_unary_or_binary_function_impl<R (*)(...)>
+struct is_unary_function_impl<R (*)(...)>
 {  static const bool value = true;  };
 
 #else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
 
 template <typename R>
-struct is_unary_or_binary_function_impl<R (__stdcall*)()>
+struct is_unary_function_impl<R (__stdcall*)()>
 {  static const bool value = true;  };
 
 #ifndef _MANAGED
 
 template <typename R>
-struct is_unary_or_binary_function_impl<R (__fastcall*)()>
+struct is_unary_function_impl<R (__fastcall*)()>
 {  static const bool value = true;  };
 
 #endif
 
 template <typename R>
-struct is_unary_or_binary_function_impl<R (__cdecl*)()>
+struct is_unary_function_impl<R (__cdecl*)()>
 {  static const bool value = true;  };
 
 template <typename R>
-struct is_unary_or_binary_function_impl<R (__cdecl*)(...)>
+struct is_unary_function_impl<R (__cdecl*)(...)>
 {  static const bool value = true;  };
 
 #endif
 
-// avoid duplicate definitions of is_unary_or_binary_function_impl
+// avoid duplicate definitions of is_unary_function_impl
 #ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
 
 template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (*)(T0)>
+struct is_unary_function_impl<R (*)(T0)>
 {  static const bool value = true;  };
 
 template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (*)(T0...)>
+struct is_unary_function_impl<R (*)(T0...)>
 {  static const bool value = true;  };
 
 #else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
 
 template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (__stdcall*)(T0)>
+struct is_unary_function_impl<R (__stdcall*)(T0)>
 {  static const bool value = true;  };
 
 #ifndef _MANAGED
 
 template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (__fastcall*)(T0)>
+struct is_unary_function_impl<R (__fastcall*)(T0)>
 {  static const bool value = true;  };
 
 #endif
 
 template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (__cdecl*)(T0)>
+struct is_unary_function_impl<R (__cdecl*)(T0)>
 {  static const bool value = true;  };
 
 template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (__cdecl*)(T0...)>
+struct is_unary_function_impl<R (__cdecl*)(T0...)>
 {  static const bool value = true;  };
 
 #endif
 
-// avoid duplicate definitions of is_unary_or_binary_function_impl
-#ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
-
-template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (*)(T0, T1)>
-{  static const bool value = true;  };
-
-template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (*)(T0, T1...)>
-{  static const bool value = true;  };
-
-#else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
-
-template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (__stdcall*)(T0, T1)>
-{  static const bool value = true;  };
-
-#ifndef _MANAGED
-
-template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (__fastcall*)(T0, T1)>
-{  static const bool value = true;  };
-
-#endif
-
-template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1)>
-{  static const bool value = true;  };
-
-template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1...)>
-{  static const bool value = true;  };
-#endif
-
 template <typename T>
-struct is_unary_or_binary_function_impl<T&>
+struct is_unary_function_impl<T&>
 {  static const bool value = false; };
 
 template<typename T>
-struct is_unary_or_binary_function
-{  static const bool value = is_unary_or_binary_function_impl<T>::value;   };
+struct is_unary_function
+{  static const bool value = is_unary_function_impl<T>::value;   };
 
 }  //namespace move_detail {
 }  //namespace boost {
diff --git a/include/boost/move/detail/workaround.hpp b/include/boost/move/detail/workaround.hpp
index b46c808..181bc12 100644
--- a/include/boost/move/detail/workaround.hpp
+++ b/include/boost/move/detail/workaround.hpp
@@ -20,6 +20,10 @@
 //Macros for documentation purposes. For code, expands to the argument
 #define BOOST_MOVE_IMPDEF(TYPE) TYPE
 #define BOOST_MOVE_SEEDOC(TYPE) TYPE
+#define BOOST_MOVE_DOC0PTR(TYPE) TYPE
+#define BOOST_MOVE_DOC1ST(TYPE1, TYPE2) TYPE2
+#define BOOST_MOVE_I ,
+#define BOOST_MOVE_DOCIGN(T1) T1
 
 #include <boost/intrusive/detail/config_end.hpp>
 
diff --git a/include/boost/move/unique_ptr.hpp b/include/boost/move/unique_ptr.hpp
index 6a95155..f9b4128 100644
--- a/include/boost/move/unique_ptr.hpp
+++ b/include/boost/move/unique_ptr.hpp
@@ -44,29 +44,27 @@ namespace move_detail {
 template <class D>
 struct deleter_types
 {
+   typedef typename add_lvalue_reference<D>::type           del_ref;
+   typedef typename add_const_lvalue_reference<D>::type     del_cref;
    typedef typename if_c
-      < is_lvalue_reference<D>::value
-      , D
-      , typename add_lvalue_reference<typename add_const<D>::type>::type
-      >::type deleter_arg_type1;
-
+      < is_lvalue_reference<D>::value, D, del_cref >::type  deleter_arg_type1;
    #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
    typedef typename remove_reference<D>::type && deleter_arg_type2;
    #else
    typedef ::boost::rv<D> &deleter_arg_type2;
    #endif
-   typedef typename add_lvalue_reference<D>::type  deleter_lvalue_reference;
-   typedef typename add_lvalue_reference
-      <typename add_const<D>::type>::type          deleter_const_lvalue_reference;
 };
 
-template <class P, class D, bool = is_unary_or_binary_function<D>::value || is_reference<D>::value >
+////////////////////////////////////////////
+//          unique_ptr_data
+////////////////////////////////////////////
+template <class P, class D, bool = is_unary_function<D>::value || is_reference<D>::value >
 struct unique_ptr_data
 {
    typedef typename deleter_types<D>::deleter_arg_type1 deleter_arg_type1;
    typedef typename deleter_types<D>::deleter_arg_type2 deleter_arg_type2;
-   typedef typename deleter_types<D>::deleter_lvalue_reference       deleter_lvalue_reference;
-   typedef typename deleter_types<D>::deleter_const_lvalue_reference deleter_const_lvalue_reference;
+   typedef typename deleter_types<D>::del_ref         del_ref;
+   typedef typename deleter_types<D>::del_cref        del_cref;
 
    unique_ptr_data() BOOST_NOEXCEPT
       : m_p(), d()
@@ -89,18 +87,15 @@ struct unique_ptr_data
       : m_p(::boost::forward<U>(p)), d(::boost::forward<U>(d))
    {}
 
-   deleter_lvalue_reference deleter()
-   { return d; }
-
-   deleter_const_lvalue_reference deleter() const
-   { return d; }
+   del_ref deleter()       { return d; }
+   del_cref deleter() const{ return d; }
 
    P m_p;
+   D d;
 
    private:
+   unique_ptr_data& operator=(const unique_ptr_data&);
    unique_ptr_data(const unique_ptr_data&);
-   unique_ptr_data &operator=(const unique_ptr_data&);
-   D d;
 };
 
 template <class P, class D>
@@ -109,8 +104,8 @@ struct unique_ptr_data<P, D, false>
 {
    typedef typename deleter_types<D>::deleter_arg_type1 deleter_arg_type1;
    typedef typename deleter_types<D>::deleter_arg_type2 deleter_arg_type2;
-   typedef typename deleter_types<D>::deleter_lvalue_reference       deleter_lvalue_reference;
-   typedef typename deleter_types<D>::deleter_const_lvalue_reference deleter_const_lvalue_reference;
+   typedef typename deleter_types<D>::del_ref       del_ref;
+   typedef typename deleter_types<D>::del_cref del_cref;
 
    unique_ptr_data() BOOST_NOEXCEPT
       : D(), m_p()
@@ -133,35 +128,30 @@ struct unique_ptr_data<P, D, false>
       : D(::boost::forward<U>(d)), m_p(p)
    {}
 
-   deleter_lvalue_reference deleter()
-   { return static_cast<deleter_lvalue_reference>(*this); }
-
-   deleter_const_lvalue_reference deleter() const
-   {  return static_cast<deleter_const_lvalue_reference>(*this);  }
+   del_ref deleter()       {  return static_cast<del_ref>(*this);   }
+   del_cref deleter() const{  return static_cast<del_cref>(*this);  }
 
    P m_p;
+
    private:
+   unique_ptr_data& operator=(const unique_ptr_data&);
    unique_ptr_data(const unique_ptr_data&);
-   unique_ptr_data &operator=(const unique_ptr_data&);
 };
 
+////////////////////////////////////////////
+//          is_unique_ptr_convertible
+////////////////////////////////////////////
+
 //Although non-standard, we avoid using pointer_traits
 //to avoid heavy dependencies
 template <typename T>
 struct get_element_type
 {
-   template <typename X>
-   static char test(int, typename X::element_type*);
-
-   template <typename X>
-   static int test(...);
-
    struct DefaultWrap { typedef natify<T> element_type; };
-
+   template <typename X>   static char test(int, typename X::element_type*);
+   template <typename X>   static int test(...);
    static const bool value = (1 == sizeof(test<T>(0, 0)));
-
-   typedef typename
-      if_c<value, T, DefaultWrap>::type::element_type type;
+   typedef typename if_c<value, T, DefaultWrap>::type::element_type type;
 };
 
 template<class T>
@@ -173,9 +163,7 @@ struct get_element_type<T*>
 template<class T>
 struct get_cvelement
 {
-   typedef typename remove_cv
-      <typename get_element_type<T>::type
-      >::type type;
+   typedef typename remove_cv<typename get_element_type<T>::type>::type type;
 };
 
 template <class P1, class P2>
@@ -183,46 +171,85 @@ struct is_same_cvelement_and_convertible
 {
    typedef typename remove_reference<P1>::type arg1;
    typedef typename remove_reference<P2>::type arg2;
-   static const bool same_cvless = is_same<typename get_cvelement<arg1>::type
-                                          ,typename get_cvelement<arg2>::type
-                                          >::value;
+   static const bool same_cvless =
+      is_same<typename get_cvelement<arg1>::type,typename get_cvelement<arg2>::type>::value;
    static const bool value = same_cvless && is_convertible<arg1, arg2>::value;
 };
 
-template <class P1, class P2, class Type = nat>
-struct enable_same_cvelement_and_convertible
-   : public enable_if_c
-      <is_same_cvelement_and_convertible<P1, P2>::value, Type>
+template<bool IsArray, class FromPointer, class ThisPointer>
+struct is_unique_ptr_convertible
+   : is_same_cvelement_and_convertible<FromPointer, ThisPointer>
 {};
 
+template<class FromPointer, class ThisPointer>
+struct is_unique_ptr_convertible<false, FromPointer, ThisPointer>
+   : is_convertible<FromPointer, ThisPointer>
+{};
 
-template<bool OtherIsArray, bool IsArray, class FromPointer, class ThisPointer>
-struct is_unique_acceptable
-{
-   static const bool value = OtherIsArray &&
-           is_same_cvelement_and_convertible
-               <FromPointer, ThisPointer>::value;
-};
-
-template<bool OtherIsArray, class FromPointer, class ThisPointer>
-struct is_unique_acceptable<OtherIsArray, false, FromPointer, ThisPointer>
-{
-   static const bool value = !OtherIsArray &&
-            is_convertible<FromPointer, ThisPointer>::value;
-};
-
+////////////////////////////////////////
+////     enable_def_del / enable_defdel_call
+////////////////////////////////////////
 
 template<class U, class T, class Type = nat>
-struct enable_default_delete
+struct enable_def_del
    : enable_if_c
-      < is_unique_acceptable < is_array<U>::value
-                             , is_array<T>::value
-                             , typename element_pointer<U>::type
-                             , typename element_pointer<T>::type
-                             >::value
+      < (is_array<T>::value == is_array<U>::value) && is_unique_ptr_convertible
+            <is_array<T>::value, typename remove_extent<U>::type*, typename remove_extent<T>::type*>::value
       , Type>
 {};
 
+template<class U, class T, class Type = nat>
+struct enable_defdel_call
+   : public enable_def_del<U, T, Type>
+{};
+
+template<class U, class T, class Type>
+struct enable_defdel_call<U, T[], Type>
+   : public enable_def_del<U[], T[], Type>
+{};
+
+////////////////////////////////////////
+////     enable_up_moveconv_assign
+////////////////////////////////////////
+
+template<class T, class FromPointer, class ThisPointer, class Type = nat>
+struct enable_up_ptr
+   : enable_if_c< is_unique_ptr_convertible < is_array<T>::value, FromPointer, ThisPointer>::value, Type>
+{};
+
+////////////////////////////////////////
+////     enable_up_moveconv_assign
+////////////////////////////////////////
+
+template<class T, class D, class U, class E>
+struct unique_moveconvert_assignable
+{
+   static const bool value = !is_array<U>::value && is_unique_ptr_convertible
+      <false, typename pointer_type<U, E>::type, typename pointer_type<T, D>::type>::value;
+};
+
+template<class T, class D, class U, class E>
+struct unique_moveconvert_assignable<T[], D, U, E>
+{
+   static const bool value = is_array<U>::value && is_unique_ptr_convertible
+      <true, typename pointer_type<U, E>::type, typename pointer_type<T, D>::type>::value;
+};
+
+template<class T, class D, class U, class E, class Type = nat>
+struct enable_up_moveconv_assign
+   : enable_if_c<unique_moveconvert_assignable<T, D, U, E>::value, Type>
+{};
+
+////////////////////////////////////////
+////     enable_up_moveconv_constr
+////////////////////////////////////////
+
+template<class D, class E, bool IsReference = is_reference<D>::value>
+struct unique_deleter_is_initializable
+{
+   static const bool value = is_same<D, E>::value;
+};
+
 template <class T, class U>
 class is_rvalue_convertible
 {
@@ -245,12 +272,6 @@ class is_rvalue_convertible
    static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t);
 };
 
-template<class D, class E, bool IsReference = is_reference<D>::value>
-struct unique_deleter_is_initializable
-{
-   static const bool value = is_same<D, E>::value;
-};
-
 template<class D, class E>
 struct unique_deleter_is_initializable<D, E, false>
 {
@@ -274,87 +295,33 @@ struct unique_deleter_is_initializable<D, E, false>
    #endif
 };
 
-template <class U, class E, class T, class D>
-struct is_ptr_convertible
-{
-   typedef typename ::boost::move_detail::pointer_type<U, E>::type from_ptr;
-   typedef typename ::boost::move_detail::pointer_type<T, D>::type to_ptr;
-   static const bool value = is_convertible<from_ptr, to_ptr>::value;
-};
-
-template<class T, class D, class U, class E>
-struct unique_moveconvert_assignable
-{
-   static const bool ptrconvert  = is_ptr_convertible<U, E, T, D>::value;
-   static const bool notarray    = !is_array<U>::value;
-   static const bool value = ptrconvert && notarray;
-};
-
-template<class T, class D, class U, class E>
-struct unique_moveconvert_constructible
-{
-   static const bool massignable = unique_moveconvert_assignable<T, D, U, E>::value;
-   static const bool value = massignable && unique_deleter_is_initializable<D, E>::value;
-};
-
 template<class T, class D, class U, class E, class Type = nat>
-struct enable_unique_moveconvert_constructible
-   : enable_if_c
-      < unique_moveconvert_constructible<T, D, U, E>::value, Type>
+struct enable_up_moveconv_constr
+   : enable_if_c<unique_moveconvert_assignable<T, D, U, E>::value &&
+                 unique_deleter_is_initializable<D, E>::value, Type>
 {};
 
-template<class T, class D, class U, class E, class Type = nat>
-struct enable_unique_moveconvert_assignable
-   : enable_if_c
-      < unique_moveconvert_assignable<T, D, U, E>::value, Type>
-{};
+////////////////////////////////////////
+////     Some bool literal zero conversion utilities
+////////////////////////////////////////
 
-template<class T, class D, class U, class E>
-struct uniquearray_moveconvert_assignable
-{
-   typedef typename ::boost::move_detail::pointer_type<U, E>::type from_ptr;
-   typedef typename ::boost::move_detail::pointer_type<T, D>::type to_ptr;
-   static const bool ptrconvert  = is_same_cvelement_and_convertible<from_ptr, to_ptr>::value;
-   static const bool yesarray    = is_array<U>::value;
-   static const bool value = ptrconvert && yesarray;
-};
+struct bool_conversion {int for_bool; int for_arg(); };
+typedef int bool_conversion::* explicit_bool_arg;
 
-template<class T, class D, class U, class E>
-struct uniquearray_moveconvert_constructible
-{
-   static const bool massignable = uniquearray_moveconvert_assignable<T, D, U, E>::value;
-   static const bool value = massignable && unique_deleter_is_initializable<D, E>::value;
-};
-
-template<class T, class D, class U, class E, class Type = nat>
-struct enable_uniquearray_moveconvert_constructible
-   : enable_if_c
-      < uniquearray_moveconvert_constructible<T, D, U, E>::value, Type>
-{};
-
-template<class T, class D, class U, class E, class Type = nat>
-struct enable_uniquearray_moveconvert_assignable
-   : enable_if_c
-      < uniquearray_moveconvert_assignable<T, D, U, E>::value, Type>
-{};
-
-template<class Deleter, class Pointer>
-void unique_ptr_call_deleter(Deleter &d, const Pointer &p, boost::move_detail::true_type)  //default_deleter
-{  d(p);  }
-
-template<class Deleter, class Pointer>
-void unique_ptr_call_deleter(Deleter &d, const Pointer &p, boost::move_detail::false_type)
-{  if(p) d(p);  }
+#if !defined(BOOST_NO_CXX11_NULLPTR) 
+typedef std::nullptr_t nullptr_type;
+#else
+typedef int (bool_conversion::*nullptr_type)();
+#endif
 
 }  //namespace move_detail {
 
 namespace movelib {
 
+namespace bmd = boost::move_detail;
+
 //!The class template <tt>default_delete</tt> serves as the default deleter
 //!(destruction policy) for the class template <tt>unique_ptr</tt>.
-//!
-//!A specialization to delete array types is provided
-//!with a slightly altered interface.
 template <class T>
 struct default_delete
 {
@@ -375,138 +342,48 @@ struct default_delete
    default_delete(const default_delete&) BOOST_NOEXCEPT = default;
    default_delete &operator=(const default_delete&) BOOST_NOEXCEPT = default;
    #else
-   typedef T element_type;
+   typedef typename bmd::remove_extent<T>::type element_type;
    #endif
 
    //! <b>Effects</b>: Constructs a default_delete object from another <tt>default_delete<U></tt> object.
    //!
-   //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless U* is
-   //!   implicitly convertible to T*.
+   //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless:
+   //!   - If T is not an array type and U* is implicitly convertible to T*.
+   //!   - If T is an array type and U* is a more CV qualified pointer to remove_extent<T>::type.
    template <class U>
    default_delete(const default_delete<U>&
-      #if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-      ,  typename ::boost::move_detail::enable_default_delete<U, T>::type* = 0
-      #endif
+      BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmd::enable_def_del<U BOOST_MOVE_I T>::type* =0)
       ) BOOST_NOEXCEPT
    {}
 
    //! <b>Effects</b>: Constructs a default_delete object from another <tt>default_delete<U></tt> object.
    //!
-   //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless U* is
-   //!   implicitly convertible to T*.
-   //!
-   //! <b>Note</b>: Non-standard extension
+   //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless:
+   //!   - If T is not an array type and U* is implicitly convertible to T*.
+   //!   - If T is an array type and U* is a more CV qualified pointer to remove_extent<T>::type.
    template <class U>
-   #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   default_delete &
-   #else
-   typename ::boost::move_detail::enable_default_delete<U, T, default_delete &>::type
-   #endif
+   BOOST_MOVE_DOC1ST(default_delete&, 
+      typename bmd::enable_def_del<U BOOST_MOVE_I T BOOST_MOVE_I default_delete &>::type)
       operator=(const default_delete<U>&) BOOST_NOEXCEPT
    {  return *this;  }
 
-   //! <b>Effects</b>: calls <tt>delete</tt> on ptr.
+   //! <b>Effects</b>: if T is not an array type, calls <tt>delete</tt> on static_cast<T*>(ptr),
+   //!   otherwise calls <tt>delete[]</tt> on static_cast<remove_extent<T>::type*>(ptr).
    //!
-   //! <b>Remarks</b>: If T is an incomplete type, the program is ill-formed.
-   void operator()(T* ptr) const
-   {
-      //T must be a complete type
-      BOOST_STATIC_ASSERT(sizeof(T) > 0);
-      delete ptr;
-   }
-};
-
-//!The specialization to delete array types (<tt>array_of_T = T[]</tt>)
-//!with a slightly altered interface.
-//!
-//! \tparam array_of_T is an alias for types of form <tt>T[]</tt>
-template <class T>
-struct default_delete
-#if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-<array_of_T>
-#else
-<T[]>
-#endif
-{
-   //! Default constructor.
-   //!
-   BOOST_CONSTEXPR default_delete()
-   //Avoid "defaulted on its first declaration must not have an exception-specification" error for GCC 4.6
-      #if !defined(BOOST_GCC) || (BOOST_GCC < 40600 && BOOST_GCC >= 40700) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   BOOST_NOEXCEPT
-   #endif
-   #if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   = default;
-   #else
-   {};
-   #endif
-
-   #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   default_delete(const default_delete&) BOOST_NOEXCEPT = default;
-   default_delete &operator=(const default_delete&) BOOST_NOEXCEPT = default;
-   #else
-   typedef T element_type;
-   #endif
-
-   //! <b>Effects</b>: Constructs a default_delete object from another <tt>default_delete<U></tt> object.
-   //!
-   //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless U* is
-   //!   a more CV cualified pointer to T.
-   //!
-   //! <b>Note</b>: Non-standard extension
+   //! <b>Remarks</b>: If U is an incomplete type, the program is ill-formed.
+   //!   This operator shall not participate in overload resolution unless:
+   //!      - T is not an array type and U* is convertible to T*, OR
+   //!      - T is an array type, and remove_cv<U>::type is the same type as
+   //!         remove_cv<remove_extent<T>::type>::type and U* is convertible to remove_extent<T>::type*.
    template <class U>
-   default_delete(const default_delete<U>&
-      #if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-      ,  typename ::boost::move_detail::enable_default_delete<U, T[]>::type* = 0
-      #endif
-      ) BOOST_NOEXCEPT
-   {}
-
-   //! <b>Effects</b>: Constructs a default_delete object from another <tt>default_delete<U></tt> object.
-   //!
-   //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless U* is
-   //!   a more CV cualified pointer to T.
-   //!
-   //! <b>Note</b>: Non-standard extension
-   template <class U>
-   #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   default_delete &
-   #else
-   typename ::boost::move_detail::enable_default_delete<U, T[], default_delete &>::type
-   #endif
-      operator=(const default_delete<U>&) BOOST_NOEXCEPT
-   {  return *this;  }
-
-   #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   //! <b>Effects</b>: calls <tt>delete[]</tt> on ptr.
-   //!
-   //! <b>Remarks</b>: If T is an incomplete type, the program is ill-formed.
-   void operator()(T* ptr) const
-   {
-      //T must be a complete type
-      BOOST_STATIC_ASSERT(sizeof(T) > 0);
-      delete [] ptr;
-   }
-
-   //! <b>Remarks</b>: This deleter can't delete pointers convertible to T unless U* is
-   //!   a more CV cualified pointer to T.
-   //!
-   //! <b>Note</b>: Non-standard extension
-   template <class U>
-   void operator()(U*) const = delete;
-   #else
-   template <class U>
-   void operator()(U* ptr
-                  #if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-                  , typename ::boost::move_detail::enable_default_delete<U[], T[]>::type * = 0
-                  #endif
-                  ) const BOOST_NOEXCEPT
+   BOOST_MOVE_DOC1ST(void, typename bmd::enable_defdel_call<U BOOST_MOVE_I T BOOST_MOVE_I void>::type)
+      operator()(U* ptr) const BOOST_NOEXCEPT
    {
       //U must be a complete type
       BOOST_STATIC_ASSERT(sizeof(U) > 0);
-      delete [] ptr;
+      element_type * const p = static_cast<element_type*>(ptr);
+      bmd::is_array<T>::value ? delete [] p : delete p;
    }
-   #endif
 };
 
 
@@ -541,6 +418,11 @@ struct default_delete
 //! ownership of dynamically allocated memory to a function, and returning dynamically allocated memory from
 //! a function.
 //!
+//! If T is an array type (e.g. unique_ptr<MyType[]>) the interface is slightly altered:
+//!   - Pointers to types derived from T are rejected by the constructors, and by reset.
+//!   - The observers <tt>operator*</tt> and <tt>operator-></tt> are not provided.
+//!   - The indexing observer <tt>operator[]</tt> is provided.
+//!
 //! \tparam T Provides the type of the stored pointer.
 //! \tparam D The deleter type:
 //!   -  The default type for the template parameter D is default_delete. A client-supplied template argument
@@ -559,15 +441,16 @@ class unique_ptr
    private:
    #else
    BOOST_MOVABLE_BUT_NOT_COPYABLE(unique_ptr)
-   typedef move_detail::pointer_type<T, D> pointer_type_obtainer;
-   typedef ::boost::move_detail::unique_ptr_data
-      <typename pointer_type_obtainer::type, D> data_type;
-   typedef typename data_type::deleter_arg_type1 deleter_arg_type1;
-   typedef typename data_type::deleter_arg_type2 deleter_arg_type2;
-   typedef typename data_type::deleter_lvalue_reference       deleter_lvalue_reference;
-   typedef typename data_type::deleter_const_lvalue_reference deleter_const_lvalue_reference;
-   struct nat {int for_bool;};
-   typedef ::boost::move_detail::integral_constant<bool, move_detail::is_same< D, default_delete<T> >::value > is_default_deleter_t;
+
+   typedef move_detail::pointer_type<T, D >                    pointer_type_obtainer;
+   typedef bmd::unique_ptr_data
+      <typename pointer_type_obtainer::type, D>                data_type;
+   typedef typename data_type::deleter_arg_type1               deleter_arg_type1;
+   typedef typename data_type::deleter_arg_type2               deleter_arg_type2;
+
+   typedef bmd::integral_constant
+      <bool, move_detail::is_same< D, default_delete<T> >::value > is_default_deleter_t;
+   data_type m_data;
    #endif
 
    public:
@@ -575,7 +458,9 @@ class unique_ptr
    //! synonym for <tt>remove_reference<D>::type::pointer</tt>. Otherwise it shall be a
    //! synonym for T*.
    typedef typename BOOST_MOVE_SEEDOC(pointer_type_obtainer::type) pointer;
-   typedef T element_type;
+   //! If T is an array type, then element_type is equal to T. Otherwise, if T is a type
+   //! in the form U[], element_type is equal to U.
+   typedef typename BOOST_MOVE_SEEDOC(bmd::remove_extent<T>::type) element_type;
    typedef D deleter_type;
 
    //! <b>Requires</b>: D shall satisfy the requirements of DefaultConstructible, and
@@ -593,8 +478,19 @@ class unique_ptr
    {
       //If this constructor is instantiated with a pointer type or reference type
       //for the template argument D, the program is ill-formed.
-      BOOST_STATIC_ASSERT(!::boost::move_detail::is_pointer<D>::value);
-      BOOST_STATIC_ASSERT(!::boost::move_detail::is_reference<D>::value);
+      BOOST_STATIC_ASSERT(!bmd::is_pointer<D>::value);
+      BOOST_STATIC_ASSERT(!bmd::is_reference<D>::value);
+   }
+
+   //! <b>Effects</b>: Same as <tt>unique_ptr()</tt> (default constructor).
+   //! 
+   BOOST_CONSTEXPR unique_ptr(BOOST_MOVE_DOC0PTR(bmd::nullptr_type)) BOOST_NOEXCEPT
+      : m_data()
+   {
+      //If this constructor is instantiated with a pointer type or reference type
+      //for the template argument D, the program is ill-formed.
+      BOOST_STATIC_ASSERT(!bmd::is_pointer<D>::value);
+      BOOST_STATIC_ASSERT(!bmd::is_reference<D>::value);
    }
 
    //! <b>Requires</b>: D shall satisfy the requirements of DefaultConstructible, and
@@ -606,14 +502,20 @@ class unique_ptr
    //! <b>Postconditions</b>: <tt>get() == p</tt>. <tt>get_deleter()</tt> returns a reference to the stored deleter.
    //!
    //! <b>Remarks</b>: If this constructor is instantiated with a pointer type or reference type
-   //!   for the template argument D, the program is ill-formed. 
-   explicit unique_ptr(pointer p) BOOST_NOEXCEPT
+   //!   for the template argument D, the program is ill-formed.
+   //!   This constructor shall not participate in overload resolution unless:
+   //!      - If T is not an array type and Pointer is implicitly convertible to pointer.
+   //!      - If T is an array type and Pointer is a more CV qualified pointer to element_type.
+   template<class Pointer>
+   explicit unique_ptr(Pointer p
+      BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmd::enable_up_ptr<T BOOST_MOVE_I Pointer BOOST_MOVE_I pointer>::type* =0)
+                 ) BOOST_NOEXCEPT
       : m_data(p)
    {
       //If this constructor is instantiated with a pointer type or reference type
       //for the template argument D, the program is ill-formed.
-      BOOST_STATIC_ASSERT(!::boost::move_detail::is_pointer<D>::value);
-      BOOST_STATIC_ASSERT(!::boost::move_detail::is_reference<D>::value);
+      BOOST_STATIC_ASSERT(!bmd::is_pointer<D>::value);
+      BOOST_STATIC_ASSERT(!bmd::is_reference<D>::value);
    }
 
    //!The signature of this constructor depends upon whether D is a reference type.
@@ -626,10 +528,21 @@ class unique_ptr
    //! 
    //! <b>Postconditions</b>: <tt>get() == p.get_deleter()</tt> returns a reference to the stored deleter. If D is a
    //!   reference type then <tt>get_deleter()</tt> returns a reference to the lvalue d.
-   unique_ptr(pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type1) d1) BOOST_NOEXCEPT
+   //!
+   //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless:
+   //!      - If T is not an array type and Pointer is implicitly convertible to pointer.
+   //!      - If T is an array type and Pointer is a more CV qualified pointer to element_type.
+   template<class Pointer>
+   unique_ptr(Pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type1) d1
+      BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmd::enable_up_ptr<T BOOST_MOVE_I Pointer BOOST_MOVE_I pointer>::type* =0)
+              ) BOOST_NOEXCEPT
       : m_data(p, d1)
    {}
 
+   unique_ptr(BOOST_MOVE_DOC0PTR(bmd::nullptr_type), BOOST_MOVE_SEEDOC(deleter_arg_type1) d1) BOOST_NOEXCEPT
+      : m_data(pointer(), d1)
+   {}
+
    //! The signature of this constructor depends upon whether D is a reference type.
    //!   - If D is non-reference type A, then the signature is <tt>unique_ptr(pointer p, A&& d)</tt>.
    //!   - If D is an lvalue-reference type A&, then the signature is <tt>unique_ptr(pointer p, A&& d)</tt>.
@@ -640,10 +553,21 @@ class unique_ptr
    //! 
    //! <b>Postconditions</b>: <tt>get() == p.get_deleter()</tt> returns a reference to the stored deleter. If D is a
    //!   reference type then <tt>get_deleter()</tt> returns a reference to the lvalue d.
-   unique_ptr(pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type2) d2) BOOST_NOEXCEPT
+   //!
+   //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless:
+   //!      - If T is not an array type and Pointer is implicitly convertible to pointer.
+   //!      - If T is an array type and Pointer is a more CV qualified pointer to element_type.
+   template<class Pointer>
+   unique_ptr(Pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type2) d2
+      BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmd::enable_up_ptr<T BOOST_MOVE_I Pointer BOOST_MOVE_I pointer>::type* =0)
+             ) BOOST_NOEXCEPT
       : m_data(p, ::boost::move(d2))
    {}
 
+   unique_ptr(BOOST_MOVE_DOC0PTR(bmd::nullptr_type), BOOST_MOVE_SEEDOC(deleter_arg_type2) d2) BOOST_NOEXCEPT
+      : m_data(pointer(), ::boost::move(d2))
+   {}
+
    //! <b>Requires</b>: If D is not a reference type, D shall satisfy the requirements of MoveConstructible.
    //! Construction of the deleter from an rvalue of type D shall not throw an exception.
    //! 
@@ -658,19 +582,6 @@ class unique_ptr
       : m_data(u.release(), ::boost::move_if_not_lvalue_reference<D>(u.get_deleter()))
    {}
 
-   #if !defined(BOOST_NO_CXX11_NULLPTR) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   //! <b>Effects</b>: Same as <tt>unique_ptr()</tt> (default constructor).
-   //! 
-   BOOST_CONSTEXPR unique_ptr(std::nullptr_t) BOOST_NOEXCEPT
-      : m_data()
-   {
-      //If this constructor is instantiated with a pointer type or reference type
-      //for the template argument D, the program is ill-formed.
-      BOOST_STATIC_ASSERT(!::boost::move_detail::is_pointer<D>::value);
-      BOOST_STATIC_ASSERT(!::boost::move_detail::is_reference<D>::value);
-   }
-   #endif
-
    //! <b>Requires</b>: If E is not a reference type, construction of the deleter from an rvalue of type E shall be
    //!   well formed and shall not throw an exception. Otherwise, E is a reference type and construction of the
    //!   deleter from an lvalue of type E shall be well formed and shall not throw an exception.
@@ -688,9 +599,7 @@ class unique_ptr
    //!   returns a reference to the stored deleter that was constructed from <tt>u.get_deleter()</tt>.
    template <class U, class E>
    unique_ptr( BOOST_RV_REF_BEG unique_ptr<U, E> BOOST_RV_REF_END u
-      #if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-             , typename ::boost::move_detail::enable_unique_moveconvert_constructible<T, D, U, E>::type * = 0
-      #endif
+      BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmd::enable_up_moveconv_constr<T BOOST_MOVE_I D BOOST_MOVE_I U BOOST_MOVE_I E>::type* =0)
       ) BOOST_NOEXCEPT
       : m_data(u.release(), ::boost::move_if_not_lvalue_reference<E>(u.get_deleter()))
    {}
@@ -702,7 +611,7 @@ class unique_ptr
    //!
    //! <b>Note</b>: The use of default_delete requires T to be a complete type
    ~unique_ptr()
-   {  unique_ptr_call_deleter(m_data.deleter(), m_data.m_p, is_default_deleter_t());   }
+   {  if(m_data.m_p) m_data.deleter()(m_data.m_p);   }
 
    //! <b>Requires</b>: If D is not a reference type, D shall satisfy the requirements of MoveAssignable
    //!   and assignment of the deleter from an rvalue of type D shall not throw an exception. Otherwise, D
@@ -733,11 +642,8 @@ class unique_ptr
    //!
    //! <b>Returns</b>: *this.
    template <class U, class E>
-   #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   unique_ptr&
-   #else
-   typename ::boost::move_detail::enable_unique_moveconvert_assignable<T, D, U, E, unique_ptr &>::type
-   #endif
+   BOOST_MOVE_DOC1ST(unique_ptr&, typename bmd::enable_up_moveconv_assign
+         <T BOOST_MOVE_I D BOOST_MOVE_I U BOOST_MOVE_I E BOOST_MOVE_I unique_ptr &>::type)
       operator=(BOOST_RV_REF_BEG unique_ptr<U, E> BOOST_RV_REF_END u) BOOST_NOEXCEPT
    {
       this->reset(u.release());
@@ -745,50 +651,55 @@ class unique_ptr
       return *this;
    }
 
-   #if !defined(BOOST_NO_CXX11_NULLPTR) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
    //! <b>Effects</b>: <tt>reset()</tt>.
    //!
    //! <b>Postcondition</b>: <tt>get() == nullptr</tt>
    //!
    //! <b>Returns</b>: *this.
-   unique_ptr& operator=(std::nullptr_t) BOOST_NOEXCEPT
+   unique_ptr& operator=(BOOST_MOVE_DOC0PTR(bmd::nullptr_type)) BOOST_NOEXCEPT
    {
       this->reset();
       return *this;
    }
-   #else
-   //! <b>Effects</b>: <tt>reset()</tt>.
-   //!
-   //! <b>Postcondition</b>: <tt>get() == nullptr</tt>
-   //!
-   //! 
-   //! <b>Note</b>: Non-standard extension to use 0 as nullptr
-   unique_ptr& operator=(int nat::*) BOOST_NOEXCEPT
-   {
-      this->reset();
-      return *this;
-   }
-   #endif
-
 
    //! <b>Requires</b>: <tt>get() != nullptr</tt>.
    //!
    //! <b>Returns</b>: <tt>*get()</tt>.
-   #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   add_lvalue_reference_t
-   #else
-   typename ::boost::move_detail::add_lvalue_reference<T>::type 
-   #endif
+   //!
+   //! <b>Remarks</b: If T is an array type, the program is ill-formed.
+   BOOST_MOVE_DOC1ST(element_type&, typename bmd::add_lvalue_reference<element_type>::type)
       operator*() const
-   {  return *get();  }
+   {
+      BOOST_STATIC_ASSERT((!bmd::is_array<T>::value));
+      return *get();
+   }
+
+   //! <b>Requires</b>: i < the number of elements in the array to which the stored pointer points.
+   //!
+   //! <b>Returns</b>: <tt>get()[i]</tt>.
+   //!
+   //! <b>Remarks</b: If T is not an array type, the program is ill-formed.
+   BOOST_MOVE_DOC1ST(element_type&, typename bmd::add_lvalue_reference<element_type>::type)
+      operator[](size_t i) const
+   {
+      BOOST_STATIC_ASSERT((bmd::is_array<T>::value));
+      const pointer p = this->get();
+      BOOST_ASSERT(p);
+      return p[i];
+   }
 
    //! <b>Requires</b>: <tt>get() != nullptr</tt>.
    //!
    //! <b>Returns</b>: <tt>get()</tt>.
    //!
    //! <b>Note</b>: use typically requires that T be a complete type.
+   //!
+   //! <b>Remarks</b: If T is an array type, the program is ill-formed.
    pointer operator->() const BOOST_NOEXCEPT
-   {  return get();  }
+   {
+      BOOST_STATIC_ASSERT((!bmd::is_array<T>::value));
+      return get();
+   }
 
    //! <b>Returns</b>: The stored pointer.
    //!
@@ -797,22 +708,30 @@ class unique_ptr
 
    //! <b>Returns</b>: A reference to the stored deleter.
    //!
-   deleter_lvalue_reference get_deleter() BOOST_NOEXCEPT
-   {  return m_data.deleter();  }
+   BOOST_MOVE_DOC1ST(D&, typename bmd::add_lvalue_reference<D>::type)
+      get_deleter() BOOST_NOEXCEPT
+   {  return m_data.deleter();  }   
 
    //! <b>Returns</b>: A reference to the stored deleter.
    //!
-   deleter_const_lvalue_reference get_deleter() const BOOST_NOEXCEPT
+   BOOST_MOVE_DOC1ST(const D&, typename bmd::add_const_lvalue_reference<D>::type)
+      get_deleter() const BOOST_NOEXCEPT
    {  return m_data.deleter();  }
 
    #ifdef BOOST_MOVE_DOXYGEN_INVOKED
    //! <b>Returns</b>: Returns: get() != nullptr.
    //!
-   explicit operator bool() const BOOST_NOEXCEPT;
+   explicit operator bool
    #else
-   operator int nat::*() const BOOST_NOEXCEPT
-   { return m_data.m_p ? &nat::for_bool : (int nat::*)0; }
+   operator bmd::explicit_bool_arg
    #endif
+      ()const BOOST_NOEXCEPT
+   {
+      return m_data.m_p
+         ? &bmd::bool_conversion::for_bool
+         : bmd::explicit_bool_arg(0);
+   }
+
 
    //! <b>Postcondition</b>: <tt>get() == nullptr</tt>.
    //!
@@ -833,263 +752,45 @@ class unique_ptr
    //!
    //! <b>Postconditions</b>: <tt>get() == p</tt>. Note: The postcondition does not hold if the call to <tt>get_deleter()</tt>
    //!   destroys *this since <tt>this->get()</tt> is no longer a valid expression.
-   void reset(pointer p = pointer()) BOOST_NOEXCEPT
+   //!
+   //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless:
+   //!      - If T is not an array type and Pointer is implicitly convertible to pointer.
+   //!      - If T is an array type and Pointer is a more CV qualified pointer to element_type.
+   template<class Pointer>
+   BOOST_MOVE_DOC1ST(void, typename bmd::enable_up_ptr<T BOOST_MOVE_I Pointer BOOST_MOVE_I pointer BOOST_MOVE_I void>::type)
+      reset(Pointer p) BOOST_NOEXCEPT
    {
       pointer tmp = m_data.m_p;
       m_data.m_p = p;
-      unique_ptr_call_deleter(m_data.deleter(), tmp, is_default_deleter_t());
+      if(tmp) m_data.deleter()(tmp);
    }
 
+   //! <b>Requires</b>: The expression <tt>get_deleter()(get())</tt> shall be well formed, shall have well-defined behavior,
+   //!   and shall not throw exceptions.
+   //!
+   //! <b>Effects</b>: assigns nullptr to the stored pointer, and then if the old value of the stored pointer, old_p, was not
+   //!   equal to nullptr, calls <tt>get_deleter()(old_p)</tt>. Note: The order of these operations is significant
+   //!   because the call to <tt>get_deleter()</tt> may destroy *this.
+   //!
+   //! <b>Postconditions</b>: <tt>get() == p</tt>. Note: The postcondition does not hold if the call to <tt>get_deleter()</tt>
+   //!   destroys *this since <tt>this->get()</tt> is no longer a valid expression.
+   void reset() BOOST_NOEXCEPT
+   {  this->reset(pointer());  }
+
+   //! <b>Effects</b>: Same as <tt>reset()</tt>
+   //! 
+   void reset(BOOST_MOVE_DOC0PTR(bmd::nullptr_type)) BOOST_NOEXCEPT
+   {  this->reset(); }
+
    //! <b>Requires</b>: <tt>get_deleter()</tt> shall be swappable and shall not throw an exception under swap.
    //!
    //! <b>Effects</b>: Invokes swap on the stored pointers and on the stored deleters of *this and u.
    void swap(unique_ptr& u) BOOST_NOEXCEPT
    {
-      using boost::move_detail::swap;
+      using bmd::swap;
       swap(m_data.m_p, u.m_data.m_p);
       swap(m_data.deleter(), u.m_data.deleter());
    }
-
-   #if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   data_type m_data;
-   #endif
-};
-
-//!A specialization for array types (<tt>array_of_T = T[]</tt>) is provided with a slightly altered interface.
-//!   - Conversions between different types of <tt>unique_ptr<T[], D></tt> or to or from the non-array forms of
-//!      unique_ptr produce an ill-formed program.
-//!   - Pointers to types derived from T are rejected by the constructors, and by reset.
-//!   - The observers <tt>operator*</tt> and <tt>operator-></tt> are not provided.
-//!   - The indexing observer <tt>operator[]</tt> is provided.
-//!   - The default deleter will call <tt>delete[]</tt>.
-//!
-//! Descriptions are provided below only for member functions that have behavior different from the primary template.
-//!
-//! \tparam array_of_T is an alias for types of form T[]. The template argument T shall be a complete type.
-template <class T, class D>
-class unique_ptr
-#if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-< array_of_T
-#else
-< T[]
-#endif
-, D>
-{
-   #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   public:
-   unique_ptr(const unique_ptr&) = delete;
-   unique_ptr& operator=(const unique_ptr&) = delete;
-   private:
-   #else
-   BOOST_MOVABLE_BUT_NOT_COPYABLE(unique_ptr)
-   typedef ::boost::move_detail::pointer_type<T, D> pointer_type_obtainer;
-   typedef ::boost::move_detail::unique_ptr_data
-      <typename pointer_type_obtainer::type, D> data_type;
-   typedef typename data_type::deleter_arg_type1 deleter_arg_type1;
-   typedef typename data_type::deleter_arg_type2 deleter_arg_type2;
-   typedef typename data_type::deleter_lvalue_reference       deleter_lvalue_reference;
-   typedef typename data_type::deleter_const_lvalue_reference deleter_const_lvalue_reference;
-   struct nat {int for_bool;};
-   typedef ::boost::move_detail::integral_constant<bool, ::boost::move_detail::is_same< D, default_delete<T[]> >::value > is_default_deleter_t;
-   #endif
-
-   public:
-   typedef typename BOOST_MOVE_SEEDOC(pointer_type_obtainer::type) pointer;
-   typedef T element_type;
-   typedef D deleter_type;
-
-   BOOST_CONSTEXPR unique_ptr() BOOST_NOEXCEPT
-      : m_data()
-   {
-      //If this constructor is instantiated with a pointer type or reference type
-      //for the template argument D, the program is ill-formed.
-      BOOST_STATIC_ASSERT(!::boost::move_detail::is_pointer<D>::value);
-      BOOST_STATIC_ASSERT(!::boost::move_detail::is_reference<D>::value);
-   }
-
-   //! This constructor behave the same as in the primary template except that it does
-   //! not accept pointer types which are convertible to pointer.
-   #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   unique_ptr(pointer p);
-   #else
-   template<class P>
-   explicit unique_ptr(P p
-      ,typename ::boost::move_detail::enable_same_cvelement_and_convertible<P, pointer>::type* = 0
-                      ) BOOST_NOEXCEPT
-      : m_data(p)
-   {
-      BOOST_STATIC_ASSERT(!::boost::move_detail::is_pointer<D>::value);
-      BOOST_STATIC_ASSERT(!::boost::move_detail::is_reference<D>::value);
-   }
-   #endif
-
-   //! This constructor behave the same as in the primary template except that it does
-   //! not accept pointer types which are convertible to pointer.
-   #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   unique_ptr(pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type1) d1);
-   #else
-   template<class P>
-   unique_ptr(P p, BOOST_MOVE_SEEDOC(deleter_arg_type1) d1
-      ,typename ::boost::move_detail::enable_same_cvelement_and_convertible<P, pointer>::type* = 0
-             ) BOOST_NOEXCEPT
-      : m_data(p, d1)
-   {}
-   #endif
-
-   //! This assignement behave the same as in the primary template except that it does
-   //! only accept pointer types which are equal or less cv qualified than pointer
-   #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   unique_ptr(pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type2) d2);
-   #else
-   template<class P>
-   unique_ptr(P p, BOOST_MOVE_SEEDOC(deleter_arg_type2) d2
-      ,typename ::boost::move_detail::enable_same_cvelement_and_convertible<P, pointer>::type* = 0
-             ) BOOST_NOEXCEPT
-      : m_data(p, ::boost::move(d2))
-   {}
-   #endif
-
-   unique_ptr(BOOST_RV_REF(unique_ptr) u) BOOST_NOEXCEPT
-      : m_data(u.release(), ::boost::move_if_not_lvalue_reference<D>(u.get_deleter()))
-   {}
-
-   //! This assignement behave the same as in the primary template except that it does
-   //! only accept pointer types which are equal or less cv qualified than pointer.
-   //!
-   //! <b>Note</b>: Non-standard extension
-   template <class U, class E>
-   unique_ptr( BOOST_RV_REF_BEG unique_ptr<U, E> BOOST_RV_REF_END u
-      #if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-             , typename ::boost::move_detail::enable_uniquearray_moveconvert_constructible<T, D, U, E>::type * = 0
-      #endif
-             ) BOOST_NOEXCEPT
-      : m_data(u.release(), ::boost::move_if_not_lvalue_reference<E>(u.get_deleter()))
-   {}
-
-   #if !defined(BOOST_NO_CXX11_NULLPTR) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   BOOST_CONSTEXPR unique_ptr(std::nullptr_t) BOOST_NOEXCEPT
-      : m_data()
-   {
-      //If this constructor is instantiated with a pointer type or reference type
-      //for the template argument D, the program is ill-formed.
-      BOOST_STATIC_ASSERT(!::boost::move_detail::is_pointer<D>::value);
-      BOOST_STATIC_ASSERT(!::boost::move_detail::is_reference<D>::value);
-   }
-   #endif
-
-   ~unique_ptr()
-   {
-      unique_ptr_call_deleter(m_data.deleter(), m_data.m_p, is_default_deleter_t());
-   }
-
-   unique_ptr& operator=(BOOST_RV_REF(unique_ptr) u) BOOST_NOEXCEPT
-   {
-      this->reset(u.release());
-      m_data.deleter() = ::boost::move_if_not_lvalue_reference<D>(u.get_deleter());
-      return *this;
-   }
-
-   //! This assignement behave the same as in the primary template except that it does
-   //! only accept pointer types which are equal or less cv qualified than pointer
-   //!
-   //! <b>Note</b>: Non-standard extension
-   template <class U, class E>
-   #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   unique_ptr&
-   #else
-   typename ::boost::move_detail::enable_uniquearray_moveconvert_assignable<T, D, U, E, unique_ptr &>::type
-   #endif
-      operator=(BOOST_RV_REF_BEG unique_ptr<U, E> BOOST_RV_REF_END u) BOOST_NOEXCEPT
-   {
-      this->reset(u.release());
-      m_data.deleter() = ::boost::move_if_not_lvalue_reference<E>(u.get_deleter());
-      return *this;
-   }
-
-   #if !defined(BOOST_NO_CXX11_NULLPTR) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   unique_ptr& operator=(std::nullptr_t) BOOST_NOEXCEPT
-   {
-      this->reset();
-      return *this;
-   }
-   #else
-   unique_ptr& operator=(int nat::*) BOOST_NOEXCEPT
-   {
-      this->reset();
-      return *this;
-   }
-   #endif
-
-   //! <b>Requires</b>: i < the number of elements in the array to which the stored pointer points.
-   //! <b>Returns</b>: <tt>get()[i]</tt>.
-   T& operator[](size_t i) const
-   {
-      const pointer p = this->get();
-      BOOST_ASSERT(p);
-      return p[i];
-   }
-
-   pointer get() const BOOST_NOEXCEPT
-   {  return m_data.m_p;  }
-
-   deleter_lvalue_reference get_deleter() BOOST_NOEXCEPT
-   {  return m_data.deleter();  }
-
-   deleter_const_lvalue_reference get_deleter() const BOOST_NOEXCEPT
-   {  return m_data.deleter();  }
-
-   #ifdef BOOST_MOVE_DOXYGEN_INVOKED
-   explicit operator bool() const BOOST_NOEXCEPT;
-   #else
-   operator int nat::*() const BOOST_NOEXCEPT
-   { return m_data.m_p ? &nat::for_bool : (int nat::*)0; }
-   #endif
-
-   pointer release() BOOST_NOEXCEPT
-   {
-      const pointer tmp = m_data.m_p;
-      m_data.m_p = pointer();
-      return tmp;
-   }
-
-   #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   void reset(pointer p = pointer());
-   #else
-   template<class P>
-   void reset(P p
-      ,typename ::boost::move_detail::enable_same_cvelement_and_convertible<P, pointer>::type* = 0
-             ) BOOST_NOEXCEPT
-   {
-      pointer tmp = m_data.m_p;
-      m_data.m_p = p;
-      unique_ptr_call_deleter(m_data.deleter(), tmp, is_default_deleter_t());
-   }
-
-   void reset() BOOST_NOEXCEPT
-   {
-      pointer tmp = m_data.m_p;
-      m_data.m_p = pointer();
-      unique_ptr_call_deleter(m_data.deleter(), tmp, is_default_deleter_t());
-   }
-   #endif
-
-   #if !defined(BOOST_NO_CXX11_NULLPTR) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   void reset(std::nullptr_t) BOOST_NOEXCEPT
-   {  this->reset(); }
-   #endif
-
-   void swap(unique_ptr& u) BOOST_NOEXCEPT
-   {
-      using boost::move_detail::swap;
-      swap(m_data.m_p, u.m_data.m_p);
-      swap(m_data.deleter(), u.m_data.deleter());
-   }
-
-   #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-   template <class U> void reset(U) = delete;
-   #else
-   data_type m_data;
-   #endif
 };
 
 //! <b>Effects</b>: Calls <tt>x.swap(y)</tt>.
@@ -1110,32 +811,13 @@ template <class T1, class D1, class T2, class D2>
 inline bool operator!=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
 {  return x.get() != y.get(); }
 
-#if 0
-//! <b>Requires</b>: Let CT be <tt>common_type<unique_ptr<T1, D1>::pointer, unique_ptr<T2, D2>::pointer>::
-//!   type</tt>. Then the specialization <tt>less<CT></tt> shall be a function object type that induces a
-//!   strict weak ordering on the pointer values.
-//!
-//! <b>Returns</b>: less<CT>()(x.get(), y.get()).
-//!
-//! <b>Remarks</b>: If <tt>unique_ptr<T1, D1>::pointer</tt> is not implicitly convertible to CT or 
-//!   <tt>unique_ptr<T2, D2>::pointer</tt> is not implicitly convertible to CT, the program is ill-formed.
-#else
 //! <b>Returns</b>: x.get() < y.get().
 //!
-//! <b>Remarks</b>: This comparison shall induces a
-//!   strict weak ordering on the pointer values.
-#endif
+//! <b>Remarks</b>: This comparison shall induce a
+//!   strict weak ordering betwen pointers.
 template <class T1, class D1, class T2, class D2>
 inline bool operator<(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
-{
-   #if 0
-    typedef typename common_type
-      < typename unique_ptr<T1, D1>::pointer
-      , typename unique_ptr<T2, D2>::pointer>::type CT;
-    return std::less<CT>()(x.get(), y.get());*/
-   #endif
-   return x.get() < y.get();
-}
+{  return x.get() < y.get();  }
 
 //! <b>Returns</b>: !(y < x).
 //!
@@ -1155,49 +837,45 @@ template <class T1, class D1, class T2, class D2>
 inline bool operator>=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
 {  return !(x < y);  }
 
-#if !defined(BOOST_NO_CXX11_NULLPTR) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
 //! <b>Returns</b>:!x.
 //!
 template <class T1, class D1>
-inline bool operator==(const unique_ptr<T1, D1> &x, std::nullptr_t) BOOST_NOEXCEPT
+inline bool operator==(const unique_ptr<T1, D1> &x, BOOST_MOVE_DOC0PTR(bmd::nullptr_type)) BOOST_NOEXCEPT
 {  return !x;  }
 
 //! <b>Returns</b>:!x.
 //!
 template <class T1, class D1>
-inline bool operator==(std::nullptr_t, const unique_ptr<T1, D1> &x) BOOST_NOEXCEPT
+inline bool operator==(BOOST_MOVE_DOC0PTR(bmd::nullptr_type), const unique_ptr<T1, D1> &x) BOOST_NOEXCEPT
 {  return !x;  }
 
 //! <b>Returns</b>: (bool)x.
 //!
 template <class T1, class D1>
-inline bool operator!=(const unique_ptr<T1, D1> &x, std::nullptr_t) BOOST_NOEXCEPT
+inline bool operator!=(const unique_ptr<T1, D1> &x, BOOST_MOVE_DOC0PTR(bmd::nullptr_type)) BOOST_NOEXCEPT
 {  return !!x;  }
 
 //! <b>Returns</b>: (bool)x.
 //!
 template <class T1, class D1>
-inline bool operator!=(std::nullptr_t, const unique_ptr<T1, D1> &x) BOOST_NOEXCEPT
+inline bool operator!=(BOOST_MOVE_DOC0PTR(bmd::nullptr_type), const unique_ptr<T1, D1> &x) BOOST_NOEXCEPT
 {  return !!x;  }
 
-//! <b>Requires</b>: The specialization <tt>less<unique_ptr<T, D>::pointer></tt> shall be a function object type
-//!   that induces a strict weak ordering on the pointer values.
+//! <b>Requires</b>: <tt>operator </tt> shall induce a strict weak ordering on unique_ptr<T1, D1>::pointer values.
 //!
-//! <b>Returns</b>: <tt>less<unique_ptr<T, D>::pointer>()(x.get(), nullptr)</tt>.
+//! <b>Returns</b>: Returns <tt>x.get() < pointer()</tt>.
 template <class T1, class D1>
-inline bool operator<(const unique_ptr<T1, D1> &x, std::nullptr_t)
+inline bool operator<(const unique_ptr<T1, D1> &x, BOOST_MOVE_DOC0PTR(bmd::nullptr_type))
 {
    typedef typename unique_ptr<T1, D1>::pointer pointer;
    return x.get() < pointer();
 }
 
-//! <b>Requires</b>: The specialization <tt>less<unique_ptr<T, D>::pointer></tt> shall be a function object type
-//!   that induces a strict weak ordering on the pointer values.
+//! <b>Requires</b>: <tt>operator </tt> shall induce a strict weak ordering on unique_ptr<T1, D1>::pointer values.
 //!
-//! <b>Returns</b>: The second function template returns <tt>less<unique_ptr<T, D>::pointer>()(nullptr, x.get())</tt>.
+//! <b>Returns</b>: Returns <tt>pointer() < x.get()</tt>.
 template <class T1, class D1>
-inline bool operator<(std::nullptr_t, const unique_ptr<T1, D1> &x)
+inline bool operator<(BOOST_MOVE_DOC0PTR(bmd::nullptr_type), const unique_ptr<T1, D1> &x)
 {
    typedef typename unique_ptr<T1, D1>::pointer pointer;
    return pointer() < x.get();
@@ -1206,7 +884,7 @@ inline bool operator<(std::nullptr_t, const unique_ptr<T1, D1> &x)
 //! <b>Returns</b>: <tt>nullptr < x</tt>.
 //!
 template <class T1, class D1>
-inline bool operator>(const unique_ptr<T1, D1> &x, std::nullptr_t)
+inline bool operator>(const unique_ptr<T1, D1> &x, BOOST_MOVE_DOC0PTR(bmd::nullptr_type))
 {
    typedef typename unique_ptr<T1, D1>::pointer pointer;
    return x.get() > pointer();
@@ -1215,7 +893,7 @@ inline bool operator>(const unique_ptr<T1, D1> &x, std::nullptr_t)
 //! <b>Returns</b>: <tt>x < nullptr</tt>.
 //!
 template <class T1, class D1>
-inline bool operator>(std::nullptr_t, const unique_ptr<T1, D1> &x)
+inline bool operator>(BOOST_MOVE_DOC0PTR(bmd::nullptr_type), const unique_ptr<T1, D1> &x)
 {
    typedef typename unique_ptr<T1, D1>::pointer pointer;
    return pointer() > x.get();
@@ -1224,28 +902,26 @@ inline bool operator>(std::nullptr_t, const unique_ptr<T1, D1> &x)
 //! <b>Returns</b>: <tt>!(nullptr < x)</tt>.
 //!
 template <class T1, class D1>
-inline bool operator<=(const unique_ptr<T1, D1> &x, std::nullptr_t)
-{  return !(nullptr < x);  }
+inline bool operator<=(const unique_ptr<T1, D1> &x, BOOST_MOVE_DOC0PTR(bmd::nullptr_type))
+{  return !(bmd::nullptr_type() < x);  }
 
 //! <b>Returns</b>: <tt>!(x < nullptr)</tt>.
 //!
 template <class T1, class D1>
-inline bool operator<=(std::nullptr_t, const unique_ptr<T1, D1> &x)
-{  return !(x < nullptr);  }
+inline bool operator<=(BOOST_MOVE_DOC0PTR(bmd::nullptr_type), const unique_ptr<T1, D1> &x)
+{  return !(x < bmd::nullptr_type());  }
 
 //! <b>Returns</b>: <tt>!(x < nullptr)</tt>.
 //!
 template <class T1, class D1>
-inline bool operator>=(const unique_ptr<T1, D1> &x, std::nullptr_t)
-{  return !(x < nullptr);  }
+inline bool operator>=(const unique_ptr<T1, D1> &x, BOOST_MOVE_DOC0PTR(bmd::nullptr_type))
+{  return !(x < bmd::nullptr_type());  }
 
 //! <b>Returns</b>: <tt>!(nullptr < x)</tt>.
 //!
 template <class T1, class D1>
-inline bool operator>=(std::nullptr_t, const unique_ptr<T1, D1> &x)
-{  return !(nullptr < x);  }
-
-#endif   //   #if !defined(BOOST_NO_CXX11_NULLPTR) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
+inline bool operator>=(BOOST_MOVE_DOC0PTR(bmd::nullptr_type), const unique_ptr<T1, D1> &x)
+{  return !(bmd::nullptr_type() < x);  }
 
 }  //namespace movelib {
 }  //namespace boost{
diff --git a/test/unique_ptr.cpp b/test/unique_ptr.cpp
index c3b4811..e242406 100644
--- a/test/unique_ptr.cpp
+++ b/test/unique_ptr.cpp
@@ -10,8 +10,6 @@
 // See http://www.boost.org/libs/move for documentation.
 //
 //////////////////////////////////////////////////////////////////////////////
-#include <boost/move/detail/config_begin.hpp>
-
 #include <boost/move/utility_core.hpp>
 #include <boost/move/unique_ptr.hpp>
 #include <boost/static_assert.hpp>
@@ -511,17 +509,22 @@ void test()
 }  //unique_ptr_asgn_move01
 
 ////////////////////////////////
-//   unique_ptr_asgn_null
+//   unique_ptr_zero
 ////////////////////////////////
-namespace unique_ptr_asgn_null {
+namespace unique_ptr_zero {
 
-// test assignment from null
+// test initialization/assignment from zero
 
 void test()
 {
    //Single unique_ptr
    reset_counters();
    {
+   bml::unique_ptr<A> s2(0);
+   BOOST_TEST(A::count == 0);
+   }
+   BOOST_TEST(A::count == 0);
+   {
    bml::unique_ptr<A> s2(new A);
    BOOST_TEST(A::count == 1);
    s2 = 0;
@@ -532,6 +535,11 @@ void test()
 
    //Array unique_ptr
    {
+   bml::unique_ptr<A[]> s2(0);
+   BOOST_TEST(A::count == 0);
+   }
+   BOOST_TEST(A::count == 0);
+   {
    bml::unique_ptr<A[]> s2(new A[2]);
    BOOST_TEST(A::count == 2);
    s2 = 0;
@@ -541,8 +549,7 @@ void test()
    BOOST_TEST(A::count == 0);
 }
 
-
-}  //namespace unique_ptr_asgn_null {
+}  //namespace unique_ptr_zero {
 
 
 ////////////////////////////////
@@ -1476,7 +1483,7 @@ void test()
 {
    //Single unique_ptr
    reset_counters();
-   {
+   {  //reset()
    bml::unique_ptr<A> p(new A);
    BOOST_TEST(A::count == 1);
    A* i = p.get();
@@ -1486,7 +1493,7 @@ void test()
    BOOST_TEST(p.get() == 0);
    }
    BOOST_TEST(A::count == 0);
-   {
+   {  //reset(p)
    bml::unique_ptr<A> p(new A);
    BOOST_TEST(A::count == 1);
    A* i = p.get();
@@ -1495,9 +1502,19 @@ void test()
    BOOST_TEST(A::count == 1);
    }
    BOOST_TEST(A::count == 0);
+   {  //reset(0)
+   bml::unique_ptr<A> p(new A);
+   BOOST_TEST(A::count == 1);
+   A* i = p.get();
+   (void)i;
+   p.reset(0);
+   BOOST_TEST(A::count == 0);
+   BOOST_TEST(p.get() == 0);
+   }
+   BOOST_TEST(A::count == 0);
    //Array unique_ptr
    reset_counters();
-   {
+   {  //reset()
    bml::unique_ptr<A[]> p(new A[2]);
    BOOST_TEST(A::count == 2);
    A* i = p.get();
@@ -1507,7 +1524,7 @@ void test()
    BOOST_TEST(p.get() == 0);
    }
    BOOST_TEST(A::count == 0);
-   {
+   {  //reset(p)
    bml::unique_ptr<A[]> p(new A[2]);
    BOOST_TEST(A::count == 2);
    A* i = p.get();
@@ -1516,6 +1533,16 @@ void test()
    BOOST_TEST(A::count == 3);
    }
    BOOST_TEST(A::count == 0);
+   {  //reset(0)
+   bml::unique_ptr<A[]> p(new A[2]);
+   BOOST_TEST(A::count == 2);
+   A* i = p.get();
+   (void)i;
+   p.reset(0);
+   BOOST_TEST(A::count == 0);
+   BOOST_TEST(p.get() == 0);
+   }
+   BOOST_TEST(A::count == 0);
 }
 
 }  //namespace unique_ptr_modifiers_reset1{
@@ -1820,6 +1847,92 @@ void test()
 
 }  //namespace unique_ptr_observers_op_index{
 
+////////////////////////////////
+//       unique_ptr_nullptr
+////////////////////////////////
+
+namespace unique_ptr_nullptr{
+
+void test()
+{
+   #if !defined(BOOST_NO_CXX11_NULLPTR)
+   //Single unique_ptr
+   reset_counters();
+   {
+      bml::unique_ptr<A> p(new A);
+      BOOST_TEST(A::count == 1);
+      A* i = p.get();
+      (void)i;
+      p.reset(nullptr);
+      BOOST_TEST(A::count == 0);
+      BOOST_TEST(p.get() == 0);
+   }
+   BOOST_TEST(A::count == 0);
+   {
+      bml::unique_ptr<A> p(new A);
+      BOOST_TEST(A::count == 1);
+      A* i = p.get();
+      (void)i;
+      p = nullptr;
+      BOOST_TEST(A::count == 0);
+      BOOST_TEST(p.get() == 0);
+   }
+   BOOST_TEST(A::count == 0);
+
+   {
+      bml::unique_ptr<A> pi(nullptr);
+      BOOST_TEST(pi.get() == nullptr);
+      BOOST_TEST(pi.get() == 0);
+   }
+   BOOST_TEST(A::count == 0);
+   {
+      bml::unique_ptr<A> pi(nullptr, bml::unique_ptr<A>::deleter_type());
+      BOOST_TEST(pi.get() == nullptr);
+      BOOST_TEST(pi.get() == 0);
+   }
+   BOOST_TEST(A::count == 0);
+
+   //Array unique_ptr
+   reset_counters();
+   {
+      bml::unique_ptr<A[]> p(new A[2]);
+      BOOST_TEST(A::count == 2);
+      A* i = p.get();
+      (void)i;
+      p.reset(nullptr);
+      BOOST_TEST(A::count == 0);
+      BOOST_TEST(p.get() == 0);
+   }
+   BOOST_TEST(A::count == 0);
+   {
+      bml::unique_ptr<A[]> p(new A[2]);
+      BOOST_TEST(A::count == 2);
+      A* i = p.get();
+      (void)i;
+      p = nullptr;
+      BOOST_TEST(A::count == 0);
+      BOOST_TEST(p.get() == 0);
+   }
+   BOOST_TEST(A::count == 0);
+   {
+      bml::unique_ptr<A[]> pi(nullptr);
+      BOOST_TEST(pi.get() == nullptr);
+      BOOST_TEST(pi.get() == 0);
+   }
+   BOOST_TEST(A::count == 0);
+   {
+      bml::unique_ptr<A[]> pi(nullptr, bml::unique_ptr<A[]>::deleter_type());
+      BOOST_TEST(pi.get() == nullptr);
+      BOOST_TEST(pi.get() == 0);
+   }
+   BOOST_TEST(A::count == 0);
+
+   //Array element
+   #endif
+}
+
+}  //namespace unique_ptr_nullptr{
+
 ////////////////////////////////
 //             main
 ////////////////////////////////
@@ -1833,7 +1946,6 @@ int main()
    unique_ptr_asgn_move_convert02::test();
    unique_ptr_asgn_move_convert03::test();
    unique_ptr_asgn_move01::test();
-   unique_ptr_asgn_null::test();
 
    //Constructor
    unique_ptr_ctor_default01::test();
@@ -1873,8 +1985,13 @@ int main()
    unique_ptr_observers_op_arrow::test();
    unique_ptr_observers_op_index::test();
 
+   //nullptr
+   unique_ptr_zero::test();
+   unique_ptr_nullptr::test();
+
    //Test results
    return boost::report_errors();
+
 }
 
 //Define the incomplete I type and out of line functions
@@ -1902,6 +2019,3 @@ J<T, D>::~J() {}
 
 void reset_counters()
 {  A::count = 0; B::count = 0; I::count = 0; }
-
-
-#include <boost/move/detail/config_end.hpp>
diff --git a/test/unique_ptr_default_deleter.cpp b/test/unique_ptr_default_deleter.cpp
index a3eff8f..94103f3 100644
--- a/test/unique_ptr_default_deleter.cpp
+++ b/test/unique_ptr_default_deleter.cpp
@@ -10,8 +10,6 @@
 // See http://www.boost.org/libs/move for documentation.
 //
 //////////////////////////////////////////////////////////////////////////////
-#include <boost/move/detail/config_begin.hpp>
-
 #include <boost/move/unique_ptr.hpp>
 #include <boost/core/lightweight_test.hpp>
 
@@ -130,5 +128,3 @@ int main()
    //Test results
    return boost::report_errors();
 }
-
-#include <boost/move/detail/config_end.hpp>
diff --git a/test/unique_ptr_functions.cpp b/test/unique_ptr_functions.cpp
index dfc3f73..d730809 100644
--- a/test/unique_ptr_functions.cpp
+++ b/test/unique_ptr_functions.cpp
@@ -9,7 +9,6 @@
 // See http://www.boost.org/libs/move for documentation.
 //
 //////////////////////////////////////////////////////////////////////////////
-#include <boost/move/detail/config_begin.hpp>
 #include <boost/move/make_unique.hpp>
 #include <boost/core/lightweight_test.hpp>
 
@@ -135,30 +134,135 @@ void test()
 
       //Equal
       BOOST_TEST(rpl == rpl && rpl.get() == rpl.get());
-      BOOST_TEST(!(rpl == rpg) && !(rpl.get() != rpg.get()));
+      BOOST_TEST(!(rpl == rpg) && !(rpl.get() == rpg.get()));
       //Unequal
       BOOST_TEST(rpl != rpg && rpl.get() != rpg.get());
       BOOST_TEST(!(rpl != rpl) && !(rpl.get() != rpl.get()));
       //Less
       BOOST_TEST(rpl < rpg && rpl.get() < rpg.get());
-      BOOST_TEST(!(rpl < rpg) && !(rpl.get() < rpg.get()));
+      BOOST_TEST(!(rpg < rpl) && !(rpg.get() < rpl.get()));
       //Greater
       BOOST_TEST(rpg > rpl && rpg.get() > rpl.get());
-      BOOST_TEST(!(rpg > rpg) && !(rpg.get() > rpl.get()));
+      BOOST_TEST(!(rpg > rpg) && !(rpg.get() > rpg.get()));
       //Less or equal
       BOOST_TEST(rpl <= rpg && rpl.get() <= rpg.get());
       BOOST_TEST(rpl <= rpl && rpl.get() <= rpl.get());
-      BOOST_TEST(!(rpg <= rpl) && !(rpg.get() < rpl.get()));
+      BOOST_TEST(!(rpg <= rpl) && !(rpg.get() <= rpl.get()));
       //Greater or equal
       BOOST_TEST(rpg >= rpl && rpg.get() >= rpl.get());
       BOOST_TEST(rpg >= rpg && rpg.get() >= rpg.get());
-      BOOST_TEST(!(rpl >= rpg) && !(rpl.get() < rpg.get()));
+      BOOST_TEST(!(rpl >= rpg) && !(rpl.get() >= rpg.get()));
    }
    BOOST_TEST(A::count == 0);
 }
 
 }  //namespace unique_compare{
 
+
+////////////////////////////////
+//       unique_compare_zero
+////////////////////////////////
+namespace unique_compare_zero{
+
+void test()
+{
+   //Single element deleter
+   reset_counters();
+   {
+      bml::unique_ptr<A> pa(bml::make_unique<A>());
+      bml::unique_ptr<A> pb;
+      BOOST_TEST(A::count == 1);
+
+      //Equal
+      BOOST_TEST(!(pa == 0));
+      BOOST_TEST(!(0  == pa));
+      BOOST_TEST((pb == 0));
+      BOOST_TEST((0  == pb));
+      //Unequal
+      BOOST_TEST((pa != 0));
+      BOOST_TEST((0  != pa));
+      BOOST_TEST(!(pb != 0));
+      BOOST_TEST(!(0  != pb));
+      //Less
+      BOOST_TEST((pa < 0) == (pa.get() < 0));
+      BOOST_TEST((0 < pa) == (0 < pa.get()));
+      BOOST_TEST((pb < 0) == (pb.get() < 0));
+      BOOST_TEST((0 < pb) == (0 < pb.get()));
+      //Greater
+      BOOST_TEST((pa > 0) == (pa.get() > 0));
+      BOOST_TEST((0 > pa) == (0 > pa.get()));
+      BOOST_TEST((pb > 0) == (pb.get() > 0));
+      BOOST_TEST((0 > pb) == (0 > pb.get()));
+      //Less or equal
+      BOOST_TEST((pa <= 0) == (pa.get() <= 0));
+      BOOST_TEST((0 <= pa) == (0 <= pa.get()));
+      BOOST_TEST((pb <= 0) == (pb.get() <= 0));
+      BOOST_TEST((0 <= pb) == (0 <= pb.get()));
+      //Greater or equal
+      BOOST_TEST((pa >= 0) == (pa.get() >= 0));
+      BOOST_TEST((0 >= pa) == (0 >= pa.get()));
+      BOOST_TEST((pb >= 0) == (pb.get() >= 0));
+      BOOST_TEST((0 >= pb) == (0 >= pb.get()));
+   }
+   BOOST_TEST(A::count == 0);
+}
+
+}  //namespace unique_compare_zero{
+
+////////////////////////////////
+//       unique_compare_nullptr
+////////////////////////////////
+
+namespace unique_compare_nullptr{
+
+void test()
+{
+   #if !defined(BOOST_NO_CXX11_NULLPTR)
+   //Single element deleter
+   reset_counters();
+   {
+      bml::unique_ptr<A> pa(bml::make_unique<A>());
+      bml::unique_ptr<A> pb;
+      BOOST_TEST(A::count == 1);
+
+      //Equal
+      BOOST_TEST(!(pa == nullptr));
+      BOOST_TEST(!(nullptr  == pa));
+      BOOST_TEST((pb == nullptr));
+      BOOST_TEST((nullptr  == pb));
+      //Unequal
+      BOOST_TEST((pa != nullptr));
+      BOOST_TEST((nullptr  != pa));
+      BOOST_TEST(!(pb != nullptr));
+      BOOST_TEST(!(nullptr  != pb));
+      //Less
+      BOOST_TEST((pa < nullptr) == (pa.get() < nullptr));
+      BOOST_TEST((nullptr < pa) == (nullptr < pa.get()));
+      BOOST_TEST((pb < nullptr) == (pb.get() < nullptr));
+      BOOST_TEST((nullptr < pb) == (nullptr < pb.get()));
+      //Greater
+      BOOST_TEST((pa > nullptr) == (pa.get() > nullptr));
+      BOOST_TEST((nullptr > pa) == (nullptr > pa.get()));
+      BOOST_TEST((pb > nullptr) == (pb.get() > nullptr));
+      BOOST_TEST((nullptr > pb) == (nullptr > pb.get()));
+      //Less or equal
+      BOOST_TEST((pa <= nullptr) == (pa.get() <= nullptr));
+      BOOST_TEST((nullptr <= pa) == (nullptr <= pa.get()));
+      BOOST_TEST((pb <= nullptr) == (pb.get() <= nullptr));
+      BOOST_TEST((nullptr <= pb) == (nullptr <= pb.get()));
+      //Greater or equal
+      BOOST_TEST((pa >= nullptr) == (pa.get() >= nullptr));
+      BOOST_TEST((nullptr >= pa) == (nullptr >= pa.get()));
+      BOOST_TEST((pb >= nullptr) == (pb.get() >= nullptr));
+      BOOST_TEST((nullptr >= pb) == (nullptr >= pb.get()));
+   }
+   BOOST_TEST(A::count == 0);
+   #endif   //#if !defined(BOOST_NO_CXX11_NULLPTR)
+}
+
+}  //namespace unique_compare_nullptr{
+
+
 ////////////////////////////////
 //             main
 ////////////////////////////////
@@ -166,9 +270,10 @@ int main()
 {
    make_unique_single::test();
    make_unique_array::test();
+   unique_compare::test();
+   unique_compare_zero::test();
+   unique_compare_nullptr::test();
 
    //Test results
    return boost::report_errors();
 }
-
-#include <boost/move/detail/config_end.hpp>