1   
//
1   
//
2   
// Copyright (c) 2022 Vinnie Falco (vinnie.falco@gmail.com)
2   
// Copyright (c) 2022 Vinnie Falco (vinnie.falco@gmail.com)
3   
//
3   
//
4   
// Distributed under the Boost Software License, Version 1.0. (See accompanying
4   
// Distributed under the Boost Software License, Version 1.0. (See accompanying
5   
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5   
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6   
//
6   
//
7   
// Official repository: https://github.com/boostorg/url
7   
// Official repository: https://github.com/boostorg/url
8   
//
8   
//
9  
9  
10   
#ifndef BOOST_URL_GRAMMAR_STRING_VIEW_BASE_HPP
10   
#ifndef BOOST_URL_GRAMMAR_STRING_VIEW_BASE_HPP
11   
#define BOOST_URL_GRAMMAR_STRING_VIEW_BASE_HPP
11   
#define BOOST_URL_GRAMMAR_STRING_VIEW_BASE_HPP
12  
12  
13   
#include <boost/url/detail/config.hpp>
13   
#include <boost/url/detail/config.hpp>
14   
#include <boost/url/detail/string_view.hpp>
14   
#include <boost/url/detail/string_view.hpp>
15   
#include <boost/core/detail/string_view.hpp>
15   
#include <boost/core/detail/string_view.hpp>
16   
#include <cstddef>
16   
#include <cstddef>
17   
#include <iterator>
17   
#include <iterator>
18   
#include <string>
18   
#include <string>
19   
#include <type_traits>
19   
#include <type_traits>
20   
#include <utility>
20   
#include <utility>
21  
21  
22   
namespace boost {
22   
namespace boost {
23   
namespace urls {
23   
namespace urls {
24   
namespace grammar {
24   
namespace grammar {
25  
25  
26   
/** Common functionality for string views
26   
/** Common functionality for string views
27  
27  
28   
    This base class is used to provide common
28   
    This base class is used to provide common
29   
    member functions for reference types that
29   
    member functions for reference types that
30   
    behave like string views. This cannot be
30   
    behave like string views. This cannot be
31   
    instantiated directly; instead, derive
31   
    instantiated directly; instead, derive
32   
    from the type and provide constructors
32   
    from the type and provide constructors
33   
    which offer any desired preconditions
33   
    which offer any desired preconditions
34   
    and invariants.
34   
    and invariants.
35   
*/
35   
*/
36   
class string_view_base
36   
class string_view_base
37   
{
37   
{
38   
protected:
38   
protected:
39   
    /** The referenced character buffer
39   
    /** The referenced character buffer
40   
    */
40   
    */
41   
    core::string_view s_;
41   
    core::string_view s_;
42  
42  
43   
    /** Constructor
43   
    /** Constructor
44  
44  
45   
        @param s The string view
45   
        @param s The string view
46   
    */
46   
    */
47   
    constexpr
47   
    constexpr
48   
    string_view_base(
48   
    string_view_base(
49   
        core::string_view s) noexcept
49   
        core::string_view s) noexcept
50   
        : s_(s)
50   
        : s_(s)
51   
    {
51   
    {
52   
    }
52   
    }
53  
53  
54   
    /** Constructor
54   
    /** Constructor
55  
55  
56   
        @param data The character buffer
56   
        @param data The character buffer
57   
        @param size The number of characters
57   
        @param size The number of characters
58   
    */
58   
    */
59   
    constexpr
59   
    constexpr
60   
    string_view_base(
60   
    string_view_base(
61   
        char const* data,
61   
        char const* data,
62   
        std::size_t size) noexcept
62   
        std::size_t size) noexcept
63   
        : s_(data, size)
63   
        : s_(data, size)
64   
    {
64   
    {
65   
    }
65   
    }
66  
66  
67   
    /** Swap
67   
    /** Swap
68  
68  
69   
        @param s The object to swap with
69   
        @param s The object to swap with
70   
    */
70   
    */
71   
    // VFALCO No idea why this fails in msvc
71   
    // VFALCO No idea why this fails in msvc
72   
    /*BOOST_CXX14_CONSTEXPR*/
72   
    /*BOOST_CXX14_CONSTEXPR*/
73   
    void
73   
    void
74   
    swap(
74   
    swap(
75   
        string_view_base& s ) noexcept
75   
        string_view_base& s ) noexcept
76   
    {
76   
    {
77   
        std::swap(s_, s.s_);
77   
        std::swap(s_, s.s_);
78   
    }
78   
    }
79  
79  
80   
    /** Constructor
80   
    /** Constructor
81   
    */
81   
    */
82   
    string_view_base() = default;
82   
    string_view_base() = default;
83  
83  
84   
    /** Constructor
84   
    /** Constructor
85   
    */
85   
    */
86   
    string_view_base(
86   
    string_view_base(
87   
        string_view_base const&) = default;
87   
        string_view_base const&) = default;
88  
88  
89   
    /** Assignment
89   
    /** Assignment
90  
90  
91   
        @param other The object to assign
91   
        @param other The object to assign
92   
        @return A reference to this object
92   
        @return A reference to this object
93   
    */
93   
    */
94   
    string_view_base& operator=(
94   
    string_view_base& operator=(
95   
        string_view_base const& other) = default;
95   
        string_view_base const& other) = default;
96  
96  
97   
public:
97   
public:
98   
    /// The character traits
98   
    /// The character traits
99   
    typedef std::char_traits<char> traits_type;
99   
    typedef std::char_traits<char> traits_type;
100   
    /// The value type
100   
    /// The value type
101   
    typedef char value_type;
101   
    typedef char value_type;
102   
    /// The pointer type
102   
    /// The pointer type
103   
    typedef char* pointer;
103   
    typedef char* pointer;
104   
    /// The const pointer type
104   
    /// The const pointer type
105   
    typedef char const* const_pointer;
105   
    typedef char const* const_pointer;
106   
    /// The reference type
106   
    /// The reference type
107   
    typedef char& reference;
107   
    typedef char& reference;
108   
    /// The const reference type
108   
    /// The const reference type
109   
    typedef char const& const_reference;
109   
    typedef char const& const_reference;
110   
    /// The const iterator type
110   
    /// The const iterator type
111   
    typedef char const* const_iterator;
111   
    typedef char const* const_iterator;
112   
    /// The iterator type
112   
    /// The iterator type
113   
    typedef const_iterator iterator;
113   
    typedef const_iterator iterator;
114   
    /// The const reverse iterator type
114   
    /// The const reverse iterator type
115   
    typedef std::reverse_iterator<
115   
    typedef std::reverse_iterator<
116   
        const_iterator> const_reverse_iterator;
116   
        const_iterator> const_reverse_iterator;
117   
    /// The reverse iterator type
117   
    /// The reverse iterator type
118   
    typedef const_reverse_iterator reverse_iterator;
118   
    typedef const_reverse_iterator reverse_iterator;
119   
    /// The size type
119   
    /// The size type
120   
    typedef std::size_t size_type;
120   
    typedef std::size_t size_type;
121   
    /// The difference type
121   
    /// The difference type
122   
    typedef std::ptrdiff_t difference_type;
122   
    typedef std::ptrdiff_t difference_type;
123  
123  
124   
    /// A constant used to represent "no position"
124   
    /// A constant used to represent "no position"
125   
    static constexpr std::size_t npos = core::string_view::npos;
125   
    static constexpr std::size_t npos = core::string_view::npos;
126  
126  
127   
    //--------------------------------------------
127   
    //--------------------------------------------
128  
128  
129   
    /** Conversion
129   
    /** Conversion
130  
130  
131   
        @return A string view with the same contents
131   
        @return A string view with the same contents
132   
     */
132   
     */
133   
    operator
133   
    operator
134   
    core::string_view() const noexcept
134   
    core::string_view() const noexcept
135   
    {
135   
    {
136   
        return s_;
136   
        return s_;
137   
    }
137   
    }
138  
138  
139   
    /** Conversion
139   
    /** Conversion
140  
140  
141   
        @return A string view with the same contents
141   
        @return A string view with the same contents
142   
     */
142   
     */
143   
#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
143   
#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
144   
    operator
144   
    operator
145   
    std::string_view() const noexcept
145   
    std::string_view() const noexcept
146   
    {
146   
    {
147   
        return std::string_view(s_);
147   
        return std::string_view(s_);
148   
    }
148   
    }
149   
#endif
149   
#endif
150  
150  
151   
    /** Conversion
151   
    /** Conversion
152  
152  
153   
        Conversion to std::string is explicit
153   
        Conversion to std::string is explicit
154   
        because assigning to string using an
154   
        because assigning to string using an
155   
        implicit constructor does not preserve
155   
        implicit constructor does not preserve
156   
        capacity.
156   
        capacity.
157  
157  
158   
        @return A string with the same contents
158   
        @return A string with the same contents
159   
    */
159   
    */
160   
    explicit
160   
    explicit
161   
    operator
161   
    operator
162   
    std::string() const noexcept
162   
    std::string() const noexcept
163   
    {
163   
    {
164   
        return std::string(s_);
164   
        return std::string(s_);
165   
    }
165   
    }
166  
166  
167   
    //--------------------------------------------
167   
    //--------------------------------------------
168  
168  
169   
    // iterator support
169   
    // iterator support
170  
170  
171   
    /** Return an iterator to the beginning
171   
    /** Return an iterator to the beginning
172  
172  
173   
        See `core::string_view::begin`
173   
        See `core::string_view::begin`
174  
174  
175   
        @return An iterator to the beginning
175   
        @return An iterator to the beginning
176   
    */
176   
    */
177   
    BOOST_CONSTEXPR const_iterator begin() const noexcept
177   
    BOOST_CONSTEXPR const_iterator begin() const noexcept
178   
    {
178   
    {
179   
        return s_.begin();
179   
        return s_.begin();
180   
    }
180   
    }
181  
181  
182   
    /** Return an iterator to the end
182   
    /** Return an iterator to the end
183  
183  
184   
        See `core::string_view::end`
184   
        See `core::string_view::end`
185  
185  
186   
        @return An iterator to the end
186   
        @return An iterator to the end
187   
    */
187   
    */
188   
    BOOST_CONSTEXPR const_iterator end() const noexcept
188   
    BOOST_CONSTEXPR const_iterator end() const noexcept
189   
    {
189   
    {
190   
        return s_.end();
190   
        return s_.end();
191   
    }
191   
    }
192  
192  
193   
    /** Return an iterator to the beginning
193   
    /** Return an iterator to the beginning
194  
194  
195   
        See `core::string_view::cbegin`
195   
        See `core::string_view::cbegin`
196  
196  
197   
        @return An iterator to the beginning
197   
        @return An iterator to the beginning
198   
    */
198   
    */
199   
    BOOST_CONSTEXPR const_iterator cbegin() const noexcept
199   
    BOOST_CONSTEXPR const_iterator cbegin() const noexcept
200   
    {
200   
    {
201   
        return s_.cbegin();
201   
        return s_.cbegin();
202   
    }
202   
    }
203  
203  
204   
    /** Return an iterator to the end
204   
    /** Return an iterator to the end
205  
205  
206   
        See `core::string_view::cend`
206   
        See `core::string_view::cend`
207  
207  
208   
        @return An iterator to the end
208   
        @return An iterator to the end
209   
    */
209   
    */
210   
    BOOST_CONSTEXPR const_iterator cend() const noexcept
210   
    BOOST_CONSTEXPR const_iterator cend() const noexcept
211   
    {
211   
    {
212   
        return s_.cend();
212   
        return s_.cend();
213   
    }
213   
    }
214  
214  
215   
    /** Return a reverse iterator to the end
215   
    /** Return a reverse iterator to the end
216  
216  
217   
        See `core::string_view::rbegin`
217   
        See `core::string_view::rbegin`
218  
218  
219   
        @return A reverse iterator to the end
219   
        @return A reverse iterator to the end
220   
    */
220   
    */
221   
    BOOST_URL_LIB_ARRAY_CONSTEXPR
221   
    BOOST_URL_LIB_ARRAY_CONSTEXPR
222   
    const_reverse_iterator rbegin() const noexcept
222   
    const_reverse_iterator rbegin() const noexcept
223   
    {
223   
    {
224   
        return s_.rbegin();
224   
        return s_.rbegin();
225   
    }
225   
    }
226  
226  
227   
    /** Return a reverse iterator to the beginning
227   
    /** Return a reverse iterator to the beginning
228  
228  
229   
        See `core::string_view::rend`
229   
        See `core::string_view::rend`
230  
230  
231   
        @return A reverse iterator to the beginning
231   
        @return A reverse iterator to the beginning
232   
    */
232   
    */
233   
    BOOST_URL_LIB_ARRAY_CONSTEXPR
233   
    BOOST_URL_LIB_ARRAY_CONSTEXPR
234   
    const_reverse_iterator rend() const noexcept
234   
    const_reverse_iterator rend() const noexcept
235   
    {
235   
    {
236   
        return s_.rend();
236   
        return s_.rend();
237   
    }
237   
    }
238  
238  
239   
    /** Return a reverse iterator to the end
239   
    /** Return a reverse iterator to the end
240  
240  
241   
        See `core::string_view::crbegin`
241   
        See `core::string_view::crbegin`
242  
242  
243   
        @return A reverse iterator to the end
243   
        @return A reverse iterator to the end
244   
    */
244   
    */
245   
    BOOST_URL_LIB_ARRAY_CONSTEXPR
245   
    BOOST_URL_LIB_ARRAY_CONSTEXPR
246   
    const_reverse_iterator crbegin() const noexcept
246   
    const_reverse_iterator crbegin() const noexcept
247   
    {
247   
    {
248   
        return s_.crbegin();
248   
        return s_.crbegin();
249   
    }
249   
    }
250  
250  
251   
    /** Return a reverse iterator to the beginning
251   
    /** Return a reverse iterator to the beginning
252  
252  
253   
        See `core::string_view::crend`
253   
        See `core::string_view::crend`
254  
254  
255   
        @return A reverse iterator to the beginning
255   
        @return A reverse iterator to the beginning
256   
    */
256   
    */
257   
    BOOST_URL_LIB_ARRAY_CONSTEXPR
257   
    BOOST_URL_LIB_ARRAY_CONSTEXPR
258   
    const_reverse_iterator crend() const noexcept
258   
    const_reverse_iterator crend() const noexcept
259   
    {
259   
    {
260   
        return s_.crend();
260   
        return s_.crend();
261   
    }
261   
    }
262  
262  
263   
    // capacity
263   
    // capacity
264  
264  
265   
    /** Return the size
265   
    /** Return the size
266  
266  
267   
        See `core::string_view::size`
267   
        See `core::string_view::size`
268  
268  
269   
        @return The size
269   
        @return The size
270   
    */
270   
    */
271   
    BOOST_CONSTEXPR size_type size() const noexcept
271   
    BOOST_CONSTEXPR size_type size() const noexcept
272   
    {
272   
    {
273   
        return s_.size();
273   
        return s_.size();
274   
    }
274   
    }
275  
275  
276   
    /** Return the size
276   
    /** Return the size
277  
277  
278   
        See `core::string_view::length`
278   
        See `core::string_view::length`
279  
279  
280   
        @return The size
280   
        @return The size
281   
    */
281   
    */
282   
    BOOST_CONSTEXPR size_type length() const noexcept
282   
    BOOST_CONSTEXPR size_type length() const noexcept
283   
    {
283   
    {
284   
        return s_.length();
284   
        return s_.length();
285   
    }
285   
    }
286  
286  
287   
    /** Return the maximum allowed size
287   
    /** Return the maximum allowed size
288  
288  
289   
        See `core::string_view::max_size`
289   
        See `core::string_view::max_size`
290  
290  
291   
        @return The maximum allowed size
291   
        @return The maximum allowed size
292   
    */
292   
    */
293   
    BOOST_CONSTEXPR size_type max_size() const noexcept
293   
    BOOST_CONSTEXPR size_type max_size() const noexcept
294   
    {
294   
    {
295   
        return s_.max_size();
295   
        return s_.max_size();
296   
    }
296   
    }
297  
297  
298   
    /** Return true if the string is empty
298   
    /** Return true if the string is empty
299  
299  
300   
        See `core::string_view::size`
300   
        See `core::string_view::size`
301  
301  
302   
        @return `true` if the string is empty
302   
        @return `true` if the string is empty
303   
    */
303   
    */
304   
    BOOST_CONSTEXPR bool empty() const noexcept
304   
    BOOST_CONSTEXPR bool empty() const noexcept
305   
    {
305   
    {
306   
        return s_.empty();
306   
        return s_.empty();
307   
    }
307   
    }
308  
308  
309   
    // element access
309   
    // element access
310  
310  
311   
    /** Access a character
311   
    /** Access a character
312  
312  
313   
        See `core::string_view::operator[]`
313   
        See `core::string_view::operator[]`
314  
314  
315   
        @param pos The position to access
315   
        @param pos The position to access
316   
        @return The character at the position
316   
        @return The character at the position
317   
    */
317   
    */
318   
    BOOST_CXX14_CONSTEXPR const_reference
318   
    BOOST_CXX14_CONSTEXPR const_reference
319   
        operator[]( size_type pos ) const noexcept
319   
        operator[]( size_type pos ) const noexcept
320   
    {
320   
    {
321   
        return s_[pos];
321   
        return s_[pos];
322   
    }
322   
    }
323  
323  
324   
    /** Access a character
324   
    /** Access a character
325  
325  
326   
        See `core::string_view::at`
326   
        See `core::string_view::at`
327  
327  
328   
        @param pos The position to access
328   
        @param pos The position to access
329   
        @return The character at the position
329   
        @return The character at the position
330   
    */
330   
    */
331   
    BOOST_CXX14_CONSTEXPR const_reference
331   
    BOOST_CXX14_CONSTEXPR const_reference
332   
        at( size_type pos ) const
332   
        at( size_type pos ) const
333   
    {
333   
    {
334   
        return s_.at(pos);
334   
        return s_.at(pos);
335   
    }
335   
    }
336  
336  
337   
    /** Return the first character
337   
    /** Return the first character
338  
338  
339   
        See `core::string_view::front`
339   
        See `core::string_view::front`
340  
340  
341   
        @return The first character
341   
        @return The first character
342   
    */
342   
    */
343   
    BOOST_CXX14_CONSTEXPR const_reference
343   
    BOOST_CXX14_CONSTEXPR const_reference
344   
        front() const noexcept
344   
        front() const noexcept
345   
    {
345   
    {
346   
        return s_.front();
346   
        return s_.front();
347   
    }
347   
    }
348  
348  
349   
    /** Return the last character
349   
    /** Return the last character
350  
350  
351   
        See `core::string_view::back`
351   
        See `core::string_view::back`
352  
352  
353   
        @return The last character
353   
        @return The last character
354   
    */
354   
    */
355   
    BOOST_CXX14_CONSTEXPR const_reference
355   
    BOOST_CXX14_CONSTEXPR const_reference
356   
        back() const noexcept
356   
        back() const noexcept
357   
    {
357   
    {
358   
        return s_.back();
358   
        return s_.back();
359   
    }
359   
    }
360  
360  
361   
    /** Return a pointer to the character buffer
361   
    /** Return a pointer to the character buffer
362  
362  
363   
        See `core::string_view::data`
363   
        See `core::string_view::data`
364  
364  
365   
        @return A pointer to the character buffer
365   
        @return A pointer to the character buffer
366   
    */
366   
    */
367   
    BOOST_CONSTEXPR const_pointer
367   
    BOOST_CONSTEXPR const_pointer
368   
        data() const noexcept
368   
        data() const noexcept
369   
    {
369   
    {
370   
        return s_.data();
370   
        return s_.data();
371   
    }
371   
    }
372  
372  
373   
    // string operations
373   
    // string operations
374  
374  
375   
    /** Copy the characters to another buffer
375   
    /** Copy the characters to another buffer
376  
376  
377   
        See `core::string_view::copy`
377   
        See `core::string_view::copy`
378  
378  
379   
        @param s The destination buffer
379   
        @param s The destination buffer
380   
        @param n The number of characters to copy
380   
        @param n The number of characters to copy
381   
        @param pos The position to start from
381   
        @param pos The position to start from
382   
        @return The number of characters copied
382   
        @return The number of characters copied
383   
    */
383   
    */
384   
    BOOST_CXX14_CONSTEXPR size_type copy(
384   
    BOOST_CXX14_CONSTEXPR size_type copy(
385   
        char* s, size_type n, size_type pos = 0 ) const
385   
        char* s, size_type n, size_type pos = 0 ) const
386   
    {
386   
    {
387   
        return s_.copy(s, n, pos);
387   
        return s_.copy(s, n, pos);
388   
    }
388   
    }
389  
389  
390   
    /** Return a view to part of the string
390   
    /** Return a view to part of the string
391  
391  
392   
        See `core::string_view::substr`
392   
        See `core::string_view::substr`
393  
393  
394   
        @param pos The position to start from
394   
        @param pos The position to start from
395   
        @param n The number of characters
395   
        @param n The number of characters
396   
        @return A view to the substring
396   
        @return A view to the substring
397   
    */
397   
    */
398   
    BOOST_CXX14_CONSTEXPR core::string_view substr(
398   
    BOOST_CXX14_CONSTEXPR core::string_view substr(
399   
        size_type pos = 0, size_type n = core::string_view::npos ) const
399   
        size_type pos = 0, size_type n = core::string_view::npos ) const
400   
    {
400   
    {
401   
        return s_.substr(pos, n);
401   
        return s_.substr(pos, n);
402   
    }
402   
    }
403  
403  
404   
    // comparison
404   
    // comparison
405  
405  
406   
    /** Return the result of comparing to another string
406   
    /** Return the result of comparing to another string
407  
407  
408   
        See `core::string_view::compare`
408   
        See `core::string_view::compare`
409  
409  
410   
        @param str The string to compare
410   
        @param str The string to compare
411   
        @return The result of the comparison
411   
        @return The result of the comparison
412   
    */
412   
    */
413   
    BOOST_CXX14_CONSTEXPR int
413   
    BOOST_CXX14_CONSTEXPR int
414   
        compare( core::string_view str ) const noexcept
414   
        compare( core::string_view str ) const noexcept
415   
    {
415   
    {
416   
        return s_.compare(str);
416   
        return s_.compare(str);
417   
    }
417   
    }
418  
418  
419   
    /** Return the result of comparing to another string
419   
    /** Return the result of comparing to another string
420  
420  
421   
        See `core::string_view::compare`
421   
        See `core::string_view::compare`
422  
422  
423   
        @param pos1 The position to start comparing from
423   
        @param pos1 The position to start comparing from
424   
        @param n1 The number of characters to compare
424   
        @param n1 The number of characters to compare
425   
        @param str The string to compare
425   
        @param str The string to compare
426   
        @return The result of the comparison
426   
        @return The result of the comparison
427   
    */
427   
    */
428   
    BOOST_CONSTEXPR int compare(
428   
    BOOST_CONSTEXPR int compare(
429   
        size_type pos1, size_type n1, core::string_view str ) const
429   
        size_type pos1, size_type n1, core::string_view str ) const
430   
    {
430   
    {
431   
        return s_.compare(pos1, n1, str);
431   
        return s_.compare(pos1, n1, str);
432   
    }
432   
    }
433  
433  
434   
    /** Return the result of comparing to another string
434   
    /** Return the result of comparing to another string
435  
435  
436   
        See `core::string_view::compare`
436   
        See `core::string_view::compare`
437  
437  
438   
        @param pos1 The position to start comparing from
438   
        @param pos1 The position to start comparing from
439   
        @param n1 The number of characters to compare
439   
        @param n1 The number of characters to compare
440   
        @param str The string to compare
440   
        @param str The string to compare
441   
        @param pos2 The position to start comparing from
441   
        @param pos2 The position to start comparing from
442   
        @param n2 The number of characters to compare
442   
        @param n2 The number of characters to compare
443   
        @return The result of the comparison
443   
        @return The result of the comparison
444   
    */
444   
    */
445   
    BOOST_CONSTEXPR int compare(
445   
    BOOST_CONSTEXPR int compare(
446   
        size_type pos1, size_type n1, core::string_view str,
446   
        size_type pos1, size_type n1, core::string_view str,
447   
        size_type pos2, size_type n2 ) const
447   
        size_type pos2, size_type n2 ) const
448   
    {
448   
    {
449   
        return s_.compare(pos1, n1, str, pos2, n2);
449   
        return s_.compare(pos1, n1, str, pos2, n2);
450   
    }
450   
    }
451  
451  
452   
    /** Return the result of comparing to another string
452   
    /** Return the result of comparing to another string
453  
453  
454   
        See `core::string_view::compare`
454   
        See `core::string_view::compare`
455  
455  
456   
        @param s The string to compare
456   
        @param s The string to compare
457   
        @return The result of the comparison
457   
        @return The result of the comparison
458   
    */
458   
    */
459   
    BOOST_CONSTEXPR int compare(
459   
    BOOST_CONSTEXPR int compare(
460   
        char const* s ) const noexcept
460   
        char const* s ) const noexcept
461   
    {
461   
    {
462   
        return s_.compare(s);
462   
        return s_.compare(s);
463   
    }
463   
    }
464  
464  
465   
    /** Return the result of comparing to another string
465   
    /** Return the result of comparing to another string
466  
466  
467   
        See `core::string_view::compare`
467   
        See `core::string_view::compare`
468  
468  
469   
        @param pos1 The position to start comparing from
469   
        @param pos1 The position to start comparing from
470   
        @param n1 The number of characters to compare
470   
        @param n1 The number of characters to compare
471   
        @param s The string to compare
471   
        @param s The string to compare
472   
        @return The result of the comparison
472   
        @return The result of the comparison
473   
    */
473   
    */
474   
    BOOST_CONSTEXPR int compare(
474   
    BOOST_CONSTEXPR int compare(
475   
        size_type pos1, size_type n1, char const* s ) const
475   
        size_type pos1, size_type n1, char const* s ) const
476   
    {
476   
    {
477   
        return s_.compare(pos1, n1, s);
477   
        return s_.compare(pos1, n1, s);
478   
    }
478   
    }
479  
479  
480   
    /** Return the result of comparing to another string
480   
    /** Return the result of comparing to another string
481  
481  
482   
        See `core::string_view::compare`
482   
        See `core::string_view::compare`
483  
483  
484   
        @param pos1 The position to start comparing from
484   
        @param pos1 The position to start comparing from
485   
        @param n1 The number of characters to compare
485   
        @param n1 The number of characters to compare
486   
        @param s The string to compare
486   
        @param s The string to compare
487   
        @param n2 The number of characters to compare
487   
        @param n2 The number of characters to compare
488   
        @return The result of the comparison
488   
        @return The result of the comparison
489   
    */
489   
    */
490   
    BOOST_CONSTEXPR int compare(
490   
    BOOST_CONSTEXPR int compare(
491   
        size_type pos1, size_type n1,
491   
        size_type pos1, size_type n1,
492   
        char const* s, size_type n2 ) const
492   
        char const* s, size_type n2 ) const
493   
    {
493   
    {
494   
        return s_.compare(pos1, n1, s, n2);
494   
        return s_.compare(pos1, n1, s, n2);
495   
    }
495   
    }
496  
496  
497   
    // starts_with
497   
    // starts_with
498  
498  
499   
    /** Return true if a matching prefix exists
499   
    /** Return true if a matching prefix exists
500  
500  
501   
        See `core::string_view::starts_with`
501   
        See `core::string_view::starts_with`
502  
502  
503   
        @param x The string to search for
503   
        @param x The string to search for
504   
        @return `true` if the prefix matches
504   
        @return `true` if the prefix matches
505   
    */
505   
    */
506   
    BOOST_CONSTEXPR bool starts_with(
506   
    BOOST_CONSTEXPR bool starts_with(
507   
        core::string_view x ) const noexcept
507   
        core::string_view x ) const noexcept
508   
    {
508   
    {
509   
        return s_.starts_with(x);
509   
        return s_.starts_with(x);
510   
    }
510   
    }
511  
511  
512   
    /** Return true if a matching prefix exists
512   
    /** Return true if a matching prefix exists
513  
513  
514   
        See `core::string_view::starts_with`
514   
        See `core::string_view::starts_with`
515  
515  
516   
        @param x The character to search for
516   
        @param x The character to search for
517   
        @return `true` if the prefix matches
517   
        @return `true` if the prefix matches
518   
    */
518   
    */
519   
    BOOST_CONSTEXPR bool starts_with(
519   
    BOOST_CONSTEXPR bool starts_with(
520   
        char x ) const noexcept
520   
        char x ) const noexcept
521   
    {
521   
    {
522   
        return s_.starts_with(x);
522   
        return s_.starts_with(x);
523   
    }
523   
    }
524  
524  
525   
    /** Return true if a matching prefix exists
525   
    /** Return true if a matching prefix exists
526  
526  
527   
        See `core::string_view::starts_with`
527   
        See `core::string_view::starts_with`
528  
528  
529   
        @param x The string to search for
529   
        @param x The string to search for
530   
        @return `true` if the prefix matches
530   
        @return `true` if the prefix matches
531   
    */
531   
    */
532   
    BOOST_CONSTEXPR bool starts_with(
532   
    BOOST_CONSTEXPR bool starts_with(
533   
        char const* x ) const noexcept
533   
        char const* x ) const noexcept
534   
    {
534   
    {
535   
        return s_.starts_with(x);
535   
        return s_.starts_with(x);
536   
    }
536   
    }
537  
537  
538   
    // ends_with
538   
    // ends_with
539  
539  
540   
    /** Return true if a matching suffix exists
540   
    /** Return true if a matching suffix exists
541  
541  
542   
        See `core::string_view::ends_with`
542   
        See `core::string_view::ends_with`
543  
543  
544   
        @param x The string to search for
544   
        @param x The string to search for
545   
        @return `true` if the suffix matches
545   
        @return `true` if the suffix matches
546   
    */
546   
    */
547   
    BOOST_CONSTEXPR bool ends_with(
547   
    BOOST_CONSTEXPR bool ends_with(
548   
        core::string_view x ) const noexcept
548   
        core::string_view x ) const noexcept
549   
    {
549   
    {
550   
        return s_.ends_with(x);
550   
        return s_.ends_with(x);
551   
    }
551   
    }
552  
552  
553   
    /** Return true if a matching suffix exists
553   
    /** Return true if a matching suffix exists
554  
554  
555   
        See `core::string_view::ends_with`
555   
        See `core::string_view::ends_with`
556  
556  
557   
        @param x The character to search for
557   
        @param x The character to search for
558   
        @return `true` if the suffix matches
558   
        @return `true` if the suffix matches
559   
    */
559   
    */
560   
    BOOST_CONSTEXPR bool ends_with(
560   
    BOOST_CONSTEXPR bool ends_with(
561   
        char x ) const noexcept
561   
        char x ) const noexcept
562   
    {
562   
    {
563   
        return s_.ends_with(x);
563   
        return s_.ends_with(x);
564   
    }
564   
    }
565  
565  
566   
    /** Return true if a matching suffix exists
566   
    /** Return true if a matching suffix exists
567  
567  
568   
        See `core::string_view::ends_with`
568   
        See `core::string_view::ends_with`
569  
569  
570   
        @param x The string to search for
570   
        @param x The string to search for
571   
        @return `true` if the suffix matches
571   
        @return `true` if the suffix matches
572   
    */
572   
    */
573   
    BOOST_CONSTEXPR bool ends_with(
573   
    BOOST_CONSTEXPR bool ends_with(
574   
        char const* x ) const noexcept
574   
        char const* x ) const noexcept
575   
    {
575   
    {
576   
        return s_.ends_with(x);
576   
        return s_.ends_with(x);
577   
    }
577   
    }
578  
578  
579   
    // find
579   
    // find
580  
580  
581   
    /** Return the position of matching characters
581   
    /** Return the position of matching characters
582  
582  
583   
        See `core::string_view::find`
583   
        See `core::string_view::find`
584  
584  
585   
        @param str The characters to search for
585   
        @param str The characters to search for
586   
        @param pos The position to start searching from
586   
        @param pos The position to start searching from
587   
        @return The position of the first match
587   
        @return The position of the first match
588   
    */
588   
    */
589   
    BOOST_CONSTEXPR size_type find(
589   
    BOOST_CONSTEXPR size_type find(
590   
        core::string_view str, size_type pos = 0 ) const noexcept
590   
        core::string_view str, size_type pos = 0 ) const noexcept
591   
    {
591   
    {
592   
        return s_.find(str, pos);
592   
        return s_.find(str, pos);
593   
    }
593   
    }
594  
594  
595   
    /** Return the position of matching characters
595   
    /** Return the position of matching characters
596  
596  
597   
        See `core::string_view::find`
597   
        See `core::string_view::find`
598  
598  
599   
        @param c The character to search for
599   
        @param c The character to search for
600   
        @param pos The position to start searching from
600   
        @param pos The position to start searching from
601   
        @return The position of the first match
601   
        @return The position of the first match
602   
    */
602   
    */
603   
    BOOST_CXX14_CONSTEXPR size_type find(
603   
    BOOST_CXX14_CONSTEXPR size_type find(
604   
        char c, size_type pos = 0 ) const noexcept
604   
        char c, size_type pos = 0 ) const noexcept
605   
    {
605   
    {
606   
        return s_.find(c, pos);
606   
        return s_.find(c, pos);
607   
    }
607   
    }
608  
608  
609   
    /** Return the position of matching characters
609   
    /** Return the position of matching characters
610  
610  
611   
        See `core::string_view::find`
611   
        See `core::string_view::find`
612  
612  
613   
        @param s The characters to search for
613   
        @param s The characters to search for
614   
        @param pos The position to start searching from
614   
        @param pos The position to start searching from
615   
        @param n The number of characters to search for
615   
        @param n The number of characters to search for
616   
        @return The position of the first match
616   
        @return The position of the first match
617   
    */
617   
    */
618   
    BOOST_CXX14_CONSTEXPR size_type find(
618   
    BOOST_CXX14_CONSTEXPR size_type find(
619   
        char const* s, size_type pos, size_type n ) const noexcept
619   
        char const* s, size_type pos, size_type n ) const noexcept
620   
    {
620   
    {
621   
        return s_.find(s, pos, n);
621   
        return s_.find(s, pos, n);
622   
    }
622   
    }
623  
623  
624   
    /** Return the position of matching characters
624   
    /** Return the position of matching characters
625  
625  
626   
        See `core::string_view::find`
626   
        See `core::string_view::find`
627  
627  
628   
        @param s The characters to search for
628   
        @param s The characters to search for
629   
        @param pos The position to start searching from
629   
        @param pos The position to start searching from
630   
        @return The position of the first match
630   
        @return The position of the first match
631   
    */
631   
    */
632   
    BOOST_CONSTEXPR size_type find(
632   
    BOOST_CONSTEXPR size_type find(
633   
        char const* s, size_type pos = 0 ) const noexcept
633   
        char const* s, size_type pos = 0 ) const noexcept
634   
    {
634   
    {
635   
        return s_.find(s, pos);
635   
        return s_.find(s, pos);
636   
    }
636   
    }
637  
637  
638   
    // rfind
638   
    // rfind
639  
639  
640   
    /** Return the position of matching characters
640   
    /** Return the position of matching characters
641  
641  
642   
        See `core::string_view::rfind`
642   
        See `core::string_view::rfind`
643  
643  
644   
        @param str The characters to search for
644   
        @param str The characters to search for
645   
        @param pos The position to start searching from
645   
        @param pos The position to start searching from
646   
        @return The position of the first match
646   
        @return The position of the first match
647   
    */
647   
    */
648   
    BOOST_CONSTEXPR size_type rfind(
648   
    BOOST_CONSTEXPR size_type rfind(
649   
        core::string_view str, size_type pos = core::string_view::npos ) const noexcept
649   
        core::string_view str, size_type pos = core::string_view::npos ) const noexcept
650   
    {
650   
    {
651   
        return s_.rfind(str, pos);
651   
        return s_.rfind(str, pos);
652   
    }
652   
    }
653  
653  
654   
    /** Return the position of matching characters
654   
    /** Return the position of matching characters
655  
655  
656   
        See `core::string_view::rfind`
656   
        See `core::string_view::rfind`
657  
657  
658   
        @param c The character to search for
658   
        @param c The character to search for
659   
        @param pos The position to start searching from
659   
        @param pos The position to start searching from
660   
        @return The position of the first match
660   
        @return The position of the first match
661   
    */
661   
    */
662   
    BOOST_CXX14_CONSTEXPR size_type rfind(
662   
    BOOST_CXX14_CONSTEXPR size_type rfind(
663   
        char c, size_type pos = core::string_view::npos ) const noexcept
663   
        char c, size_type pos = core::string_view::npos ) const noexcept
664   
    {
664   
    {
665   
        return s_.rfind(c, pos);
665   
        return s_.rfind(c, pos);
666   
    }
666   
    }
667  
667  
668   
    /** Return the position of matching characters
668   
    /** Return the position of matching characters
669  
669  
670   
        See `core::string_view::rfind`
670   
        See `core::string_view::rfind`
671  
671  
672   
        @param s The characters to search for
672   
        @param s The characters to search for
673   
        @param pos The position to start searching from
673   
        @param pos The position to start searching from
674   
        @param n The number of characters to search for
674   
        @param n The number of characters to search for
675   
        @return The position of the first match
675   
        @return The position of the first match
676   
    */
676   
    */
677   
    BOOST_CXX14_CONSTEXPR size_type rfind(
677   
    BOOST_CXX14_CONSTEXPR size_type rfind(
678   
        char const* s, size_type pos, size_type n ) const noexcept
678   
        char const* s, size_type pos, size_type n ) const noexcept
679   
    {
679   
    {
680   
        return s_.rfind(s, pos, n);
680   
        return s_.rfind(s, pos, n);
681   
    }
681   
    }
682  
682  
683   
    /** Return the position of matching characters
683   
    /** Return the position of matching characters
684  
684  
685   
        See `core::string_view::rfind`
685   
        See `core::string_view::rfind`
686  
686  
687   
        @param s The characters to search for
687   
        @param s The characters to search for
688   
        @param pos The position to start searching from
688   
        @param pos The position to start searching from
689   
        @return The position of the first match
689   
        @return The position of the first match
690   
    */
690   
    */
691   
    BOOST_CONSTEXPR size_type rfind(
691   
    BOOST_CONSTEXPR size_type rfind(
692   
        char const* s, size_type pos = core::string_view::npos ) const noexcept
692   
        char const* s, size_type pos = core::string_view::npos ) const noexcept
693   
    {
693   
    {
694   
        return s_.rfind(s, pos);
694   
        return s_.rfind(s, pos);
695   
    }
695   
    }
696  
696  
697   
    // find_first_of
697   
    // find_first_of
698  
698  
699   
    /** Return the position of the first match
699   
    /** Return the position of the first match
700  
700  
701   
        See `core::string_view::find_first_of`
701   
        See `core::string_view::find_first_of`
702  
702  
703   
        @param str The characters to search for
703   
        @param str The characters to search for
704   
        @param pos The position to start searching from
704   
        @param pos The position to start searching from
705   
        @return The position of the first match
705   
        @return The position of the first match
706   
    */
706   
    */
707   
    BOOST_CXX14_CONSTEXPR size_type find_first_of(
707   
    BOOST_CXX14_CONSTEXPR size_type find_first_of(
708   
        core::string_view str, size_type pos = 0 ) const noexcept
708   
        core::string_view str, size_type pos = 0 ) const noexcept
709   
    {
709   
    {
710   
        return s_.find_first_of(str, pos);
710   
        return s_.find_first_of(str, pos);
711   
    }
711   
    }
712  
712  
713   
    /** Return the position of the first match
713   
    /** Return the position of the first match
714  
714  
715   
        See `core::string_view::find_first_of`
715   
        See `core::string_view::find_first_of`
716  
716  
717   
        @param c The character to search for
717   
        @param c The character to search for
718   
        @param pos The position to start searching from
718   
        @param pos The position to start searching from
719   
        @return The position of the first match
719   
        @return The position of the first match
720   
    */
720   
    */
721   
    BOOST_CONSTEXPR size_type find_first_of(
721   
    BOOST_CONSTEXPR size_type find_first_of(
722   
        char c, size_type pos = 0 ) const noexcept
722   
        char c, size_type pos = 0 ) const noexcept
723   
    {
723   
    {
724   
        return s_.find_first_of(c, pos);
724   
        return s_.find_first_of(c, pos);
725   
    }
725   
    }
726  
726  
727   
    /** Return the position of the first match
727   
    /** Return the position of the first match
728  
728  
729   
        See `core::string_view::find_first_of`
729   
        See `core::string_view::find_first_of`
730  
730  
731   
        @param s The characters to search for
731   
        @param s The characters to search for
732   
        @param pos The position to start searching from
732   
        @param pos The position to start searching from
733   
        @param n The number of characters to search for
733   
        @param n The number of characters to search for
734   
        @return The position of the first match
734   
        @return The position of the first match
735   
    */
735   
    */
736   
    BOOST_CXX14_CONSTEXPR size_type find_first_of(
736   
    BOOST_CXX14_CONSTEXPR size_type find_first_of(
737   
        char const* s, size_type pos, size_type n ) const noexcept
737   
        char const* s, size_type pos, size_type n ) const noexcept
738   
    {
738   
    {
739   
        return s_.find_first_of(s, pos, n);
739   
        return s_.find_first_of(s, pos, n);
740   
    }
740   
    }
741  
741  
742   
    /** Return the position of the first match
742   
    /** Return the position of the first match
743  
743  
744   
        See `core::string_view::find_first_of`
744   
        See `core::string_view::find_first_of`
745  
745  
746   
        @param s The characters to search for
746   
        @param s The characters to search for
747   
        @param pos The position to start searching from
747   
        @param pos The position to start searching from
748   
        @return The position of the first match
748   
        @return The position of the first match
749   
    */
749   
    */
750   
    BOOST_CXX14_CONSTEXPR size_type find_first_of(
750   
    BOOST_CXX14_CONSTEXPR size_type find_first_of(
751   
        char const* s, size_type pos = 0 ) const noexcept
751   
        char const* s, size_type pos = 0 ) const noexcept
752   
    {
752   
    {
753   
        return s_.find_first_of(s, pos);
753   
        return s_.find_first_of(s, pos);
754   
    }
754   
    }
755  
755  
756   
    // find_last_of
756   
    // find_last_of
757  
757  
758   
    /** Return the position of the last match
758   
    /** Return the position of the last match
759  
759  
760   
        See `core::string_view::find_last_of`
760   
        See `core::string_view::find_last_of`
761  
761  
762   
        @param str The characters to search for
762   
        @param str The characters to search for
763   
        @param pos The position to start searching from
763   
        @param pos The position to start searching from
764   
        @return The position of the last match
764   
        @return The position of the last match
765   
    */
765   
    */
766   
    BOOST_CXX14_CONSTEXPR size_type find_last_of(
766   
    BOOST_CXX14_CONSTEXPR size_type find_last_of(
767   
        core::string_view str, size_type pos = core::string_view::npos ) const noexcept
767   
        core::string_view str, size_type pos = core::string_view::npos ) const noexcept
768   
    {
768   
    {
769   
        return s_.find_last_of(str, pos);
769   
        return s_.find_last_of(str, pos);
770   
    }
770   
    }
771  
771  
772   
    /** Return the position of the last match
772   
    /** Return the position of the last match
773  
773  
774   
        See `core::string_view::find_last_of`
774   
        See `core::string_view::find_last_of`
775  
775  
776   
        @param c The character to search for
776   
        @param c The character to search for
777   
        @param pos The position to start searching from
777   
        @param pos The position to start searching from
778   
        @return The position of the last match
778   
        @return The position of the last match
779   
    */
779   
    */
780   
    BOOST_CONSTEXPR size_type find_last_of(
780   
    BOOST_CONSTEXPR size_type find_last_of(
781   
        char c, size_type pos = core::string_view::npos ) const noexcept
781   
        char c, size_type pos = core::string_view::npos ) const noexcept
782   
    {
782   
    {
783   
        return s_.find_last_of(c, pos);
783   
        return s_.find_last_of(c, pos);
784   
    }
784   
    }
785  
785  
786   
    /** Return the position of the last match
786   
    /** Return the position of the last match
787  
787  
788   
        See `core::string_view::find_last_of`
788   
        See `core::string_view::find_last_of`
789  
789  
790   
        @param s The characters to search for
790   
        @param s The characters to search for
791   
        @param pos The position to start searching from
791   
        @param pos The position to start searching from
792   
        @param n The number of characters to search for
792   
        @param n The number of characters to search for
793   
        @return The position of the last match
793   
        @return The position of the last match
794   
    */
794   
    */
795   
    BOOST_CXX14_CONSTEXPR size_type find_last_of(
795   
    BOOST_CXX14_CONSTEXPR size_type find_last_of(
796   
        char const* s, size_type pos, size_type n ) const noexcept
796   
        char const* s, size_type pos, size_type n ) const noexcept
797   
    {
797   
    {
798   
        return s_.find_last_of(s, pos, n);
798   
        return s_.find_last_of(s, pos, n);
799   
    }
799   
    }
800  
800  
801   
    /** Return the position of the last match
801   
    /** Return the position of the last match
802  
802  
803   
        See `core::string_view::find_last_of`
803   
        See `core::string_view::find_last_of`
804  
804  
805   
        @param s The characters to search for
805   
        @param s The characters to search for
806   
        @param pos The position to start searching from
806   
        @param pos The position to start searching from
807   
        @return The position of the last match
807   
        @return The position of the last match
808   
    */
808   
    */
809   
    BOOST_CXX14_CONSTEXPR size_type find_last_of(
809   
    BOOST_CXX14_CONSTEXPR size_type find_last_of(
810   
        char const* s, size_type pos = core::string_view::npos ) const noexcept
810   
        char const* s, size_type pos = core::string_view::npos ) const noexcept
811   
    {
811   
    {
812   
        return s_.find_last_of(s, pos);
812   
        return s_.find_last_of(s, pos);
813   
    }
813   
    }
814  
814  
815   
    // find_first_not_of
815   
    // find_first_not_of
816  
816  
817   
    /** Return the position of the first non-match
817   
    /** Return the position of the first non-match
818  
818  
819   
        See `core::string_view::find_first_not_of`
819   
        See `core::string_view::find_first_not_of`
820  
820  
821   
        @param str The characters to search for
821   
        @param str The characters to search for
822   
        @param pos The position to start searching from
822   
        @param pos The position to start searching from
823   
        @return The position of the first non-match
823   
        @return The position of the first non-match
824   
    */
824   
    */
825   
    BOOST_CXX14_CONSTEXPR size_type find_first_not_of(
825   
    BOOST_CXX14_CONSTEXPR size_type find_first_not_of(
826   
        core::string_view str, size_type pos = 0 ) const noexcept
826   
        core::string_view str, size_type pos = 0 ) const noexcept
827   
    {
827   
    {
828   
        return s_.find_first_not_of(str, pos);
828   
        return s_.find_first_not_of(str, pos);
829   
    }
829   
    }
830  
830  
831   
    /** Return the position of the first non-match
831   
    /** Return the position of the first non-match
832  
832  
833   
        See `core::string_view::find_first_not_of`
833   
        See `core::string_view::find_first_not_of`
834  
834  
835   
        @param c The character to search for
835   
        @param c The character to search for
836   
        @param pos The position to start searching from
836   
        @param pos The position to start searching from
837   
        @return The position of the first non-match
837   
        @return The position of the first non-match
838   
    */
838   
    */
839   
    BOOST_CXX14_CONSTEXPR size_type find_first_not_of(
839   
    BOOST_CXX14_CONSTEXPR size_type find_first_not_of(
840   
        char c, size_type pos = 0 ) const noexcept
840   
        char c, size_type pos = 0 ) const noexcept
841   
    {
841   
    {
842   
        return s_.find_first_not_of(c, pos);
842   
        return s_.find_first_not_of(c, pos);
843   
    }
843   
    }
844  
844  
845   
    /** Return the position of the first non-match
845   
    /** Return the position of the first non-match
846  
846  
847   
        See `core::string_view::find_first_not_of`
847   
        See `core::string_view::find_first_not_of`
848  
848  
849   
        @param s The characters to search for
849   
        @param s The characters to search for
850   
        @param pos The position to start searching from
850   
        @param pos The position to start searching from
851   
        @param n The number of characters to search for
851   
        @param n The number of characters to search for
852   
        @return The position of the first non-match
852   
        @return The position of the first non-match
853   
    */
853   
    */
854   
    BOOST_CXX14_CONSTEXPR size_type find_first_not_of(
854   
    BOOST_CXX14_CONSTEXPR size_type find_first_not_of(
855   
        char const* s, size_type pos, size_type n ) const noexcept
855   
        char const* s, size_type pos, size_type n ) const noexcept
856   
    {
856   
    {
857   
        return s_.find_first_not_of(s, pos, n);
857   
        return s_.find_first_not_of(s, pos, n);
858   
    }
858   
    }
859  
859  
860   
    /** Return the position of the first non-match
860   
    /** Return the position of the first non-match
861  
861  
862   
        See `core::string_view::find_first_not_of`
862   
        See `core::string_view::find_first_not_of`
863  
863  
864   
        @param s The characters to search for
864   
        @param s The characters to search for
865   
        @param pos The position to start searching from
865   
        @param pos The position to start searching from
866   
        @return The position of the first non-match
866   
        @return The position of the first non-match
867   
    */
867   
    */
868   
    BOOST_CXX14_CONSTEXPR size_type find_first_not_of(
868   
    BOOST_CXX14_CONSTEXPR size_type find_first_not_of(
869   
        char const* s, size_type pos = 0 ) const noexcept
869   
        char const* s, size_type pos = 0 ) const noexcept
870   
    {
870   
    {
871   
        return s_.find_first_not_of(s, pos);
871   
        return s_.find_first_not_of(s, pos);
872   
    }
872   
    }
873  
873  
874   
    // find_last_not_of
874   
    // find_last_not_of
875  
875  
876   
    /** Return the position of the last non-match
876   
    /** Return the position of the last non-match
877  
877  
878   
        See `core::string_view::find_last_not_of`
878   
        See `core::string_view::find_last_not_of`
879  
879  
880   
        @param str The characters to search for
880   
        @param str The characters to search for
881   
        @param pos The position to start searching from
881   
        @param pos The position to start searching from
882   
        @return The position of the last non-match
882   
        @return The position of the last non-match
883   
    */
883   
    */
884   
    BOOST_CXX14_CONSTEXPR size_type find_last_not_of(
884   
    BOOST_CXX14_CONSTEXPR size_type find_last_not_of(
885   
        core::string_view str, size_type pos = core::string_view::npos ) const noexcept
885   
        core::string_view str, size_type pos = core::string_view::npos ) const noexcept
886   
    {
886   
    {
887   
        return s_.find_last_not_of(str, pos);
887   
        return s_.find_last_not_of(str, pos);
888   
    }
888   
    }
889  
889  
890   
    /** Return the position of the last non-match
890   
    /** Return the position of the last non-match
891  
891  
892   
        See `core::string_view::find_last_not_of`
892   
        See `core::string_view::find_last_not_of`
893  
893  
894   
        @param c The character to search for
894   
        @param c The character to search for
895   
        @param pos The position to start searching from
895   
        @param pos The position to start searching from
896   
        @return The position of the last non-match
896   
        @return The position of the last non-match
897   
    */
897   
    */
898   
    BOOST_CXX14_CONSTEXPR size_type find_last_not_of(
898   
    BOOST_CXX14_CONSTEXPR size_type find_last_not_of(
899   
        char c, size_type pos = core::string_view::npos ) const noexcept
899   
        char c, size_type pos = core::string_view::npos ) const noexcept
900   
    {
900   
    {
901   
        return s_.find_last_not_of(c, pos);
901   
        return s_.find_last_not_of(c, pos);
902   
    }
902   
    }
903  
903  
904   
    /** Return the position of the last non-match
904   
    /** Return the position of the last non-match
905  
905  
906   
        See `core::string_view::find_last_not_of`
906   
        See `core::string_view::find_last_not_of`
907  
907  
908   
        @param s The characters to search for
908   
        @param s The characters to search for
909   
        @param pos The position to start searching from
909   
        @param pos The position to start searching from
910   
        @param n The number of characters to search for
910   
        @param n The number of characters to search for
911   
        @return The position of the last non-match
911   
        @return The position of the last non-match
912   
    */
912   
    */
913   
    BOOST_CXX14_CONSTEXPR size_type find_last_not_of(
913   
    BOOST_CXX14_CONSTEXPR size_type find_last_not_of(
914   
        char const* s, size_type pos, size_type n ) const noexcept
914   
        char const* s, size_type pos, size_type n ) const noexcept
915   
    {
915   
    {
916   
        return s_.find_last_not_of(s, pos, n);
916   
        return s_.find_last_not_of(s, pos, n);
917   
    }
917   
    }
918  
918  
919   
    /** Return the position of the last non-match
919   
    /** Return the position of the last non-match
920  
920  
921   
        See `core::string_view::find_last_not_of`
921   
        See `core::string_view::find_last_not_of`
922  
922  
923   
        @param s The characters to search for
923   
        @param s The characters to search for
924   
        @param pos The position to start searching from
924   
        @param pos The position to start searching from
925   
        @return The position of the last non-match
925   
        @return The position of the last non-match
926   
    */
926   
    */
927   
    BOOST_CXX14_CONSTEXPR size_type find_last_not_of(
927   
    BOOST_CXX14_CONSTEXPR size_type find_last_not_of(
928   
        char const* s, size_type pos = core::string_view::npos ) const noexcept
928   
        char const* s, size_type pos = core::string_view::npos ) const noexcept
929   
    {
929   
    {
930   
        return s_.find_last_not_of(s, pos);
930   
        return s_.find_last_not_of(s, pos);
931   
    }
931   
    }
932  
932  
933   
    // contains
933   
    // contains
934  
934  
935   
    /** Return true if matching characters are found
935   
    /** Return true if matching characters are found
936  
936  
937   
        See `core::string_view::contains`
937   
        See `core::string_view::contains`
938  
938  
939   
        @param sv The string to search for
939   
        @param sv The string to search for
940   
        @return `true` if the string contains the characters, otherwise `false`
940   
        @return `true` if the string contains the characters, otherwise `false`
941   
    */
941   
    */
942   
    BOOST_CONSTEXPR bool contains( core::string_view sv ) const noexcept
942   
    BOOST_CONSTEXPR bool contains( core::string_view sv ) const noexcept
943   
    {
943   
    {
944   
        return s_.contains(sv);
944   
        return s_.contains(sv);
945   
    }
945   
    }
946  
946  
947   
    /** Return true if matching characters are found
947   
    /** Return true if matching characters are found
948  
948  
949   
        See `core::string_view::contains`
949   
        See `core::string_view::contains`
950  
950  
951   
        @param c The character to search for
951   
        @param c The character to search for
952   
        @return `true` if the string contains the character, otherwise `false`
952   
        @return `true` if the string contains the character, otherwise `false`
953   
    */
953   
    */
954   
    BOOST_CXX14_CONSTEXPR bool contains( char c ) const noexcept
954   
    BOOST_CXX14_CONSTEXPR bool contains( char c ) const noexcept
955   
    {
955   
    {
956   
        return s_.contains(c);
956   
        return s_.contains(c);
957   
    }
957   
    }
958  
958  
959   
    /** Return true if matching characters are found
959   
    /** Return true if matching characters are found
960  
960  
961   
        See `core::string_view::contains`
961   
        See `core::string_view::contains`
962  
962  
963   
        @param s The string to search for
963   
        @param s The string to search for
964   
        @return `true` if the string contains the characters, otherwise `false`
964   
        @return `true` if the string contains the characters, otherwise `false`
965   
    */
965   
    */
966   
    BOOST_CONSTEXPR bool contains( char const* s ) const noexcept
966   
    BOOST_CONSTEXPR bool contains( char const* s ) const noexcept
967   
    {
967   
    {
968   
        return s_.contains(s);
968   
        return s_.contains(s);
969   
    }
969   
    }
970  
970  
971   
    // relational operators
971   
    // relational operators
972   
#ifndef BOOST_URL_DOCS
972   
#ifndef BOOST_URL_DOCS
973   
private:
973   
private:
974   
    template<class S0, class S1>
974   
    template<class S0, class S1>
975   
    using is_match = std::integral_constant<bool,
975   
    using is_match = std::integral_constant<bool,
976   
        std::is_convertible<S0, core::string_view>::value &&
976   
        std::is_convertible<S0, core::string_view>::value &&
977   
        std::is_convertible<S1, core::string_view>::value && (
977   
        std::is_convertible<S1, core::string_view>::value && (
978   
            (std::is_base_of<string_view_base,
978   
            (std::is_base_of<string_view_base,
979   
                typename std::decay<S0>::type>::value &&
979   
                typename std::decay<S0>::type>::value &&
980   
            std::is_convertible<S0 const volatile*,
980   
            std::is_convertible<S0 const volatile*,
981   
                string_view_base const volatile*>::value) ||
981   
                string_view_base const volatile*>::value) ||
982   
            (std::is_base_of<string_view_base,
982   
            (std::is_base_of<string_view_base,
983   
                typename std::decay<S1>::type>::value &&
983   
                typename std::decay<S1>::type>::value &&
984   
            std::is_convertible<S1 const volatile*,
984   
            std::is_convertible<S1 const volatile*,
985   
                string_view_base const volatile*>::value))>;
985   
                string_view_base const volatile*>::value))>;
986   
public:
986   
public:
987  
987  
988   
    /** Compare two string views for equality
988   
    /** Compare two string views for equality
989  
989  
990   
        This function is only enabled if both arguments
990   
        This function is only enabled if both arguments
991   
        are convertible to `core::string_view` and at least
991   
        are convertible to `core::string_view` and at least
992   
        one of the arguments is derived from `string_view_base`.
992   
        one of the arguments is derived from `string_view_base`.
993  
993  
994   
        @param s0 The first string
994   
        @param s0 The first string
995   
        @param s1 The second string
995   
        @param s1 The second string
996   
        @return `true` if the strings are equal, otherwise `false`
996   
        @return `true` if the strings are equal, otherwise `false`
997   
     */
997   
     */
998   
    template<class S0, class S1>
998   
    template<class S0, class S1>
999   
    BOOST_CXX14_CONSTEXPR friend auto operator==(
999   
    BOOST_CXX14_CONSTEXPR friend auto operator==(
1000   
        S0 const& s0, S1 const& s1) noexcept ->
1000   
        S0 const& s0, S1 const& s1) noexcept ->
1001   
        typename std::enable_if<
1001   
        typename std::enable_if<
1002   
            is_match<S0, S1>::value, bool>::type
1002   
            is_match<S0, S1>::value, bool>::type
1003   
    {
1003   
    {
1004   
        return urls::detail::to_sv(s0) == urls::detail::to_sv(s1);
1004   
        return urls::detail::to_sv(s0) == urls::detail::to_sv(s1);
1005   
    }
1005   
    }
1006  
1006  
1007   
    /** Compare two string views for inequality
1007   
    /** Compare two string views for inequality
1008  
1008  
1009   
        This function is only enabled if both arguments
1009   
        This function is only enabled if both arguments
1010   
        are convertible to `core::string_view` and at least
1010   
        are convertible to `core::string_view` and at least
1011   
        one of the arguments is derived from `string_view_base`.
1011   
        one of the arguments is derived from `string_view_base`.
1012  
1012  
1013   
        @param s0 The first string
1013   
        @param s0 The first string
1014   
        @param s1 The second string
1014   
        @param s1 The second string
1015   
        @return `true` if the strings are not equal, otherwise `false`
1015   
        @return `true` if the strings are not equal, otherwise `false`
1016   
     */
1016   
     */
1017   
    template<class S0, class S1>
1017   
    template<class S0, class S1>
1018   
    BOOST_CXX14_CONSTEXPR friend auto operator!=(
1018   
    BOOST_CXX14_CONSTEXPR friend auto operator!=(
1019   
        S0 const& s0, S1 const& s1) noexcept ->
1019   
        S0 const& s0, S1 const& s1) noexcept ->
1020   
        typename std::enable_if<
1020   
        typename std::enable_if<
1021   
            is_match<S0, S1>::value, bool>::type
1021   
            is_match<S0, S1>::value, bool>::type
1022   
    {
1022   
    {
1023   
        return urls::detail::to_sv(s0) != urls::detail::to_sv(s1);
1023   
        return urls::detail::to_sv(s0) != urls::detail::to_sv(s1);
1024   
    }
1024   
    }
1025  
1025  
1026   
    /** Compare two string views for less than
1026   
    /** Compare two string views for less than
1027  
1027  
1028   
        This function is only enabled if both arguments
1028   
        This function is only enabled if both arguments
1029   
        are convertible to `core::string_view` and at least
1029   
        are convertible to `core::string_view` and at least
1030   
        one of the arguments is derived from `string_view_base`.
1030   
        one of the arguments is derived from `string_view_base`.
1031  
1031  
1032   
        @param s0 The first string
1032   
        @param s0 The first string
1033   
        @param s1 The second string
1033   
        @param s1 The second string
1034   
        @return `true` if the first string is less than the second, otherwise `false`
1034   
        @return `true` if the first string is less than the second, otherwise `false`
1035   
     */
1035   
     */
1036   
    template<class S0, class S1>
1036   
    template<class S0, class S1>
1037   
    BOOST_CXX14_CONSTEXPR friend auto operator<(
1037   
    BOOST_CXX14_CONSTEXPR friend auto operator<(
1038   
        S0 const& s0, S1 const& s1) noexcept ->
1038   
        S0 const& s0, S1 const& s1) noexcept ->
1039   
        typename std::enable_if<
1039   
        typename std::enable_if<
1040   
            is_match<S0, S1>::value, bool>::type
1040   
            is_match<S0, S1>::value, bool>::type
1041   
    {
1041   
    {
1042   
        return urls::detail::to_sv(s0) < urls::detail::to_sv(s1);
1042   
        return urls::detail::to_sv(s0) < urls::detail::to_sv(s1);
1043   
    }
1043   
    }
1044  
1044  
1045   
    /** Compare two string views for less than or equal
1045   
    /** Compare two string views for less than or equal
1046  
1046  
1047   
        This function is only enabled if both arguments
1047   
        This function is only enabled if both arguments
1048   
        are convertible to `core::string_view` and at least
1048   
        are convertible to `core::string_view` and at least
1049   
        one of the arguments is derived from `string_view_base`.
1049   
        one of the arguments is derived from `string_view_base`.
1050  
1050  
1051   
        @param s0 The first string
1051   
        @param s0 The first string
1052   
        @param s1 The second string
1052   
        @param s1 The second string
1053   
        @return `true` if the first string is less than or equal to the second, otherwise `false`
1053   
        @return `true` if the first string is less than or equal to the second, otherwise `false`
1054   
     */
1054   
     */
1055   
    template<class S0, class S1>
1055   
    template<class S0, class S1>
1056   
    BOOST_CXX14_CONSTEXPR friend auto operator<=(
1056   
    BOOST_CXX14_CONSTEXPR friend auto operator<=(
1057   
        S0 const& s0, S1 const& s1) noexcept ->
1057   
        S0 const& s0, S1 const& s1) noexcept ->
1058   
        typename std::enable_if<
1058   
        typename std::enable_if<
1059   
            is_match<S0, S1>::value, bool>::type
1059   
            is_match<S0, S1>::value, bool>::type
1060   
    {
1060   
    {
1061   
        return urls::detail::to_sv(s0) <= urls::detail::to_sv(s1);
1061   
        return urls::detail::to_sv(s0) <= urls::detail::to_sv(s1);
1062   
    }
1062   
    }
1063  
1063  
1064   
    /** Compare two string views for greater than
1064   
    /** Compare two string views for greater than
1065  
1065  
1066   
        This function is only enabled if both arguments
1066   
        This function is only enabled if both arguments
1067   
        are convertible to `core::string_view` and at least
1067   
        are convertible to `core::string_view` and at least
1068   
        one of the arguments is derived from `string_view_base`.
1068   
        one of the arguments is derived from `string_view_base`.
1069  
1069  
1070   
        @param s0 The first string
1070   
        @param s0 The first string
1071   
        @param s1 The second string
1071   
        @param s1 The second string
1072   
        @return `true` if the first string is greater than the second, otherwise `false`
1072   
        @return `true` if the first string is greater than the second, otherwise `false`
1073   
     */
1073   
     */
1074   
    template<class S0, class S1>
1074   
    template<class S0, class S1>
1075   
    BOOST_CXX14_CONSTEXPR friend auto operator>(
1075   
    BOOST_CXX14_CONSTEXPR friend auto operator>(
1076   
        S0 const& s0, S1 const& s1) noexcept ->
1076   
        S0 const& s0, S1 const& s1) noexcept ->
1077   
        typename std::enable_if<
1077   
        typename std::enable_if<
1078   
            is_match<S0, S1>::value, bool>::type
1078   
            is_match<S0, S1>::value, bool>::type
1079   
    {
1079   
    {
1080   
        return urls::detail::to_sv(s0) > urls::detail::to_sv(s1);
1080   
        return urls::detail::to_sv(s0) > urls::detail::to_sv(s1);
1081   
    }
1081   
    }
1082  
1082  
1083   
    /** Compare two string views for greater than or equal
1083   
    /** Compare two string views for greater than or equal
1084  
1084  
1085   
        This function is only enabled if both arguments
1085   
        This function is only enabled if both arguments
1086   
        are convertible to `core::string_view` and at least
1086   
        are convertible to `core::string_view` and at least
1087   
        one of the arguments is derived from `string_view_base`.
1087   
        one of the arguments is derived from `string_view_base`.
1088  
1088  
1089   
        @param s0 The first string
1089   
        @param s0 The first string
1090   
        @param s1 The second string
1090   
        @param s1 The second string
1091   
        @return `true` if the first string is greater than or equal to the second, otherwise `false`
1091   
        @return `true` if the first string is greater than or equal to the second, otherwise `false`
1092   
     */
1092   
     */
1093   
    template<class S0, class S1>
1093   
    template<class S0, class S1>
1094   
    BOOST_CXX14_CONSTEXPR friend auto operator>=(
1094   
    BOOST_CXX14_CONSTEXPR friend auto operator>=(
1095   
        S0 const& s0, S1 const& s1) noexcept ->
1095   
        S0 const& s0, S1 const& s1) noexcept ->
1096   
        typename std::enable_if<
1096   
        typename std::enable_if<
1097   
            is_match<S0, S1>::value, bool>::type
1097   
            is_match<S0, S1>::value, bool>::type
1098   
    {
1098   
    {
1099   
        return urls::detail::to_sv(s0) >= urls::detail::to_sv(s1);
1099   
        return urls::detail::to_sv(s0) >= urls::detail::to_sv(s1);
1100   
    }
1100   
    }
1101   
#endif
1101   
#endif
1102  
1102  
1103   
    //--------------------------------------------
1103   
    //--------------------------------------------
1104  
1104  
1105   
    /** Format a string to an output stream
1105   
    /** Format a string to an output stream
1106  
1106  
1107   
        @param os The output stream to write to
1107   
        @param os The output stream to write to
1108   
        @param s The string to write
1108   
        @param s The string to write
1109   
        @return A reference to the output stream, for chaining
1109   
        @return A reference to the output stream, for chaining
1110   
     */
1110   
     */
1111   
    BOOST_URL_DECL
1111   
    BOOST_URL_DECL
1112   
    friend
1112   
    friend
1113   
    std::ostream&
1113   
    std::ostream&
1114   
    operator<<(
1114   
    operator<<(
1115   
        std::ostream& os,
1115   
        std::ostream& os,
1116   
        string_view_base const& s);
1116   
        string_view_base const& s);
1117   
};
1117   
};
1118  
1118  
1119   
//------------------------------------------------
1119   
//------------------------------------------------
1120  
1120  
1121   
/** Format a string to an output stream
1121   
/** Format a string to an output stream
1122   
*/
1122   
*/
1123   
BOOST_URL_DECL
1123   
BOOST_URL_DECL
1124   
std::ostream&
1124   
std::ostream&
1125   
operator<<(
1125   
operator<<(
1126   
    std::ostream& os,
1126   
    std::ostream& os,
1127   
    string_view_base const& s);
1127   
    string_view_base const& s);
1128  
1128  
1129   
} // grammar
1129   
} // grammar
1130  
1130  
1131   
#ifndef BOOST_URL_DOCS
1131   
#ifndef BOOST_URL_DOCS
1132   
namespace detail {
1132   
namespace detail {
1133   
template <>
1133   
template <>
1134   
inline
1134   
inline
1135   
core::string_view
1135   
core::string_view
1136   
to_sv(grammar::string_view_base const& s) noexcept
1136   
to_sv(grammar::string_view_base const& s) noexcept
1137   
{
1137   
{
1138   
    return s.operator core::string_view();
1138   
    return s.operator core::string_view();
1139   
}
1139   
}
1140   
} // detail
1140   
} // detail
1141   
#endif
1141   
#endif
1142  
1142  
1143   
} // urls
1143   
} // urls
1144   
} // boost
1144   
} // boost
1145  
1145  
1146   
#endif
1146   
#endif