Add tests to ensure that string_view|ref from rvalue fails (whenever it can)

Use non-deprecated include paths

base_from_member_test.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;
 

doc/Jamfile.v2

@@ -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 ;

include/boost/utility.hpp

@@ -14,8 +14,8 @@
 #include <boost/utility/binary.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/utility/identity_type.hpp>
-#include <boost/checked_delete.hpp>
+#include <boost/core/checked_delete.hpp>
+#include <boost/core/noncopyable.hpp>
 #include <boost/next_prior.hpp>
-#include <boost/noncopyable.hpp>
 
 #endif  // BOOST_UTILITY_HPP

include/boost/utility/base_from_member.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
 

include/boost/utility/compare_pointees.hpp

@@ -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) ; }
 } ;

include/boost/utility/string_ref.hpp

@@ -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
@@ -174,13 +197,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 +218,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 +235,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 +424,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 +435,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 +463,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;

include/boost/utility/string_view.hpp

@@ -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,13 +165,18 @@ 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 {
@@ -204,7 +228,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 +239,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 +264,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 +335,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);
@@ -357,7 +381,7 @@ 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 { 
+                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         if ( x.size () != y.size ()) return true;
         return x.compare(y) != 0;
         }
@@ -365,180 +389,180 @@ namespace boost {
 //  Less than
     template<typename charT, typename traits>
     inline bool operator<(basic_string_view<charT, traits> x,
-                          basic_string_view<charT, traits> y) BOOST_NOEXCEPT { 
+                          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 { 
+                          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 { 
+                           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 { 
+                           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 { 
+                     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 { 
+                                 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 { 
+                                              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 { 
+                           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 { 
+                     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 { 
+                                 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 { 
+                           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 { 
+                           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 { 
+                    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 { 
+                                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 { 
+                          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 { 
+                          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 { 
+                    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 { 
+                                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 { 
+                          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 { 
+                          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 { 
+                     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 { 
+                                 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 { 
+                           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 { 
+                           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 { 
+                     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 { 
+                                 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 { 
+                           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 { 
+                           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 +573,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 +602,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;

test/Jamfile.v2

@@ -11,7 +11,7 @@ import testing ;
 alias unit_test_framework
     : # sources
         /boost//unit_test_framework
-    ;        
+    ;
 
 # Please keep the tests ordered by filename
 test-suite utility
@@ -20,16 +20,18 @@ test-suite utility
         [ 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 ../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 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 ]
+        [ 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 ]
         [ 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 ]

test/string_ref_from_rvalue.cpp

@@ -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;
+}

test/string_ref_test2.cpp

@@ -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())++;

test/string_view_from_rvalue.cpp

@@ -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;
+}

test/string_view_test2.cpp

@@ -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())++;

value_init_workaround_test.cpp

@@ -132,7 +132,7 @@ 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>());
 
 #ifdef BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
   // One or more failures are expected.