Rename detail identifiers in addressof

I'm seeing compiler errors with vc12, when testing serialization of Boost.Multiprecision types - there is ambiguity between boost::detail and boost::multiprecision::detail.  I assume the error occurs for serialization of any type that has it's own detail namespace.  The fix is trivially to qualify the use of "detail::".

.travis.yml

@@ -1,4 +1,4 @@
-# Copyright 2016 Peter Dimov
+# Copyright 2016, 2017 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
 
@@ -6,14 +6,13 @@ language: cpp
 
 sudo: false
 
-os:
-  - linux
-  - osx
+python: "2.7"
 
 branches:
   only:
     - master
     - develop
+    - /feature\/.*/
 
 env:
   matrix:
@@ -26,10 +25,12 @@ matrix:
 
   include:
     - os: linux
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=c++03
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
 
     - os: linux
-      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++03
+      compiler: g++-4.7
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
       addons:
         apt:
           packages:
@@ -38,16 +39,8 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-4.7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++03
+      compiler: g++-4.8
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
       addons:
         apt:
           packages:
@@ -56,16 +49,8 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-4.8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++03
+      compiler: g++-4.9
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
       addons:
         apt:
           packages:
@@ -74,16 +59,8 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-4.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++03
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
@@ -92,25 +69,8 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++03
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
@@ -119,40 +79,35 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++11
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
       addons:
         apt:
           packages:
-            - g++-6
+            - g++-7
           sources:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
+
+    - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
-            - g++-6
+            - clang-3.5
+            - libstdc++-4.9-dev
           sources:
             - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
 
     - os: linux
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++1z
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++03
+      compiler: clang++-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
@@ -162,17 +117,8 @@ matrix:
             - llvm-toolchain-precise-3.6
 
     - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - clang-3.6
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.6
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++03
+      compiler: clang++-3.7
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
@@ -182,67 +128,59 @@ matrix:
             - llvm-toolchain-precise-3.7
 
     - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - clang-3.7
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++03
+      compiler: clang++-3.8
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
             - clang-3.8
+            - libstdc++-4.9-dev
           sources:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-precise-3.8
 
     - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++11
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
-            - clang-3.8
+            - clang-3.9
+            - libstdc++-4.9-dev
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
+            - llvm-toolchain-precise-3.9
 
     - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++14
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
-            - clang-3.8
+            - clang-4.0
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
+            - llvm-toolchain-trusty-4.0
 
     - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++1z
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
-            - clang-3.8
+            - clang-5.0
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
+            - llvm-toolchain-trusty-5.0
 
     - os: osx
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
-
-    - os: osx
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
-
-    - os: osx
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++14
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
 
 install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
   - cd ..
-  - git clone -b $TRAVIS_BRANCH https://github.com/boostorg/boost.git boost-root
+  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
   - cd boost-root
   - git submodule init libs/assert
   - git submodule init libs/config
@@ -257,8 +195,8 @@ install:
 
 script:
   - |-
-    echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
-  - ./b2 libs/core/test toolset=$TOOLSET
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ./b2 -j 3 libs/core/test toolset=$TOOLSET cxxstd=$CXXSTD
 
 notifications:
   email:

appveyor.yml

@@ -1,4 +1,4 @@
-# Copyright 2016 Peter Dimov
+# Copyright 2016, 2017 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
 
@@ -10,10 +10,40 @@ branches:
   only:
     - master
     - develop
+    - /feature\/.*/
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\cygwin\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\mingw\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-14.0
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+      CXXSTD: 14,17
 
 install:
+  - set BOOST_BRANCH=develop
+  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
   - cd ..
-  - git clone -b %APPVEYOR_REPO_BRANCH% https://github.com/boostorg/boost.git boost-root
+  - git clone -b %BOOST_BRANCH% https://github.com/boostorg/boost.git boost-root
   - cd boost-root
   - git submodule init libs/assert
   - git submodule init libs/config
@@ -23,10 +53,12 @@ install:
   - git submodule init tools/build
   - git submodule update
   - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\core
-  - bootstrap
+  - cmd /c bootstrap
   - b2 headers
 
 build: off
 
 test_script:
-  - b2 libs/core/test toolset=msvc-9.0,msvc-10.0,msvc-11.0,msvc-14.0
+  - PATH=%ADDPATH%%PATH%
+  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+  - b2 -j 3 libs/core/test toolset=%TOOLSET% %CXXSTD%

doc/noncopyable.qbk

@@ -18,9 +18,9 @@
 
 [section Header <boost/core/noncopyable.hpp>]
 
-The header `<boost/noncopyable.hpp>` defines the class
+The header `<boost/core/noncopyable.hpp>` defines the class
 `boost::noncopyable`. It is intended to be used as a private
-base. `boost::noncopyable` has private (under C++03) or
+base class. `boost::noncopyable` has private (under C++03) or
 deleted (under C++11) copy constructor and a copy assignment
 operator and can't be copied or assigned; a class that derives
 from it inherits these properties.

doc/pointer_traits.qbk

@@ -1,5 +1,5 @@
 [/
-Copyright 2017 Glen Joseph Fernandes
+Copyright 2017-2018 Glen Joseph Fernandes
 (glenjofe@gmail.com)
 
 Distributed under the Boost Software License, Version 1.0.
@@ -20,23 +20,24 @@ The header <boost/core/pointer_traits.hpp> provides the class template
 `boost::pointer_traits` to facilitate use of pointer-like types. The C++11
 standard library introduced `std::pointer_traits` along with an allocator
 model which supported pointer-like types in addition to plain raw pointers.
-This implementation also supports C++98, and adds additional functionality
-for obtaining raw pointers from pointers.
+This implementation also supports C++98.
+
+It also provides the function template `boost::to_address` to obtain a raw
+pointer from an object of any pointer-like type.
 
 [endsect]
 
 [section Examples]
 
-The following function template obtains a raw pointer from a pointer and is
-well defined when the pointer aliases storage that has no object constructed
-in it.
+The following example allocates storage and constructs an object in that
+storage using an allocator.
 
 ```
-template<class T>
-inline typename boost::pointer_traits<T>::element_type*
-to_raw_pointer(T v) noexcept
+template<class Allocator>
+void function(Allocator& a)
 {
-    return boost::pointer_traits<T>::to_address(v);
+    auto p = a.allocate(1);
+    std::allocator_traits<Allocator>::construct(a, boost::to_address(p));
 }
 ```
 
@@ -55,7 +56,6 @@ namespace boost {
     template<class U> using rebind = typename rebind_to<U>::type;
 
     static pointer pointer_to(``['see below]`` v);
-    static element_type* to_address(pointer v) noexcept;
   };
 
   template<class T> struct pointer_traits<T*> {
@@ -67,65 +67,74 @@ namespace boost {
     template<class U> using rebind = typename rebind_to<U>::type;
 
     static pointer pointer_to(``['see below]`` v) noexcept;
-    static element_type* to_address(pointer v) noexcept;
   };
+
+  template<class T>
+  constexpr T* to_address(T* v) noexcept;
+
+  template<class T>
+  auto to_address(const T& v) noexcept;
 }
 ```
 
 [section Member types]
 
 [variablelist
-  [[`typedef` ['see below] `element_type;`]
-    [[variablelist
-      [[Type]
-        [`T::element_type` if such a type exists; otherwise `U` if `T` is a
-          class template instantiation of the form `Pointer<U, Args>`, where
-          `Args` is zero or more type arguments; otherwise the specialization
-          is ill-formed.]]]]]
-  [[`typedef` ['see below] `difference_type;`]
-    [[variablelist
-      [[Type]
-        [`T::difference_type` if such a type exists; otherwise
-          `std::ptrdiff_t`.]]]]]
-  [[`template<class U> struct rebind_to { typedef` ['see below] `type; };`]
-    [[variablelist
-      [[Type]
-        [`type` is `T::rebind<U>` if such a type exists; otherwise,
-          `Pointer<V, Args>` if `T` is a class template instantiation of the
-          form `Pointer<T, Args>`, where `Args` is zero or more type
-          arguments; otherwise, the instantiation of `rebind_to` is
-          ill-formed.]]]]]]
+[[`typedef` ['see below] `element_type;`]
+[`T::element_type` if such a type exists; otherwise `U` if `T` is a class
+  template instantiation of the form `Pointer<U, Args>`, where `Args` is zero
+  or more type arguments; otherwise the specialization is ill-formed.]]
+[[`typedef` ['see below] `difference_type;`]
+[`T::difference_type` if such a type exists; otherwise `std::ptrdiff_t`.]]
+[[`template<class U> struct rebind_to { typedef` ['see below] `type; };`]
+[`type` is `T::rebind<U>` if such a type exists; otherwise, `Pointer<V, Args>`
+  if `T` is a class template instantiation of the form `Pointer<T, Args>`,
+  where `Args` is zero or more type arguments; otherwise, the instantiation of
+  `rebind_to` is ill-formed.]]]
 
 [endsect]
 
 [section Member functions]
 
-[variablelist pointer_traits
-  [[`static pointer pointer_to(`['see below] `v);`]
-    [[variablelist
-      [[Remark]
-        [If `element_type` is a void type, the type of `v` is unspecified;
-          otherwise, it is `element_type&`.]]
-      [[Returns]
-        [A pointer to `v` obtained by calling `T::pointer_to(v)`.]]]]]
-  [[`static element_type* to_address(pointer v) noexcept;`]
-    [[variablelist
-      [[Requires]
-        [`v` is not a null pointer.]]
-      [[Returns]
-        [A pointer of type `element_type*` that references the same location
-          as the argument.]]]]]]
+[variablelist
+[[`static pointer pointer_traits::pointer_to(`['see below] `v);`]
+[[variablelist
+[[Remark]
+[If `element_type` is a void type, the type of `v` is unspecified; otherwise,
+  it is `element_type&`.]]
+[[Returns]
+[A pointer to `v` obtained by calling `T::pointer_to(v)`.]]]]]
+[[`static pointer pointer_traits<T*>::pointer_to(`['see below] `v) noexcept;`]
+[[variablelist
+[[Remark]
+[If `element_type` is a void type, the type of `v` is unspecified; otherwise,
+  it is `element_type&`.]]
+[[Returns] [`addressof(v)`.]]]]]]
 
-[variablelist pointer_traits<T*>
-  [[`static pointer pointer_to(`['see below] `v) noexcept;`]
-    [[variablelist
-      [[Remark]
-        [If `element_type` is a void type, the type of `v` is unspecified;
-          otherwise, it is `element_type&`.]]
-      [[Returns]
-        [The result of `std::addressof(v)`.]]]]]
-  [[`static element_type* to_address(pointer v) noexcept;`]
-    [[variablelist [[Returns] [The value of `v`.]]]]]]
+[endsect]
+
+[section Optional members]
+
+[variablelist
+[[`static element_type* to_address(pointer v) noexcept;`]
+[[variablelist
+[[Returns]
+[A pointer of type `element_type*` that references the same location as the
+  argument `p`.]]
+[[Note]
+[This function should be the inverse of `pointer_to`. If defined, it
+  customizes the behavior of the non-member function `to_address`.]]]]]]
+
+[endsect]
+
+[section Free functions]
+
+[variablelist
+[[`template<class T> constexpr T* to_address(T* v) noexcept;`]
+[[variablelist [[Returns] [`v`.]]]]]
+[[`template<class T> auto to_address(const T& v) noexcept;`]
+[[variablelist [[Returns] [`pointer_traits<T>::to_address(v)` if that
+  expression is well-formed, otherwise `to_address(v.operator->())`.]]]]]]
 
 [endsect]
 
@@ -133,8 +142,8 @@ namespace boost {
 
 [section Acknowledgments]
 
-Glen Fernandes implemented `pointer_traits` with reviews and guidance from
-Peter Dimov.
+Glen Fernandes implemented `pointer_traits` and `to_address` with reviews and
+guidance from Peter Dimov.
 
 [endsect]
 

include/boost/core/addressof.hpp

@@ -49,20 +49,20 @@ namespace boost {
 namespace detail {
 
 template<class T>
-class addressof_ref {
+class addrof_ref {
 public:
-    BOOST_FORCEINLINE addressof_ref(T& o) BOOST_NOEXCEPT
+    BOOST_FORCEINLINE addrof_ref(T& o) BOOST_NOEXCEPT
         : o_(o) { }
     BOOST_FORCEINLINE operator T&() const BOOST_NOEXCEPT {
         return o_;
     }
 private:
-    addressof_ref& operator=(const addressof_ref&);
+    addrof_ref& operator=(const addrof_ref&);
     T& o_;
 };
 
 template<class T>
-struct address_of {
+struct addrof {
     static BOOST_FORCEINLINE T* get(T& o, long) BOOST_NOEXCEPT {
         return reinterpret_cast<T*>(&
             const_cast<char&>(reinterpret_cast<const volatile char&>(o)));
@@ -76,38 +76,38 @@ struct address_of {
 #if !defined(BOOST_NO_CXX11_DECLTYPE) && \
     (defined(__INTEL_COMPILER) || \
         (defined(__clang__) && !defined(_LIBCPP_VERSION)))
-typedef decltype(nullptr) addressof_null_t;
+typedef decltype(nullptr) addrof_null_t;
 #else
-typedef std::nullptr_t addressof_null_t;
+typedef std::nullptr_t addrof_null_t;
 #endif
 
 template<>
-struct address_of<addressof_null_t> {
-    typedef addressof_null_t type;
+struct addrof<addrof_null_t> {
+    typedef addrof_null_t type;
     static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
         return &o;
     }
 };
 
 template<>
-struct address_of<const addressof_null_t> {
-    typedef const addressof_null_t type;
+struct addrof<const addrof_null_t> {
+    typedef const addrof_null_t type;
     static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
         return &o;
     }
 };
 
 template<>
-struct address_of<volatile addressof_null_t> {
-    typedef volatile addressof_null_t type;
+struct addrof<volatile addrof_null_t> {
+    typedef volatile addrof_null_t type;
     static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
         return &o;
     }
 };
 
 template<>
-struct address_of<const volatile addressof_null_t> {
-    typedef const volatile addressof_null_t type;
+struct addrof<const volatile addrof_null_t> {
+    typedef const volatile addrof_null_t type;
     static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
         return &o;
     }
@@ -127,9 +127,9 @@ addressof(T& o) BOOST_NOEXCEPT
 {
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) || \
     BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5120)
-    return detail::address_of<T>::get(o, 0);
+    return boost::detail::addrof<T>::get(o, 0);
 #else
-    return detail::address_of<T>::get(detail::addressof_ref<T>(o), 0);
+    return boost::detail::addrof<T>::get(boost::detail::addrof_ref<T>(o), 0);
 #endif
 }
 
@@ -137,14 +137,14 @@ addressof(T& o) BOOST_NOEXCEPT
 namespace detail {
 
 template<class T>
-struct addressof_result {
+struct addrof_result {
     typedef T* type;
 };
 
 } /* detail */
 
 template<class T, std::size_t N>
-BOOST_FORCEINLINE typename detail::addressof_result<T[N]>::type
+BOOST_FORCEINLINE typename boost::detail::addrof_result<T[N]>::type
 addressof(T (&o)[N]) BOOST_NOEXCEPT
 {
     return &o;
@@ -170,79 +170,79 @@ const T (*addressof(const T (&o)[N]) BOOST_NOEXCEPT)[N]
 namespace detail {
 
 template<class T>
-T addressof_declval() BOOST_NOEXCEPT;
+T addrof_declval() BOOST_NOEXCEPT;
 
 template<class>
-struct addressof_void {
+struct addrof_void {
     typedef void type;
 };
 
 template<class T, class E = void>
-struct addressof_member_operator {
+struct addrof_member_operator {
     static constexpr bool value = false;
 };
 
 template<class T>
-struct addressof_member_operator<T, typename
-    addressof_void<decltype(addressof_declval<T&>().operator&())>::type> {
+struct addrof_member_operator<T, typename
+    addrof_void<decltype(addrof_declval<T&>().operator&())>::type> {
     static constexpr bool value = true;
 };
 
 #if BOOST_WORKAROUND(BOOST_INTEL, < 1600)
-struct addressof_addressable { };
+struct addrof_addressable { };
 
-addressof_addressable*
-operator&(addressof_addressable&) BOOST_NOEXCEPT;
+addrof_addressable*
+operator&(addrof_addressable&) BOOST_NOEXCEPT;
 #endif
 
 template<class T, class E = void>
-struct addressof_non_member_operator {
+struct addrof_non_member_operator {
     static constexpr bool value = false;
 };
 
 template<class T>
-struct addressof_non_member_operator<T, typename
-    addressof_void<decltype(operator&(addressof_declval<T&>()))>::type> {
+struct addrof_non_member_operator<T, typename
+    addrof_void<decltype(operator&(addrof_declval<T&>()))>::type> {
     static constexpr bool value = true;
 };
 
 template<class T, class E = void>
-struct addressof_expression {
+struct addrof_expression {
     static constexpr bool value = false;
 };
 
 template<class T>
-struct addressof_expression<T,
-    typename addressof_void<decltype(&addressof_declval<T&>())>::type> {
+struct addrof_expression<T,
+    typename addrof_void<decltype(&addrof_declval<T&>())>::type> {
     static constexpr bool value = true;
 };
 
 template<class T>
-struct addressof_is_constexpr {
-    static constexpr bool value = addressof_expression<T>::value &&
-        !addressof_member_operator<T>::value &&
-        !addressof_non_member_operator<T>::value;
+struct addrof_is_constexpr {
+    static constexpr bool value = addrof_expression<T>::value &&
+        !addrof_member_operator<T>::value &&
+        !addrof_non_member_operator<T>::value;
 };
 
 template<bool E, class T>
-struct addressof_if { };
+struct addrof_if { };
 
 template<class T>
-struct addressof_if<true, T> {
+struct addrof_if<true, T> {
     typedef T* type;
 };
 
 template<class T>
 BOOST_FORCEINLINE
-typename addressof_if<!addressof_is_constexpr<T>::value, T>::type
+typename addrof_if<!addrof_is_constexpr<T>::value, T>::type
 addressof(T& o) BOOST_NOEXCEPT
 {
-    return address_of<T>::get(addressof_ref<T>(o), 0);
+    return addrof<T>::get(addrof_ref<T>(o), 0);
 }
 
 template<class T>
 constexpr BOOST_FORCEINLINE
-typename addressof_if<addressof_is_constexpr<T>::value, T>::type
+typename addrof_if<addrof_is_constexpr<T>::value, T>::type
 addressof(T& o) BOOST_NOEXCEPT
 {
     return &o;
@@ -254,7 +254,7 @@ template<class T>
 constexpr BOOST_FORCEINLINE T*
 addressof(T& o) BOOST_NOEXCEPT
 {
-    return detail::addressof(o);
+    return boost::detail::addressof(o);
 }
 #endif
 

include/boost/core/lightweight_test.hpp

@@ -19,11 +19,11 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <iterator>
+#include <boost/core/no_exceptions_support.hpp>
 #include <boost/assert.hpp>
 #include <boost/current_function.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 #include <iostream>
+#include <iterator>
 #include <cstring>
 #include <cstddef>
 
@@ -115,7 +115,7 @@ inline const void* test_output_impl(signed char* v) { return v; }
 template<class T> inline const void* test_output_impl(T volatile* v) { return const_cast<T*>(v); }
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
-inline const void* test_output_impl(std::nullptr_t v) { return v; }
+inline const void* test_output_impl(std::nullptr_t) { return nullptr; }
 #endif
 
 template<class T, class U> inline void test_eq_impl( char const * expr1, char const * expr2,

include/boost/core/pointer_traits.hpp

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 Glen Joseph Fernandes
+Copyright 2017-2018 Glen Joseph Fernandes
 (glenjofe@gmail.com)
 
 Distributed under the Boost Software License, Version 1.0.
@@ -17,20 +17,6 @@ Distributed under the Boost Software License, Version 1.0.
 
 namespace boost {
 
-template<class T>
-struct pointer_traits;
-
-namespace detail {
-
-template<class U>
-static typename boost::pointer_traits<U>::element_type*
-ptr_traits_address(U v) BOOST_NOEXCEPT
-{
-    return boost::pointer_traits<U>::to_address(v);
-}
-
-} /* detail */
-
 #if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
 template<class T>
 struct pointer_traits
@@ -39,10 +25,6 @@ struct pointer_traits
     struct rebind_to {
         typedef typename std::pointer_traits<T>::template rebind<U> type;
     };
-    static typename std::pointer_traits<T>::element_type*
-    to_address(T v) BOOST_NOEXCEPT {
-        return detail::ptr_traits_address(v.operator->());
-    }
 };
 
 template<class T>
@@ -52,143 +34,107 @@ struct pointer_traits<T*>
     struct rebind_to {
         typedef U* type;
     };
-    static T* to_address(T* v) BOOST_NOEXCEPT {
-        return v;
-    }
 };
 #else
 namespace detail {
 
-struct ptr_traits_none { char first, second; };
-
-template<class T>
-struct ptr_traits_has_element {
-private:
-    template<class U>
-    static ptr_traits_none call(...);
-    template<class U>
-    static char call(typename U::element_type* = 0);
-public:
-    static const bool value = sizeof(call<T>(0)) == 1;
+template<class>
+struct ptr_void {
+    typedef void type;
 };
 
 template<class T>
-struct ptr_traits_first;
+struct ptr_first;
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 template<template<class, class...> class T, class U, class... Args>
-struct ptr_traits_first<T<U, Args...> > {
+struct ptr_first<T<U, Args...> > {
     typedef U type;
 };
 #else
 template<template<class> class T, class U>
-struct ptr_traits_first<T<U> > {
+struct ptr_first<T<U> > {
     typedef U type;
 };
 
 template<template<class, class> class T, class U1, class U2>
-struct ptr_traits_first<T<U1, U2> > {
+struct ptr_first<T<U1, U2> > {
     typedef U1 type;
 };
 
 template<template<class, class, class> class T, class U1, class U2, class U3>
-struct ptr_traits_first<T<U1, U2, U3> > {
+struct ptr_first<T<U1, U2, U3> > {
     typedef U1 type;
 };
 #endif
 
-template<class T, bool = ptr_traits_has_element<T>::value>
-struct ptr_traits_element {
+template<class T, class = void>
+struct ptr_element {
+    typedef typename ptr_first<T>::type type;
+};
+
+template<class T>
+struct ptr_element<T, typename ptr_void<typename T::element_type>::type> {
     typedef typename T::element_type type;
 };
 
-template<class T>
-struct ptr_traits_element<T, false> {
-    typedef typename ptr_traits_first<T>::type type;
-};
-
-template<class T>
-struct ptr_traits_has_difference {
-private:
-    template<class U>
-    static ptr_traits_none call(...);
-    template<class U>
-    static char call(typename U::difference_type* = 0);
-public:
-    static const bool value = sizeof(call<T>(0)) == 1;
-};
-
-template<class T, bool = ptr_traits_has_difference<T>::value>
-struct ptr_traits_difference {
-    typedef typename T::difference_type type;
-};
-
-template<class T>
-struct ptr_traits_difference<T, false> {
+template<class, class = void>
+struct ptr_difference {
     typedef std::ptrdiff_t type;
 };
 
-template<class T, class V>
-struct ptr_traits_has_rebind {
-private:
-    template<class U>
-    static ptr_traits_none call(...);
-    template<class U>
-    static char call(typename U::template rebind<V>* = 0);
-public:
-    static const bool value = sizeof(call<T>(0)) == 1;
+template<class T>
+struct ptr_difference<T,
+    typename ptr_void<typename T::difference_type>::type> {
+    typedef typename T::difference_type type;
 };
 
 template<class T, class V>
-struct ptr_traits_rebind_to;
+struct ptr_transform;
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 template<template<class, class...> class T, class U, class... Args, class V>
-struct ptr_traits_rebind_to<T<U, Args...>, V> {
+struct ptr_transform<T<U, Args...>, V> {
     typedef T<V, Args...> type;
 };
 #else
 template<template<class> class T, class U, class V>
-struct ptr_traits_rebind_to<T<U>, V> {
+struct ptr_transform<T<U>, V> {
     typedef T<V> type;
 };
 
 template<template<class, class> class T, class U1, class U2, class V>
-struct ptr_traits_rebind_to<T<U1, U2>, V> {
+struct ptr_transform<T<U1, U2>, V> {
     typedef T<V, U2> type;
 };
 
 template<template<class, class, class> class T,
     class U1, class U2, class U3, class V>
-struct ptr_traits_rebind_to<T<U1, U2, U3>, V> {
+struct ptr_transform<T<U1, U2, U3>, V> {
     typedef T<V, U2, U3> type;
 };
 #endif
 
-#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-template<class T, class U, bool = ptr_traits_has_rebind<T, U>::value>
-struct ptr_traits_rebind {
-    typedef typename T::template rebind<U> type;
+template<class T, class U, class = void>
+struct ptr_rebind {
+    typedef typename ptr_transform<T, U>::type type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 template<class T, class U>
-struct ptr_traits_rebind<T, U, false> {
-    typedef typename ptr_traits_rebind_to<T, U>::type type;
-};
-#else
-template<class T, class U>
-struct ptr_traits_rebind {
-    typedef typename ptr_traits_rebind_to<T, U>::type type;
+struct ptr_rebind<T, U,
+    typename ptr_void<typename T::template rebind<U> >::type> {
+    typedef typename T::template rebind<U> type;
 };
 #endif
 
 template<class T>
-struct ptr_traits_value {
+struct ptr_value {
     typedef T type;
 };
 
 template<>
-struct ptr_traits_value<void> {
+struct ptr_value<void> {
     typedef struct { } type;
 };
 
@@ -197,23 +143,20 @@ struct ptr_traits_value<void> {
 template<class T>
 struct pointer_traits {
     typedef T pointer;
-    typedef typename detail::ptr_traits_element<T>::type element_type;
-    typedef typename detail::ptr_traits_difference<T>::type difference_type;
+    typedef typename detail::ptr_element<T>::type element_type;
+    typedef typename detail::ptr_difference<T>::type difference_type;
     template<class U>
     struct rebind_to {
-        typedef typename detail::ptr_traits_rebind<T, U>::type type;
+        typedef typename detail::ptr_rebind<T, U>::type type;
     };
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
     template<class U>
-    using rebind = typename detail::ptr_traits_rebind<T, U>::type;
+    using rebind = typename detail::ptr_rebind<T, U>::type;
 #endif
     static pointer
-    pointer_to(typename detail::ptr_traits_value<element_type>::type& v) {
+    pointer_to(typename detail::ptr_value<element_type>::type& v) {
         return pointer::pointer_to(v);
     }
-    static element_type* to_address(pointer v) BOOST_NOEXCEPT {
-        return detail::ptr_traits_address(v.operator->());
-    }
 };
 
 template<class T>
@@ -230,15 +173,61 @@ struct pointer_traits<T*> {
     using rebind = U*;
 #endif
     static T*
-    pointer_to(typename detail::ptr_traits_value<T>::type& v) BOOST_NOEXCEPT {
-        return addressof(v);
-    }
-    static T* to_address(T* v) BOOST_NOEXCEPT {
-        return v;
+    pointer_to(typename detail::ptr_value<T>::type& v) BOOST_NOEXCEPT {
+        return boost::addressof(v);
     }
 };
 #endif
 
+template<class T>
+BOOST_CONSTEXPR inline T*
+to_address(T* v) BOOST_NOEXCEPT
+{
+    return v;
+}
+
+#if !defined(BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION)
+namespace detail {
+
+template<class T>
+inline T*
+ptr_address(T* v, int) BOOST_NOEXCEPT
+{
+    return v;
+}
+
+template<class T>
+inline auto
+ptr_address(const T& v, int) BOOST_NOEXCEPT
+-> decltype(boost::pointer_traits<T>::to_address(v))
+{
+    return boost::pointer_traits<T>::to_address(v);
+}
+
+template<class T>
+inline auto
+ptr_address(const T& v, long) BOOST_NOEXCEPT
+{
+    return boost::detail::ptr_address(v.operator->(), 0);
+}
+
+} /* detail */
+
+template<class T>
+inline auto
+to_address(const T& v) BOOST_NOEXCEPT
+{
+    return boost::detail::ptr_address(v, 0);
+}
+#else
+template<class T>
+inline typename pointer_traits<T>::element_type*
+to_address(const T& v) BOOST_NOEXCEPT
+{
+    return boost::to_address(v.operator->());
+}
+#endif
+
 } /* boost */
 
 #endif

include/boost/utility/empty_deleter.hpp

@@ -1,43 +0,0 @@
-/*
- *          Copyright Andrey Semashev 2007 - 2013.
- * Distributed under the Boost Software License, Version 1.0.
- *    (See accompanying file LICENSE_1_0.txt or copy at
- *          http://www.boost.org/LICENSE_1_0.txt)
- */
-
-/*!
- * \file   empty_deleter.hpp
- * \author Andrey Semashev
- * \date   22.04.2007
- *
- * This header contains an \c empty_deleter implementation. This is an empty
- * function object that receives a pointer and does nothing with it.
- * Such empty deletion strategy may be convenient, for example, when
- * constructing <tt>shared_ptr</tt>s that point to some object that should not be
- * deleted (i.e. a variable on the stack or some global singleton, like <tt>std::cout</tt>).
- */
-
-#ifndef BOOST_UTILITY_EMPTY_DELETER_HPP
-#define BOOST_UTILITY_EMPTY_DELETER_HPP
-
-#include <boost/config.hpp>
-#include <boost/core/null_deleter.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-#if defined(__GNUC__)
-#pragma message "This header is deprecated, use boost/core/null_deleter.hpp instead."
-#elif defined(_MSC_VER)
-#pragma message("This header is deprecated, use boost/core/null_deleter.hpp instead.")
-#endif
-
-namespace boost {
-
-//! A deprecated name for \c null_deleter
-typedef null_deleter empty_deleter;
-
-} // namespace boost
-
-#endif // BOOST_UTILITY_EMPTY_DELETER_HPP

test/Jamfile.v2

@@ -1,6 +1,6 @@
 #  Boost.Core Library test Jamfile
 #
-#  Copyright (c) 2014 Peter Dimov
+#  Copyright (c) 2014, 2017 Peter Dimov
 #
 #  Distributed under the Boost Software License, Version 1.0.
 #  See accompanying file LICENSE_1_0.txt or copy at
@@ -9,6 +9,10 @@
 import modules ;
 import testing ;
 
+# quick test (for CI)
+run quick.cpp ;
+
+# full test suite
 run addressof_test.cpp ;
 run addressof_test2.cpp ;
 run addressof_np_test.cpp ;
@@ -110,12 +114,12 @@ compile-fail scoped_enum_compile_fail_conv_to_int.cpp ;
 
 run underlying_type.cpp ;
 
-run pointer_traits_to_address_test.cpp ;
 run pointer_traits_pointer_test.cpp ;
 run pointer_traits_element_type_test.cpp ;
 run pointer_traits_difference_type_test.cpp ;
 run pointer_traits_rebind_test.cpp ;
 run pointer_traits_pointer_to_test.cpp ;
+run to_address_test.cpp ;
 
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;

test/pointer_traits_to_address_test.cpp

@@ -1,63 +0,0 @@
-/*
-Copyright 2017 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/core/pointer_traits.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-template<class T>
-class pointer {
-public:
-    typedef typename boost::pointer_traits<T>::element_type element_type;
-    pointer(T value)
-        : value_(value) { }
-    T operator->() const BOOST_NOEXCEPT {
-        return value_;
-    }
-private:
-    T value_;
-};
-
-int main()
-{
-    int i = 0;
-    {
-        typedef int* type;
-        type p = &i;
-        BOOST_TEST(boost::pointer_traits<type>::to_address(p) == &i);
-    }
-    {
-        typedef pointer<int*> type;
-        type p(&i);
-        BOOST_TEST(boost::pointer_traits<type>::to_address(p) == &i);
-    }
-    {
-        typedef pointer<pointer<int*> > type;
-        type p(&i);
-        BOOST_TEST(boost::pointer_traits<type>::to_address(p) == &i);
-    }
-    {
-        typedef void* type;
-        type p = &i;
-        BOOST_TEST(boost::pointer_traits<type>::to_address(p) == &i);
-    }
-    {
-        typedef pointer<void*> type;
-        type p(&i);
-        BOOST_TEST(boost::pointer_traits<type>::to_address(p) == &i);
-    }
-    {
-        typedef const int* type;
-        type p = &i;
-        BOOST_TEST(boost::pointer_traits<type>::to_address(p) == &i);
-    }
-    {
-        typedef pointer<const int*> type;
-        type p(&i);
-        BOOST_TEST(boost::pointer_traits<type>::to_address(p) == &i);
-    }
-    return boost::report_errors();
-}

test/quick.cpp

@@ -0,0 +1,34 @@
+//
+// quick.cpp - a quick (CI) test for Boost.Core
+//
+// Copyright 2017 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+//
+
+#include <boost/core/addressof.hpp>
+#include <boost/core/checked_delete.hpp>
+#include <boost/core/demangle.hpp>
+#include <boost/detail/iterator.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/core/explicit_operator_bool.hpp>
+#include <boost/get_pointer.hpp>
+#include <boost/core/ignore_unused.hpp>
+#include <boost/core/is_same.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/core/null_deleter.hpp>
+#include <boost/core/pointer_traits.hpp>
+#include <boost/ref.hpp>
+#include <boost/core/scoped_enum.hpp>
+#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/core/typeinfo.hpp>
+#include <boost/core/underlying_type.hpp>
+#include <boost/visit_each.hpp>
+
+int main()
+{
+}

test/to_address_test.cpp

@@ -0,0 +1,158 @@
+/*
+Copyright 2017-2018 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/core/pointer_traits.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+template<class T>
+class P1 {
+public:
+    explicit P1(T* p)
+        : p_(p) { }
+    T* operator->() const BOOST_NOEXCEPT {
+        return p_;
+    }
+private:
+    T* p_;
+};
+
+template<class T>
+class P2 {
+public:
+    explicit P2(T* p)
+        : p_(p) { }
+    P1<T> operator->() const BOOST_NOEXCEPT {
+        return p_;
+    }
+private:
+    P1<T> p_;
+};
+
+#if !defined(BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION)
+template<class T>
+class P3 {
+public:
+    explicit P3(T* p)
+        : p_(p) { }
+    T* get() const BOOST_NOEXCEPT {
+        return p_;
+    }
+private:
+    T* p_;
+};
+
+namespace boost {
+template<class T>
+struct pointer_traits<P3<T> > {
+    static T* to_address(const P3<T>& p) BOOST_NOEXCEPT {
+        return p.get();
+    }
+};
+} /* boost */
+
+template<class T>
+class P4 {
+public:
+    explicit P4(T* p)
+        : p_(p) { }
+    T* operator->() const BOOST_NOEXCEPT {
+        return 0;
+    }
+    T* get() const BOOST_NOEXCEPT {
+        return p_;
+    }
+private:
+    int* p_;
+};
+
+namespace boost {
+template<class T>
+struct pointer_traits<P4<T> > {
+    static T* to_address(const P4<T>& p) BOOST_NOEXCEPT {
+        return p.get();
+    }
+};
+} /* boost */
+
+#if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
+template<class T>
+class P5 {
+public:
+    explicit P5(T* p)
+        : p_(p) { }
+    T* get() const BOOST_NOEXCEPT {
+        return p_;
+    }
+private:
+    T* p_;
+};
+
+namespace std {
+template<class T>
+struct pointer_traits<P5<T> > {
+    static T* to_address(const P5<T>& p) BOOST_NOEXCEPT {
+        return p.get();
+    }
+};
+} /* std */
+
+template<class T>
+class P6 {
+public:
+    explicit P6(T* p)
+        : p_(p) { }
+    T* get() const BOOST_NOEXCEPT {
+        return p_;
+    }
+private:
+    T* p_;
+};
+
+namespace boost {
+template<class T>
+struct pointer_traits<P6<T> > {
+    static T* to_address(const P6<T>& p) BOOST_NOEXCEPT {
+        return p.get();
+    }
+};
+} /* boost */
+
+namespace std {
+template<class T>
+struct pointer_traits<P6<T> > {
+    static T* to_address(const P6<T>& p) BOOST_NOEXCEPT {
+        return 0;
+    }
+};
+} /* std */
+#endif
+#endif
+
+int main()
+{
+    int i = 0;
+    BOOST_TEST(boost::to_address(&i) == &i);
+    int* p = &i;
+    BOOST_TEST(boost::to_address(p) == &i);
+    P1<int> p1(&i);
+    BOOST_TEST(boost::to_address(p1) == &i);
+    P2<int> p2(&i);
+    BOOST_TEST(boost::to_address(p2) == &i);
+#if !defined(BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION)
+    P3<int> p3(&i);
+    BOOST_TEST(boost::to_address(p3) == &i);
+    P4<int> p4(&i);
+    BOOST_TEST(boost::to_address(p4) == &i);
+#if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
+    P5<int> p5(&i);
+    BOOST_TEST(boost::to_address(p5) == &i);
+    P6<int> p6(&i);
+    BOOST_TEST(boost::to_address(p6) == &i);
+#endif
+#endif
+    return boost::report_errors();
+}