EIC code displayed by LXR master/​include/​boost/​url/​grammar/​string_view_base.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-09-18 09:07:55

 //
 // Copyright (c) 2022 Vinnie Falco (vinnie.falco@gmail.com)
 //
 // 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)
 //
 // Official repository: https://github.com/boostorg/url
 //
 
 #ifndef BOOST_URL_GRAMMAR_STRING_VIEW_BASE_HPP
 #define BOOST_URL_GRAMMAR_STRING_VIEW_BASE_HPP
 
 #include <boost/url/detail/config.hpp>
 #include <boost/url/detail/string_view.hpp>
 #include <boost/core/detail/string_view.hpp>
 #include <cstddef>
 #include <iterator>
 #include <string>
 #include <type_traits>
 #include <utility>
 
 namespace boost {
 namespace urls {
 namespace grammar {
 
 /** Common functionality for string views
 
     This base class is used to provide common
     member functions for reference types that
     behave like string views. This cannot be
     instantiated directly; Instead, derive
     from the type and provide constructors
     which offer any desired preconditions
     and invariants.
 */
 class string_view_base
 {
 protected:
     /** The referenced character buffer
     */
     core::string_view s_;
 
     /** Constructor
 
         @param s The string view
     */
     constexpr
     string_view_base(
         core::string_view s) noexcept
         : s_(s)
     {
     }
 
     /** Constructor
 
         @param data The character buffer
         @param size The number of characters
     */
     constexpr
     string_view_base(
         char const* data,
         std::size_t size) noexcept
         : s_(data, size)
     {
     }
 
     /** Swap
 
         @param s The object to swap with
     */
     // VFALCO No idea why this fails in msvc
     /*BOOST_CXX14_CONSTEXPR*/
     void
     swap(
         string_view_base& s ) noexcept
     {
         std::swap(s_, s.s_);
     }
 
     /** Constructor
     */
     string_view_base() = default;
 
     /** Constructor
     */
     string_view_base(
         string_view_base const&) = default;
 
     /** Assignment
 
         @param other The object to assign
         @return A reference to this object
     */
     string_view_base& operator=(
         string_view_base const& other) = default;
 
 public:
     /// The character traits
     typedef std::char_traits<char> traits_type;
     /// The value type
     typedef char value_type;
     /// The pointer type
     typedef char* pointer;
     /// The const pointer type
     typedef char const* const_pointer;
     /// The reference type
     typedef char& reference;
     /// The const reference type
     typedef char const& const_reference;
     /// The const iterator type
     typedef char const* const_iterator;
     /// The iterator type
     typedef const_iterator iterator;
     /// The const reverse iterator type
     typedef std::reverse_iterator<
         const_iterator> const_reverse_iterator;
     /// The reverse iterator type
     typedef const_reverse_iterator reverse_iterator;
     /// The size type
     typedef std::size_t size_type;
     /// The difference type
     typedef std::ptrdiff_t difference_type;
 
     /// A constant used to represent "no position"
     static constexpr std::size_t npos = core::string_view::npos;
 
     //--------------------------------------------
 
     /** Conversion
 
         @return A string view with the same contents
      */
     operator
     core::string_view() const noexcept
     {
         return s_;
     }
 
     /** Conversion
 
         @return A string view with the same contents
      */
 #if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
     operator
     std::string_view() const noexcept
     {
         return std::string_view(s_);
     }
 #endif
 
     /** Conversion
 
         Conversion to std::string is explicit
         because assigning to string using an
         implicit constructor does not preserve
         capacity.
 
         @return A string with the same contents
     */
     explicit
     operator
     std::string() const noexcept
     {
         return std::string(s_);
     }
 
     //--------------------------------------------
 
     // iterator support
 
     /** Return an iterator to the beginning
 
         See `core::string_view::begin`
 
         @return An iterator to the beginning
     */
     BOOST_CONSTEXPR const_iterator begin() const noexcept
     {
         return s_.begin();
     }
 
     /** Return an iterator to the end
 
         See `core::string_view::end`
 
         @return An iterator to the end
     */
     BOOST_CONSTEXPR const_iterator end() const noexcept
     {
         return s_.end();
     }
 
     /** Return an iterator to the beginning
 
         See `core::string_view::cbegin`
 
         @return An iterator to the beginning
     */
     BOOST_CONSTEXPR const_iterator cbegin() const noexcept
     {
         return s_.cbegin();
     }
 
     /** Return an iterator to the end
 
         See `core::string_view::cend`
 
         @return An iterator to the end
     */
     BOOST_CONSTEXPR const_iterator cend() const noexcept
     {
         return s_.cend();
     }
 
     /** Return a reverse iterator to the end
 
         See `core::string_view::rbegin`
 
         @return A reverse iterator to the end
     */
     BOOST_URL_LIB_ARRAY_CONSTEXPR
     const_reverse_iterator rbegin() const noexcept
     {
         return s_.rbegin();
     }
 
     /** Return a reverse iterator to the beginning
 
         See `core::string_view::rend`
 
         @return A reverse iterator to the beginning
     */
     BOOST_URL_LIB_ARRAY_CONSTEXPR
     const_reverse_iterator rend() const noexcept
     {
         return s_.rend();
     }
 
     /** Return a reverse iterator to the end
 
         See `core::string_view::crbegin`
 
         @return A reverse iterator to the end
     */
     BOOST_URL_LIB_ARRAY_CONSTEXPR
     const_reverse_iterator crbegin() const noexcept
     {
         return s_.crbegin();
     }
 
     /** Return a reverse iterator to the beginning
 
         See `core::string_view::crend`
 
         @return A reverse iterator to the beginning
     */
     BOOST_URL_LIB_ARRAY_CONSTEXPR
     const_reverse_iterator crend() const noexcept
     {
         return s_.crend();
     }
 
     // capacity
 
     /** Return the size
 
         See `core::string_view::size`
 
         @return The size
     */
     BOOST_CONSTEXPR size_type size() const noexcept
     {
         return s_.size();
     }
 
     /** Return the size
 
         See `core::string_view::length`
 
         @return The size
     */
     BOOST_CONSTEXPR size_type length() const noexcept
     {
         return s_.length();
     }
 
     /** Return the maximum allowed size
 
         See `core::string_view::max_size`
 
         @return The maximum allowed size
     */
     BOOST_CONSTEXPR size_type max_size() const noexcept
     {
         return s_.max_size();
     }
 
     /** Return true if the string is empty
 
         See `core::string_view::size`
 
         @return `true` if the string is empty
     */
     BOOST_CONSTEXPR bool empty() const noexcept
     {
         return s_.empty();
     }
    
     // element access
 
     /** Access a character
 
         See `core::string_view::operator[]`
 
         @param pos The position to access
         @return The character at the position
     */
     BOOST_CXX14_CONSTEXPR const_reference
         operator[]( size_type pos ) const noexcept
     {
         return s_[pos];
     }
 
     /** Access a character
 
         See `core::string_view::at`
 
         @param pos The position to access
         @return The character at the position
     */
     BOOST_CXX14_CONSTEXPR const_reference
         at( size_type pos ) const
     {
         return s_.at(pos);
     }
 
     /** Return the first character
 
         See `core::string_view::front`
 
         @return The first character
     */
     BOOST_CXX14_CONSTEXPR const_reference
         front() const noexcept
     {
         return s_.front();
     }
 
     /** Return the last character
 
         See `core::string_view::back`
 
         @return The last character
     */
     BOOST_CXX14_CONSTEXPR const_reference
         back() const noexcept
     {
         return s_.back();
     }
 
     /** Return a pointer to the character buffer
 
         See `core::string_view::data`
 
         @return A pointer to the character buffer
     */
     BOOST_CONSTEXPR const_pointer
         data() const noexcept
     {
         return s_.data();
     }
 
     // string operations
 
     /** Copy the characters to another buffer
 
         See `core::string_view::copy`
 
         @param s The destination buffer
         @param n The number of characters to copy
         @param pos The position to start from
         @return The number of characters copied
     */
     BOOST_CXX14_CONSTEXPR size_type copy(
         char* s, size_type n, size_type pos = 0 ) const
     {
         return s_.copy(s, n, pos);
     }
 
     /** Return a view to part of the string
 
         See `core::string_view::substr`
 
         @param pos The position to start from
         @param n The number of characters
         @return A view to the substring
     */
     BOOST_CXX14_CONSTEXPR core::string_view substr(
         size_type pos = 0, size_type n = core::string_view::npos ) const
     {
         return s_.substr(pos, n);
     }
 
     // comparison
 
     /** Return the result of comparing to another string
 
         See `core::string_view::compare`
 
         @param str The string to compare
         @return The result of the comparison
     */
     BOOST_CXX14_CONSTEXPR int
         compare( core::string_view str ) const noexcept
     {
         return s_.compare(str);
     }
 
     /** Return the result of comparing to another string
 
         See `core::string_view::compare`
 
         @param pos1 The position to start comparing from
         @param n1 The number of characters to compare
         @param str The string to compare
         @return The result of the comparison
     */
     BOOST_CONSTEXPR int compare(
         size_type pos1, size_type n1, core::string_view str ) const
     {
         return s_.compare(pos1, n1, str);
     }
 
     /** Return the result of comparing to another string
 
         See `core::string_view::compare`
 
         @param pos1 The position to start comparing from
         @param n1 The number of characters to compare
         @param str The string to compare
         @param pos2 The position to start comparing from
         @param n2 The number of characters to compare
         @return The result of the comparison
     */
     BOOST_CONSTEXPR int compare(
         size_type pos1, size_type n1, core::string_view str,
         size_type pos2, size_type n2 ) const
     {
         return s_.compare(pos1, n1, str, pos2, n2);
     }
 
     /** Return the result of comparing to another string
 
         See `core::string_view::compare`
 
         @param s The string to compare
         @return The result of the comparison
     */
     BOOST_CONSTEXPR int compare(
         char const* s ) const noexcept
     {
         return s_.compare(s);
     }
 
     /** Return the result of comparing to another string
 
         See `core::string_view::compare`
 
         @param pos1 The position to start comparing from
         @param n1 The number of characters to compare
         @param s The string to compare
         @return The result of the comparison
     */
     BOOST_CONSTEXPR int compare(
         size_type pos1, size_type n1, char const* s ) const
     {
         return s_.compare(pos1, n1, s);
     }
 
     /** Return the result of comparing to another string
 
         See `core::string_view::compare`
 
         @param pos1 The position to start comparing from
         @param n1 The number of characters to compare
         @param s The string to compare
         @param n2 The number of characters to compare
         @return The result of the comparison
     */
     BOOST_CONSTEXPR int compare(
         size_type pos1, size_type n1,
         char const* s, size_type n2 ) const
     {
         return s_.compare(pos1, n1, s, n2);
     }
 
     // starts_with
 
     /** Return true if a matching prefix exists
 
         See `core::string_view::starts_with`
 
         @param x The string to search for
         @return `true` if the prefix matches
     */
     BOOST_CONSTEXPR bool starts_with(
         core::string_view x ) const noexcept
     {
         return s_.starts_with(x);
     }
 
     /** Return true if a matching prefix exists
 
         See `core::string_view::starts_with`
 
         @param x The character to search for
         @return `true` if the prefix matches
     */
     BOOST_CONSTEXPR bool starts_with(
         char x ) const noexcept
     {
         return s_.starts_with(x);
     }
 
     /** Return true if a matching prefix exists
 
         See `core::string_view::starts_with`
 
         @param x The string to search for
         @return `true` if the prefix matches
     */
     BOOST_CONSTEXPR bool starts_with(
         char const* x ) const noexcept
     {
         return s_.starts_with(x);
     }
 
     // ends_with
 
     /** Return true if a matching suffix exists
 
         See `core::string_view::ends_with`
 
         @param x The string to search for
         @return `true` if the suffix matches
     */
     BOOST_CONSTEXPR bool ends_with(
         core::string_view x ) const noexcept
     {
         return s_.ends_with(x);
     }
 
     /** Return true if a matching suffix exists
 
         See `core::string_view::ends_with`
 
         @param x The character to search for
         @return `true` if the suffix matches
     */
     BOOST_CONSTEXPR bool ends_with(
         char x ) const noexcept
     {
         return s_.ends_with(x);
     }
 
     /** Return true if a matching suffix exists
 
         See `core::string_view::ends_with`
 
         @param x The string to search for
         @return `true` if the suffix matches
     */
     BOOST_CONSTEXPR bool ends_with(
         char const* x ) const noexcept
     {
         return s_.ends_with(x);
     }
 
     // find
 
     /** Return the position of matching characters
 
         See `core::string_view::find`
 
         @param str The characters to search for
         @param pos The position to start searching from
         @return The position of the first match
     */
     BOOST_CONSTEXPR size_type find(
         core::string_view str, size_type pos = 0 ) const noexcept
     {
         return s_.find(str, pos);
     }
 
     /** Return the position of matching characters
 
         See `core::string_view::find`
 
         @param c The character to search for
         @param pos The position to start searching from
         @return The position of the first match
     */
     BOOST_CXX14_CONSTEXPR size_type find(
         char c, size_type pos = 0 ) const noexcept
     {
         return s_.find(c, pos);
     }
 
     /** Return the position of matching characters
 
         See `core::string_view::find`
 
         @param s The characters to search for
         @param pos The position to start searching from
         @param n The number of characters to search for
         @return The position of the first match
     */
     BOOST_CXX14_CONSTEXPR size_type find(
         char const* s, size_type pos, size_type n ) const noexcept
     {
         return s_.find(s, pos, n);
     }
 
     /** Return the position of matching characters
 
         See `core::string_view::find`
 
         @param s The characters to search for
         @param pos The position to start searching from
         @return The position of the first match
     */
     BOOST_CONSTEXPR size_type find(
         char const* s, size_type pos = 0 ) const noexcept
     {
         return s_.find(s, pos);
     }
 
     // rfind
 
     /** Return the position of matching characters
 
         See `core::string_view::rfind`
 
         @param str The characters to search for
         @param pos The position to start searching from
         @return The position of the first match
     */
     BOOST_CONSTEXPR size_type rfind(
         core::string_view str, size_type pos = core::string_view::npos ) const noexcept
     {
         return s_.rfind(str, pos);
     }
 
     /** Return the position of matching characters
 
         See `core::string_view::rfind`
 
         @param c The character to search for
         @param pos The position to start searching from
         @return The position of the first match
     */
     BOOST_CXX14_CONSTEXPR size_type rfind(
         char c, size_type pos = core::string_view::npos ) const noexcept
     {
         return s_.rfind(c, pos);
     }
 
     /** Return the position of matching characters
 
         See `core::string_view::rfind`
 
         @param s The characters to search for
         @param pos The position to start searching from
         @param n The number of characters to search for
         @return The position of the first match
     */
     BOOST_CXX14_CONSTEXPR size_type rfind(
         char const* s, size_type pos, size_type n ) const noexcept
     {
         return s_.rfind(s, pos, n);
     }
 
     /** Return the position of matching characters
 
         See `core::string_view::rfind`
 
         @param s The characters to search for
         @param pos The position to start searching from
         @return The position of the first match
     */
     BOOST_CONSTEXPR size_type rfind(
         char const* s, size_type pos = core::string_view::npos ) const noexcept
     {
         return s_.rfind(s, pos);
     }
 
     // find_first_of
 
     /** Return the position of the first match
 
         See `core::string_view::find_first_of`
 
         @param str The characters to search for
         @param pos The position to start searching from
         @return The position of the first match
     */
     BOOST_CXX14_CONSTEXPR size_type find_first_of(
         core::string_view str, size_type pos = 0 ) const noexcept
     {
         return s_.find_first_of(str, pos);
     }
 
     /** Return the position of the first match
 
         See `core::string_view::find_first_of`
 
         @param c The character to search for
         @param pos The position to start searching from
         @return The position of the first match
     */
     BOOST_CONSTEXPR size_type find_first_of(
         char c, size_type pos = 0 ) const noexcept
     {
         return s_.find_first_of(c, pos);
     }
 
     /** Return the position of the first match
 
         See `core::string_view::find_first_of`
 
         @param s The characters to search for
         @param pos The position to start searching from
         @param n The number of characters to search for
         @return The position of the first match
     */
     BOOST_CXX14_CONSTEXPR size_type find_first_of(
         char const* s, size_type pos, size_type n ) const noexcept
     {
         return s_.find_first_of(s, pos, n);
     }
 
     /** Return the position of the first match
 
         See `core::string_view::find_first_of`
 
         @param s The characters to search for
         @param pos The position to start searching from
         @return The position of the first match
     */
     BOOST_CXX14_CONSTEXPR size_type find_first_of(
         char const* s, size_type pos = 0 ) const noexcept
     {
         return s_.find_first_of(s, pos);
     }
 
     // find_last_of
 
     /** Return the position of the last match
 
         See `core::string_view::find_last_of`
 
         @param str The characters to search for
         @param pos The position to start searching from
         @return The position of the last match
     */
     BOOST_CXX14_CONSTEXPR size_type find_last_of(
         core::string_view str, size_type pos = core::string_view::npos ) const noexcept
     {
         return s_.find_last_of(str, pos);
     }
 
     /** Return the position of the last match
 
         See `core::string_view::find_last_of`
 
         @param c The character to search for
         @param pos The position to start searching from
         @return The position of the last match
     */
     BOOST_CONSTEXPR size_type find_last_of(
         char c, size_type pos = core::string_view::npos ) const noexcept
     {
         return s_.find_last_of(c, pos);
     }
 
     /** Return the position of the last match
 
         See `core::string_view::find_last_of`
 
         @param s The characters to search for
         @param pos The position to start searching from
         @param n The number of characters to search for
         @return The position of the last match
     */
     BOOST_CXX14_CONSTEXPR size_type find_last_of(
         char const* s, size_type pos, size_type n ) const noexcept
     {
         return s_.find_last_of(s, pos, n);
     }
 
     /** Return the position of the last match
 
         See `core::string_view::find_last_of`
 
         @param s The characters to search for
         @param pos The position to start searching from
         @return The position of the last match
     */
     BOOST_CXX14_CONSTEXPR size_type find_last_of(
         char const* s, size_type pos = core::string_view::npos ) const noexcept
     {
         return s_.find_last_of(s, pos);
     }
 
     // find_first_not_of
 
     /** Return the position of the first non-match
 
         See `core::string_view::find_first_not_of`
 
         @param str The characters to search for
         @param pos The position to start searching from
         @return The position of the first non-match
     */
     BOOST_CXX14_CONSTEXPR size_type find_first_not_of(
         core::string_view str, size_type pos = 0 ) const noexcept
     {
         return s_.find_first_not_of(str, pos);
     }
 
     /** Return the position of the first non-match
 
         See `core::string_view::find_first_not_of`
 
         @param c The character to search for
         @param pos The position to start searching from
         @return The position of the first non-match
     */
     BOOST_CXX14_CONSTEXPR size_type find_first_not_of(
         char c, size_type pos = 0 ) const noexcept
     {
         return s_.find_first_not_of(c, pos);
     }
 
     /** Return the position of the first non-match
 
         See `core::string_view::find_first_not_of`
 
         @param s The characters to search for
         @param pos The position to start searching from
         @param n The number of characters to search for
         @return The position of the first non-match
     */
     BOOST_CXX14_CONSTEXPR size_type find_first_not_of(
         char const* s, size_type pos, size_type n ) const noexcept
     {
         return s_.find_first_not_of(s, pos, n);
     }
 
     /** Return the position of the first non-match
 
         See `core::string_view::find_first_not_of`
 
         @param s The characters to search for
         @param pos The position to start searching from
         @return The position of the first non-match
     */
     BOOST_CXX14_CONSTEXPR size_type find_first_not_of(
         char const* s, size_type pos = 0 ) const noexcept
     {
         return s_.find_first_not_of(s, pos);
     }
 
     // find_last_not_of
 
     /** Return the position of the last non-match
 
         See `core::string_view::find_last_not_of`
 
         @param str The characters to search for
         @param pos The position to start searching from
         @return The position of the last non-match
     */
     BOOST_CXX14_CONSTEXPR size_type find_last_not_of(
         core::string_view str, size_type pos = core::string_view::npos ) const noexcept
     {
         return s_.find_last_not_of(str, pos);
     }
 
     /** Return the position of the last non-match
 
         See `core::string_view::find_last_not_of`
 
         @param c The character to search for
         @param pos The position to start searching from
         @return The position of the last non-match
     */
     BOOST_CXX14_CONSTEXPR size_type find_last_not_of(
         char c, size_type pos = core::string_view::npos ) const noexcept
     {
         return s_.find_last_not_of(c, pos);
     }
 
     /** Return the position of the last non-match
 
         See `core::string_view::find_last_not_of`
 
         @param s The characters to search for
         @param pos The position to start searching from
         @param n The number of characters to search for
         @return The position of the last non-match
     */
     BOOST_CXX14_CONSTEXPR size_type find_last_not_of(
         char const* s, size_type pos, size_type n ) const noexcept
     {
         return s_.find_last_not_of(s, pos, n);
     }
 
     /** Return the position of the last non-match
 
         See `core::string_view::find_last_not_of`
 
         @param s The characters to search for
         @param pos The position to start searching from
         @return The position of the last non-match
     */
     BOOST_CXX14_CONSTEXPR size_type find_last_not_of(
         char const* s, size_type pos = core::string_view::npos ) const noexcept
     {
         return s_.find_last_not_of(s, pos);
     }
 
     // contains
 
     /** Return true if matching characters are found
 
         See `core::string_view::contains`
 
         @param sv The string to search for
         @return `true` if the string contains the characters, otherwise `false`
     */
     BOOST_CONSTEXPR bool contains( core::string_view sv ) const noexcept
     {
         return s_.contains(sv);
     }
 
     /** Return true if matching characters are found
 
         See `core::string_view::contains`
 
         @param c The character to search for
         @return `true` if the string contains the character, otherwise `false`
     */
     BOOST_CXX14_CONSTEXPR bool contains( char c ) const noexcept
     {
         return s_.contains(c);
     }
 
     /** Return true if matching characters are found
 
         See `core::string_view::contains`
 
         @param s The string to search for
         @return `true` if the string contains the characters, otherwise `false`
     */
     BOOST_CONSTEXPR bool contains( char const* s ) const noexcept
     {
         return s_.contains(s);
     }
 
     // relational operators
 #ifndef BOOST_URL_DOCS
 private:
     template<class S0, class S1>
     using is_match = std::integral_constant<bool,
         std::is_convertible<S0, core::string_view>::value &&
         std::is_convertible<S1, core::string_view>::value && (
             (std::is_base_of<string_view_base,
                 typename std::decay<S0>::type>::value &&
             std::is_convertible<S0 const volatile*,
                 string_view_base const volatile*>::value) ||
             (std::is_base_of<string_view_base,
                 typename std::decay<S1>::type>::value &&
             std::is_convertible<S1 const volatile*,
                 string_view_base const volatile*>::value))>;
 public:
 
     /** Compare two string views for equality
 
         This function is only enabled if both arguments
         are convertible to `core::string_view` and at least
         one of the arguments is derived from `string_view_base`.
 
         @param s0 The first string
         @param s1 The second string
         @return `true` if the strings are equal, otherwise `false`
      */
     template<class S0, class S1>
     BOOST_CXX14_CONSTEXPR friend auto operator==(
         S0 const& s0, S1 const& s1) noexcept ->
         typename std::enable_if<
             is_match<S0, S1>::value, bool>::type
     {
         return urls::detail::to_sv(s0) == urls::detail::to_sv(s1);
     }
 
     /** Compare two string views for inequality
 
         This function is only enabled if both arguments
         are convertible to `core::string_view` and at least
         one of the arguments is derived from `string_view_base`.
 
         @param s0 The first string
         @param s1 The second string
         @return `true` if the strings are not equal, otherwise `false`
      */
     template<class S0, class S1>
     BOOST_CXX14_CONSTEXPR friend auto operator!=(
         S0 const& s0, S1 const& s1) noexcept ->
         typename std::enable_if<
             is_match<S0, S1>::value, bool>::type
     {
         return urls::detail::to_sv(s0) != urls::detail::to_sv(s1);
     }
 
     /** Compare two string views for less than
 
         This function is only enabled if both arguments
         are convertible to `core::string_view` and at least
         one of the arguments is derived from `string_view_base`.
 
         @param s0 The first string
         @param s1 The second string
         @return `true` if the first string is less than the second, otherwise `false`
      */
     template<class S0, class S1>
     BOOST_CXX14_CONSTEXPR friend auto operator<(
         S0 const& s0, S1 const& s1) noexcept ->
         typename std::enable_if<
             is_match<S0, S1>::value, bool>::type
     {
         return urls::detail::to_sv(s0) < urls::detail::to_sv(s1);
     }
 
     /** Compare two string views for less than or equal
 
         This function is only enabled if both arguments
         are convertible to `core::string_view` and at least
         one of the arguments is derived from `string_view_base`.
 
         @param s0 The first string
         @param s1 The second string
         @return `true` if the first string is less than or equal to the second, otherwise `false`
      */
     template<class S0, class S1>
     BOOST_CXX14_CONSTEXPR friend auto operator<=(
         S0 const& s0, S1 const& s1) noexcept ->
         typename std::enable_if<
             is_match<S0, S1>::value, bool>::type
     {
         return urls::detail::to_sv(s0) <= urls::detail::to_sv(s1);
     }
 
     /** Compare two string views for greater than
 
         This function is only enabled if both arguments
         are convertible to `core::string_view` and at least
         one of the arguments is derived from `string_view_base`.
 
         @param s0 The first string
         @param s1 The second string
         @return `true` if the first string is greater than the second, otherwise `false`
      */
     template<class S0, class S1>
     BOOST_CXX14_CONSTEXPR friend auto operator>(
         S0 const& s0, S1 const& s1) noexcept ->
         typename std::enable_if<
             is_match<S0, S1>::value, bool>::type
     {
         return urls::detail::to_sv(s0) > urls::detail::to_sv(s1);
     }
 
     /** Compare two string views for greater than or equal
 
         This function is only enabled if both arguments
         are convertible to `core::string_view` and at least
         one of the arguments is derived from `string_view_base`.
 
         @param s0 The first string
         @param s1 The second string
         @return `true` if the first string is greater than or equal to the second, otherwise `false`
      */
     template<class S0, class S1>
     BOOST_CXX14_CONSTEXPR friend auto operator>=(
         S0 const& s0, S1 const& s1) noexcept ->
         typename std::enable_if<
             is_match<S0, S1>::value, bool>::type
     {
         return urls::detail::to_sv(s0) >= urls::detail::to_sv(s1);
     }
 #endif
 
     //--------------------------------------------
 
     /** Format a string to an output stream
 
         @param os The output stream to write to
         @param s The string to write
         @return A reference to the output stream, for chaining
      */
     BOOST_URL_DECL
     friend
     std::ostream&
     operator<<(
         std::ostream& os,
         string_view_base const& s);
 };
 
 //------------------------------------------------
 
 /** Format a string to an output stream
 */
 BOOST_URL_DECL
 std::ostream&
 operator<<(
     std::ostream& os,
     string_view_base const& s);
 
 } // grammar
 
 #ifndef BOOST_URL_DOCS
 namespace detail {
 template <>
 inline
 core::string_view
 to_sv(grammar::string_view_base const& s) noexcept
 {
     return s.operator core::string_view();
 }
 } // detail
 #endif
 
 } // urls
 } // boost
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team