merge [82901], [82902], and [83147] from trunk

[SVN r83403]

include/boost/utility/string_ref.hpp

@@ -94,6 +94,10 @@ namespace boost {
             }
 #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_; }
@@ -155,7 +159,7 @@ namespace boost {
             }
 
         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 );
             }
 
@@ -172,7 +176,7 @@ namespace boost {
         size_type find(basic_string_ref s) const {
             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 {
@@ -252,39 +256,165 @@ namespace boost {
         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>

test/string_ref_test2.cpp

@@ -112,6 +112,16 @@ void find ( const char *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;
 //  for all possible chars, see if we find them in the right place.
@@ -231,6 +241,56 @@ void find ( const char *arg ) {
 
     }
 
+
+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",
@@ -250,6 +310,8 @@ BOOST_AUTO_TEST_CASE( test_main )
         ends_with ( *p );
         reverse ( *p );
         find ( *p );
+        to_string ( *p );
+        compare ( *p );
 
         p++;
         }