Silenced warnings about unused variables.

Fix test for enable_if_has_type

.travis.yml

@@ -0,0 +1,41 @@
+# Copyright 2016 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+os:
+  - linux
+  - osx
+
+branches:
+  only:
+    - master
+    - develop
+
+install:
+  - cd ..
+  - git clone -b $TRAVIS_BRANCH https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule init libs/assert
+  - git submodule init libs/config
+  - git submodule init libs/predef
+  - git submodule init libs/static_assert
+  - git submodule init libs/type_traits
+  - git submodule init tools/build
+  - git submodule init tools/inspect
+  - git submodule update
+  - cp -r $TRAVIS_BUILD_DIR/* libs/core
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - TOOLSET=gcc,clang
+  - if [ $TRAVIS_OS_NAME == osx ]; then TOOLSET=clang; fi
+  - ./b2 libs/core/test toolset=$TOOLSET
+
+notifications:
+  email:
+    on_success: always

README.md

@@ -8,6 +8,13 @@ The criteria for inclusion is that the utility component be:
 * used by other Boost libraries, and
 * not dependent on any other Boost modules except Core itself, Config, Assert, Static Assert, or Predef.
 
+### CI Status
+
+Branch   | Travis | Appveyor
+---------|--------|---------
+Develop  | [![Build Status](https://travis-ci.org/boostorg/core.svg?branch=develop)](https://travis-ci.org/boostorg/core) | [![Build Status](https://ci.appveyor.com/api/projects/status/github/boostorg/core?branch=develop&svg=true)](https://ci.appveyor.com/project/pdimov/core)
+Master   | [![Build Status](https://travis-ci.org/boostorg/core.svg?branch=master)](https://travis-ci.org/boostorg/core) | [![Build Status](https://ci.appveyor.com/api/projects/status/github/boostorg/core?branch=master&svg=true)](https://ci.appveyor.com/project/pdimov/core)
+
 ### Directories
 
 * **doc** - Documentation of the components
@@ -16,7 +23,9 @@ The criteria for inclusion is that the utility component be:
 
 ### More information
 
-* [Documentation](http://boostorg.github.io/core)
+* [Documentation](http://boost.org/libs/core)
+* [Report bugs](https://svn.boost.org/trac/boost/newticket?component=core;version=Boost%20Release%20Branch). Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
+* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
 
 ### License
 

appveyor.yml

@@ -0,0 +1,33 @@
+# Copyright 2016 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+
+install:
+  - cd ..
+  - git clone -b %APPVEYOR_REPO_BRANCH% https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule init libs/assert
+  - git submodule init libs/config
+  - git submodule init libs/predef
+  - git submodule init libs/static_assert
+  - git submodule init libs/type_traits
+  - git submodule init tools/build
+  - git submodule init tools/inspect
+  - git submodule update
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\core
+  - bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - b2 libs/core/test toolset=msvc-9.0,msvc-10.0,msvc-11.0,msvc-14.0

doc/Jamfile.v2

@@ -51,3 +51,9 @@ boostbook standalone
     <xsl:param>toc.max.depth=1
     <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/core/doc/html
   ;
+
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : standalone ;
+explicit boostrelease ;

doc/enable_if.qbk

@@ -304,6 +304,26 @@ depends on the template arguments of the class. Note that
 again, the second argument to `enable_if` is not needed; the
 default (`void`) is the correct value.
 
+The `enable_if_has_type` template is usable this scenario but instead of
+using a type traits to enable or disable a specialization, it use a
+SFINAE context to check for the existence of a dependent type inside
+its parameter. For example, the following structure extracts a dependent
+`value_type` from T if and only if `T::value_type` exists.
+
+``
+template <class T, class Enable = void>
+class value_type_from
+{
+  typedef T type;
+};
+
+template <class T>
+class value_type_from<T, typename enable_if_has_type<typename T::value_type>::type>
+{
+  typedef typename T::value_type type;
+};
+``
+
 [endsect]
 
 [section Overlapping enabler conditions]

doc/lightweight_test.qbk

@@ -32,6 +32,7 @@ When using `lightweight_test.hpp`, *do not forget* to
 
 ``
 #define BOOST_TEST(expression) /*unspecified*/
+#define BOOST_TEST_NOT(expression) /*unspecified*/
 #define BOOST_ERROR(message) /*unspecified*/
 #define BOOST_TEST_EQ(expr1, expr2) /*unspecified*/
 #define BOOST_TEST_NE(expr1, expr2) /*unspecified*/
@@ -56,6 +57,17 @@ message containing `expression`.
 
 [endsect]
 
+[section BOOST_TEST_NOT]
+
+``
+BOOST_TEST_NOT(expression)
+``
+
+If expression is true increases the error count and outputs a
+message containing `!(expression)`.
+
+[endsect]
+
 [section BOOST_ERROR]
 
 ``

include/boost/core/addressof.hpp

@@ -107,7 +107,7 @@ template<class T>
 BOOST_FORCEINLINE
 T * addressof( T & v )
 {
-#if (defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) ) ) || defined( __SUNPRO_CC )
+#if (defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) ) ) || (defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5120))
 
     return boost::detail::addressof_impl<T>::f( v, 0 );
 

include/boost/core/demangle.hpp

@@ -17,7 +17,10 @@
 # pragma once
 #endif
 
-#if defined( __clang__ ) && defined( __has_include )
+// __has_include is currently supported by GCC and Clang. However GCC 4.9 may have issues and
+// returns 1 for 'defined( __has_include )', while '__has_include' is actually not supported:
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63662
+#if defined( __has_include ) && (!defined( BOOST_GCC ) || (__GNUC__ + 0) >= 5)
 # if __has_include(<cxxabi.h>)
 #  define BOOST_CORE_HAS_CXXABI_H
 # endif
@@ -27,8 +30,15 @@
 
 #if defined( BOOST_CORE_HAS_CXXABI_H )
 # include <cxxabi.h>
-# include <cstdlib>
-# include <cstddef>
+// For some archtectures (mips, mips64, x86, x86_64) cxxabi.h in Android NDK is implemented by gabi++ library
+// (https://android.googlesource.com/platform/ndk/+/master/sources/cxx-stl/gabi++/), which does not implement
+// abi::__cxa_demangle(). We detect this implementation by checking the include guard here.
+# if defined( __GABIXX_CXXABI_H__ )
+#  undef BOOST_CORE_HAS_CXXABI_H
+# else
+#  include <cstdlib>
+#  include <cstddef>
+# endif
 #endif
 
 namespace boost

include/boost/core/enable_if.hpp

@@ -23,6 +23,11 @@
 
 namespace boost
 {
+  template<typename T, typename R=void>
+  struct enable_if_has_type
+  {
+    typedef R type;
+  };
  
   template <bool B, class T = void>
   struct enable_if_c {
@@ -80,6 +85,10 @@ namespace boost {
   template <typename T>
   struct enable_if_does_not_work_on_this_compiler;
 
+  template<typename T, typename R=void>
+  struct enable_if_has_type : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
   template <bool B, class T = detail::enable_if_default_T>
   struct enable_if_c : enable_if_does_not_work_on_this_compiler<T>
   { };

include/boost/core/ignore_unused.hpp

@@ -14,53 +14,53 @@ namespace boost {
 #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
 
 template <typename... Ts>
-inline void ignore_unused(Ts const& ...)
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(Ts const& ...)
 {}
 
 template <typename... Ts>
-inline void ignore_unused()
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
 {}
 
 #else
 
 template <typename T1>
-inline void ignore_unused(T1 const&)
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&)
 {}
 
 template <typename T1, typename T2>
-inline void ignore_unused(T1 const&, T2 const&)
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&)
 {}
 
 template <typename T1, typename T2, typename T3>
-inline void ignore_unused(T1 const&, T2 const&, T3 const&)
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&, T3 const&)
 {}
 
 template <typename T1, typename T2, typename T3, typename T4>
-inline void ignore_unused(T1 const&, T2 const&, T3 const&, T4 const&)
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&, T3 const&, T4 const&)
 {}
 
 template <typename T1, typename T2, typename T3, typename T4, typename T5>
-inline void ignore_unused(T1 const&, T2 const&, T3 const&, T4 const&, T5 const&)
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&, T3 const&, T4 const&, T5 const&)
 {}
 
 template <typename T1>
-inline void ignore_unused()
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
 {}
 
 template <typename T1, typename T2>
-inline void ignore_unused()
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
 {}
 
 template <typename T1, typename T2, typename T3>
-inline void ignore_unused()
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
 {}
 
 template <typename T1, typename T2, typename T3, typename T4>
-inline void ignore_unused()
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
 {}
 
 template <typename T1, typename T2, typename T3, typename T4, typename T5>
-inline void ignore_unused()
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
 {}
 
 #endif

include/boost/core/lightweight_test.hpp

@@ -85,6 +85,22 @@ inline void throw_failed_impl(char const * excep, char const * file, int line, c
    ++test_errors();
 }
 
+// In the comparisons below, it is possible that T and U are signed and unsigned integer types, which generates warnings in some compilers.
+// A cleaner fix would require common_type trait or some meta-programming, which would introduce a dependency on Boost.TypeTraits. To avoid
+// the dependency we just disable the warnings.
+#if defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable: 4389)
+#elif defined(__clang__) && defined(__has_warning)
+# if __has_warning("-Wsign-compare")
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wsign-compare"
+# endif
+#elif defined(__GNUC__) && !(defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 406
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
 template<class T, class U> inline void test_eq_impl( char const * expr1, char const * expr2,
   char const * file, int line, char const * function, T const & t, U const & u )
 {
@@ -119,13 +135,23 @@ template<class T, class U> inline void test_ne_impl( char const * expr1, char co
     }
 }
 
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#elif defined(__clang__) && defined(__has_warning)
+# if __has_warning("-Wsign-compare")
+#  pragma clang diagnostic pop
+# endif
+#elif defined(__GNUC__) && !(defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 406
+# pragma GCC diagnostic pop
+#endif
+
 } // namespace detail
 
 inline int report_errors()
 {
-    detail::report_errors_remind().called_report_errors_function = true;
+    boost::detail::report_errors_remind().called_report_errors_function = true;
 
-    int errors = detail::test_errors();
+    int errors = boost::detail::test_errors();
 
     if( errors == 0 )
     {
@@ -144,6 +170,7 @@ inline int report_errors()
 } // namespace boost
 
 #define BOOST_TEST(expr) ((expr)? (void)0: ::boost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION))
+#define BOOST_TEST_NOT(expr) BOOST_TEST(!(expr))
 
 #define BOOST_ERROR(msg) ( ::boost::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
 

include/boost/core/scoped_enum.hpp

@@ -43,7 +43,8 @@ namespace boost
    * @throws No-throws.
    */
   template <typename UnderlyingType, typename EnumType>
-  UnderlyingType underlying_cast(EnumType v)
+  inline
+  BOOST_CONSTEXPR UnderlyingType underlying_cast(EnumType v) BOOST_NOEXCEPT
   {
     return v.get_underlying_value_();
   }
@@ -61,7 +62,7 @@ namespace boost
    */
   template <typename EnumType>
   inline
-  typename EnumType::enum_type native_value(EnumType e)
+  BOOST_CONSTEXPR typename EnumType::enum_type native_value(EnumType e) BOOST_NOEXCEPT
   {
     return e.get_native_value_();
   }
@@ -75,14 +76,15 @@ namespace boost
   };
 
   template <typename UnderlyingType, typename EnumType>
-  UnderlyingType underlying_cast(EnumType v)
+  inline
+  BOOST_CONSTEXPR UnderlyingType underlying_cast(EnumType v) BOOST_NOEXCEPT
   {
     return static_cast<UnderlyingType>(v);
   }
 
   template <typename EnumType>
   inline
-  EnumType native_value(EnumType e)
+  BOOST_CONSTEXPR EnumType native_value(EnumType e) BOOST_NOEXCEPT
   {
     return e;
   }
@@ -96,7 +98,7 @@ namespace boost
 #ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
 
 #define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \
-     explicit operator underlying_type() const BOOST_NOEXCEPT { return get_underlying_value_(); }
+     explicit BOOST_CONSTEXPR operator underlying_type() const BOOST_NOEXCEPT { return get_underlying_value_(); }
 
 #else
 
@@ -115,8 +117,8 @@ namespace boost
         typedef void is_boost_scoped_enum_tag;                          \
         typedef UnderlyingType underlying_type;                         \
         EnumType() BOOST_NOEXCEPT {}                                    \
-        explicit EnumType(underlying_type v) BOOST_NOEXCEPT : v_(v) {}                 \
-        underlying_type get_underlying_value_() const BOOST_NOEXCEPT { return v_; }    \
+        explicit BOOST_CONSTEXPR EnumType(underlying_type v) BOOST_NOEXCEPT : v_(v) {}                 \
+        BOOST_CONSTEXPR underlying_type get_underlying_value_() const BOOST_NOEXCEPT { return v_; }    \
         BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR                \
     private:                                                            \
         underlying_type v_;                                             \
@@ -125,30 +127,30 @@ namespace boost
         enum enum_type
 
 #define BOOST_SCOPED_ENUM_DECLARE_END2() \
-        enum_type get_native_value_() const BOOST_NOEXCEPT { return enum_type(v_); } \
-        friend bool operator ==(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==enum_type(rhs.v_); } \
-        friend bool operator ==(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==rhs; } \
-        friend bool operator ==(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs==enum_type(rhs.v_); } \
-        friend bool operator !=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=enum_type(rhs.v_); } \
-        friend bool operator !=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=rhs; } \
-        friend bool operator !=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs!=enum_type(rhs.v_); } \
-        friend bool operator <(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<enum_type(rhs.v_); } \
-        friend bool operator <(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<rhs; } \
-        friend bool operator <(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<enum_type(rhs.v_); } \
-        friend bool operator <=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=enum_type(rhs.v_); } \
-        friend bool operator <=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=rhs; } \
-        friend bool operator <=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<=enum_type(rhs.v_); } \
-        friend bool operator >(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>enum_type(rhs.v_); } \
-        friend bool operator >(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>rhs; } \
-        friend bool operator >(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>enum_type(rhs.v_); } \
-        friend bool operator >=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=enum_type(rhs.v_); } \
-        friend bool operator >=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=rhs; } \
-        friend bool operator >=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>=enum_type(rhs.v_); } \
+        BOOST_CONSTEXPR enum_type get_native_value_() const BOOST_NOEXCEPT { return enum_type(v_); } \
+        friend BOOST_CONSTEXPR bool operator ==(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator ==(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==rhs; } \
+        friend BOOST_CONSTEXPR bool operator ==(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs==enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator !=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator !=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=rhs; } \
+        friend BOOST_CONSTEXPR bool operator !=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs!=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<rhs; } \
+        friend BOOST_CONSTEXPR bool operator <(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=rhs; } \
+        friend BOOST_CONSTEXPR bool operator <=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>rhs; } \
+        friend BOOST_CONSTEXPR bool operator >(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=rhs; } \
+        friend BOOST_CONSTEXPR bool operator >=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>=enum_type(rhs.v_); } \
     };
 
 #define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) \
     ; \
-    EnumType(enum_type v) BOOST_NOEXCEPT : v_(v) {}                 \
+    BOOST_CONSTEXPR EnumType(enum_type v) BOOST_NOEXCEPT : v_(v) {}                 \
     BOOST_SCOPED_ENUM_DECLARE_END2()
 
 /**

include/boost/detail/iterator.hpp

@@ -9,6 +9,9 @@
 // This header is obsolete and will be deprecated.
 
 #include <iterator>
+#if defined(__SUNPRO_CC) && (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
+#include <cstddef>
+#endif
 
 namespace boost
 {
@@ -19,6 +22,16 @@ namespace detail
 using std::iterator_traits;
 using std::distance;
 
+#if defined(__SUNPRO_CC) && (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
+// std::distance from stlport with Oracle compiler 12.4 and 12.5 fails to deduce template parameters
+// when one of the arguments is an array and the other one is a pointer.
+template< typename T, std::size_t N >
+inline typename std::iterator_traits< T* >::difference_type distance(T (&left)[N], T* right)
+{
+    return std::distance(static_cast< T* >(left), right);
+}
+#endif
+
 } // namespace detail
 
 } // namespace boost

include/boost/get_pointer.hpp

@@ -24,11 +24,39 @@ template<class T> T * get_pointer(T * p)
 
 // get_pointer(shared_ptr<T> const & p) has been moved to shared_ptr.hpp
 
+#if !defined( BOOST_NO_AUTO_PTR )
+
+#if defined( __GNUC__ ) && (defined( __GXX_EXPERIMENTAL_CXX0X__ ) || (__cplusplus >= 201103L))
+#if defined( BOOST_GCC )
+#if BOOST_GCC >= 40600
+#define BOOST_CORE_DETAIL_DISABLE_LIBSTDCXX_DEPRECATED_WARNINGS
+#endif // BOOST_GCC >= 40600
+#elif defined( __clang__ ) && defined( __has_warning )
+#if __has_warning("-Wdeprecated-declarations")
+#define BOOST_CORE_DETAIL_DISABLE_LIBSTDCXX_DEPRECATED_WARNINGS
+#endif // __has_warning("-Wdeprecated-declarations")
+#endif
+#endif // defined( __GNUC__ ) && (defined( __GXX_EXPERIMENTAL_CXX0X__ ) || (__cplusplus >= 201103L))
+
+#if defined( BOOST_CORE_DETAIL_DISABLE_LIBSTDCXX_DEPRECATED_WARNINGS )
+// Disable libstdc++ warnings about std::auto_ptr being deprecated in C++11 mode
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#define BOOST_CORE_DETAIL_DISABLED_DEPRECATED_WARNINGS
+#endif
+
 template<class T> T * get_pointer(std::auto_ptr<T> const& p)
 {
     return p.get();
 }
 
+#if defined( BOOST_CORE_DETAIL_DISABLE_LIBSTDCXX_DEPRECATED_WARNINGS )
+#pragma GCC diagnostic pop
+#undef BOOST_CORE_DETAIL_DISABLE_LIBSTDCXX_DEPRECATED_WARNINGS
+#endif
+
+#endif // !defined( BOOST_NO_AUTO_PTR )
+
 #if !defined( BOOST_NO_CXX11_SMART_PTR )
 
 template<class T> T * get_pointer( std::unique_ptr<T> const& p )

test/Jamfile.v2

@@ -6,6 +6,7 @@
 #  See accompanying file LICENSE_1_0.txt or copy at
 #  http://www.boost.org/LICENSE_1_0.txt
 
+import modules ;
 import testing ;
 
 run addressof_test.cpp ;
@@ -92,3 +93,6 @@ compile-fail scoped_enum_compile_fail_conv_from_int.cpp ;
 compile-fail scoped_enum_compile_fail_conv_to_int.cpp ;
 
 run underlying_type.cpp ;
+
+use-project /boost/core/swap : ./swap ;
+build-project ./swap ;

test/demangle_test.cpp

@@ -10,6 +10,7 @@
 //
 
 #include <boost/core/demangle.hpp>
+#include <typeinfo>
 #include <iostream>
 
 template<class T1, class T2> struct Y1

test/eif_namespace_disambiguation.cpp

@@ -10,16 +10,19 @@
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 
-#include <boost/mpl/not.hpp>
-
+#include <boost/config.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/detail/lightweight_test.hpp>
 
 using boost::enable_if;
-using boost::mpl::not_;
 using boost::is_arithmetic;
 
+template<class T> struct not_
+{
+  BOOST_STATIC_CONSTANT( bool, value = !T::value );
+};
+
 namespace A {
   template<class T>
   typename enable_if<is_arithmetic<T>, bool>::type

test/eif_no_disambiguation.cpp

@@ -10,16 +10,19 @@
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 
-#include <boost/mpl/not.hpp>
-
+#include <boost/config.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/detail/lightweight_test.hpp>
 
-using boost::mpl::not_;
 using boost::enable_if;
 using boost::is_arithmetic;
 
+template<class T> struct not_
+{
+  BOOST_STATIC_CONSTANT( bool, value = !T::value );
+};
+
 template<class T>
 typename enable_if<is_arithmetic<T>, bool>::type
 arithmetic_object(T t) { return true; }

test/eif_partial_specializations.cpp

@@ -14,6 +14,7 @@
 #include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/detail/lightweight_test.hpp>
 
+using boost::enable_if_has_type;
 using boost::enable_if_c;
 using boost::disable_if_c;
 using boost::enable_if;
@@ -46,9 +47,28 @@ struct tester2<T, typename disable_if<is_arithmetic<T> >::type> {
   BOOST_STATIC_CONSTANT(bool, value = false);
 };
 
+template <class T, class Enable = void>
+struct tester3
+{
+  typedef T type;
+  BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template <class T>
+struct tester3<T, typename enable_if_has_type<typename T::value_type>::type>
+{
+  typedef typename T::value_type type;
+  BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+struct sample_value_type
+{
+  typedef float***& value_type;
+};
+
 int main()
 {
- 
+
   BOOST_TEST(tester<int>::value);
   BOOST_TEST(tester<double>::value);
 
@@ -61,6 +81,9 @@ int main()
   BOOST_TEST(!tester2<char*>::value);
   BOOST_TEST(!tester2<void*>::value);
 
+  BOOST_TEST(!tester3<char*>::value);
+  BOOST_TEST(tester3<sample_value_type>::value);
+
   return boost::report_errors();
 }
 

test/explicit_operator_bool_compile_fail_conv_int.cpp

@@ -35,6 +35,7 @@ int main(int, char*[])
 {
     checkable val;
     int n = val;
+    (void)n;
 
     return 0;
 }

test/explicit_operator_bool_compile_fail_conv_pvoid.cpp

@@ -35,6 +35,7 @@ int main(int, char*[])
 {
     checkable val;
     void* p = val;
+    (void)p;
 
     return 0;
 }

test/get_pointer_test.cpp

@@ -27,10 +27,12 @@ int main()
         delete p;
     }
 
+#if !defined( BOOST_NO_AUTO_PTR )
     {
         std::auto_ptr< X > p( new X );
         BOOST_TEST( get_pointer( p ) == p.get() );
     }
+#endif
 
 #if !defined( BOOST_NO_CXX11_SMART_PTR )
 

test/ignore_unused_test.cpp

@@ -6,6 +6,12 @@
 
 #include <boost/core/ignore_unused.hpp>
 
+BOOST_CXX14_CONSTEXPR int test_fun(int a)
+{
+    boost::ignore_unused(a);
+    return 0;
+}
+
 int main()
 {
     {
@@ -60,5 +66,10 @@ int main()
         boost::ignore_unused<a, b, c, d, e>();
     }
 
+    {
+        BOOST_CXX14_CONSTEXPR const int a = test_fun(0);
+        boost::ignore_unused(a);
+    }
+
     return 0;
 }

test/lightweight_test_test.cpp

@@ -43,6 +43,16 @@ int main()
     BOOST_TEST( x++ == 1 );
     BOOST_TEST( x == 2? true: false );
     BOOST_TEST( x == 2? &x: 0 );
+    
+    // BOOST_TEST_NOT
+    
+    BOOST_TEST_NOT( x == 1 );
+    BOOST_TEST_NOT( ++x == 2 );
+    BOOST_TEST_NOT( x++ == 2 );
+    BOOST_TEST_NOT( --x == 2 );
+    BOOST_TEST_NOT( x-- == 2 );
+    BOOST_TEST_NOT( x == 2? false: true );
+    BOOST_TEST_NOT( x == 2? 0: &x );
 
     // BOOST_TEST_EQ
 

test/ref_rv_fail1.cpp

@@ -15,6 +15,7 @@
 int main()
 {
     boost::reference_wrapper<int const> r( 1 ); // this should produce an ERROR
+    (void)r;
 }
 
 #else

test/ref_rv_fail2.cpp

@@ -13,4 +13,5 @@
 int main()
 {
     boost::reference_wrapper<int> r = boost::ref( 2 ); // this should produce an ERROR
+    (void)r;
 }

test/ref_rv_fail3.cpp

@@ -19,6 +19,7 @@ X const crv() { return X(); }
 int main()
 {
     boost::reference_wrapper<X const> r = boost::ref( crv() ); // this should produce an ERROR
+    (void)r;
 }
 
 #else

test/ref_rv_fail4.cpp

@@ -16,6 +16,7 @@
 int main()
 {
     boost::reference_wrapper<int const> r = boost::cref( 2 ); // should fail
+    (void)r;
 }
 
 #else

test/ref_rv_fail5.cpp

@@ -20,6 +20,7 @@ X const crv() { return X(); }
 int main()
 {
     boost::reference_wrapper<X const> r = boost::cref( crv() ); // must fail
+    (void)r;
 }
 
 #else