Release 1.54.0 beta1

[SVN r84619]

doc/string_ref.qbk

@@ -54,7 +54,7 @@ Integrating `string_ref` into your code is fairly simple. Wherever you pass a `c
         return bar.substr ( 2, 3 );
         }
         
-    if ( extract_part ( "ABCDEFG" ).front() == "C" ) { /* do something */ }
+    if ( extract_part ( "ABCDEFG" ).front() == 'C' ) { /* do something */ }
     
 Let's figure out what happens in this (contrived) example.
 

in_place_factories.html

@@ -46,7 +46,7 @@ HREF="../../boost/utility/typed_in_place_factory.hpp">boost/utility/typed_in_pla
 <p>Suppose we have a class</p>
 <pre>struct X
 {
-  X ( int, std:::string ) ;
+  X ( int, std::string ) ;
 } ;</pre>
 <p>And a container for it which supports an empty state (that is, which can contain zero objects):</p>
 <pre>struct C

include/boost/assert.hpp

@@ -101,7 +101,12 @@ namespace boost
               << "***** Internal Program Error - assertion (" << expr << ") failed in "
               << function << ":\n"
               << file << '(' << line << "): " << msg << std::endl;
-            std::abort();
+			#ifdef UNDER_CE
+				// The Windows CE CRT library does not have abort() so use exit(-1) instead.
+				std::exit(-1);
+			#else
+				std::abort();
+			#endif
           }
         } // detail
       } // assertion

include/boost/noncopyable.hpp

@@ -9,6 +9,8 @@
 #ifndef BOOST_NONCOPYABLE_HPP_INCLUDED
 #define BOOST_NONCOPYABLE_HPP_INCLUDED
 
+#include <boost/config.hpp>
+
 namespace boost {
 
 //  Private copy constructor and copy assignment ensure classes derived from
@@ -21,11 +23,21 @@ namespace noncopyable_  // protection from unintended ADL
   class noncopyable
   {
    protected:
-      noncopyable() {}
+#ifndef BOOST_NO_DEFAULTED_FUNCTIONS
+    BOOST_CONSTEXPR noncopyable() = default;
+    ~noncopyable() = default;
+#else
+    noncopyable() {}
       ~noncopyable() {}
-   private:  // emphasize the following members are private
+#endif
+#ifndef BOOST_NO_DELETED_FUNCTIONS
+        noncopyable( const noncopyable& ) = delete;
+        noncopyable& operator=( const noncopyable& ) = delete;
+#else
+    private:  // emphasize the following members are private
       noncopyable( const noncopyable& );
-      const noncopyable& operator=( const noncopyable& );
+      noncopyable& operator=( const noncopyable& );
+#endif
   };
 }
 

include/boost/utility/addressof.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2002 Brad King (brad.king@kitware.com) 
+// Copyright (C) 2002 Brad King (brad.king@kitware.com)
 //                    Douglas Gregor (gregod@cs.rpi.edu)
 //
 // Copyright (C) 2002, 2008 Peter Dimov
@@ -50,7 +50,7 @@ template<class T> struct addressof_impl
 
 template<class T> T * addressof( T & v )
 {
-#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) )
+#if (defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) ) ) || defined( __SUNPRO_CC )
 
     return boost::detail::addressof_impl<T>::f( v, 0 );
 

include/boost/utility/result_of.hpp

@@ -68,6 +68,13 @@ template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_im
 
 #ifdef BOOST_NO_SFINAE_EXPR
 
+// There doesn't seem to be any other way to turn this off such that the presence of
+// the user-defined operator,() below doesn't cause spurious warning all over the place,
+// so unconditionally turn it off.
+#if BOOST_MSVC
+#  pragma warning(disable: 4913) // user defined binary operator ',' exists but no overload could convert all operands, default built-in binary operator ',' used
+#endif
+
 struct result_of_private_type {};
 
 struct result_of_weird_type {

include/boost/utility/string_ref.hpp

@@ -1,11 +1,11 @@
-/* 
+/*
    Copyright (c) Marshall Clow 2012-2012.
 
    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
-    
+
     Based on the StringRef implementation in LLVM (http://llvm.org) and
     N3422 by Jeffrey Yasskin
         http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
@@ -24,7 +24,7 @@
 #include <string>
 
 namespace boost {
-    
+
     namespace detail {
     //  A helper functor because sometimes we don't have lambdas
         template <typename charT, typename traits>
@@ -35,7 +35,7 @@ namespace boost {
             charT ch_;
             };
         }
-    
+
     template<typename charT, typename traits> class basic_string_ref;
     typedef basic_string_ref<char,     std::char_traits<char> >        string_ref;
     typedef basic_string_ref<wchar_t,  std::char_traits<wchar_t> >    wstring_ref;
@@ -47,7 +47,7 @@ namespace boost {
 #ifndef BOOST_NO_CXX11_CHAR32_T
     typedef basic_string_ref<char32_t, std::char_traits<char32_t> > u32string_ref;
 #endif
-    
+
     template<typename charT, typename traits>
     class basic_string_ref {
     public:
@@ -63,7 +63,7 @@ namespace boost {
         typedef std::size_t size_type;
         typedef ptrdiff_t difference_type;
         static BOOST_CONSTEXPR_OR_CONST size_type npos = size_type(-1);
-        
+
         // construct/copy
         BOOST_CONSTEXPR basic_string_ref ()
             : ptr_(NULL), len_(0) {}
@@ -76,7 +76,7 @@ namespace boost {
             len_ = rhs.len_;
             return *this;
             }
-            
+
         basic_string_ref(const charT* str)
             : ptr_(str), len_(traits::length(str)) {}
 
@@ -93,7 +93,11 @@ namespace boost {
             return std::basic_string<charT, traits, Allocator> ( ptr_, len_ );
             }
 #endif
-        
+
+        std::basic_string<charT, traits> to_string () const {
+            return std::basic_string<charT, traits> ( ptr_, len_ );
+            }
+
         // iterators
         BOOST_CONSTEXPR const_iterator   begin() const { return ptr_; }
         BOOST_CONSTEXPR const_iterator  cbegin() const { return ptr_; }
@@ -103,13 +107,13 @@ namespace boost {
                 const_reverse_iterator crbegin() const { return const_reverse_iterator (end()); }
                 const_reverse_iterator    rend() const { return const_reverse_iterator (begin()); }
                 const_reverse_iterator   crend() const { return const_reverse_iterator (begin()); }
-        
+
         // capacity
         BOOST_CONSTEXPR size_type size()     const { return len_; }
         BOOST_CONSTEXPR size_type length()   const { return len_; }
         BOOST_CONSTEXPR size_type max_size() const { return len_; }
         BOOST_CONSTEXPR bool empty()         const { return len_ == 0; }
-        
+
         // element access
         BOOST_CONSTEXPR const charT& operator[](size_type pos) const { return ptr_[pos]; }
 
@@ -118,11 +122,11 @@ namespace boost {
                 throw std::out_of_range ( "boost::string_ref::at" );
             return ptr_[pos];
             }
-            
+
         BOOST_CONSTEXPR const charT& front() const { return ptr_[0]; }
         BOOST_CONSTEXPR const charT& back()  const { return ptr_[len_-1]; }
         BOOST_CONSTEXPR const charT* data()  const { return ptr_; }
-        
+
         // modifiers
         void clear() { len_ = 0; }
         void remove_prefix(size_type n) {
@@ -131,14 +135,14 @@ namespace boost {
             ptr_ += n;
             len_ -= n;
             }
-            
+
         void remove_suffix(size_type n) {
             if ( n > len_ )
                 n = len_;
             len_ -= n;
             }
-            
-        
+
+
         // basic_string_ref string operations
         BOOST_CONSTEXPR
         basic_string_ref substr(size_type pos, size_type n=npos) const {
@@ -153,78 +157,78 @@ namespace boost {
                 basic_string_ref ( data() + pos, n == npos || pos + n > size() ? size() - pos : n );
 #endif
             }
-        
+
         int compare(basic_string_ref x) const {
-            int cmp = traits::compare ( ptr_, x.ptr_, (std::min)(len_, x.len_));
+            const int cmp = traits::compare ( ptr_, x.ptr_, (std::min)(len_, x.len_));
             return cmp != 0 ? cmp : ( len_ == x.len_ ? 0 : len_ < x.len_ ? -1 : 1 );
             }
-        
+
         bool starts_with(charT c) const { return !empty() && traits::eq ( c, front()); }
         bool starts_with(basic_string_ref x) const {
             return len_ >= x.len_ && traits::compare ( ptr_, x.ptr_, x.len_ ) == 0;
             }
-        
+
         bool ends_with(charT c) const { return !empty() && traits::eq ( c, back()); }
         bool ends_with(basic_string_ref x) const {
             return len_ >= x.len_ && traits::compare ( ptr_ + len_ - x.len_, x.ptr_, x.len_ ) == 0;
             }
 
         size_type find(basic_string_ref s) const {
-            const_iterator iter = std::search ( this->cbegin (), this->cend (), 
+            const_iterator iter = std::search ( this->cbegin (), this->cend (),
                                                 s.cbegin (), s.cend (), traits::eq );
-            return iter = this->cend () ? npos : std::distance ( this->cbegin (), iter );
+            return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
             }
-        
+
         size_type find(charT c) const {
-            const_iterator iter = std::find_if ( this->cbegin (), this->cend (), 
+            const_iterator iter = std::find_if ( this->cbegin (), this->cend (),
                                     detail::string_ref_traits_eq<charT, traits> ( c ));
             return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
             }
-                        
+
         size_type rfind(basic_string_ref s) const {
-            const_reverse_iterator iter = std::search ( this->crbegin (), this->crend (), 
+            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 );
             }
 
         size_type rfind(charT c) const {
-            const_reverse_iterator iter = std::find_if ( this->crbegin (), this->crend (), 
+            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 );
             }
-        
+
         size_type find_first_of(charT c) const { return  find (c); }
         size_type find_last_of (charT c) const { return rfind (c); }
-        
+
         size_type find_first_of(basic_string_ref s) const {
-            const_iterator iter = std::find_first_of 
-            	( this->cbegin (), this->cend (), s.cbegin (), s.cend (), traits::eq );
+            const_iterator iter = std::find_first_of
+                ( this->cbegin (), this->cend (), s.cbegin (), s.cend (), traits::eq );
             return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
             }
-        
+
         size_type find_last_of(basic_string_ref s) const {
-            const_reverse_iterator iter = std::find_first_of 
+            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);
             }
-        
+
         size_type find_first_not_of(basic_string_ref s) const {
-        	const_iterator iter = find_not_of ( this->cbegin (), this->cend (), s );
+            const_iterator iter = find_not_of ( this->cbegin (), this->cend (), s );
             return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
             }
-        
+
         size_type find_first_not_of(charT c) const {
             for ( const_iterator iter = this->cbegin (); iter != this->cend (); ++iter )
                 if ( !traits::eq ( c, *iter ))
                     return std::distance ( this->cbegin (), iter );
             return npos;
             }
-        
+
         size_type find_last_not_of(basic_string_ref s) const {
-        	const_reverse_iterator iter = find_not_of ( this->crbegin (), this->crend (), s );
+            const_reverse_iterator iter = find_not_of ( this->crbegin (), this->crend (), s );
             return iter == this->crend () ? npos : reverse_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 ))
@@ -237,55 +241,181 @@ namespace boost {
         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 {
-			for ( ; first != last ; ++first )
-				if ( 0 == traits::find ( s.ptr_, s.len_, *first ))
-					return first;
-			return last;
-			}
-		
-       		
-        
+            for ( ; first != last ; ++first )
+                if ( 0 == traits::find ( s.ptr_, s.len_, *first ))
+                    return first;
+            return last;
+            }
+
+
+
         const charT *ptr_;
         std::size_t len_;
         };
-    
-    // Comparison operators
+
+
+//  Comparison operators
+//  Equality
     template<typename charT, typename traits>
     bool operator==(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
         if ( x.size () != y.size ()) return false;
         return x.compare(y) == 0;
         }
-    
+
+    template<typename charT, typename traits, typename Allocator>
+    bool operator==(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+        return x == basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits, typename Allocator>
+    bool operator==(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) == y;
+        }
+
+    template<typename charT, typename traits>
+    bool operator==(basic_string_ref<charT, traits> x, const charT * y) {
+        return x == basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits>
+    bool operator==(const charT * x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) == y;
+        }
+
+//  Inequality
     template<typename charT, typename traits>
     bool operator!=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
         if ( x.size () != y.size ()) return true;
         return x.compare(y) != 0;
         }
 
+    template<typename charT, typename traits, typename Allocator>
+    bool operator!=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+        return x != basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits, typename Allocator>
+    bool operator!=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) != y;
+        }
+
+    template<typename charT, typename traits>
+    bool operator!=(basic_string_ref<charT, traits> x, const charT * y) {
+        return x != basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits>
+    bool operator!=(const charT * x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) != y;
+        }
+
+//  Less than
     template<typename charT, typename traits>
     bool operator<(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
         return x.compare(y) < 0;
         }
 
+    template<typename charT, typename traits, typename Allocator>
+    bool operator<(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+        return x < basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits, typename Allocator>
+    bool operator<(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) < y;
+        }
+
+    template<typename charT, typename traits>
+    bool operator<(basic_string_ref<charT, traits> x, const charT * y) {
+        return x < basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits>
+    bool operator<(const charT * x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) < y;
+        }
+
+//  Greater than
     template<typename charT, typename traits>
     bool operator>(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
         return x.compare(y) > 0;
         }
 
+    template<typename charT, typename traits, typename Allocator>
+    bool operator>(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+        return x > basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits, typename Allocator>
+    bool operator>(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) > y;
+        }
+
+    template<typename charT, typename traits>
+    bool operator>(basic_string_ref<charT, traits> x, const charT * y) {
+        return x > basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits>
+    bool operator>(const charT * x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) > y;
+        }
+
+//  Less than or equal to
     template<typename charT, typename traits>
     bool operator<=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
         return x.compare(y) <= 0;
         }
 
+    template<typename charT, typename traits, typename Allocator>
+    bool operator<=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+        return x <= basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits, typename Allocator>
+    bool operator<=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) <= y;
+        }
+
+    template<typename charT, typename traits>
+    bool operator<=(basic_string_ref<charT, traits> x, const charT * y) {
+        return x <= basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits>
+    bool operator<=(const charT * x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) <= y;
+        }
+
+//  Greater than or equal to
     template<typename charT, typename traits>
     bool operator>=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
         return x.compare(y) >= 0;
         }
 
-    
+    template<typename charT, typename traits, typename Allocator>
+    bool operator>=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+        return x >= basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits, typename Allocator>
+    bool operator>=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) >= y;
+        }
+
+    template<typename charT, typename traits>
+    bool operator>=(basic_string_ref<charT, traits> x, const charT * y) {
+        return x >= basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits>
+    bool operator>=(const charT * x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) >= y;
+        }
+
     // Inserter
     template<class charT, class traits>
     std::basic_ostream<charT, traits>&
@@ -299,7 +429,7 @@ namespace boost {
 #endif
         return os;
         }
-    
+
 #if 0
     // numeric conversions
     //
@@ -309,63 +439,63 @@ namespace boost {
     int stoi (string_ref str, size_t* idx=0, int base=10) {
         return std::stoi ( std::string(str), idx, base );
         }
-    
+
     long stol (string_ref str, size_t* idx=0, int base=10) {
         return std::stol ( std::string(str), idx, base );
         }
-        
+
     unsigned long stoul (string_ref str, size_t* idx=0, int base=10) {
         return std::stoul ( std::string(str), idx, base );
         }
-        
+
     long long stoll (string_ref str, size_t* idx=0, int base=10) {
         return std::stoll ( std::string(str), idx, base );
         }
-    
+
     unsigned long long stoull (string_ref str, size_t* idx=0, int base=10) {
         return std::stoull ( std::string(str), idx, base );
         }
-    
+
     float stof (string_ref str, size_t* idx=0) {
         return std::stof ( std::string(str), idx );
         }
-        
+
     double stod (string_ref str, size_t* idx=0) {
         return std::stod ( std::string(str), idx );
         }
-        
+
     long double stold (string_ref str, size_t* idx=0)  {
         return std::stold ( std::string(str), idx );
         }
-    
+
     int  stoi (wstring_ref str, size_t* idx=0, int base=10) {
         return std::stoi ( std::wstring(str), idx, base );
         }
-        
+
     long stol (wstring_ref str, size_t* idx=0, int base=10) {
         return std::stol ( std::wstring(str), idx, base );
         }
-        
+
     unsigned long stoul (wstring_ref str, size_t* idx=0, int base=10) {
         return std::stoul ( std::wstring(str), idx, base );
         }
-        
+
     long long stoll (wstring_ref str, size_t* idx=0, int base=10) {
         return std::stoll ( std::wstring(str), idx, base );
         }
-        
+
     unsigned long long stoull (wstring_ref str, size_t* idx=0, int base=10) {
         return std::stoull ( std::wstring(str), idx, base );
         }
-    
+
     float  stof (wstring_ref str, size_t* idx=0) {
         return std::stof ( std::wstring(str), idx );
         }
-        
+
     double stod (wstring_ref str, size_t* idx=0) {
         return std::stod ( std::wstring(str), idx );
         }
-        
+
     long double stold (wstring_ref str, size_t* idx=0) {
         return std::stold ( std::wstring(str), idx );
         }

test/Jamfile.v2

@@ -8,6 +8,11 @@
 # bring in rules for testing
 import testing ;
 
+alias unit_test_framework
+    : # sources
+        /boost//unit_test_framework
+    ;        
+
 # Please keep the tests ordered by filename
 test-suite utility
     :
@@ -31,8 +36,8 @@ test-suite utility
         [ run ../ref_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 ]
-        [ run string_ref_test2.cpp ]
+        [ run string_ref_test1.cpp unit_test_framework ]
+        [ run string_ref_test2.cpp unit_test_framework ]
         [ run ../value_init_test.cpp ]
         [ run ../value_init_workaround_test.cpp ]
         [ run ../initialized_test.cpp ]

test/string_ref_test1.cpp

@@ -1,4 +1,4 @@
-/* 
+/*
    Copyright (c) Marshall Clow 2012-2012.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -13,8 +13,8 @@
 
 #include <boost/utility/string_ref.hpp>
 
-
-#include <boost/test/included/test_exec_monitor.hpp>
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
 
 typedef boost::string_ref string_ref;
 
@@ -33,30 +33,30 @@ void null_tests ( const char *p ) {
     string_ref sr3 ( p, 0 );
     string_ref sr4 ( p );
     sr4.clear ();
-    
+
     BOOST_CHECK ( sr1 == sr2 );
     BOOST_CHECK ( sr1 == sr3 );
     BOOST_CHECK ( sr2 == sr3 );
-    BOOST_CHECK ( sr1 == sr4 );    
+    BOOST_CHECK ( sr1 == sr4 );
     }
 
 //  make sure that substrings work just like strings
 void test_substr ( const std::string &str ) {
     const size_t sz = str.size ();
     string_ref ref ( str );
-    
+
 //  Substrings at the end
     for ( size_t i = 0; i <= sz; ++ i )
         interop ( str.substr ( i ), ref.substr ( i ));
-        
+
 //  Substrings at the beginning
     for ( size_t i = 0; i <= sz; ++ i )
         interop ( str.substr ( 0, i ), ref.substr ( 0, i ));
-        
+
 //  All possible substrings
     for ( size_t i = 0; i < sz; ++i )
         for ( size_t j = i; j < sz; ++j )
-            interop ( str.substr ( i, j ), ref.substr ( i, j ));    
+            interop ( str.substr ( i, j ), ref.substr ( i, j ));
     }
 
 //  make sure that removing prefixes and suffixes work just like strings
@@ -64,20 +64,20 @@ void test_remove ( const std::string &str ) {
     const size_t sz = str.size ();
     std::string work;
     string_ref ref;
-    
+
     for ( size_t i = 1; i <= sz; ++i ) {
       work = str;
-      ref  = str;     
+      ref  = str;
       while ( ref.size () >= i ) {
           interop ( work, ref );
           work.erase ( 0, i );
           ref.remove_prefix (i);
           }
       }
-    
+
     for ( size_t i = 1; i < sz; ++ i ) {
       work = str;
-      ref  = str;     
+      ref  = str;
       while ( ref.size () >= i ) {
           interop ( work, ref );
           work.erase ( work.size () - i, i );
@@ -93,9 +93,9 @@ const char *test_strings [] = {
     "0123456789",
     NULL
     };
-    
-int test_main( int , char* [] ) {
 
+BOOST_AUTO_TEST_CASE( test_main )
+{
     const char **p = &test_strings[0];
 
     while ( *p != NULL ) {
@@ -103,9 +103,7 @@ int test_main( int , char* [] ) {
         test_substr ( *p );
         test_remove ( *p );
         null_tests ( *p );
-    
+
         p++;
         }
-
-    return 0;
-    }
+}

test/string_ref_test2.cpp

@@ -1,4 +1,4 @@
-/* 
+/*
    Copyright (c) Marshall Clow 2012-2012.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -12,7 +12,8 @@
 
 #include <boost/utility/string_ref.hpp>
 
-#include <boost/test/included/test_exec_monitor.hpp>
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
 
 typedef boost::string_ref string_ref;
 
@@ -22,7 +23,7 @@ void ends_with ( const char *arg ) {
     string_ref sr2 ( arg );
     const char *p = arg;
 
-    while ( !*p ) {
+    while ( *p ) {
         BOOST_CHECK ( sr.ends_with ( p ));
         ++p;
         }
@@ -45,7 +46,7 @@ void ends_with ( const char *arg ) {
     BOOST_CHECK ( !sr2.ends_with ( ++ch ));
     BOOST_CHECK ( sr2.ends_with ( string_ref ()));
     }
-    
+
 void starts_with ( const char *arg ) {
     const size_t sz = strlen ( arg );
     string_ref sr  ( arg );
@@ -84,9 +85,9 @@ void reverse ( const char *arg ) {
 
 //	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 );
-	}
+    BOOST_CHECK ( res >= base );
+    return static_cast<string_ref::size_type> ( res - base );
+    }
 
 void find ( const char *arg ) {
     string_ref sr1;
@@ -94,22 +95,32 @@ void find ( const char *arg ) {
     const char *p;
 
 //  Look for each character in the string(searching from the start)
-  p = arg;
-  sr1 = arg;
-  while ( *p ) {
-    string_ref::size_type pos = sr1.find(*p);
-    BOOST_CHECK ( pos != string_ref::npos && ( pos <= ptr_diff ( p, arg )));
-    ++p;
-    }
-  
+    p = arg;
+    sr1 = arg;
+    while ( *p ) {
+      string_ref::size_type pos = sr1.find(*p);
+      BOOST_CHECK ( pos != string_ref::npos && ( pos <= ptr_diff ( p, arg )));
+      ++p;
+      }
+
 //  Look for each character in the string (searching from the end)
     p = arg;
     sr1 = arg;
     while ( *p ) {
-    string_ref::size_type pos = sr1.rfind(*p);
-    BOOST_CHECK ( pos != string_ref::npos && pos < sr1.size () && ( pos >= ptr_diff ( p, arg )));
-    ++p;
-    }
+      string_ref::size_type pos = sr1.rfind(*p);
+      BOOST_CHECK ( pos != string_ref::npos && pos < sr1.size () && ( pos >= ptr_diff ( p, arg )));
+      ++p;
+      }
+
+//	Look for pairs on characters (searching from the start)
+    sr1 = arg;
+    p = arg;
+    while ( *p && *(p+1)) {
+        string_ref sr3 ( p, 2 );
+        string_ref::size_type pos = sr1.find ( sr3 );
+        BOOST_CHECK ( pos != string_ref::npos && pos <= static_cast<string_ref::size_type>( p - arg ));
+        p++;
+        }
 
     sr1 = arg;
     p = arg;
@@ -155,7 +166,7 @@ void find ( const char *arg ) {
         sr1.remove_suffix (1);
         --p;
         }
-        
+
 //  Find everything at the start
     sr1  = arg;
     p    = arg;
@@ -176,7 +187,7 @@ void find ( const char *arg ) {
         sr1.remove_suffix (1);
         --p;
         }
-        
+
 //  Basic sanity checking for "find_first_of / find_first_not_of"
     sr1 = arg;
     sr2 = arg;
@@ -201,7 +212,7 @@ void find ( const char *arg ) {
         BOOST_CHECK ( pos2 != pos1 );
         ++p;
         }
-        
+
 //  Basic sanity checking for "find_last_of / find_last_not_of"
     sr1 = arg;
     sr2 = arg;
@@ -223,13 +234,63 @@ void find ( const char *arg ) {
                 BOOST_CHECK ( sr1[i] == *p );
             BOOST_CHECK ( sr1 [ pos2 ] != *p );
             }
-         
+
         BOOST_CHECK ( pos2 != pos1 );
         ++p;
         }
 
     }
 
+
+void to_string ( const char *arg ) {
+    string_ref sr1;
+    std::string str1;
+    std::string str2;
+
+    str1.assign ( arg );
+    sr1 = arg;
+//	str2 = sr1.to_string<std::allocator<char> > ();
+    str2 = sr1.to_string ();
+    BOOST_CHECK ( str1 == str2 );
+
+#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+    std::string str3 = static_cast<std::string> ( sr1 );
+    BOOST_CHECK ( str1 == str3 );
+#endif
+    }
+
+void compare ( const char *arg ) {
+    string_ref sr1;
+    std::string str1;
+    std::string str2 = str1;
+
+    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
+
+    if ( sr1.size () > 0 ) {
+        (*str1.rbegin())++;
+        BOOST_CHECK ( sr1  != str1 );
+        BOOST_CHECK ( str1 != sr1 );
+        BOOST_CHECK ( sr1 < str1 );
+        BOOST_CHECK ( sr1 <= str1 );
+        BOOST_CHECK ( str1 > sr1 );
+        BOOST_CHECK ( str1 >= sr1 );
+
+        (*str1.rbegin()) -= 2;
+        BOOST_CHECK ( sr1  != str1 );
+        BOOST_CHECK ( str1 != sr1 );
+        BOOST_CHECK ( sr1 > str1 );
+        BOOST_CHECK ( sr1 >= str1 );
+        BOOST_CHECK ( str1 < sr1 );
+        BOOST_CHECK ( str1 <= sr1 );
+        }
+    }
+
 const char *test_strings [] = {
     "",
     "0",
@@ -239,18 +300,19 @@ const char *test_strings [] = {
     "abc\0asdfadsfasf",
     NULL
     };
-    
-int test_main( int , char* [] ) {
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
     const char **p = &test_strings[0];
-    
+
     while ( *p != NULL ) {
         starts_with ( *p );
         ends_with ( *p );
         reverse ( *p );
         find ( *p );
+        to_string ( *p );
+        compare ( *p );
 
         p++;
         }
-
-    return 0;
-    }
+}

utility.htm

@@ -84,8 +84,10 @@ const std::list&lt;T&gt;::iterator next = boost::next(prev, 2);</pre>
 			will prevent the otherwise implicitly-generated functions (which don't have the 
 			proper semantics) from becoming a trap for other programmers.</p>
 		<p>The traditional way to deal with these is to declare a private copy constructor 
-			and copy assignment, and then document why this is done.&nbsp; But deriving 
-			from <b>noncopyable</b> is simpler and clearer, and doesn't require additional 
+        and copy assignment, and then document why this is done.&nbsp; A new alternative  
+        was introduced in C++2011, declaring a copy constructor and a copy assignment  
+        operator, but marking both as <code>delete</code>d.&nbsp; Deriving
+        from <b>noncopyable</b> is simpler and clearer, and doesn't require additional 
 			documentation.</p>
 		<p>The program <a href="noncopyable_test.cpp">noncopyable_test.cpp</a> can be used 
 			to verify class <b>noncopyable</b> works as expected. It has have been run 
@@ -106,7 +108,9 @@ class ResourceLadenFileSystem : boost::noncopyable {
 			about the effect on compiler optimization of adding (even trivial inline) 
 			destructor declarations. He says &quot;Probably this concern is misplaced, 
 			because noncopyable will be used mostly for classes which own resources and 
-			thus have non-trivial destruction semantics.&quot;</p>
+        thus have non-trivial destruction semantics.&quot;&nbsp; With C++2011, using an  
+        optimized and trivial constructor and similar destructor can be enforced by  
+        declaring both and marking them <code>default</code>.</p> 
 		<h2><a name="addressof">Function template addressof()</a></h2>
 		<p>Function <strong>addressof()</strong> returns the address of an object.</p>
 		<blockquote>