• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_STRING_VIEW
11#define _LIBCPP_STRING_VIEW
12
13// clang-format off
14
15/*
16
17    string_view synopsis
18
19#include <compare>
20
21namespace std {
22
23    // 7.2, Class template basic_string_view
24    template<class charT, class traits = char_traits<charT>>
25        class basic_string_view;
26
27    template<class charT, class traits>
28    inline constexpr bool ranges::enable_view<basic_string_view<charT, traits>> = true;
29
30    template<class charT, class traits>
31    inline constexpr bool ranges::enable_borrowed_range<basic_string_view<charT, traits>> = true;  // C++20
32
33    // 7.9, basic_string_view non-member comparison functions
34    template<class charT, class traits>
35    constexpr bool operator==(basic_string_view<charT, traits> x,
36                              basic_string_view<charT, traits> y) noexcept;
37    template<class charT, class traits>                                                            // Removed in C++20
38    constexpr bool operator!=(basic_string_view<charT, traits> x,
39                              basic_string_view<charT, traits> y) noexcept;
40    template<class charT, class traits>                                                            // Removed in C++20
41    constexpr bool operator< (basic_string_view<charT, traits> x,
42                                 basic_string_view<charT, traits> y) noexcept;
43    template<class charT, class traits>                                                            // Removed in C++20
44    constexpr bool operator> (basic_string_view<charT, traits> x,
45                              basic_string_view<charT, traits> y) noexcept;
46    template<class charT, class traits>                                                            // Removed in C++20
47    constexpr bool operator<=(basic_string_view<charT, traits> x,
48                                 basic_string_view<charT, traits> y) noexcept;
49    template<class charT, class traits>                                                            // Removed in C++20
50    constexpr bool operator>=(basic_string_view<charT, traits> x,
51                              basic_string_view<charT, traits> y) noexcept;
52    template<class charT, class traits>                                                            // Since C++20
53    constexpr see below operator<=>(basic_string_view<charT, traits> x,
54                                    basic_string_view<charT, traits> y) noexcept;
55
56    // see below, sufficient additional overloads of comparison functions
57
58    // 7.10, Inserters and extractors
59    template<class charT, class traits>
60      basic_ostream<charT, traits>&
61        operator<<(basic_ostream<charT, traits>& os,
62                   basic_string_view<charT, traits> str);
63
64    // basic_string_view typedef names
65    typedef basic_string_view<char> string_view;
66    typedef basic_string_view<char8_t> u8string_view; // C++20
67    typedef basic_string_view<char16_t> u16string_view;
68    typedef basic_string_view<char32_t> u32string_view;
69    typedef basic_string_view<wchar_t> wstring_view;
70
71    template<class charT, class traits = char_traits<charT>>
72    class basic_string_view {
73      public:
74      // types
75      typedef traits traits_type;
76      typedef charT value_type;
77      typedef charT* pointer;
78      typedef const charT* const_pointer;
79      typedef charT& reference;
80      typedef const charT& const_reference;
81      typedef implementation-defined const_iterator;
82      typedef const_iterator iterator;
83      typedef reverse_iterator<const_iterator> const_reverse_iterator;
84      typedef const_reverse_iterator reverse_iterator;
85      typedef size_t size_type;
86      typedef ptrdiff_t difference_type;
87      static constexpr size_type npos = size_type(-1);
88
89      // 7.3, basic_string_view constructors and assignment operators
90      constexpr basic_string_view() noexcept;
91      constexpr basic_string_view(const basic_string_view&) noexcept = default;
92      basic_string_view& operator=(const basic_string_view&) noexcept = default;
93      template<class Allocator>
94      constexpr basic_string_view(const charT* str);
95      basic_string_view(nullptr_t) = delete; // C++23
96      constexpr basic_string_view(const charT* str, size_type len);
97      template <class It, class End>
98      constexpr basic_string_view(It begin, End end); // C++20
99      template <class Range>
100      constexpr basic_string_view(Range&& r); // C++23
101
102      // 7.4, basic_string_view iterator support
103      constexpr const_iterator begin() const noexcept;
104      constexpr const_iterator end() const noexcept;
105      constexpr const_iterator cbegin() const noexcept;
106      constexpr const_iterator cend() const noexcept;
107      const_reverse_iterator rbegin() const noexcept;
108      const_reverse_iterator rend() const noexcept;
109      const_reverse_iterator crbegin() const noexcept;
110      const_reverse_iterator crend() const noexcept;
111
112      // 7.5, basic_string_view capacity
113      constexpr size_type size() const noexcept;
114      constexpr size_type length() const noexcept;
115      constexpr size_type max_size() const noexcept;
116      constexpr bool empty() const noexcept;
117
118      // 7.6, basic_string_view element access
119      constexpr const_reference operator[](size_type pos) const;
120      constexpr const_reference at(size_type pos) const;
121      constexpr const_reference front() const;
122      constexpr const_reference back() const;
123      constexpr const_pointer data() const noexcept;
124
125      // 7.7, basic_string_view modifiers
126      constexpr void remove_prefix(size_type n);
127      constexpr void remove_suffix(size_type n);
128      constexpr void swap(basic_string_view& s) noexcept;
129
130      size_type copy(charT* s, size_type n, size_type pos = 0) const;  // constexpr in C++20
131
132      constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
133      constexpr int compare(basic_string_view s) const noexcept;
134      constexpr int compare(size_type pos1, size_type n1, basic_string_view s) const;
135      constexpr int compare(size_type pos1, size_type n1,
136                            basic_string_view s, size_type pos2, size_type n2) const;
137      constexpr int compare(const charT* s) const;
138      constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
139      constexpr int compare(size_type pos1, size_type n1,
140                            const charT* s, size_type n2) const;
141      constexpr size_type find(basic_string_view s, size_type pos = 0) const noexcept;
142      constexpr size_type find(charT c, size_type pos = 0) const noexcept;
143      constexpr size_type find(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
144      constexpr size_type find(const charT* s, size_type pos = 0) const noexcept; // noexcept as an extension
145      constexpr size_type rfind(basic_string_view s, size_type pos = npos) const noexcept;
146      constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
147      constexpr size_type rfind(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
148      constexpr size_type rfind(const charT* s, size_type pos = npos) const noexcept; // noexcept as an extension
149      constexpr size_type find_first_of(basic_string_view s, size_type pos = 0) const noexcept;
150      constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
151      constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
152      constexpr size_type find_first_of(const charT* s, size_type pos = 0) const noexcept; // noexcept as an extension
153      constexpr size_type find_last_of(basic_string_view s, size_type pos = npos) const noexcept;
154      constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
155      constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
156      constexpr size_type find_last_of(const charT* s, size_type pos = npos) const noexcept; // noexcept as an extension
157      constexpr size_type find_first_not_of(basic_string_view s, size_type pos = 0) const noexcept;
158      constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
159      constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
160      constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const noexcept; // noexcept as an extension
161      constexpr size_type find_last_not_of(basic_string_view s, size_type pos = npos) const noexcept;
162      constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
163      constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
164      constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const noexcept; // noexcept as an extension
165
166      constexpr bool starts_with(basic_string_view s) const noexcept; // C++20
167      constexpr bool starts_with(charT c) const noexcept;             // C++20
168      constexpr bool starts_with(const charT* s) const;               // C++20
169      constexpr bool ends_with(basic_string_view s) const noexcept;   // C++20
170      constexpr bool ends_with(charT c) const noexcept;               // C++20
171      constexpr bool ends_with(const charT* s) const;                 // C++20
172
173      constexpr bool contains(basic_string_view s) const noexcept; // C++23
174      constexpr bool contains(charT c) const noexcept;             // C++23
175      constexpr bool contains(const charT* s) const;               // C++23
176
177     private:
178      const_pointer data_;  // exposition only
179      size_type     size_;  // exposition only
180    };
181
182  // basic_string_view deduction guides
183  template<class It, class End>
184    basic_string_view(It, End) -> basic_string_view<iter_value_t<It>>; // C++20
185  template<class Range>
186    basic_string_view(Range&&) -> basic_string_view<ranges::range_value_t<Range>>; // C++23
187
188  // 7.11, Hash support
189  template <class T> struct hash;
190  template <> struct hash<string_view>;
191  template <> struct hash<u8string_view>; // C++20
192  template <> struct hash<u16string_view>;
193  template <> struct hash<u32string_view>;
194  template <> struct hash<wstring_view>;
195
196  constexpr basic_string_view<char>     operator""sv(const char *str,     size_t len) noexcept;
197  constexpr basic_string_view<wchar_t>  operator""sv(const wchar_t *str,  size_t len) noexcept;
198  constexpr basic_string_view<char8_t>  operator""sv(const char8_t *str,  size_t len) noexcept; // C++20
199  constexpr basic_string_view<char16_t> operator""sv(const char16_t *str, size_t len) noexcept;
200  constexpr basic_string_view<char32_t> operator""sv(const char32_t *str, size_t len) noexcept;
201
202}  // namespace std
203
204*/
205
206// clang-format on
207
208#include <__algorithm/min.h>
209#include <__assert>
210#include <__config>
211#include <__cstddef/nullptr_t.h>
212#include <__cstddef/ptrdiff_t.h>
213#include <__cstddef/size_t.h>
214#include <__functional/hash.h>
215#include <__functional/unary_function.h>
216#include <__fwd/ostream.h>
217#include <__fwd/string.h>
218#include <__fwd/string_view.h>
219#include <__iterator/bounded_iter.h>
220#include <__iterator/concepts.h>
221#include <__iterator/iterator_traits.h>
222#include <__iterator/reverse_iterator.h>
223#include <__iterator/wrap_iter.h>
224#include <__memory/pointer_traits.h>
225#include <__ranges/concepts.h>
226#include <__ranges/data.h>
227#include <__ranges/enable_borrowed_range.h>
228#include <__ranges/enable_view.h>
229#include <__ranges/size.h>
230#include <__string/char_traits.h>
231#include <__type_traits/is_array.h>
232#include <__type_traits/is_convertible.h>
233#include <__type_traits/is_same.h>
234#include <__type_traits/is_standard_layout.h>
235#include <__type_traits/is_trivial.h>
236#include <__type_traits/remove_cvref.h>
237#include <__type_traits/remove_reference.h>
238#include <__type_traits/type_identity.h>
239#include <iosfwd>
240#include <limits>
241#include <stdexcept>
242#include <version>
243
244// standard-mandated includes
245
246// [iterator.range]
247#include <__iterator/access.h>
248#include <__iterator/data.h>
249#include <__iterator/empty.h>
250#include <__iterator/reverse_access.h>
251#include <__iterator/size.h>
252
253// [string.view.synop]
254#include <compare>
255
256#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
257#  pragma GCC system_header
258#endif
259
260_LIBCPP_PUSH_MACROS
261#include <__undef_macros>
262
263_LIBCPP_BEGIN_NAMESPACE_STD
264
265// TODO: This is a workaround for some vendors to carry a downstream diff to accept `nullptr` in
266//       string_view constructors. This can be refactored when this exact form isn't needed anymore.
267template <class _Traits>
268_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR inline size_t
269__char_traits_length_checked(const typename _Traits::char_type* __s) _NOEXCEPT {
270  // This needs to be a single statement for C++11 constexpr
271  return _LIBCPP_ASSERT_NON_NULL(
272             __s != nullptr, "null pointer passed to non-null argument of char_traits<...>::length"),
273         _Traits::length(__s);
274}
275
276template <class _CharT, class _Traits>
277class basic_string_view {
278public:
279  // types
280  using traits_type     = _Traits;
281  using value_type      = _CharT;
282  using pointer         = _CharT*;
283  using const_pointer   = const _CharT*;
284  using reference       = _CharT&;
285  using const_reference = const _CharT&;
286#if defined(_LIBCPP_ABI_BOUNDED_ITERATORS)
287  using const_iterator = __bounded_iter<const_pointer>;
288#elif defined(_LIBCPP_ABI_USE_WRAP_ITER_IN_STD_STRING_VIEW)
289  using const_iterator = __wrap_iter<const_pointer>;
290#else
291  using const_iterator = const_pointer;
292#endif
293  using iterator                                = const_iterator;
294  using const_reverse_iterator                  = std::reverse_iterator<const_iterator>;
295  using reverse_iterator                        = const_reverse_iterator;
296  using size_type                               = size_t;
297  using difference_type                         = ptrdiff_t;
298  static _LIBCPP_CONSTEXPR const size_type npos = -1; // size_type(-1);
299
300  static_assert(!is_array<value_type>::value, "Character type of basic_string_view must not be an array");
301  static_assert(is_standard_layout<value_type>::value, "Character type of basic_string_view must be standard-layout");
302  static_assert(is_trivial<value_type>::value, "Character type of basic_string_view must be trivial");
303  static_assert(is_same<_CharT, typename traits_type::char_type>::value,
304                "traits_type::char_type must be the same type as CharT");
305
306  // [string.view.cons], construct/copy
307  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI basic_string_view() _NOEXCEPT : __data_(nullptr), __size_(0) {}
308
309  _LIBCPP_HIDE_FROM_ABI basic_string_view(const basic_string_view&) _NOEXCEPT = default;
310
311  _LIBCPP_HIDE_FROM_ABI basic_string_view& operator=(const basic_string_view&) _NOEXCEPT = default;
312
313  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI basic_string_view(const _CharT* __s, size_type __len) _NOEXCEPT
314      : __data_(__s),
315        __size_(__len) {
316#if _LIBCPP_STD_VER >= 14
317    // Allocations must fit in `ptrdiff_t` for pointer arithmetic to work. If `__len` exceeds it, the input
318    // range could not have been valid. Most likely the caller underflowed some arithmetic and inadvertently
319    // passed in a negative length.
320    _LIBCPP_ASSERT_VALID_INPUT_RANGE(
321        __len <= static_cast<size_type>(numeric_limits<difference_type>::max()),
322        "string_view::string_view(_CharT *, size_t): length does not fit in difference_type");
323    _LIBCPP_ASSERT_NON_NULL(
324        __len == 0 || __s != nullptr, "string_view::string_view(_CharT *, size_t): received nullptr");
325#endif
326  }
327
328#if _LIBCPP_STD_VER >= 20
329  template <contiguous_iterator _It, sized_sentinel_for<_It> _End>
330    requires(is_same_v<iter_value_t<_It>, _CharT> && !is_convertible_v<_End, size_type>)
331  constexpr _LIBCPP_HIDE_FROM_ABI basic_string_view(_It __begin, _End __end)
332      : __data_(std::to_address(__begin)), __size_(__end - __begin) {
333    _LIBCPP_ASSERT_VALID_INPUT_RANGE(
334        (__end - __begin) >= 0, "std::string_view::string_view(iterator, sentinel) received invalid range");
335  }
336#endif // _LIBCPP_STD_VER >= 20
337
338#if _LIBCPP_STD_VER >= 23
339  template <class _Range>
340    requires(!is_same_v<remove_cvref_t<_Range>, basic_string_view> && ranges::contiguous_range<_Range> &&
341             ranges::sized_range<_Range> && is_same_v<ranges::range_value_t<_Range>, _CharT> &&
342             !is_convertible_v<_Range, const _CharT*> &&
343             (!requires(remove_cvref_t<_Range>& __d) { __d.operator std::basic_string_view<_CharT, _Traits>(); }))
344  constexpr explicit _LIBCPP_HIDE_FROM_ABI basic_string_view(_Range&& __r)
345      : __data_(ranges::data(__r)), __size_(ranges::size(__r)) {}
346#endif // _LIBCPP_STD_VER >= 23
347
348  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI basic_string_view(const _CharT* __s)
349      : __data_(__s), __size_(std::__char_traits_length_checked<_Traits>(__s)) {}
350
351#if _LIBCPP_STD_VER >= 23
352  basic_string_view(nullptr_t) = delete;
353#endif
354
355  // [string.view.iterators], iterators
356  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return cbegin(); }
357
358  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return cend(); }
359
360  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT {
361#ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
362    return std::__make_bounded_iter(data(), data(), data() + size());
363#else
364    return const_iterator(__data_);
365#endif
366  }
367
368  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT {
369#ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
370    return std::__make_bounded_iter(data() + size(), data(), data() + size());
371#else
372    return const_iterator(__data_ + __size_);
373#endif
374  }
375
376  _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT {
377    return const_reverse_iterator(cend());
378  }
379
380  _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT {
381    return const_reverse_iterator(cbegin());
382  }
383
384  _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT {
385    return const_reverse_iterator(cend());
386  }
387
388  _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT {
389    return const_reverse_iterator(cbegin());
390  }
391
392  // [string.view.capacity], capacity
393  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __size_; }
394
395  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI size_type length() const _NOEXCEPT { return __size_; }
396
397  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
398    return numeric_limits<size_type>::max() / sizeof(value_type);
399  }
400
401  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT { return __size_ == 0; }
402
403  // [string.view.access], element access
404  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __pos) const _NOEXCEPT {
405    return _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__pos < size(), "string_view[] index out of bounds"), __data_[__pos];
406  }
407
408  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __pos) const {
409    return __pos >= size() ? (__throw_out_of_range("string_view::at"), __data_[0]) : __data_[__pos];
410  }
411
412  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference front() const _NOEXCEPT {
413    return _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string_view::front(): string is empty"), __data_[0];
414  }
415
416  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference back() const _NOEXCEPT {
417    return _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string_view::back(): string is empty"), __data_[__size_ - 1];
418  }
419
420  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_pointer data() const _NOEXCEPT { return __data_; }
421
422  // [string.view.modifiers], modifiers:
423  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI void remove_prefix(size_type __n) _NOEXCEPT {
424    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n <= size(), "remove_prefix() can't remove more than size()");
425    __data_ += __n;
426    __size_ -= __n;
427  }
428
429  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI void remove_suffix(size_type __n) _NOEXCEPT {
430    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n <= size(), "remove_suffix() can't remove more than size()");
431    __size_ -= __n;
432  }
433
434  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI void swap(basic_string_view& __other) _NOEXCEPT {
435    const value_type* __p = __data_;
436    __data_               = __other.__data_;
437    __other.__data_       = __p;
438
439    size_type __sz  = __size_;
440    __size_         = __other.__size_;
441    __other.__size_ = __sz;
442  }
443
444  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
445  copy(_CharT* __s, size_type __n, size_type __pos = 0) const {
446    if (__pos > size())
447      __throw_out_of_range("string_view::copy");
448    size_type __rlen = std::min(__n, size() - __pos);
449    _Traits::copy(__s, data() + __pos, __rlen);
450    return __rlen;
451  }
452
453  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI basic_string_view substr(size_type __pos = 0, size_type __n = npos) const {
454    // Use the `__assume_valid` form of the constructor to avoid an unnecessary check. Any substring of a view is a
455    // valid view. In particular, `size()` is known to be smaller than `numeric_limits<difference_type>::max()`, so the
456    // new size is also smaller. See also https://github.com/llvm/llvm-project/issues/91634.
457    return __pos > size() ? (__throw_out_of_range("string_view::substr"), basic_string_view())
458                          : basic_string_view(__assume_valid(), data() + __pos, std::min(__n, size() - __pos));
459  }
460
461  _LIBCPP_CONSTEXPR_SINCE_CXX14 int compare(basic_string_view __sv) const _NOEXCEPT {
462    size_type __rlen = std::min(size(), __sv.size());
463    int __retval     = _Traits::compare(data(), __sv.data(), __rlen);
464    if (__retval == 0) // first __rlen chars matched
465      __retval = size() == __sv.size() ? 0 : (size() < __sv.size() ? -1 : 1);
466    return __retval;
467  }
468
469  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
470  compare(size_type __pos1, size_type __n1, basic_string_view __sv) const {
471    return substr(__pos1, __n1).compare(__sv);
472  }
473
474  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
475  compare(size_type __pos1, size_type __n1, basic_string_view __sv, size_type __pos2, size_type __n2) const {
476    return substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
477  }
478
479  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int compare(const _CharT* __s) const _NOEXCEPT {
480    return compare(basic_string_view(__s));
481  }
482
483  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
484  compare(size_type __pos1, size_type __n1, const _CharT* __s) const {
485    return substr(__pos1, __n1).compare(basic_string_view(__s));
486  }
487
488  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
489  compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const {
490    return substr(__pos1, __n1).compare(basic_string_view(__s, __n2));
491  }
492
493  // find
494  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
495  find(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT {
496    _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
497    return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __s.data(), __pos, __s.size());
498  }
499
500  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type find(_CharT __c, size_type __pos = 0) const _NOEXCEPT {
501    return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
502  }
503
504  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
505  find(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
506    _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find(): received nullptr");
507    return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
508  }
509
510  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
511  find(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT {
512    _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find(): received nullptr");
513    return std::__str_find<value_type, size_type, traits_type, npos>(
514        data(), size(), __s, __pos, traits_type::length(__s));
515  }
516
517  // rfind
518  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
519  rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT {
520    _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
521    return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __s.data(), __pos, __s.size());
522  }
523
524  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
525  rfind(_CharT __c, size_type __pos = npos) const _NOEXCEPT {
526    return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
527  }
528
529  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
530  rfind(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
531    _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::rfind(): received nullptr");
532    return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
533  }
534
535  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
536  rfind(const _CharT* __s, size_type __pos = npos) const _NOEXCEPT {
537    _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::rfind(): received nullptr");
538    return std::__str_rfind<value_type, size_type, traits_type, npos>(
539        data(), size(), __s, __pos, traits_type::length(__s));
540  }
541
542  // find_first_of
543  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
544  find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT {
545    _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): received nullptr");
546    return std::__str_find_first_of<value_type, size_type, traits_type, npos>(
547        data(), size(), __s.data(), __pos, __s.size());
548  }
549
550  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
551  find_first_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT {
552    return find(__c, __pos);
553  }
554
555  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
556  find_first_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
557    _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_first_of(): received nullptr");
558    return std::__str_find_first_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
559  }
560
561  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
562  find_first_of(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT {
563    _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_first_of(): received nullptr");
564    return std::__str_find_first_of<value_type, size_type, traits_type, npos>(
565        data(), size(), __s, __pos, traits_type::length(__s));
566  }
567
568  // find_last_of
569  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
570  find_last_of(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT {
571    _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): received nullptr");
572    return std::__str_find_last_of<value_type, size_type, traits_type, npos>(
573        data(), size(), __s.data(), __pos, __s.size());
574  }
575
576  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
577  find_last_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT {
578    return rfind(__c, __pos);
579  }
580
581  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
582  find_last_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
583    _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_last_of(): received nullptr");
584    return std::__str_find_last_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
585  }
586
587  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
588  find_last_of(const _CharT* __s, size_type __pos = npos) const _NOEXCEPT {
589    _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_last_of(): received nullptr");
590    return std::__str_find_last_of<value_type, size_type, traits_type, npos>(
591        data(), size(), __s, __pos, traits_type::length(__s));
592  }
593
594  // find_first_not_of
595  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
596  find_first_not_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT {
597    _LIBCPP_ASSERT_NON_NULL(
598        __s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): received nullptr");
599    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(
600        data(), size(), __s.data(), __pos, __s.size());
601  }
602
603  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
604  find_first_not_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT {
605    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
606  }
607
608  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
609  find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
610    _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): received nullptr");
611    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
612  }
613
614  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
615  find_first_not_of(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT {
616    _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_first_not_of(): received nullptr");
617    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(
618        data(), size(), __s, __pos, traits_type::length(__s));
619  }
620
621  // find_last_not_of
622  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
623  find_last_not_of(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT {
624    _LIBCPP_ASSERT_NON_NULL(
625        __s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): received nullptr");
626    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(
627        data(), size(), __s.data(), __pos, __s.size());
628  }
629
630  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
631  find_last_not_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT {
632    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
633  }
634
635  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
636  find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
637    _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): received nullptr");
638    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
639  }
640
641  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
642  find_last_not_of(const _CharT* __s, size_type __pos = npos) const _NOEXCEPT {
643    _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_last_not_of(): received nullptr");
644    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(
645        data(), size(), __s, __pos, traits_type::length(__s));
646  }
647
648#if _LIBCPP_STD_VER >= 20
649  constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(basic_string_view __s) const noexcept {
650    return size() >= __s.size() && compare(0, __s.size(), __s) == 0;
651  }
652
653  constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(value_type __c) const noexcept {
654    return !empty() && _Traits::eq(front(), __c);
655  }
656
657  constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(const value_type* __s) const noexcept {
658    return starts_with(basic_string_view(__s));
659  }
660
661  constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(basic_string_view __s) const noexcept {
662    return size() >= __s.size() && compare(size() - __s.size(), npos, __s) == 0;
663  }
664
665  constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(value_type __c) const noexcept {
666    return !empty() && _Traits::eq(back(), __c);
667  }
668
669  constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(const value_type* __s) const noexcept {
670    return ends_with(basic_string_view(__s));
671  }
672#endif
673
674#if _LIBCPP_STD_VER >= 23
675  constexpr _LIBCPP_HIDE_FROM_ABI bool contains(basic_string_view __sv) const noexcept { return find(__sv) != npos; }
676
677  constexpr _LIBCPP_HIDE_FROM_ABI bool contains(value_type __c) const noexcept { return find(__c) != npos; }
678
679  constexpr _LIBCPP_HIDE_FROM_ABI bool contains(const value_type* __s) const { return find(__s) != npos; }
680#endif
681
682private:
683  struct __assume_valid {};
684
685  // This is the same as the pointer and length constructor, but without the additional hardening checks. It is intended
686  // for use within the class, when the class invariants already guarantee the resulting object is valid. The compiler
687  // usually cannot eliminate the redundant checks because it does not know class invariants.
688  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI
689  basic_string_view(__assume_valid, const _CharT* __s, size_type __len) _NOEXCEPT
690      : __data_(__s),
691        __size_(__len) {}
692
693  const value_type* __data_;
694  size_type __size_;
695
696  template <class, class, class>
697  friend class basic_string;
698};
699_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_string_view);
700
701#if _LIBCPP_STD_VER >= 20
702template <class _CharT, class _Traits>
703inline constexpr bool ranges::enable_view<basic_string_view<_CharT, _Traits>> = true;
704
705template <class _CharT, class _Traits>
706inline constexpr bool ranges::enable_borrowed_range<basic_string_view<_CharT, _Traits> > = true;
707#endif // _LIBCPP_STD_VER >= 20
708
709// [string.view.deduct]
710
711#if _LIBCPP_STD_VER >= 20
712template <contiguous_iterator _It, sized_sentinel_for<_It> _End>
713basic_string_view(_It, _End) -> basic_string_view<iter_value_t<_It>>;
714#endif // _LIBCPP_STD_VER >= 20
715
716#if _LIBCPP_STD_VER >= 23
717template <ranges::contiguous_range _Range>
718basic_string_view(_Range) -> basic_string_view<ranges::range_value_t<_Range>>;
719#endif
720
721// [string.view.comparison]
722
723#if _LIBCPP_STD_VER >= 20
724
725template <class _CharT, class _Traits>
726_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(basic_string_view<_CharT, _Traits> __lhs,
727                                                type_identity_t<basic_string_view<_CharT, _Traits>> __rhs) noexcept {
728  if (__lhs.size() != __rhs.size())
729    return false;
730  return __lhs.compare(__rhs) == 0;
731}
732
733template <class _CharT, class _Traits>
734_LIBCPP_HIDE_FROM_ABI constexpr auto operator<=>(basic_string_view<_CharT, _Traits> __lhs,
735                                                 type_identity_t<basic_string_view<_CharT, _Traits>> __rhs) noexcept {
736  if constexpr (requires { typename _Traits::comparison_category; }) {
737    // [string.view]/4
738    static_assert(
739        __comparison_category<typename _Traits::comparison_category>, "return type is not a comparison category type");
740    return static_cast<typename _Traits::comparison_category>(__lhs.compare(__rhs) <=> 0);
741  } else {
742    return static_cast<weak_ordering>(__lhs.compare(__rhs) <=> 0);
743  }
744}
745
746#else
747
748// operator ==
749
750template <class _CharT, class _Traits>
751_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
752operator==(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
753  if (__lhs.size() != __rhs.size())
754    return false;
755  return __lhs.compare(__rhs) == 0;
756}
757
758// The dummy default template parameters are used to work around a MSVC issue with mangling, see VSO-409326 for details.
759// This applies to the other sufficient overloads below for the other comparison operators.
760template <class _CharT, class _Traits, int = 1>
761_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
762operator==(basic_string_view<_CharT, _Traits> __lhs,
763           __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
764  if (__lhs.size() != __rhs.size())
765    return false;
766  return __lhs.compare(__rhs) == 0;
767}
768
769template <class _CharT, class _Traits, int = 2>
770_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
771operator==(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
772           basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
773  if (__lhs.size() != __rhs.size())
774    return false;
775  return __lhs.compare(__rhs) == 0;
776}
777
778// operator !=
779template <class _CharT, class _Traits>
780_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
781operator!=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
782  if (__lhs.size() != __rhs.size())
783    return true;
784  return __lhs.compare(__rhs) != 0;
785}
786
787template <class _CharT, class _Traits, int = 1>
788_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
789operator!=(basic_string_view<_CharT, _Traits> __lhs,
790           __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
791  if (__lhs.size() != __rhs.size())
792    return true;
793  return __lhs.compare(__rhs) != 0;
794}
795
796template <class _CharT, class _Traits, int = 2>
797_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
798operator!=(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
799           basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
800  if (__lhs.size() != __rhs.size())
801    return true;
802  return __lhs.compare(__rhs) != 0;
803}
804
805// operator <
806template <class _CharT, class _Traits>
807_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
808operator<(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
809  return __lhs.compare(__rhs) < 0;
810}
811
812template <class _CharT, class _Traits, int = 1>
813_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
814operator<(basic_string_view<_CharT, _Traits> __lhs,
815          __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
816  return __lhs.compare(__rhs) < 0;
817}
818
819template <class _CharT, class _Traits, int = 2>
820_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
821operator<(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
822          basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
823  return __lhs.compare(__rhs) < 0;
824}
825
826// operator >
827template <class _CharT, class _Traits>
828_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
829operator>(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
830  return __lhs.compare(__rhs) > 0;
831}
832
833template <class _CharT, class _Traits, int = 1>
834_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
835operator>(basic_string_view<_CharT, _Traits> __lhs,
836          __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
837  return __lhs.compare(__rhs) > 0;
838}
839
840template <class _CharT, class _Traits, int = 2>
841_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
842operator>(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
843          basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
844  return __lhs.compare(__rhs) > 0;
845}
846
847// operator <=
848template <class _CharT, class _Traits>
849_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
850operator<=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
851  return __lhs.compare(__rhs) <= 0;
852}
853
854template <class _CharT, class _Traits, int = 1>
855_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
856operator<=(basic_string_view<_CharT, _Traits> __lhs,
857           __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
858  return __lhs.compare(__rhs) <= 0;
859}
860
861template <class _CharT, class _Traits, int = 2>
862_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
863operator<=(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
864           basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
865  return __lhs.compare(__rhs) <= 0;
866}
867
868// operator >=
869template <class _CharT, class _Traits>
870_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
871operator>=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
872  return __lhs.compare(__rhs) >= 0;
873}
874
875template <class _CharT, class _Traits, int = 1>
876_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
877operator>=(basic_string_view<_CharT, _Traits> __lhs,
878           __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
879  return __lhs.compare(__rhs) >= 0;
880}
881
882template <class _CharT, class _Traits, int = 2>
883_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
884operator>=(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
885           basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
886  return __lhs.compare(__rhs) >= 0;
887}
888
889#endif //  _LIBCPP_STD_VER >= 20
890
891template <class _CharT, class _Traits>
892_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
893operator<<(basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT, _Traits> __str);
894
895// [string.view.hash]
896template <class _CharT>
897struct __string_view_hash : public __unary_function<basic_string_view<_CharT, char_traits<_CharT> >, size_t> {
898  _LIBCPP_HIDE_FROM_ABI size_t operator()(const basic_string_view<_CharT, char_traits<_CharT> > __val) const _NOEXCEPT {
899    return std::__do_string_hash(__val.data(), __val.data() + __val.size());
900  }
901};
902
903template <>
904struct hash<basic_string_view<char, char_traits<char> > > : __string_view_hash<char> {};
905
906#if _LIBCPP_HAS_CHAR8_T
907template <>
908struct hash<basic_string_view<char8_t, char_traits<char8_t> > > : __string_view_hash<char8_t> {};
909#endif
910
911template <>
912struct hash<basic_string_view<char16_t, char_traits<char16_t> > > : __string_view_hash<char16_t> {};
913
914template <>
915struct hash<basic_string_view<char32_t, char_traits<char32_t> > > : __string_view_hash<char32_t> {};
916
917#if _LIBCPP_HAS_WIDE_CHARACTERS
918template <>
919struct hash<basic_string_view<wchar_t, char_traits<wchar_t> > > : __string_view_hash<wchar_t> {};
920#endif
921
922#if _LIBCPP_STD_VER >= 14
923inline namespace literals {
924inline namespace string_view_literals {
925inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char> operator""sv(const char* __str, size_t __len) noexcept {
926  return basic_string_view<char>(__str, __len);
927}
928
929#  if _LIBCPP_HAS_WIDE_CHARACTERS
930inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<wchar_t>
931operator""sv(const wchar_t* __str, size_t __len) noexcept {
932  return basic_string_view<wchar_t>(__str, __len);
933}
934#  endif
935
936#  if _LIBCPP_HAS_CHAR8_T
937inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char8_t>
938operator""sv(const char8_t* __str, size_t __len) noexcept {
939  return basic_string_view<char8_t>(__str, __len);
940}
941#  endif
942
943inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char16_t>
944operator""sv(const char16_t* __str, size_t __len) noexcept {
945  return basic_string_view<char16_t>(__str, __len);
946}
947
948inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char32_t>
949operator""sv(const char32_t* __str, size_t __len) noexcept {
950  return basic_string_view<char32_t>(__str, __len);
951}
952} // namespace string_view_literals
953} // namespace literals
954#endif
955_LIBCPP_END_NAMESPACE_STD
956
957_LIBCPP_POP_MACROS
958
959#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
960#  include <algorithm>
961#  include <concepts>
962#  include <cstdlib>
963#  include <iterator>
964#  include <type_traits>
965#endif
966
967#endif // _LIBCPP_STRING_VIEW
968