Replace use of mpl/has_xxx.hpp with handwritten traits

Merge branch 'develop' into feature/result_of-no-mpl
Add appveyor.yml
2026-06-11 11:51:14 +02:00 · 2017-12-21 06:30:03 +02:00 · 2017-12-20 23:16:08 +02:00 · 2017-12-20 23:14:36 +02:00 · 2017-12-20 21:55:07 +02:00 · 2017-12-02 04:35:22 +02:00
42 changed files with 859 additions and 1158 deletions
@@ -0,0 +1,202 @@
+# 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)
+
+language: cpp
+
+sudo: false
+
+python: "2.7"
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
+
+    - os: linux
+      compiler: g++-4.7
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.8
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+    - os: linux
+      compiler: g++-4.9
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      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
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
+
+    - os: linux
+      compiler: clang++-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+            - libstdc++-5-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      compiler: clang++-3.7
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+            - libstdc++-5-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      compiler: clang++-3.8
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+            - libstdc++-5-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+            - libstdc++-5-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+            - libstdc++-5-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+            - libstdc++-5-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
+    - os: osx
+      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 $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - cp -r $TRAVIS_BUILD_DIR/* libs/utility
+  - python tools/boostdep/depinst/depinst.py utility
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ./b2 libs/utility/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+notifications:
+  email:
+    on_success: always
@@ -0,0 +1,44 @@
+# 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)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+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 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 %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\utility
+  - python tools/boostdep/depinst/depinst.py utility
+  - cmd /c bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - PATH=%ADDPATH%%PATH%
+  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+  - b2 -j3 libs/utility/test toolset=%TOOLSET% %CXXSTD%
@@ -117,3 +117,11 @@ boostbook standalone_string_ref
        # How far down we go with TOC's
        <xsl:param>generate.section.toc.level=1
     ;
+
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease :
+    standalone_base_from_member standalone_compressed_pair
+    standalone_declval standalone_string_ref ;
+explicit boostrelease ;
@@ -1,163 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-<head>
-  <meta http-equiv="Content-Language" content="en-us">
-  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
-
-  <title>Generator Iterator Adaptor Documentation</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-  <img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle"
-  width="277" height="86">
-
-  <h1>Generator Iterator Adaptor</h1>
-
-  <p>Defined in header <a href=
-  "../../boost/generator_iterator.hpp">boost/generator_iterator.hpp</a></p>
-
-  <p>The generator iterator adaptor makes it easier to create custom input
-  iterators from 0-ary functions and function objects. The adaptor takes a
-  <a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a> and
-  creates a model of <a href=
-  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>. Each
-  increment retrieves an item from the generator and makes it available to be
-  retrieved by dereferencing. The motivation for this iterator is that some
-  concepts can be more naturally expressed as a generator, while most STL
-  algorithms expect an iterator. An example is the <a href=
-  "../random/index.html">Random Number</a> library.</p>
-
-  <h2>Synopsis</h2>
-
-  <blockquote>
-    <pre>
-namespace boost {
-  template &lt;class Generator&gt;
-  class generator_iterator_policies;
-
-  template &lt;class Generator&gt;
-  class generator_iterator_generator;
-
-  template &lt;class Generator&gt;
-  typename generator_iterator_generator&lt;Generator&gt;::type
-  make_generator_iterator(Generator &amp; gen);
-}
-</pre>
-  </blockquote>
-  <hr>
-
-  <h2>The Generator Iterator Generator Class</h2>
-
-  <p>The class generator_iterator_generator is a helper class whose purpose
-  is to construct a generator iterator type. The template parameter for this
-  class is the Generator function object type that is being wrapped. The
-  generator iterator adaptor only holds a reference (or pointer) to the
-  function object, therefore the function object must outlive the generator
-  iterator adaptor constructed from it.</p>
-  <pre>
-template &lt;class Generator&gt;
-class generator_iterator_generator
-{
-public:
-  typedef <i>unspecified</i> type; // the resulting generator iterator type 
-}
-</pre>
-
-  <h3>Template Parameters</h3>
-
-  <table border summary="">
-    <tr>
-      <th>Parameter</th>
-
-      <th>Description</th>
-    </tr>
-
-    <tr>
-      <td><tt><a href=
-      "http://www.sgi.com/tech/stl/Generator.html">Generator</a></tt></td>
-
-      <td>The generator (0-ary function object) type being wrapped. The
-      return type of the function must be defined as
-      <tt>Generator::result_type</tt>. The function object must be a model of
-      <a href=
-      "http://www.sgi.com/tech/stl/Generator.html">Generator</a>.</td>
-    </tr>
-  </table>
-
-  <h3>Concept Model</h3>
-
-  <p>The generator iterator class is a model of <a href=
-  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>.</p>
-
-  <h3>Members</h3>
-
-  <p>The generator iterator implements the member functions and operators
-  required of the <a href=
-  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
-  concept.<br></p>
-  <hr>
-
-  <h2><a name="make_generator_iterator" id="make_generator_iterator">The
-  Generator Iterator Object Generator</a></h2>
-
-  <p>The <tt>make_generator_iterator()</tt> function provides a convenient
-  way to create generator iterator objects. The function saves the user the
-  trouble of explicitly writing out the iterator types.</p>
-
-  <blockquote>
-    <pre>
-template &lt;class Generator&gt;
-typename generator_iterator_generator&lt;Generator&gt;::type
-make_generator_iterator(Generator &amp; gen);
-</pre>
-  </blockquote>
-  <hr>
-
-  <h3>Example</h3>
-
-  <p>The following program shows how <code>generator_iterator</code>
-  transforms a generator into an input iterator.</p>
-
-  <blockquote>
-    <pre>
-#include &lt;iostream&gt;
-#include &lt;boost/generator_iterator.hpp&gt;
-
-class my_generator
-{
-public:
-  typedef int result_type;
-  my_generator() : state(0) { }
-  int operator()() { return ++state; }
-private:
-  int state;
-};
-
-int main()
-{
-  my_generator gen;
-  boost::generator_iterator_generator&lt;my_generator&gt;::type it = boost::make_generator_iterator(gen);
-  for(int i = 0; i &lt; 10; ++i, ++it)
-    std::cout &lt;&lt; *it &lt;&lt; std::endl;
-}
-</pre>
-  </blockquote>
-  <hr>
-
-  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
-  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
-  height="31" width="88"></a></p>
-
-  <p>Revised 
-  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05 December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
-
-  <p><i>Copyright &copy; 2001 <a href=
-  "http://www.boost.org/people/jens_maurer.htm">Jens Maurer</a></i></p>
-
-  <p><i>Distributed under the Boost Software License, Version 1.0. (See
-  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
-  copy at <a href=
-  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
-</body>
-</html>
@@ -1,63 +0,0 @@
-//
-// Copyright 2014 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/generator_iterator.hpp>
-#include <boost/detail/lightweight_test.hpp>
-#include <algorithm>
-
-class X
-{
-private:
-
-    int v;
-
-public:
-
-    typedef int result_type;
-
-    X(): v( 0 )
-    {
-    }
-
-    int operator()()
-    {
-        return ++v;
-    }
-};
-
-template<class InputIterator, class Size, class OutputIterator> OutputIterator copy_n( InputIterator first, Size n, OutputIterator result )
-{
-    while( n-- > 0 )
-    {
-        *result++ = *first++;
-    }
-
-    return result;
-}
-
-void copy_test()
-{
-    X x;
-    boost::generator_iterator<X> in( &x );
-
-    int const N = 4;
-    int v[ N ] = { 0 };
-
-    ::copy_n( in, 4, v );
-
-    BOOST_TEST_EQ( v[0], 1 );
-    BOOST_TEST_EQ( v[1], 2 );
-    BOOST_TEST_EQ( v[2], 3 );
-    BOOST_TEST_EQ( v[3], 4 );
-}
-
-int main()
-{
-    copy_test();
-    return boost::report_errors();
-}
@@ -1,165 +0,0 @@
-//  Boost next_prior.hpp header file  ---------------------------------------//
-
-//  (C) Copyright Dave Abrahams and Daniel Walker 1999-2003. 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)
-
-//  See http://www.boost.org/libs/utility for documentation.
-
-//  Revision History
-//  13 Dec 2003  Added next(x, n) and prior(x, n) (Daniel Walker)
-
-#ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED
-#define BOOST_NEXT_PRIOR_HPP_INCLUDED
-
-#include <iterator>
-#if defined(_MSC_VER) && _MSC_VER <= 1310
-#include <boost/mpl/and.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#endif
-#include <boost/type_traits/is_unsigned.hpp>
-#include <boost/type_traits/integral_promotion.hpp>
-#include <boost/type_traits/make_signed.hpp>
-#include <boost/type_traits/has_plus.hpp>
-#include <boost/type_traits/has_plus_assign.hpp>
-#include <boost/type_traits/has_minus.hpp>
-#include <boost/type_traits/has_minus_assign.hpp>
-
-namespace boost {
-
-//  Helper functions for classes like bidirectional iterators not supporting
-//  operator+ and operator-
-//
-//  Usage:
-//    const std::list<T>::iterator p = get_some_iterator();
-//    const std::list<T>::iterator prev = boost::prior(p);
-//    const std::list<T>::iterator next = boost::next(prev, 2);
-
-//  Contributed by Dave Abrahams
-
-namespace next_prior_detail {
-
-template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
-struct next_impl2
-{
-    static T call(T x, Distance n)
-    {
-        std::advance(x, n);
-        return x;
-    }
-};
-
-template< typename T, typename Distance >
-struct next_impl2< T, Distance, true >
-{
-    static T call(T x, Distance n)
-    {
-        return x + n;
-    }
-};
-
-
-template< typename T, typename Distance, bool HasPlusAssign = has_plus_assign< T, Distance >::value >
-struct next_impl1 :
-    public next_impl2< T, Distance >
-{
-};
-
-template< typename T, typename Distance >
-struct next_impl1< T, Distance, true >
-{
-    static T call(T x, Distance n)
-    {
-        x += n;
-        return x;
-    }
-};
-
-
-template<
-    typename T,
-    typename Distance,
-    typename PromotedDistance = typename integral_promotion< Distance >::type,
-#if !defined(_MSC_VER) || _MSC_VER > 1310
-    bool IsUInt = is_unsigned< PromotedDistance >::value
-#else
-    // MSVC 7.1 has problems with applying is_unsigned to non-integral types
-    bool IsUInt = mpl::and_< is_integral< PromotedDistance >, is_unsigned< PromotedDistance > >::value
-#endif
->
-struct prior_impl3
-{
-    static T call(T x, Distance n)
-    {
-        std::advance(x, -n);
-        return x;
-    }
-};
-
-template< typename T, typename Distance, typename PromotedDistance >
-struct prior_impl3< T, Distance, PromotedDistance, true >
-{
-    static T call(T x, Distance n)
-    {
-        typedef typename make_signed< PromotedDistance >::type signed_distance;
-        std::advance(x, -static_cast< signed_distance >(static_cast< PromotedDistance >(n)));
-        return x;
-    }
-};
-
-
-template< typename T, typename Distance, bool HasMinus = has_minus< T, Distance >::value >
-struct prior_impl2 :
-    public prior_impl3< T, Distance >
-{
-};
-
-template< typename T, typename Distance >
-struct prior_impl2< T, Distance, true >
-{
-    static T call(T x, Distance n)
-    {
-        return x - n;
-    }
-};
-
-
-template< typename T, typename Distance, bool HasMinusAssign = has_minus_assign< T, Distance >::value >
-struct prior_impl1 :
-    public prior_impl2< T, Distance >
-{
-};
-
-template< typename T, typename Distance >
-struct prior_impl1< T, Distance, true >
-{
-    static T call(T x, Distance n)
-    {
-        x -= n;
-        return x;
-    }
-};
-
-} // namespace next_prior_detail
-
-template <class T>
-inline T next(T x) { return ++x; }
-
-template <class T, class Distance>
-inline T next(T x, Distance n)
-{
-    return next_prior_detail::next_impl1< T, Distance >::call(x, n);
-}
-
-template <class T>
-inline T prior(T x) { return --x; }
-
-template <class T, class Distance>
-inline T prior(T x, Distance n)
-{
-    return next_prior_detail::prior_impl1< T, Distance >::call(x, n);
-}
-
-} // namespace boost
-
-#endif  // BOOST_NEXT_PRIOR_HPP_INCLUDED
@@ -1,7 +1,7 @@
 //  Boost operators.hpp header file  ----------------------------------------//

 //  (C) Copyright David Abrahams, Jeremy Siek, Daryle Walker 1999-2001.
-//  (C) Copyright Daniel Frey 2002-2016.
+//  (C) Copyright Daniel Frey 2002-2017.
 //  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)
@@ -9,6 +9,9 @@
 //  See http://www.boost.org/libs/utility/operators.htm for documentation.

 //  Revision History
+//  23 Nov 17 Protect dereferenceable<> from overloaded operator&.
+//  15 Oct 17 Adapted to C++17, replace std::iterator<> with manual
+//            implementation.
 //  22 Feb 16 Added ADL protection, preserve old work-arounds in
 //            operators_v1.hpp and clean up this file. (Daniel Frey)
 //  16 Dec 10 Limit warning suppression for 4284 to older versions of VC++
@@ -96,6 +99,7 @@

 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/core/addressof.hpp>

 #if defined(__sgi) && !defined(__GNUC__)
 #   pragma set woff 1234
@@ -300,7 +304,7 @@ struct dereferenceable : B
 {
  P operator->() const
  {
-    return &*static_cast<const T&>(*this);
+    return ::boost::addressof(*static_cast<const T&>(*this));
  }
 };

@@ -824,6 +828,21 @@ template <class T> struct operators<T, T>
 //  Iterator helper classes (contributed by Jeremy Siek) -------------------//
 //  (Input and output iterator helpers contributed by Daryle Walker) -------//
 //  (Changed to use combined operator classes by Daryle Walker) ------------//
+//  (Adapted to C++17 by Daniel Frey) --------------------------------------//
+template <class Category,
+          class T,
+          class Distance = std::ptrdiff_t,
+          class Pointer = T*,
+          class Reference = T&>
+struct iterator_helper
+{
+  typedef Category iterator_category;
+  typedef T value_type;
+  typedef Distance difference_type;
+  typedef Pointer pointer;
+  typedef Reference reference;
+};
+
 template <class T,
          class V,
          class D = std::ptrdiff_t,
@@ -831,13 +850,13 @@ template <class T,
          class R = V const &>
 struct input_iterator_helper
  : input_iteratable<T, P
-  , std::iterator<std::input_iterator_tag, V, D, P, R
+  , iterator_helper<std::input_iterator_tag, V, D, P, R
    > > {};

 template<class T>
 struct output_iterator_helper
  : output_iteratable<T
-  , std::iterator<std::output_iterator_tag, void, void, void, void
+  , iterator_helper<std::output_iterator_tag, void, void, void, void
  > >
 {
  T& operator*()  { return static_cast<T&>(*this); }
@@ -851,7 +870,7 @@ template <class T,
          class R = V&>
 struct forward_iterator_helper
  : forward_iteratable<T, P
-  , std::iterator<std::forward_iterator_tag, V, D, P, R
+  , iterator_helper<std::forward_iterator_tag, V, D, P, R
    > > {};

 template <class T,
@@ -861,7 +880,7 @@ template <class T,
          class R = V&>
 struct bidirectional_iterator_helper
  : bidirectional_iteratable<T, P
-  , std::iterator<std::bidirectional_iterator_tag, V, D, P, R
+  , iterator_helper<std::bidirectional_iterator_tag, V, D, P, R
    > > {};

 template <class T,
@@ -871,7 +890,7 @@ template <class T,
          class R = V&>
 struct random_access_iterator_helper
  : random_access_iteratable<T, P, D, R
-  , std::iterator<std::random_access_iterator_tag, V, D, P, R
+  , iterator_helper<std::random_access_iterator_tag, V, D, P, R
    > >
 {
  friend D requires_difference_operator(const T& x, const T& y) {
@@ -9,13 +9,16 @@
 #ifndef BOOST_UTILITY_HPP
 #define BOOST_UTILITY_HPP

-#include <boost/utility/addressof.hpp>
+// Use of this header is discouraged and it will be deprecated.
+// Please include one or more of the headers below instead.
+
 #include <boost/utility/base_from_member.hpp>
 #include <boost/utility/binary.hpp>
-#include <boost/utility/enable_if.hpp>
 #include <boost/utility/identity_type.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/next_prior.hpp>
-#include <boost/noncopyable.hpp>
+
+#include <boost/core/addressof.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/core/checked_delete.hpp>
+#include <boost/core/noncopyable.hpp>

 #endif  // BOOST_UTILITY_HPP
@@ -47,11 +47,11 @@
 //         {}
 // This macro should only persist within this file.

-#define BOOST_PRIVATE_CTR_DEF( z, n, data )                            \
-    template < BOOST_PP_ENUM_PARAMS(n, typename T) >                   \
-    explicit base_from_member( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) )  \
-        : member( BOOST_PP_ENUM_PARAMS(n, x) )                         \
-        {}                                                             \
+#define BOOST_PRIVATE_CTR_DEF( z, n, data )                   \
+    template < BOOST_PP_ENUM_PARAMS(n, typename T) >          \
+    base_from_member( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) )  \
+        : member( BOOST_PP_ENUM_PARAMS(n, x) )                \
+        {}                                                    \
    /**/


@@ -142,7 +142,8 @@ protected:
        : member()
        {}

-    BOOST_PP_REPEAT_FROM_TO( 1, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY),
+    template < typename T0 > explicit base_from_member( T0 x0 ) : member( x0 ) {}
+    BOOST_PP_REPEAT_FROM_TO( 2, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY),
     BOOST_PRIVATE_CTR_DEF, _ )
 #endif

@@ -33,8 +33,12 @@ bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
 }

 template<class OptionalPointee>
-struct equal_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
+struct equal_pointees_t
 {
+  typedef bool result_type;
+  typedef OptionalPointee first_argument_type;
+  typedef OptionalPointee second_argument_type;
+
  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
    { return equal_pointees(x,y) ; }
 } ;
@@ -56,8 +60,12 @@ bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y )
 }

 template<class OptionalPointee>
-struct less_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
+struct less_pointees_t
 {
+  typedef bool result_type;
+  typedef OptionalPointee first_argument_type;
+  typedef OptionalPointee second_argument_type;
+
  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
    { return less_pointees(x,y) ; }
 } ;
@@ -25,16 +25,16 @@
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
 template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of<F(BOOST_RESULT_OF_ARGS)>
-    : mpl::if_<
-          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+    : conditional<
+        is_pointer<F>::value || is_member_function_pointer<F>::value
        , boost::detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type(BOOST_RESULT_OF_ARGS),
-            (boost::detail::has_result_type<F>::value)>
+            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F(BOOST_RESULT_OF_ARGS),
-            (boost::detail::has_result_type<F>::value)> >::type { };
+            (boost::detail::result_of_has_result_type<F>::value)> >::type { };
 #endif

 #ifdef BOOST_RESULT_OF_USE_DECLTYPE
@@ -46,7 +46,7 @@ struct result_of<F(BOOST_RESULT_OF_ARGS)>
 #ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
 template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct result_of<F(BOOST_RESULT_OF_ARGS)>
-    : mpl::if_<mpl::or_<detail::has_result_type<F>, detail::has_result<F> >,
+    : conditional<detail::result_of_has_result_type<F>::value || detail::result_of_has_result<F>::value,
               tr1_result_of<F(BOOST_RESULT_OF_ARGS)>,
               detail::cpp0x_result_of<F(BOOST_RESULT_OF_ARGS)> >::type { };
 #endif // BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
@@ -57,8 +57,8 @@ namespace detail {

 template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct cpp0x_result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
-    : mpl::if_<
-          is_member_function_pointer<F>
+    : conditional<
+          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false
@@ -82,25 +82,22 @@ struct BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<R(BOOST_PP_
 };

 template<typename F>
-struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION());
+struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())
+  : BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<F>
+{};

 template<typename F>
 struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<F *>
  : BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<F>
 {};

-template<typename F>
-struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<F &>
-  : BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<F>
-{};
-
 template<typename F>
 struct BOOST_PP_CAT(result_of_select_call_wrapper_type_, BOOST_PP_ITERATION())
-  : mpl::eval_if<
-        is_class<typename remove_reference<F>::type>,
+  : conditional<
+        is_class<typename remove_reference<F>::type>::value,
        result_of_wrap_callable_class<F>,
-        mpl::identity<BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<typename remove_cv<F>::type> >
-    >
+        type_identity<BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<typename remove_cv<typename remove_reference<F>::type>::type> >
+    >::type
 {};

 template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename T)>
@@ -111,7 +108,7 @@ struct BOOST_PP_CAT(result_of_is_callable_, BOOST_PP_ITERATION()) {
            (boost::declval<wrapper_t>()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)), result_of_weird_type())
        ))
    );
-    typedef mpl::bool_<value> type;
+    typedef integral_constant<bool, value> type;
 };

 template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
@@ -18,19 +18,16 @@
 #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
 #include <boost/preprocessor/facilities/intercept.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/mpl/has_xxx.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/or.hpp>
 #include <boost/type_traits/is_class.hpp>
 #include <boost/type_traits/is_pointer.hpp>
 #include <boost/type_traits/is_member_function_pointer.hpp>
 #include <boost/type_traits/remove_cv.hpp>
 #include <boost/type_traits/remove_reference.hpp>
-#include <boost/utility/declval.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/declval.hpp>
+#include <boost/type_traits/conditional.hpp>
+#include <boost/type_traits/type_identity.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/core/enable_if.hpp>

 #ifndef BOOST_RESULT_OF_NUM_ARGS
 #  define BOOST_RESULT_OF_NUM_ARGS 16
@@ -47,10 +44,6 @@
  BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK cannot be defined at the same time.
 #endif

-#if defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK) && defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
-#  error Cannot fallback to decltype if BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE is not defined.
-#endif
-
 #ifndef BOOST_RESULT_OF_USE_TR1
 #  ifndef BOOST_RESULT_OF_USE_DECLTYPE
 #    ifndef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
@@ -71,11 +64,40 @@ template<typename F> struct tr1_result_of; // a TR1-style implementation of resu
 #if !defined(BOOST_NO_SFINAE)
 namespace detail {

-BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
+typedef char result_of_yes_type;      // sizeof(result_of_yes_type) == 1
+typedef char (&result_of_no_type)[2]; // sizeof(result_of_no_type)  == 2
+
+template<class T> struct result_of_has_type {};
+
+template<class T> struct result_of_has_result_type_impl
+{
+    template<class U> static result_of_yes_type f( result_of_has_type<typename U::result_type>* );
+    template<class U> static result_of_no_type f( ... );
+
+    typedef boost::integral_constant<bool, sizeof(f<T>(0)) == sizeof(result_of_yes_type)> type;
+};
+
+template<class T> struct result_of_has_result_type: result_of_has_result_type_impl<T>::type
+{
+};

 // Work around a nvcc bug by only defining has_result when it's needed.
 #ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
-BOOST_MPL_HAS_XXX_TEMPLATE_DEF(result)
+
+template<template<class> class C> struct result_of_has_template {};
+
+template<class T> struct result_of_has_result_impl
+{
+    template<class U> static result_of_yes_type f( result_of_has_template<U::template result>* );
+    template<class U> static result_of_no_type f( ... );
+
+    typedef boost::integral_constant<bool, sizeof(f<T>(0)) == sizeof(result_of_yes_type)> type;
+};
+
+template<class T> struct result_of_has_result: result_of_has_result_impl<T>::type
+{
+};
+
 #endif

 template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
@@ -97,9 +119,6 @@ struct result_of_weird_type {
  friend result_of_private_type operator,(result_of_private_type, result_of_weird_type);
 };

-typedef char result_of_yes_type;      // sizeof(result_of_yes_type) == 1
-typedef char (&result_of_no_type)[2]; // sizeof(result_of_no_type)  == 2
-
 template<typename T>
 result_of_no_type result_of_is_private_type(T const &);
 result_of_yes_type result_of_is_private_type(result_of_private_type);
@@ -180,10 +199,10 @@ struct tr1_result_of_impl<F, FArgs, true>
 };

 template<typename FArgs>
-struct is_function_with_no_args : mpl::false_ {};
+struct is_function_with_no_args : false_type {};

 template<typename F>
-struct is_function_with_no_args<F(void)> : mpl::true_ {};
+struct is_function_with_no_args<F(void)> : true_type {};

 template<typename F, typename FArgs>
 struct result_of_nested_result : F::template result<FArgs>
@@ -191,7 +210,7 @@ struct result_of_nested_result : F::template result<FArgs>

 template<typename F, typename FArgs>
 struct tr1_result_of_impl<F, FArgs, false>
-  : mpl::if_<is_function_with_no_args<FArgs>,
+  : conditional<is_function_with_no_args<FArgs>::value,
             result_of_void_impl<F>,
             result_of_nested_result<F, FArgs> >::type
 {};
@@ -201,6 +220,11 @@ struct tr1_result_of_impl<F, FArgs, false>
 #define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_RESULT_OF_NUM_ARGS,<boost/utility/detail/result_of_iterate.hpp>))
 #include BOOST_PP_ITERATE()

+#if 0
+// inform dependency trackers, as they can't see through macro includes
+#include <boost/utility/detail/result_of_iterate.hpp>
+#endif
+
 #else
 #  define BOOST_NO_RESULT_OF 1
 #endif
@@ -27,6 +27,11 @@
 #include <string>
 #include <iosfwd>

+#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || (defined(BOOST_GCC) && ((BOOST_GCC+0) / 100) <= 406)
+// GCC 4.6 cannot handle a defaulted function with noexcept specifier
+#define BOOST_STRING_REF_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
+#endif
+
 namespace boost {

    namespace detail {
@@ -57,26 +62,44 @@ namespace boost {
        static BOOST_CONSTEXPR_OR_CONST size_type npos = size_type(-1);

        // construct/copy
-        BOOST_CONSTEXPR basic_string_ref ()
+        BOOST_CONSTEXPR basic_string_ref () BOOST_NOEXCEPT
            : ptr_(NULL), len_(0) {}

-        BOOST_CONSTEXPR basic_string_ref (const basic_string_ref &rhs)
+        // by defaulting these functions, basic_string_ref becomes
+        //  trivially copy/move constructible.
+        BOOST_CONSTEXPR basic_string_ref (const basic_string_ref &rhs) BOOST_NOEXCEPT
+#ifndef BOOST_STRING_REF_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
+            = default;
+#else
            : ptr_(rhs.ptr_), len_(rhs.len_) {}
+#endif

-        basic_string_ref& operator=(const basic_string_ref &rhs) {
+        basic_string_ref& operator=(const basic_string_ref &rhs) BOOST_NOEXCEPT
+#ifndef BOOST_STRING_REF_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
+            = default;
+#else
+            {
            ptr_ = rhs.ptr_;
            len_ = rhs.len_;
            return *this;
            }
+#endif

-        basic_string_ref(const charT* str)
+        basic_string_ref(const charT* str) BOOST_NOEXCEPT
            : ptr_(str), len_(traits::length(str)) {}

        template<typename Allocator>
        basic_string_ref(const std::basic_string<charT, traits, Allocator>& str)
            : ptr_(str.data()), len_(str.length()) {}

-        BOOST_CONSTEXPR basic_string_ref(const charT* str, size_type len)
+// #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+//         // Constructing a string_ref from a temporary string is a bad idea
+//         template<typename Allocator>
+//         basic_string_ref(      std::basic_string<charT, traits, Allocator>&&)
+//             = delete;
+// #endif
+
+        BOOST_CONSTEXPR basic_string_ref(const charT* str, size_type len) BOOST_NOEXCEPT
            : ptr_(str), len_(len) {}

 #ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
@@ -139,9 +162,7 @@ namespace boost {
        basic_string_ref substr(size_type pos, size_type n=npos) const {
            if ( pos > size())
                BOOST_THROW_EXCEPTION( std::out_of_range ( "string_ref::substr" ) );
-            if ( n == npos || pos + n > size())
-                n = size () - pos;
-            return basic_string_ref ( data() + pos, n );
+            return basic_string_ref(data() + pos, (std::min)(size() - pos, n));
            }

        int compare(basic_string_ref x) const {
@@ -174,13 +195,13 @@ namespace boost {
        size_type rfind(basic_string_ref s) const {
            const_reverse_iterator iter = std::search ( this->crbegin (), this->crend (),
                                                s.crbegin (), s.crend (), traits::eq );
-            return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter );
+            return iter == this->crend () ? npos : (std::distance(iter, this->crend()) - s.size());
            }

        size_type rfind(charT c) const {
            const_reverse_iterator iter = std::find_if ( this->crbegin (), this->crend (),
                                    detail::string_ref_traits_eq<charT, traits> ( c ));
-            return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter );
+            return iter == this->crend () ? npos : (this->size() - 1 - std::distance(this->crbegin(), iter));
            }

        size_type find_first_of(charT c) const { return  find (c); }
@@ -195,7 +216,7 @@ namespace boost {
        size_type find_last_of(basic_string_ref s) const {
            const_reverse_iterator iter = std::find_first_of
                ( this->crbegin (), this->crend (), s.cbegin (), s.cend (), traits::eq );
-            return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter);
+            return iter == this->crend () ? npos : (this->size() - 1 - std::distance(this->crbegin(), iter));
            }

        size_type find_first_not_of(basic_string_ref s) const {
@@ -212,21 +233,17 @@ namespace boost {

        size_type find_last_not_of(basic_string_ref s) const {
            const_reverse_iterator iter = find_not_of ( this->crbegin (), this->crend (), s );
-            return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter );
+            return iter == this->crend () ? npos : (this->size() - 1 - std::distance(this->crbegin(), iter));
            }

        size_type find_last_not_of(charT c) const {
            for ( const_reverse_iterator iter = this->crbegin (); iter != this->crend (); ++iter )
                if ( !traits::eq ( c, *iter ))
-                    return reverse_distance ( this->crbegin (), iter );
+                    return this->size() - 1 - std::distance(this->crbegin(), iter);
            return npos;
            }

    private:
-        template <typename r_iter>
-        size_type reverse_distance ( r_iter first, r_iter last ) const {
-            return len_ - 1 - std::distance ( first, last );
-            }

        template <typename Iterator>
        Iterator find_not_of ( Iterator first, Iterator last, basic_string_ref s ) const {
@@ -405,7 +422,7 @@ namespace boost {
    namespace detail {

        template<class charT, class traits>
-        inline void insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) {
+        inline void sr_insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) {
            enum { chunk_size = 8 };
            charT fill_chars[chunk_size];
            std::fill_n(fill_chars, static_cast< std::size_t >(chunk_size), os.fill());
@@ -416,19 +433,19 @@ namespace boost {
            }

        template<class charT, class traits>
-        void insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) {
+        void sr_insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) {
            const std::size_t size = str.size();
            const std::size_t alignment_size = static_cast< std::size_t >(os.width()) - size;
            const bool align_left = (os.flags() & std::basic_ostream<charT, traits>::adjustfield) == std::basic_ostream<charT, traits>::left;
            if (!align_left) {
-                detail::insert_fill_chars(os, alignment_size);
+                detail::sr_insert_fill_chars(os, alignment_size);
                if (os.good())
                    os.write(str.data(), size);
                }
            else {
                os.write(str.data(), size);
                if (os.good())
-                    detail::insert_fill_chars(os, alignment_size);
+                    detail::sr_insert_fill_chars(os, alignment_size);
                }
            }

@@ -444,7 +461,7 @@ namespace boost {
            if (w <= size)
                os.write(str.data(), size);
            else
-                detail::insert_aligned(os, str);
+                detail::sr_insert_aligned(os, str);
            os.width(0);
            }
        return os;
@@ -1,6 +1,6 @@
 /*
-   © Copyright (c) Marshall Clow 2012-2015.
-   © Copyright Beman Dawes 2015
+   Copyright (c) Marshall Clow 2012-2015.
+   Copyright (c) Beman Dawes 2015

   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)
@@ -30,6 +30,11 @@
 #include <cstring>
 #include <iosfwd>

+#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || (defined(BOOST_GCC) && ((BOOST_GCC+0) / 100) <= 406)
+// GCC 4.6 cannot handle a defaulted function with noexcept specifier
+#define BOOST_STRING_VIEW_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
+#endif
+
 namespace boost {

    namespace detail {
@@ -65,19 +70,36 @@ namespace boost {
      BOOST_CONSTEXPR basic_string_view() BOOST_NOEXCEPT
        : ptr_(NULL), len_(0) {}

+      // by defaulting these functions, basic_string_ref becomes
+      //  trivially copy/move constructible.
      BOOST_CONSTEXPR basic_string_view(const basic_string_view &rhs) BOOST_NOEXCEPT
+#ifndef BOOST_STRING_VIEW_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
+        = default;
+#else
        : ptr_(rhs.ptr_), len_(rhs.len_) {}
+#endif

-      basic_string_view& operator=(const basic_string_view &rhs) BOOST_NOEXCEPT {
+      basic_string_view& operator=(const basic_string_view &rhs) BOOST_NOEXCEPT
+#ifndef BOOST_STRING_VIEW_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
+            = default;
+#else
+        {
        ptr_ = rhs.ptr_;
        len_ = rhs.len_;
        return *this;
        }
+#endif

      template<typename Allocator>
-        basic_string_view(const std::basic_string<charT, traits,
-          Allocator>& str) BOOST_NOEXCEPT
-        : ptr_(str.data()), len_(str.length()) {}
+        basic_string_view(const std::basic_string<charT, traits, Allocator>& str) BOOST_NOEXCEPT
+          : ptr_(str.data()), len_(str.length()) {}
+
+// #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+//       // Constructing a string_view from a temporary string is a bad idea
+//       template<typename Allocator>
+//         basic_string_view(      std::basic_string<charT, traits, Allocator>&&)
+//           = delete;
+// #endif

      BOOST_CONSTEXPR basic_string_view(const charT* str)
        : ptr_(str), len_(traits::length(str)) {}
@@ -105,10 +127,7 @@ namespace boost {
        BOOST_CONSTEXPR const_reference operator[](size_type pos) const BOOST_NOEXCEPT { return ptr_[pos]; }

        BOOST_CONSTEXPR const_reference at(size_t pos) const {
-            return pos >= len_ ? BOOST_THROW_EXCEPTION(std::out_of_range("boost::string_view::at")) : ptr_[pos];
-//             if ( pos >= len_ )
-//                 BOOST_THROW_EXCEPTION( std::out_of_range ( "boost::string_view::at" ) );
-//             return ptr_[pos];
+            return pos >= len_ ? BOOST_THROW_EXCEPTION(std::out_of_range("boost::string_view::at")), ptr_[0] : ptr_[pos];
            }

        BOOST_CONSTEXPR const_reference front() const                { return ptr_[0]; }
@@ -146,31 +165,32 @@ namespace boost {

 #ifndef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
        template<typename Allocator = std::allocator<charT> >
-        std::basic_string<charT, traits> to_string(const Allocator& a = Allocator()) const {
+        std::basic_string<charT, traits, Allocator> to_string(const Allocator& a = Allocator()) const {
            return std::basic_string<charT, traits, Allocator>(begin(), end(), a);
            }
 #else
        std::basic_string<charT, traits> to_string() const {
            return std::basic_string<charT, traits>(begin(), end());
            }
+
+        template<typename Allocator>
+        std::basic_string<charT, traits, Allocator> to_string(const Allocator& a) const {
+            return std::basic_string<charT, traits, Allocator>(begin(), end(), a);
+            }
 #endif

        size_type copy(charT* s, size_type n, size_type pos=0) const {
            if (pos > size())
                BOOST_THROW_EXCEPTION(std::out_of_range("string_view::copy" ));
            size_type rlen = (std::min)(n, len_ - pos);
-            // use std::copy(begin() + pos, begin() + pos + rlen, s) rather than
-            // std::copy_n(begin() + pos, rlen, s) to support pre-C++11 standard libraries
-            std::copy(begin() + pos, begin() + pos + rlen, s);
+    		traits_type::copy(s, data() + pos, rlen);
            return rlen;
            }

        BOOST_CXX14_CONSTEXPR basic_string_view substr(size_type pos, size_type n=npos) const {
            if ( pos > size())
                BOOST_THROW_EXCEPTION( std::out_of_range ( "string_view::substr" ) );
-            if (n == npos || pos + n > size())
-                n = size () - pos;
-            return basic_string_view(data() + pos, n);
+            return basic_string_view(data() + pos, (std::min)(size() - pos, n));
            }

        BOOST_CXX14_CONSTEXPR int compare(basic_string_view x) const BOOST_NOEXCEPT {
@@ -204,7 +224,7 @@ namespace boost {
        //  Searches
        BOOST_CONSTEXPR bool starts_with(charT c) const BOOST_NOEXCEPT {              // Boost extension
            return !empty() && traits::eq(c, front());
-            }  
+            }

        BOOST_CONSTEXPR bool starts_with(basic_string_view x) const BOOST_NOEXCEPT {  // Boost extension
            return len_ >= x.len_ && traits::compare(ptr_, x.ptr_, x.len_) == 0;
@@ -215,7 +235,7 @@ namespace boost {
            }

        BOOST_CONSTEXPR bool ends_with(basic_string_view x) const BOOST_NOEXCEPT {    // Boost extension
-            return len_ >= x.len_ && 
+            return len_ >= x.len_ &&
               traits::compare(ptr_ + len_ - x.len_, x.ptr_, x.len_) == 0;
            }

@@ -240,11 +260,11 @@ namespace boost {
        BOOST_CXX14_CONSTEXPR size_type rfind(basic_string_view s, size_type pos = npos) const BOOST_NOEXCEPT {
            if (len_ < s.len_)
              return npos;
-            if (pos > len_ - s.len_) 
+            if (pos > len_ - s.len_)
              pos = len_ - s.len_;
            if (s.len_ == 0u)     // an empty string is always found
              return pos;
-            for (const charT* cur = ptr_ + pos;; --cur) {
+            for (const charT* cur = ptr_ + pos; ; --cur) {
                if (traits::compare(cur, s.ptr_, s.len_) == 0)
                  return cur - ptr_;
                if (cur == ptr_)
@@ -311,7 +331,7 @@ namespace boost {
        //  find_last_not_of
        BOOST_CXX14_CONSTEXPR size_type find_last_not_of(basic_string_view s, size_type pos = npos) const BOOST_NOEXCEPT {
            if (pos >= len_)
-              pos = len_ - 1;;
+              pos = len_ - 1;
            if (s.len_ == 0u)
              return pos;
            pos = len_ - (pos+1);
@@ -348,7 +368,7 @@ namespace boost {
 //  Comparison operators
 //  Equality
    template<typename charT, typename traits>
-    inline bool operator==(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        if (x.size () != y.size ()) return false;
        return x.compare(y) == 0;
@@ -356,189 +376,189 @@ namespace boost {

 //  Inequality
    template<typename charT, typename traits>
-    inline bool operator!=(basic_string_view<charT, traits> x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
+                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        if ( x.size () != y.size ()) return true;
        return x.compare(y) != 0;
        }

 //  Less than
    template<typename charT, typename traits>
-    inline bool operator<(basic_string_view<charT, traits> x,
-                          basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
+                          basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return x.compare(y) < 0;
        }

 //  Greater than
    template<typename charT, typename traits>
-    inline bool operator>(basic_string_view<charT, traits> x,
-                          basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
+                          basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return x.compare(y) > 0;
        }

 //  Less than or equal to
    template<typename charT, typename traits>
-    inline bool operator<=(basic_string_view<charT, traits> x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
+                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return x.compare(y) <= 0;
        }

 //  Greater than or equal to
    template<typename charT, typename traits>
-    inline bool operator>=(basic_string_view<charT, traits> x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
+                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return x.compare(y) >= 0;
        }

 // "sufficient additional overloads of comparison functions"
    template<typename charT, typename traits, typename Allocator>
-    inline bool operator==(basic_string_view<charT, traits> x,
-                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
+                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
        return x == basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
-    inline bool operator==(const std::basic_string<charT, traits, Allocator> & x,
-                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator==(const std::basic_string<charT, traits, Allocator> & x,
+                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return basic_string_view<charT, traits>(x) == y;
        }

    template<typename charT, typename traits>
-    inline bool operator==(basic_string_view<charT, traits> x,
-                                              const charT * y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
+                                              const charT * y) BOOST_NOEXCEPT {
        return x == basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits>
-    inline bool operator==(const charT * x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator==(const charT * x,
+                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return basic_string_view<charT, traits>(x) == y;
        }

    template<typename charT, typename traits, typename Allocator>
-    inline bool operator!=(basic_string_view<charT, traits> x,
-                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
+                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
        return x != basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
-    inline bool operator!=(const std::basic_string<charT, traits, Allocator> & x,
-                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(const std::basic_string<charT, traits, Allocator> & x,
+                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return basic_string_view<charT, traits>(x) != y;
        }

    template<typename charT, typename traits>
-    inline bool operator!=(basic_string_view<charT, traits> x,
-                           const charT * y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
+                           const charT * y) BOOST_NOEXCEPT {
        return x != basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits>
-    inline bool operator!=(const charT * x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(const charT * x,
+                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return basic_string_view<charT, traits>(x) != y;
        }

    template<typename charT, typename traits, typename Allocator>
-    inline bool operator<(basic_string_view<charT, traits> x,
-                    const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
+                    const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
        return x < basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
-    inline bool operator<(const std::basic_string<charT, traits, Allocator> & x,
-                                basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator<(const std::basic_string<charT, traits, Allocator> & x,
+                                basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return basic_string_view<charT, traits>(x) < y;
        }

    template<typename charT, typename traits>
-    inline bool operator<(basic_string_view<charT, traits> x,
-                          const charT * y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
+                          const charT * y) BOOST_NOEXCEPT {
        return x < basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits>
-    inline bool operator<(const charT * x,
-                          basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator<(const charT * x,
+                          basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return basic_string_view<charT, traits>(x) < y;
        }

    template<typename charT, typename traits, typename Allocator>
-    inline bool operator>(basic_string_view<charT, traits> x,
-                    const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
+                    const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
        return x > basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
-    inline bool operator>(const std::basic_string<charT, traits, Allocator> & x,
-                                basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator>(const std::basic_string<charT, traits, Allocator> & x,
+                                basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return basic_string_view<charT, traits>(x) > y;
        }

    template<typename charT, typename traits>
-    inline bool operator>(basic_string_view<charT, traits> x,
-                          const charT * y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
+                          const charT * y) BOOST_NOEXCEPT {
        return x > basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits>
-    inline bool operator>(const charT * x,
-                          basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator>(const charT * x,
+                          basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return basic_string_view<charT, traits>(x) > y;
        }

    template<typename charT, typename traits, typename Allocator>
-    inline bool operator<=(basic_string_view<charT, traits> x,
-                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
+                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
        return x <= basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
-    inline bool operator<=(const std::basic_string<charT, traits, Allocator> & x,
-                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(const std::basic_string<charT, traits, Allocator> & x,
+                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return basic_string_view<charT, traits>(x) <= y;
        }

    template<typename charT, typename traits>
-    inline bool operator<=(basic_string_view<charT, traits> x,
-                           const charT * y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
+                           const charT * y) BOOST_NOEXCEPT {
        return x <= basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits>
-    inline bool operator<=(const charT * x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(const charT * x,
+                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return basic_string_view<charT, traits>(x) <= y;
        }

    template<typename charT, typename traits, typename Allocator>
-    inline bool operator>=(basic_string_view<charT, traits> x,
-                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
+                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
        return x >= basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
-    inline bool operator>=(const std::basic_string<charT, traits, Allocator> & x,
-                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(const std::basic_string<charT, traits, Allocator> & x,
+                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return basic_string_view<charT, traits>(x) >= y;
        }

    template<typename charT, typename traits>
-    inline bool operator>=(basic_string_view<charT, traits> x,
-                           const charT * y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
+                           const charT * y) BOOST_NOEXCEPT {
        return x >= basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits>
-    inline bool operator>=(const charT * x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(const charT * x,
+                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
        return basic_string_view<charT, traits>(x) >= y;
        }

    namespace detail {

        template<class charT, class traits>
-        inline void insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) {
+        inline void sv_insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) {
            enum { chunk_size = 8 };
            charT fill_chars[chunk_size];
            std::fill_n(fill_chars, static_cast< std::size_t >(chunk_size), os.fill());
@@ -549,19 +569,19 @@ namespace boost {
            }

        template<class charT, class traits>
-        void insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_view<charT,traits>& str) {
+        void sv_insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_view<charT,traits>& str) {
            const std::size_t size = str.size();
            const std::size_t alignment_size = static_cast< std::size_t >(os.width()) - size;
            const bool align_left = (os.flags() & std::basic_ostream<charT, traits>::adjustfield) == std::basic_ostream<charT, traits>::left;
            if (!align_left) {
-                detail::insert_fill_chars(os, alignment_size);
+                detail::sv_insert_fill_chars(os, alignment_size);
                if (os.good())
                    os.write(str.data(), size);
                }
            else {
                os.write(str.data(), size);
                if (os.good())
-                    detail::insert_fill_chars(os, alignment_size);
+                    detail::sv_insert_fill_chars(os, alignment_size);
                }
            }

@@ -578,7 +598,7 @@ namespace boost {
            if (w <= size)
                os.write(str.data(), size);
            else
-                detail::insert_aligned(os, str);
+                detail::sv_insert_aligned(os, str);
            os.width(0);
            }
        return os;
@@ -24,8 +24,8 @@
 				<a href="../core/doc/html/core/enable_if.html">enable_if</a> (moved to the Boost.Core library)<br>
 				<a href="in_place_factories.html">in_place_factory</a><br>
 				<a href="iterator_adaptors.htm">iterator_adaptors</a><br>
-				<a href="generator_iterator.htm">generator iterator adaptors</a><br>
-				<a href="utility.htm#functions_next_prior">next/prior</a><br>
+				<a href="../iterator/doc/generator_iterator.htm">generator iterator adaptors</a> (moved to the Boost.Iterator library)<br>
+				<a href="../iterator/doc/html/iterator/algorithms/next_prior.html">next/prior</a> (moved to the Boost.Iterator library)<br>
 				<a href="../core/doc/html/core/noncopyable.html">noncopyable</a> (moved to the Boost.Core library)<br>
 				<a href="operators.htm">operators</a><br>
 				<a href="utility.htm#result_of">result_of</a><br>
@@ -1,406 +0,0 @@
-//  (C) Copyright David Abrahams 2001.
-// 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)
-
-//  See http://www.boost.org for most recent version including documentation.
-
-//  Revision History
-//  1  Apr 2001 Fixes for ICL; use BOOST_STATIC_CONSTANT
-//  11 Feb 2001 Fixes for Borland (David Abrahams)
-//  23 Jan 2001 Added test for wchar_t (David Abrahams)
-//  23 Jan 2001 Now statically selecting a test for signed numbers to avoid
-//              warnings with fancy compilers. Added commentary and
-//              additional dumping of traits data for tested types (David
-//              Abrahams).
-//  21 Jan 2001 Initial version (David Abrahams)
-
-#include <boost/detail/numeric_traits.hpp>
-#include <cassert>
-#include <boost/type_traits.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/utility.hpp>
-#include <boost/lexical_cast.hpp>
-#include <climits>
-#include <typeinfo>
-#include <iostream>
-#include <string>
-#ifndef BOOST_NO_LIMITS
-# include <limits>
-#endif
-
-// =================================================================================
-// template class complement_traits<Number> --
-//
-//    statically computes the max and min for 1s and 2s-complement binary
-//    numbers. This helps on platforms without <limits> support. It also shows
-//    an example of a recursive template that works with MSVC!
-//
-
-template <unsigned size> struct complement; // forward
-
-// The template complement, below, does all the real work, using "poor man's
-// partial specialization". We need complement_traits_aux<> so that MSVC doesn't
-// complain about undefined min/max as we're trying to recursively define them. 
-template <class Number, unsigned size>
-struct complement_traits_aux
-{
-    BOOST_STATIC_CONSTANT(Number, max = complement<size>::template traits<Number>::max);
-    BOOST_STATIC_CONSTANT(Number, min = complement<size>::template traits<Number>::min);
-};
-
-template <unsigned size>
-struct complement
-{
-    template <class Number>
-    struct traits
-    {
-     private:
-        // indirection through complement_traits_aux necessary to keep MSVC happy
-        typedef complement_traits_aux<Number, size - 1> prev;
-     public:
-#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
-        // GCC 4.0.2 ICEs on these C-style casts
-        BOOST_STATIC_CONSTANT(Number, max =
-                            Number((prev::max) << CHAR_BIT)
-                            + Number(UCHAR_MAX));
-        BOOST_STATIC_CONSTANT(Number, min = Number((prev::min) << CHAR_BIT));
-#else
-        // Avoid left shifting negative integers, use multiplication instead
-        BOOST_STATIC_CONSTANT(Number, shift = 1u << CHAR_BIT);
-        BOOST_STATIC_CONSTANT(Number, max =
-                            Number(Number(prev::max) * shift)
-                            + Number(UCHAR_MAX));
-        BOOST_STATIC_CONSTANT(Number, min = Number(Number(prev::min) * shift));
-#endif
-    };
-};
-
-// Template class complement_base<> -- defines values for min and max for
-// complement<1>, at the deepest level of recursion. Uses "poor man's partial
-// specialization" again.
-template <bool is_signed> struct complement_base;
-
-template <> struct complement_base<false>
-{
-    template <class Number>
-    struct values
-    {
-        BOOST_STATIC_CONSTANT(Number, min = 0);
-        BOOST_STATIC_CONSTANT(Number, max = UCHAR_MAX);
-    };
-};
-
-template <> struct complement_base<true>
-{
-    template <class Number>
-    struct values
-    {
-        BOOST_STATIC_CONSTANT(Number, min = SCHAR_MIN);
-        BOOST_STATIC_CONSTANT(Number, max = SCHAR_MAX);
-    };
-};
-
-// Base specialization of complement, puts an end to the recursion.
-template <>
-struct complement<1>
-{
-    template <class Number>
-    struct traits
-    {
-        BOOST_STATIC_CONSTANT(bool, is_signed = boost::detail::is_signed<Number>::value);
-        BOOST_STATIC_CONSTANT(Number, min =
-                            complement_base<is_signed>::template values<Number>::min);
-        BOOST_STATIC_CONSTANT(Number, max =
-                            complement_base<is_signed>::template values<Number>::max);
-    };
-};
-
-// Now here's the "pretty" template you're intended to actually use.
-//   complement_traits<Number>::min, complement_traits<Number>::max are the
-//   minimum and maximum values of Number if Number is a built-in integer type.
-template <class Number>
-struct complement_traits
-{
-    BOOST_STATIC_CONSTANT(Number, max = (complement_traits_aux<Number, sizeof(Number)>::max));
-    BOOST_STATIC_CONSTANT(Number, min = (complement_traits_aux<Number, sizeof(Number)>::min));
-};
-
-// =================================================================================
-
-// Support for streaming various numeric types in exactly the format I want. I
-// needed this in addition to all the assertions so that I could see exactly
-// what was going on.
-//
-// Numbers go through a 2-stage conversion process (by default, though, no real
-// conversion).
-//
-template <class T> struct stream_as {
-    typedef T t1;
-    typedef T t2;
-};
-
-// char types first get converted to unsigned char, then to unsigned.
-template <> struct stream_as<char> {
-    typedef unsigned char t1;
-    typedef unsigned t2;
-};
-template <> struct stream_as<unsigned char> {
-    typedef unsigned char t1; typedef unsigned t2;
-};
-template <> struct stream_as<signed char>  {
-    typedef unsigned char t1; typedef unsigned t2;
-};
-
-#if defined(BOOST_MSVC_STD_ITERATOR) // No intmax streaming built-in
-
-// With this library implementation, __int64 and __uint64 get streamed as strings
-template <> struct stream_as<boost::uintmax_t> {
-    typedef std::string t1;
-    typedef std::string t2;
-};
-
-template <> struct stream_as<boost::intmax_t>  {
-    typedef std::string t1;
-    typedef std::string t2;
-};
-#endif
-
-// Standard promotion process for streaming
-template <class T> struct promote
-{
-    static typename stream_as<T>::t1 from(T x) {
-        typedef typename stream_as<T>::t1 t1;
-        return t1(x);
-    }
-};
-
-#if defined(BOOST_MSVC_STD_ITERATOR) // No intmax streaming built-in
-
-// On this platform, stream them as long/unsigned long if they fit.
-// Otherwise, write a string.
-template <> struct promote<boost::uintmax_t> {
-    std::string static from(const boost::uintmax_t x) {
-        if (x > ULONG_MAX)
-            return std::string("large unsigned value");
-        else
-            return boost::lexical_cast<std::string>((unsigned long)x);
-    }
-};
-template <> struct promote<boost::intmax_t> {
-    std::string static from(const boost::intmax_t x) {
-        if (x > boost::intmax_t(ULONG_MAX))
-            return std::string("large positive signed value");
-        else if (x >= 0)
-            return boost::lexical_cast<std::string>((unsigned long)x);
-        
-        if (x < boost::intmax_t(LONG_MIN))
-            return std::string("large negative signed value");
-        else
-            return boost::lexical_cast<std::string>((long)x);
-    }
-};
-#endif
-
-// This is the function which converts types to the form I want to stream them in.
-template <class T>
-typename stream_as<T>::t2 stream_number(T x)
-{
-    return promote<T>::from(x);
-}
-// =================================================================================
-
-//
-// Tests for built-in signed and unsigned types
-//
-
-// Tag types for selecting tests
-struct unsigned_tag {};
-struct signed_tag {};
-
-// Tests for unsigned numbers. The extra default Number parameter works around
-// an MSVC bug.
-template <class Number>
-void test_aux(unsigned_tag, Number*)
-{
-    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
-    BOOST_STATIC_ASSERT(!boost::detail::is_signed<Number>::value);
-    BOOST_STATIC_ASSERT(
-        (sizeof(Number) < sizeof(boost::intmax_t))
-        | (boost::is_same<difference_type, boost::intmax_t>::value));
-
-#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
-    // GCC 4.0.2 ICEs on this C-style cases
-    BOOST_STATIC_ASSERT((complement_traits<Number>::max) > Number(0));
-    BOOST_STATIC_ASSERT((complement_traits<Number>::min) == Number(0));
-#else
-    // Force casting to Number here to work around the fact that it's an enum on MSVC
-    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::max) > Number(0));
-    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::min) == Number(0));
-#endif
-
-    const Number max = complement_traits<Number>::max;
-    const Number min = complement_traits<Number>::min;
-    
-    const Number test_max = (sizeof(Number) < sizeof(boost::intmax_t))
-        ? max
-        : max / 2 - 1;
-
-    std::cout << std::hex << "(unsigned) min = " << stream_number(min) << ", max = "
-              << stream_number(max) << "..." << std::flush;
-    std::cout << "difference_type = " << typeid(difference_type).name() << "..."
-              << std::flush;
-    
-    difference_type d1 = boost::detail::numeric_distance(Number(0), test_max);
-    difference_type d2 = boost::detail::numeric_distance(test_max, Number(0));
-    
-    std::cout << "0->" << stream_number(test_max) << "==" << std::dec << stream_number(d1) << "; "
-              << std::hex << stream_number(test_max) << "->0==" << std::dec << stream_number(d2) << "..." << std::flush;
-
-    assert(d1 == difference_type(test_max));
-    assert(d2 == -difference_type(test_max));
-}
-
-// Tests for signed numbers. The extra default Number parameter works around an
-// MSVC bug.
-struct out_of_range_tag {};
-struct in_range_tag {};
-
-// This test morsel gets executed for numbers whose difference will always be
-// representable in intmax_t
-template <class Number>
-void signed_test(in_range_tag, Number*)
-{
-    BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
-    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
-    const Number max = complement_traits<Number>::max;
-    const Number min = complement_traits<Number>::min;
-    
-    difference_type d1 = boost::detail::numeric_distance(min, max);
-    difference_type d2 = boost::detail::numeric_distance(max, min);
-
-    std::cout << stream_number(min) << "->" << stream_number(max) << "==";
-    std::cout << std::dec << stream_number(d1) << "; ";
-    std::cout << std::hex << stream_number(max) << "->" << stream_number(min)
-              << "==" << std::dec << stream_number(d2) << "..." << std::flush;
-    assert(d1 == difference_type(max) - difference_type(min));
-    assert(d2 == difference_type(min) - difference_type(max));
-}
-
-// This test morsel gets executed for numbers whose difference may exceed the
-// capacity of intmax_t.
-template <class Number>
-void signed_test(out_of_range_tag, Number*)
-{
-    BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
-    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
-    const Number max = complement_traits<Number>::max;
-    const Number min = complement_traits<Number>::min;
-
-    difference_type min_distance = complement_traits<difference_type>::min;
-    difference_type max_distance = complement_traits<difference_type>::max;
-
-    const Number n1 = Number(min + max_distance);
-    const Number n2 = Number(max + min_distance);
-    difference_type d1 = boost::detail::numeric_distance(min, n1);
-    difference_type d2 = boost::detail::numeric_distance(max, n2);
-
-    std::cout << stream_number(min) << "->" << stream_number(n1) << "==";
-    std::cout << std::dec << stream_number(d1) << "; ";
-    std::cout << std::hex << stream_number(max) << "->" << stream_number(n2)
-              << "==" << std::dec << stream_number(d2) << "..." << std::flush;
-    assert(d1 == max_distance);
-    assert(d2 == min_distance);
-}
-
-template <class Number>
-void test_aux(signed_tag, Number*)
-{
-    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
-    BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
-    BOOST_STATIC_ASSERT(
-        (sizeof(Number) < sizeof(boost::intmax_t))
-        | (boost::is_same<difference_type, Number>::value));
-
-#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
-    // GCC 4.0.2 ICEs on this cast
-    BOOST_STATIC_ASSERT((complement_traits<Number>::max) > Number(0));
-    BOOST_STATIC_ASSERT((complement_traits<Number>::min) < Number(0));
-#else
-    // Force casting to Number here to work around the fact that it's an enum on MSVC
-    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::max) > Number(0));
-    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::min) < Number(0));
-#endif    
-    const Number max = complement_traits<Number>::max;
-    const Number min = complement_traits<Number>::min;
-    
-    std::cout << std::hex << "min = " << stream_number(min) << ", max = "
-              << stream_number(max) << "..." << std::flush;
-    std::cout << "difference_type = " << typeid(difference_type).name() << "..."
-              << std::flush;
-
-    typedef typename boost::detail::if_true<
-                          (sizeof(Number) < sizeof(boost::intmax_t))>
-                        ::template then<
-                          in_range_tag,
-                          out_of_range_tag
-                        >::type
-        range_tag;
-    signed_test<Number>(range_tag(), 0);
-}
-
-
-// Test for all numbers. The extra default Number parameter works around an MSVC
-// bug.
-template <class Number>
-void test(Number* = 0)
-{
-    std::cout << "testing " << typeid(Number).name() << ":\n"
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-              << "is_signed: " << (std::numeric_limits<Number>::is_signed ? "true\n" : "false\n")
-              << "is_bounded: " << (std::numeric_limits<Number>::is_bounded ? "true\n" : "false\n")
-              << "digits: " << std::numeric_limits<Number>::digits << "\n"
-#endif
-              << "..." << std::flush;
-
-    // factoring out difference_type for the assert below confused Borland :(
-    typedef boost::detail::is_signed<
-#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
-        typename
-#endif
-        boost::detail::numeric_traits<Number>::difference_type
-        > is_signed;
-    BOOST_STATIC_ASSERT(is_signed::value);
-
-    typedef typename boost::detail::if_true<
-        boost::detail::is_signed<Number>::value
-        >::template then<signed_tag, unsigned_tag>::type signedness;
-    
-    test_aux<Number>(signedness(), 0);
-    std::cout << "passed" << std::endl;
-}
-
-int main()
-{
-    test<char>();
-    test<unsigned char>();
-    test<signed char>();
-    test<wchar_t>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-#if defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_INTEGRAL_INT64_T)
-    test< ::boost::long_long_type>();
-    test< ::boost::ulong_long_type>();
-#elif defined(BOOST_MSVC)
-    // The problem of not having compile-time static class constants other than
-    // enums prevents this from working, since values get truncated.
-    // test<boost::uintmax_t>();
-    // test<boost::intmax_t>();
-#endif
-    return 0;
-}
@@ -1667,8 +1667,8 @@ T operator+( T lhs, const T&amp; rhs )

        <td><code>P operator-&gt;() const</code></td>

-        <td><code>(&amp;*i)</code>. Return convertible to
-        <code>P</code>.</td>
+        <td><code>*i</code>. Address of the returned value convertible
+        to <code>P</code>.</td>
      </tr>

      <tr>
@@ -11,37 +11,40 @@ import testing ;
 alias unit_test_framework
    : # sources
        /boost//unit_test_framework
-    ;        
-
-# Please keep the tests ordered by filename
-test-suite utility
-    :
-        [ run ../base_from_member_test.cpp ]
-        [ run ../base_from_member_ref_test.cpp ]
-        [ run ../binary_test.cpp ]
-        [ run ../call_traits_test.cpp : -u ]
-        [ run ../compressed_pair_test.cpp ../../test/build//boost_test_exec_monitor/<link>static : -u ]
-        [ run ../iterators_test.cpp ../../test/build//boost_test_exec_monitor/<link>static ]
-        [ run next_prior_test.cpp ../../test/build//boost_test_exec_monitor/<link>static ]
-        [ run ../numeric_traits_test.cpp ]
-        [ run ../operators_test.cpp ../../test/build//boost_test_exec_monitor/<link>static ]
-        [ compile result_of_test.cpp ]
-        [ run ../shared_iterator_test.cpp ]
-        [ run string_ref_test1.cpp unit_test_framework ]
-        [ run string_ref_test2.cpp unit_test_framework ]
-        [ run string_ref_test_io.cpp unit_test_framework ]
-        [ run string_view_test1.cpp unit_test_framework ]
-        [ run string_view_test2.cpp unit_test_framework ]
-        [ run string_view_test_io.cpp unit_test_framework ]
-        [ run ../value_init_test.cpp ]
-        [ run ../value_init_workaround_test.cpp ]
-        [ run ../initialized_test.cpp ]
-        [ compile-fail ../value_init_test_fail1.cpp ]
-        [ compile-fail ../value_init_test_fail2.cpp ]
-        [ compile-fail ../value_init_test_fail3.cpp ]
-        [ compile-fail ../initialized_test_fail1.cpp ]
-        [ compile-fail ../initialized_test_fail2.cpp ]
-
-        [ run ../generator_iterator_test.cpp ]
    ;

+run base_from_member_test.cpp ;
+run base_from_member_ref_test.cpp ;
+
+run binary_test.cpp ;
+
+run call_traits_test.cpp : -u ;
+
+run compressed_pair_test.cpp ../../test/build//boost_test_exec_monitor/<link>static ;
+
+run iterators_test.cpp ../../test/build//boost_test_exec_monitor/<link>static ;
+
+run operators_test.cpp ../../test/build//boost_test_exec_monitor/<link>static ;
+
+compile result_of_test.cpp ;
+
+run shared_iterator_test.cpp ;
+
+# compile-fail string_ref_from_rvalue.cpp ;
+run string_ref_test1.cpp unit_test_framework ;
+run string_ref_test2.cpp unit_test_framework ;
+run string_ref_test_io.cpp unit_test_framework ;
+# compile-fail string_view_from_rvalue.cpp ;
+compile string_view_constexpr_test1.cpp ;
+run string_view_test1.cpp unit_test_framework ;
+run string_view_test2.cpp unit_test_framework ;
+run string_view_test_io.cpp unit_test_framework ;
+
+run value_init_test.cpp ;
+run value_init_workaround_test.cpp ;
+run initialized_test.cpp ;
+compile-fail value_init_test_fail1.cpp ;
+compile-fail value_init_test_fail2.cpp ;
+compile-fail value_init_test_fail3.cpp ;
+compile-fail initialized_test_fail1.cpp ;
+compile-fail initialized_test_fail2.cpp ;
@@ -18,7 +18,7 @@

 #include <boost/utility/base_from_member.hpp>  // for boost::base_from_member

-#include <functional>  // for std::binary_function, std::less
+#include <functional>  // for std::less
 #include <iostream>    // for std::cout (std::ostream, std::endl indirectly)
 #include <set>         // for std::set
 #include <typeinfo>    // for std::type_info
@@ -46,7 +46,6 @@ template < typename T >

 // A custom comparison type is needed
 struct object_id_compare
-    : std::binary_function<object_id, object_id, bool>
 {
    bool  operator ()( object_id const &a, object_id const &b ) const;

@@ -1,97 +0,0 @@
-// Boost test program for next() and prior() utilities.
-
-// Copyright 2003 Daniel Walker.  Use, modification, and distribution
-// are subject to the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or a copy at
-// http://www.boost.org/LICENSE_1_0.txt.)
-
-// See http://www.boost.org/libs/utility for documentation.
-
-// Revision History 13 Dec 2003 Initial Version (Daniel Walker)
-
-// next() and prior() are replacements for operator+ and operator- for
-// non-random-access iterators. The semantics of these operators are
-// such that after executing j = i + n, std::distance(i, j) equals
-// n. Tests are provided to ensure next() has the same
-// result. Parallel tests are provided for prior(). The tests call
-// next() and prior() several times. next() and prior() are very
-// simple functions, though, and it would be very strange if these
-// tests were to fail.
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-
-#include <list>
-#include <vector>
-
-#include <boost/next_prior.hpp>
-
-template<class RandomAccessIterator, class ForwardIterator>
-bool plus_one_test(RandomAccessIterator first, RandomAccessIterator last, ForwardIterator first2)
-{
-    RandomAccessIterator i = first;
-    ForwardIterator j = first2;
-    while(i != last)
-        i = i + 1, j = boost::next(j);
-    return std::distance(first, i) == std::distance(first2, j);
-}
-
-template<class RandomAccessIterator, class ForwardIterator>
-bool plus_n_test(RandomAccessIterator first, RandomAccessIterator last, ForwardIterator first2)
-{
-    RandomAccessIterator i = first;
-    ForwardIterator j = first2;
-    for(int n = 0; i != last; ++n)
-        i = first + n, j = boost::next(first2, n);
-    return std::distance(first, i) == std::distance(first2, j);
-}
-
-template<class RandomAccessIterator, class BidirectionalIterator>
-bool minus_one_test(RandomAccessIterator first, RandomAccessIterator last, BidirectionalIterator last2)
-{
-    RandomAccessIterator i = last;
-    BidirectionalIterator j = last2;
-    while(i != first)
-        i = i - 1, j = boost::prior(j);
-    return std::distance(i, last) == std::distance(j, last2);
-}
-
-template<class RandomAccessIterator, class BidirectionalIterator>
-bool minus_n_test(RandomAccessIterator first, RandomAccessIterator last, BidirectionalIterator last2)
-{
-    RandomAccessIterator i = last;
-    BidirectionalIterator j = last2;
-    for(int n = 0; i != first; ++n)
-        i = last - n, j = boost::prior(last2, n);
-    return std::distance(i, last) == std::distance(j, last2);
-}
-
-template<class Iterator, class Distance>
-bool minus_n_unsigned_test(Iterator first, Iterator last, Distance size)
-{
-    Iterator i = boost::prior(last, size);
-    return i == first;
-}
-
-int test_main(int, char*[])
-{
-    std::vector<int> x(8);
-    std::list<int> y(x.begin(), x.end());
-
-    // Tests with iterators
-    BOOST_REQUIRE(plus_one_test(x.begin(), x.end(), y.begin()));
-    BOOST_REQUIRE(plus_n_test(x.begin(), x.end(), y.begin()));
-    BOOST_REQUIRE(minus_one_test(x.begin(), x.end(), y.end()));
-    BOOST_REQUIRE(minus_n_test(x.begin(), x.end(), y.end()));
-    BOOST_REQUIRE(minus_n_unsigned_test(x.begin(), x.end(), x.size()));
-    BOOST_REQUIRE(minus_n_unsigned_test(y.begin(), y.end(), y.size()));
-
-    // Tests with integers
-    BOOST_REQUIRE(boost::next(5) == 6);
-    BOOST_REQUIRE(boost::next(5, 7) == 12);
-    BOOST_REQUIRE(boost::prior(5) == 4);
-    BOOST_REQUIRE(boost::prior(5, 7) == -2);
-    BOOST_REQUIRE(boost::prior(5, 7u) == -2);
-
-    return 0;
-}
@@ -297,6 +297,12 @@ int main()
  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_template<void>(void)>::type, cv_overload_check<const int> >::value));
  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_template<void>(void)>::type, cv_overload_check<volatile int> >::value));
  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_template<void>(void)>::type, cv_overload_check<const volatile int> >::value));
+
+  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr&(char, float)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr const&(char, float)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of&(double)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of const&(double)>::type, int>::value));
+
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(int&&)>::type, short>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(int&)>::type, int>::value));
@@ -0,0 +1,28 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <iostream>
+#include <algorithm>
+#include <string>
+
+#include <boost/utility/string_ref.hpp>
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+#error "Unsupported test"
+#endif
+
+#include "boost/test/minimal.hpp"
+
+std::string makeatemp() { return "abc"; }
+
+int test_main(int, char **)
+{
+  boost::basic_string_ref<char> sv(makeatemp());
+  return 0;
+}
@@ -83,7 +83,7 @@ void reverse ( const char *arg ) {
    BOOST_CHECK ( std::equal ( sr1.begin (), sr1.end (), string2.begin ()));
    }

-//	This helper function eliminates signed vs. unsigned warnings
+// This helper function eliminates signed vs. unsigned warnings
 string_ref::size_type ptr_diff ( const char *res, const char *base ) {
    BOOST_CHECK ( res >= base );
    return static_cast<string_ref::size_type> ( res - base );
@@ -112,7 +112,7 @@ void find ( const char *arg ) {
      ++p;
      }

-//	Look for pairs on characters (searching from the start)
+// Look for pairs on characters (searching from the start)
    sr1 = arg;
    p = arg;
    while ( *p && *(p+1)) {
@@ -249,7 +249,7 @@ void to_string ( const char *arg ) {

    str1.assign ( arg );
    sr1 = arg;
-//	str2 = sr1.to_string<std::allocator<char> > ();
+// str2 = sr1.to_string<std::allocator<char> > ();
    str2 = sr1.to_string ();
    BOOST_CHECK ( str1 == str2 );

@@ -266,11 +266,11 @@ void compare ( const char *arg ) {

    str1.assign ( arg );
    sr1 = arg;
-    BOOST_CHECK ( sr1  == sr1);	    // compare string_ref and string_ref
-    BOOST_CHECK ( sr1  == str1);	// compare string and string_ref
-    BOOST_CHECK ( str1 == sr1 );	// compare string_ref and string
-    BOOST_CHECK ( sr1  == arg );	// compare string_ref and pointer
-    BOOST_CHECK ( arg  == sr1 );	// compare pointer and string_ref
+    BOOST_CHECK ( sr1  == sr1);     // compare string_ref and string_ref
+    BOOST_CHECK ( sr1  == str1);    // compare string and string_ref
+    BOOST_CHECK ( str1 == sr1 );    // compare string_ref and string
+    BOOST_CHECK ( sr1  == arg );    // compare string_ref and pointer
+    BOOST_CHECK ( arg  == sr1 );    // compare pointer and string_ref

    if ( sr1.size () > 0 ) {
        (*str1.rbegin())++;
@@ -0,0 +1,121 @@
+/*
+   Copyright (c) Marshall Clow 2017-2017.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <new>        // for placement new
+#include <iostream>
+#include <cstddef>    // for NULL, std::size_t, std::ptrdiff_t
+#include <cstring>    // for std::strchr and std::strcmp
+#include <cstdlib>    // for std::malloc and std::free
+
+#include <boost/config.hpp>
+#include <boost/utility/string_view.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+
+#if __cplusplus < 201402L
+BOOST_AUTO_TEST_CASE( test_main ) {}
+#else
+
+struct constexpr_char_traits
+{
+    typedef char		    char_type;
+    typedef int   			int_type;
+    typedef std::streamoff	off_type;
+    typedef std::streampos	pos_type;
+    typedef std::mbstate_t	state_type;
+
+    static void assign(char_type& c1, const char_type& c2) noexcept { c1 = c2; }
+    static constexpr bool eq(char_type c1, char_type c2) noexcept   { return c1 == c2; }
+    static constexpr bool lt(char_type c1, char_type c2) noexcept   { return c1 < c2; }
+
+    static constexpr int              compare(const char_type* s1, const char_type* s2, size_t n) noexcept;
+    static constexpr size_t           length(const char_type* s) noexcept;
+    static constexpr const char_type* find(const char_type* s, size_t n, const char_type& a) noexcept;
+    static constexpr char_type*       move(char_type* s1, const char_type* s2, size_t n) noexcept;
+    static constexpr char_type*       copy(char_type* s1, const char_type* s2, size_t n) noexcept;
+    static constexpr char_type*       assign(char_type* s, size_t n, char_type a) noexcept;
+
+    static constexpr int_type  not_eof(int_type c) noexcept { return eq_int_type(c, eof()) ? ~eof() : c; }
+    static constexpr char_type to_char_type(int_type c) noexcept              { return char_type(c); }
+    static constexpr int_type  to_int_type(char_type c) noexcept              { return int_type(c); }
+    static constexpr bool      eq_int_type(int_type c1, int_type c2) noexcept { return c1 == c2; }
+    static constexpr int_type  eof() noexcept                                 { return EOF; }
+};
+
+//	yields:
+//		0 if for each i in [0,n), X::eq(s1[i],s2[i]) is true; 
+//		else, a negative value if, for some j in [0,n), X::lt(s1[j],s2[j]) is true and
+//			for each i in [0,j) X::eq(s2[i],s2[i]) is true;
+//		else a positive value.
+constexpr int constexpr_char_traits::compare(const char_type* s1, const char_type* s2, size_t n) noexcept
+{
+    for (; n != 0; --n, ++s1, ++s2)
+    {
+        if (lt(*s1, *s2))
+            return -1;
+        if (lt(*s2, *s1))
+            return 1;
+    }
+    return 0;
+}
+
+//	yields: the smallest i such that X::eq(s[i],charT()) is true.
+constexpr size_t constexpr_char_traits::length(const char_type* s) noexcept
+{
+    size_t len = 0;
+    for (; !eq(*s, char_type(0)); ++s)
+        ++len;
+    return len;
+}
+
+typedef boost::basic_string_view<char, constexpr_char_traits> string_view;
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+    constexpr string_view sv1;
+    constexpr string_view sv2{"abc", 3}; // ptr, len
+    constexpr string_view sv3{"def"}; 	 // ptr
+
+	constexpr const char *s1 = "";
+	constexpr const char *s2 = "abc";
+	
+	static_assert( (sv1 == sv1), "" );
+	
+	static_assert(!(sv1 == sv2), "" );    
+	static_assert( (sv1 != sv2), "" );    
+	static_assert( (sv1 <  sv2), "" );    
+	static_assert( (sv1 <= sv2), "" );    
+	static_assert(!(sv1 >  sv2), "" );    
+	static_assert(!(sv1 >= sv2), "" );    
+
+	static_assert(!(s1 == sv2), "" );    
+	static_assert( (s1 != sv2), "" );    
+	static_assert( (s1 <  sv2), "" );    
+	static_assert( (s1 <= sv2), "" );    
+	static_assert(!(s1 >  sv2), "" );    
+	static_assert(!(s1 >= sv2), "" );    
+
+	static_assert(!(sv1 == s2), "" );    
+	static_assert( (sv1 != s2), "" );    
+	static_assert( (sv1 <  s2), "" );    
+	static_assert( (sv1 <= s2), "" );    
+	static_assert(!(sv1 >  s2), "" );    
+	static_assert(!(sv1 >= s2), "" );    
+
+	static_assert( sv1.compare(sv2)  < 0, "" );    
+	static_assert( sv1.compare(sv1) == 0, "" );    
+	static_assert( sv3.compare(sv1)  > 0, "" );    
+
+	static_assert( sv1.compare(s2)  < 0, "" );    
+	static_assert( sv1.compare(s1) == 0, "" );    
+	static_assert( sv3.compare(s1)  > 0, "" );    
+}
+#endif
@@ -0,0 +1,28 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <iostream>
+#include <algorithm>
+#include <string>
+
+#include <boost/utility/string_view.hpp>
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+#error "Unsupported test"
+#endif
+
+#include "boost/test/minimal.hpp"
+
+std::string makeatemp() { return "abc"; }
+
+int test_main(int, char **)
+{
+  boost::basic_string_view<char> sv(makeatemp());
+  return 0;
+}
@@ -7,10 +7,14 @@
    For more information, see http://www.boost.org
 */

+#include <new>        // for placement new
 #include <iostream>
-#include <cstring>    // for std::strchr
+#include <cstddef>    // for NULL, std::size_t, std::ptrdiff_t
+#include <cstring>    // for std::strchr and std::strcmp
+#include <cstdlib>    // for std::malloc and std::free

 #include <boost/utility/string_view.hpp>
+#include <boost/config.hpp>

 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp>
@@ -83,7 +87,7 @@ void reverse ( const char *arg ) {
    BOOST_CHECK ( std::equal ( sr1.begin (), sr1.end (), string2.begin ()));
    }

-//	This helper function eliminates signed vs. unsigned warnings
+//  This helper function eliminates signed vs. unsigned warnings
 string_view::size_type ptr_diff ( const char *res, const char *base ) {
    BOOST_CHECK ( res >= base );
    return static_cast<string_view::size_type> ( res - base );
@@ -112,7 +116,7 @@ void find ( const char *arg ) {
      ++p;
      }

-//	Look for pairs on characters (searching from the start)
+//  Look for pairs on characters (searching from the start)
    sr1 = arg;
    p = arg;
    while ( *p && *(p+1)) {
@@ -241,6 +245,86 @@ void find ( const char *arg ) {

    }

+template <typename T>
+class custom_allocator {
+public:
+    typedef T value_type;
+    typedef T* pointer;
+    typedef const T* const_pointer;
+    typedef void* void_pointer;
+    typedef const void* const_void_pointer;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef T& reference;
+    typedef const T& const_reference;
+
+    template<class U>
+    struct rebind {
+        typedef custom_allocator<U> other;
+        };
+
+    custom_allocator() BOOST_NOEXCEPT {}
+    template <typename U>
+    custom_allocator(custom_allocator<U> const&) BOOST_NOEXCEPT {}
+
+    pointer allocate(size_type n) const {
+        return static_cast<pointer>(std::malloc(sizeof(value_type) * n));
+        }
+    void deallocate(pointer p, size_type) const BOOST_NOEXCEPT {
+        std::free(p);
+        }
+
+    pointer address(reference value) const BOOST_NOEXCEPT {
+        return &value;
+        }
+
+    const_pointer address(const_reference value) const BOOST_NOEXCEPT {
+        return &value;
+        }
+
+    BOOST_CONSTEXPR size_type max_size() const BOOST_NOEXCEPT {
+        return (~(size_type)0u) / sizeof(value_type);
+        }
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template <class U, class... Args>
+    void construct(U* ptr, Args&&... args) const {
+        ::new((void*)ptr) U(static_cast<Args&&>(args)...);
+        }
+#else
+    template <class U, class V>
+    void construct(U* ptr, V&& value) const {
+        ::new((void*)ptr) U(static_cast<V&&>(value));
+        }
+#endif
+#else
+    template <class U, class V>
+    void construct(U* ptr, const V& value) const {
+        ::new((void*)ptr) U(value);
+        }
+#endif
+
+    template <class U>
+    void construct(U* ptr) const {
+        ::new((void*)ptr) U();
+        }
+
+    template <class U>
+    void destroy(U* ptr) const {
+        (void)ptr;
+        ptr->~U();
+        }
+    };
+
+template <typename T, typename U>
+BOOST_CONSTEXPR bool operator==(const custom_allocator<T> &, const custom_allocator<U> &) BOOST_NOEXCEPT {
+    return true;
+    }
+template <typename T, typename U>
+BOOST_CONSTEXPR bool operator!=(const custom_allocator<T> &, const custom_allocator<U> &) BOOST_NOEXCEPT {
+    return false;
+    }

 void to_string ( const char *arg ) {
    string_view sr1;
@@ -249,13 +333,16 @@ void to_string ( const char *arg ) {

    str1.assign ( arg );
    sr1 = arg;
-//	str2 = sr1.to_string<std::allocator<char> > ();
+//  str2 = sr1.to_string<std::allocator<char> > ();
    str2 = sr1.to_string ();
    BOOST_CHECK ( str1 == str2 );

+    std::basic_string<char, std::char_traits<char>, custom_allocator<char> > str3 = sr1.to_string(custom_allocator<char>());
+    BOOST_CHECK ( std::strcmp(str1.c_str(), str3.c_str()) == 0 );
+
 #ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-    std::string str3 = static_cast<std::string> ( sr1 );
-    BOOST_CHECK ( str1 == str3 );
+    std::string str4 = static_cast<std::string> ( sr1 );
+    BOOST_CHECK ( str1 == str4 );
 #endif
    }

@@ -266,11 +353,11 @@ void compare ( const char *arg ) {

    str1.assign ( arg );
    sr1 = arg;
-    BOOST_CHECK ( sr1  == sr1);	    // compare string_view and string_view
-    BOOST_CHECK ( sr1  == str1);	// compare string and string_view
-    BOOST_CHECK ( str1 == sr1 );	// compare string_view and string
-    BOOST_CHECK ( sr1  == arg );	// compare string_view and pointer
-    BOOST_CHECK ( arg  == sr1 );	// compare pointer and string_view
+    BOOST_CHECK ( sr1  == sr1);    // compare string_view and string_view
+    BOOST_CHECK ( sr1  == str1);   // compare string and string_view
+    BOOST_CHECK ( str1 == sr1 );   // compare string_view and string
+    BOOST_CHECK ( sr1  == arg );   // compare string_view and pointer
+    BOOST_CHECK ( arg  == sr1 );   // compare pointer and string_view

    if ( sr1.size () > 0 ) {
        (*str1.rbegin())++;
@@ -75,6 +75,24 @@ namespace
    return true;
  }

+  struct int_pair_struct
+  {
+    int first;
+    int second;
+  };
+
+  typedef int int_pair_struct::*ptr_to_member_type;
+
+  struct ptr_to_member_struct
+  {
+    ptr_to_member_type data;
+  };
+
+  bool is_value_initialized(const ptr_to_member_struct& arg)
+  {
+    return arg.data == 0;
+  }
+
  template <typename T>
  bool is_value_initialized(const T(& arg)[2])
  {
@@ -132,7 +150,8 @@ int main()
  const unsigned num_failures =
    FAILED_TO_VALUE_INITIALIZE(boost::value_initialized<derived_struct>()) +
    FAILED_TO_VALUE_INITIALIZE(boost::value_initialized<virtual_destructor_holder[2]>()) +
-	FAILED_TO_VALUE_INITIALIZE(boost::value_initialized<private_int_array_pair>());
+    FAILED_TO_VALUE_INITIALIZE(boost::value_initialized<private_int_array_pair>()) +
+    FAILED_TO_VALUE_INITIALIZE(boost::value_initialized<ptr_to_member_struct>());

 #ifdef BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
  // One or more failures are expected.
@@ -17,7 +17,7 @@
 				Function templates <a href="../core/doc/html/core/checked_delete.html">checked_delete() and 
 					checked_array_delete()</a> (moved to the Boost.Core library)</li>
 			<li>
-				Function templates <a href="#functions_next_prior">next() and prior()</a></li>
+				Function templates <a href="../iterator/doc/html/iterator/algorithms/next_prior.html">next() and prior()</a> (moved to the Boost.Iterator library)</li>
 			<li>
 				Class <a href="../core/doc/html/core/noncopyable.html">noncopyable</a> (moved to the Boost.Core library)</li>
 			<li>
@@ -28,45 +28,6 @@
                        <li><a href="index.html">Other utilities not part of <code>utility.hpp</code></a></li>
 		</ul>
 		<h2>
-			<a name="functions_next_prior">Function</a> templates next() and prior()</h2>
-		<p>Certain data types, such as the C++ Standard Library's forward and bidirectional 
-			iterators, do not provide addition and subtraction via operator+() or 
-			operator-().&nbsp; This means that non-modifying computation of the next or 
-			prior value requires a temporary, even though operator++() or operator--() is 
-			provided.&nbsp; It also means that writing code like <code>itr+1</code> inside 
-			a template restricts the iterator category to random access iterators.</p>
-		<p>The next() and prior() functions provide a simple way around these problems:</p>
-		<blockquote>
-			<pre>template &lt;class T&gt;
-T next(T x) { return ++x; }
-
-template &lt;class T, class Distance&gt;
-T next(T x, Distance n)
-{
-    std::advance(x, n);
-    return x;
-}
-
-template &lt;class T&gt;
-T prior(T x) { return --x; }
-
-template &lt;class T, class Distance&gt;
-T prior(T x, Distance n)
-{
-    std::advance(x, -n);
-    return x;
-}</pre>
-		</blockquote>
-		<p>Usage is simple:</p>
-		<blockquote>
-			<pre>const std::list&lt;T&gt;::iterator p = get_some_iterator();
-const std::list&lt;T&gt;::iterator prev = boost::prior(p);
-const std::list&lt;T&gt;::iterator next = boost::next(prev, 2);</pre>
-		</blockquote>
-                <p>The distance from the given iterator should be supplied as an absolute value. For
-			example, the iterator four iterators prior to the given iterator <code>p</code>
-			may be obtained by <code>prior(p, 4)</code>.</p>
-		<p>Contributed by <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a>.  Two-argument versions by Daniel Walker.</p>

                <h2><a name="result_of">Class template
                result_of</a></h2> <p>The class template
Author	SHA1	Message	Date
Peter Dimov	9d46de1578	Replace use of mpl/has_xxx.hpp with handwritten traits	2017-12-21 06:30:03 +02:00
Peter Dimov	976a4d2fc1	Merge branch 'develop' into feature/result_of-no-mpl	2017-12-20 23:16:08 +02:00
Peter Dimov	ea81279b35	Add appveyor.yml	2017-12-20 23:14:36 +02:00
Peter Dimov	7d101d420c	Replace mpl primitives with type_traits	2017-12-20 21:55:07 +02:00
Peter Dimov	d8acfef27b	Update includes in utility.hpp; add deprecation comment	2017-12-02 04:35:22 +02:00
Peter Dimov	d7ae336915	Merge branch 'master' into develop	2017-12-02 03:47:03 +02:00
Peter Dimov	b74f49f1e5	Remove dependency on iterator in <boost/utility.hpp>	2017-12-02 03:38:29 +02:00
Daniel Frey	5977f11be8	Merge pull request #36 from boostorg/develop Protect dereferenceable<> against overloaded operator&, fixes #35	2017-12-01 20:59:24 +01:00
Daniel Frey	ad0fc7c9d3	Protect dereferenceable<> against overloaded operator&, fixes #35	2017-11-23 21:14:07 +01:00
Peter Dimov	a6c175e2c3	clang 3.5 can't handle libstdc++-5	2017-10-28 14:11:41 +03:00
Peter Dimov	874ca2307b	Update clangs to libstdc++-5-dev for constexpr std::min	2017-10-28 04:49:50 +03:00
Peter Dimov	5220260145	Update .travis.yml	2017-10-27 15:31:19 +03:00
Daniel Frey	2f5a6fbcf1	Adapt to C++17, fixes #34	2017-10-15 10:34:04 +02:00
Peter Dimov	51ba9f1b45	Add one more case to value_init_workaround_test	2017-09-24 12:47:05 +03:00
Andrey Semashev	5cef1403b0	Merge pull request #33 from morinmorin/fix_no_expr_sfinae result_of<F&(…)> fails on MSVC-12 if F is a function pointer	2017-09-23 21:59:06 +03:00
morinmorin	81ce4693f6	Add tests for result_of<F&(...)> in C++11.	2017-09-20 23:44:35 +09:00
morinmorin	fb2f110eb4	Fix result_of_is_callable to support references to function pointers. On compilers without the support of expression SFINAE, decltype-based result_of<FP&(...)> failed to compile (FP is a function pointer type).	2017-09-20 23:40:56 +09:00
Andrey Semashev	2ed5ee9588	Moved numeric_traits_test.cpp to Boost.Detail.	2017-09-20 01:42:15 +03:00
Andrey Semashev	88c36c1941	Remove generator iterator test and docs as these were moved to Boost.Iterator.	2017-08-28 20:41:11 +03:00
Andrey Semashev	0b2409a942	Updated links to next/prior docs.	2017-08-26 20:07:12 +03:00
Andrey Semashev	62b39548be	Moved next/prior to Boost.Iterator.	2017-08-26 17:25:14 +03:00
Andrey Semashev	2722fdcda3	Use std::iterator_traits to detect iterators, when possible. This allows next/prior to detect user's iterators that do not define iterator_category nested type but specialize std::iterator_traits instead.	2017-07-23 20:29:25 +03:00
Andrey Semashev	792d0538d2	Merge branch 'develop'	2017-07-17 20:47:57 +03:00
Andrey Semashev	06ae661775	Merge pull request #31 from Lastique/next_prior_use_traversal Use Boost.Iterator to advance iterators.	2017-07-13 21:04:18 +03:00
Andrey Semashev	d9d076874e	Merge branch 'develop'	2017-07-13 20:59:28 +03:00
Andrey Semashev	e25d85446e	Use Boost.Iterator to advance iterators. By using Boost.Iterator we rely on the separate traversal category instead of the standard iterator category to advance iterators efficiently. For instance, this allows to advance transform iterators over a random access sequence in constant time, despite that they are formally input iterators. Also, std::reverse_iterator formally requires at least bidirectional iterator as the underlying iterator type. Transform iterators from the example above don't qualify, so potentially std::reverse_iterator could fail to compile.	2017-07-12 21:15:20 +03:00
Andrey Semashev	5bc9e47688	Changed iterator_category nested type detection to work with MSVC and different versions of gcc.	2017-07-12 20:14:48 +03:00
Andrey Semashev	ec50f22b8b	Merge pull request #30 from Lastique/fix_next_prior_for_iterators Fix next/prior for iterators	2017-07-09 13:41:03 +03:00
Brian Minard	592382dc61	Add test cases for std::reverse_iterator	2017-07-09 03:10:10 +03:00
Andrey Semashev	6cf9c22cf1	Reworked iterator handling in next/prior helpers. The new implementation tries to detect if the incremented/decremented type is an iterator first and if not falls back to operator probing. This way iterators that are not SFINAE-friendly (i.e. unconditionally define arithmetic operators regardless of the iterator category) are still treated as iterators through std::advance and do not fail the compilation. The iterator detection is based on probing for the nested iterator_category type that is expected to be present in class-type iterators. This heuristic is not flawless since iterators are not required to defined this type. User-defined iterators may not have it and instead specialize std::iterator_traits. This use case is not covered by the current implementation and will likely fail to compile. With C++17 SFINAE-friendly std::iterator_traits this can be fixed, but currently Boost.Config lacks the macro to detect availability of this feature. Support for it can be added by a later commit. Also simplified boost::prior for iterators, removing the possibility of integer overflow caused by negation of the distance value.	2017-07-09 03:10:01 +03:00
Peter Dimov	33475f87e4	Merge branch 'develop'	2017-05-30 15:08:09 +03:00
Peter Dimov	21261a8630	Add visible dependency to result_of_iterate.hpp	2017-05-30 01:20:02 +03:00
Peter Dimov	7d60e8e378	Merge branch 'develop'	2017-05-30 00:56:41 +03:00
Peter Dimov	10ff4d4fcd	Try to upgrade libstdc++ for clang in 14/1z mode	2017-05-29 21:27:57 +03:00
Peter Dimov	89bf74beee	Add .travis.yml	2017-05-29 19:16:28 +03:00
Peter Dimov	bfdcce0f97	Move test files to test/	2017-05-29 19:10:46 +03:00
Marshall Clow	330b49d602	Mark comparison operators for string_view as constexpr; add tests. Reference: https://svn.boost.org/trac/boost/ticket/12896	2017-05-03 19:58:02 -07:00
Marshall Clow	68b26cddbe	Merge branch 'develop' of github.com:boostorg/utility into develop	2017-04-06 07:59:12 -07:00
Marshall Clow	6c4ab93573	Revert change disallowing construction of string_view/string_ref from rvalue string	2017-03-28 15:17:09 +02:00
Marshall Clow	0876da45db	Fix potential overflow in substr; Trac #11536 . Also change string_view::copy to use the traits::copy	2017-02-13 10:49:17 -08:00
Marshall Clow	00f02167e3	Add tests to ensure that string_view\|ref from rvalue fails (whenever it can)	2017-02-13 10:25:04 -08:00
Marshall Clow	9960d9f395	Don't construct string_view\|string_ref from rvalue string. That way lies pain	2017-02-13 08:15:44 -08:00
Andrey Semashev	ccfd741c0a	Merge pull request #27 from MarcelRaad/patch-1 Use non-deprecated include paths	2016-12-21 12:20:20 +04:00
Marcel Raad	c5c479d49c	Use non-deprecated include paths According to the comments in these two headers, the files in the core directory should be used instead.	2016-12-21 08:22:35 +01:00
Marshall Clow	3e8f73c6ac	Merge pull request #26 from Surrog/develop Fixing visual studio compilation of string_view::at(); preserving C++11 constexpr-ness.	2016-12-12 17:22:29 -08:00
Surogate	38121f2af3	Allow string_view::at() to be constexpr again on VS2015 VS2015 doesn't support extended constexpr. Thanks to Lastique for the ternary trick	2016-12-12 23:45:34 +01:00
Surogate	38b536ff05	Fixing visual studio compilation of string_view::at() VS2013, VS2015 & VS2017RC don't like the ternary throwing an exception : 'return': cannot convert from 'void' to 'const char &' Now using classic if when compiling on a windows platform.	2016-12-12 22:57:56 +01:00
Marshall Clow	9ae6492af9	Merge pull request #25 from zerotypos-found/inspection_report Remove tabs and Non-ASCII characters. Thanks!	2016-11-21 18:25:08 -08:00
zerotypos-found	816607e212	Remove tabs and Non-ASCII characters.	2016-11-15 11:59:51 +09:00
Andrey Semashev	a3ab942bc2	Merge branch 'develop'	2016-11-08 16:56:27 +03:00
Andrey Semashev	0f1f793caf	Removed std::binary_function from a comment.	2016-11-06 21:18:27 +03:00
Peter Dimov	ff445c0ece	Remove std::binary_function use, it has been removed in C++17	2016-11-06 14:38:13 +02:00
Rene Rivera	9fae8be166	Add, and update, documentation build targets.	2016-10-10 11:39:54 -05:00
Rene Rivera	b90a28f0e1	Add, and update, documentation build targets.	2016-10-07 23:07:37 -05:00
Andrey Semashev	febca584d9	Removed -u command line option for the compressed_pair_test as this option is not recognized by Boost.Test (and presumably never was). This fixes the test execution failure.	2016-09-03 00:25:51 +03:00
Andrey Semashev	21dc552cf9	Added a workaround for gcc 4.6 in C++11 mode as it can't seem to handle defaulted functions with noexcept specifier. The problem was discovered with autotests.	2016-09-02 19:14:00 +03:00
Andrey Semashev	fda210f597	Merge branch 'develop'	2016-09-02 18:34:58 +03:00
Andrey Semashev	3d853b0e83	Reworked to_string test to verify the overload with a custom allocator even when explicit conversion operators are not supported. Made the custom allocator more standard-compliant.	2016-09-01 22:42:29 +03:00
Andrey Semashev	4814d1ebfe	Added another overload of to_string when default function template arguments are not supported. The additional overload more closely emulates the official interface and allows to construct strings with custom allocators.	2016-09-01 22:08:28 +03:00
gnaggnoyil	e5932ebb08	fix compile error on basic_string_view::to_string when Allocator is user-defined	2016-09-01 21:56:20 +03:00
Marshall Clow	93a2e25092	Merge to master for 1.62.0 release	2016-08-17 13:02:13 -07:00
Marshall Clow	39577f86d1	Fix rfind (and other finders). Fixes bug https://svn.boost.org/trac/boost/ticket/9518	2016-08-14 11:20:28 -07:00
Marshall Clow	8392991c46	Remove extraneous semicolon; no functional change	2016-08-14 11:19:32 -07:00
Marshall Clow	c5b1256650	rename routines in detail namespace so that someone who includes both <string_ref> and <string_view> won't get duplicate decls	2016-08-14 11:11:12 -07:00
Marshall Clow	c56dd13592	Mark the copy ctor/assignment operator as '= default' when the compiler supports it. This makes these types trivially copy/move assignable/constructible. See https://svn.boost.org/trac/boost/ticket/11684	2016-07-27 11:18:18 -07:00
Marshall Clow	181f302ee4	Fix Ticket 12140; mark only single-arg ctor as explicit. Thanks to Thimo for the patch.	2016-06-15 15:50:21 -07:00
Marshall Clow	287844fe76	Merge branch 'develop' of github.com:boostorg/utility into develop	2016-06-15 14:52:40 -07:00
Marshall Clow	0b492bee9c	Re-install string_ref - to be removed in the future	2016-04-14 07:50:28 -07:00
Andrey Semashev	a9236d00a9	Ensure the file ends with a newline. Fixes compiler warnings.	2016-03-26 14:00:12 +03:00
Marshall Clow	4313bfc323	Revert "Remove the 'basic_string_ref template; use 'basic_string_view' instead. Keep the string_ref, etc typedefs around, though" This reverts commit `8ab8e36dcf`.	2016-03-07 08:45:25 -08:00
Daniel Frey	1dfacff7ec	Renamed namespace detail to operators_detail	2016-02-23 20:30:16 +01:00
Daniel Frey	a25ac4550b	Removed unused overloads	2016-02-22 20:46:58 +01:00
Daniel Frey	d767054a79	Merge branch 'develop' of github.com:boostorg/utility into develop	2016-02-22 20:39:26 +01:00
Daniel Frey	08a1b7da61	Added ADL protector	2016-02-22 20:39:16 +01:00
Marshall Clow	8ab8e36dcf	Remove the 'basic_string_ref template; use 'basic_string_view' instead. Keep the string_ref, etc typedefs around, though	2016-02-17 11:32:16 -08:00