libcxx/include/string_view

   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
  21 namespace 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.
 267 template <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
 276 template <class _CharT, class _Traits>
 277 class basic_string_view {
 278 public:
 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
 682 private:
 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
 702 template <class _CharT, class _Traits>
 703 inline constexpr bool ranges::enable_view<basic_string_view<_CharT, _Traits>> = true;
 704
 705 template <class _CharT, class _Traits>
 706 inline 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
 712 template <contiguous_iterator _It, sized_sentinel_for<_It> _End>
 713 basic_string_view(_It, _End) -> basic_string_view<iter_value_t<_It>>;
 714 #endif // _LIBCPP_STD_VER >= 20
 715
 716 #if _LIBCPP_STD_VER >= 23
 717 template <ranges::contiguous_range _Range>
 718 basic_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
 725 template <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
 733 template <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
 750 template <class _CharT, class _Traits>
 751 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 752 operator==(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.
 760 template <class _CharT, class _Traits, int = 1>
 761 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 762 operator==(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
 769 template <class _CharT, class _Traits, int = 2>
 770 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 771 operator==(__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 !=
 779 template <class _CharT, class _Traits>
 780 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 781 operator!=(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
 787 template <class _CharT, class _Traits, int = 1>
 788 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 789 operator!=(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
 796 template <class _CharT, class _Traits, int = 2>
 797 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 798 operator!=(__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 <
 806 template <class _CharT, class _Traits>
 807 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 808 operator<(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
 809   return __lhs.compare(__rhs) < 0;
 810 }
 811
 812 template <class _CharT, class _Traits, int = 1>
 813 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 814 operator<(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
 819 template <class _CharT, class _Traits, int = 2>
 820 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 821 operator<(__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 >
 827 template <class _CharT, class _Traits>
 828 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 829 operator>(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
 830   return __lhs.compare(__rhs) > 0;
 831 }
 832
 833 template <class _CharT, class _Traits, int = 1>
 834 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 835 operator>(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
 840 template <class _CharT, class _Traits, int = 2>
 841 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 842 operator>(__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 <=
 848 template <class _CharT, class _Traits>
 849 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 850 operator<=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
 851   return __lhs.compare(__rhs) <= 0;
 852 }
 853
 854 template <class _CharT, class _Traits, int = 1>
 855 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 856 operator<=(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
 861 template <class _CharT, class _Traits, int = 2>
 862 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 863 operator<=(__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 >=
 869 template <class _CharT, class _Traits>
 870 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 871 operator>=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
 872   return __lhs.compare(__rhs) >= 0;
 873 }
 874
 875 template <class _CharT, class _Traits, int = 1>
 876 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 877 operator>=(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
 882 template <class _CharT, class _Traits, int = 2>
 883 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
 884 operator>=(__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
 891 template <class _CharT, class _Traits>
 892 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 893 operator<<(basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT, _Traits> __str);
 894
 895 // [string.view.hash]
 896 template <class _CharT>
 897 struct __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
 903 template <>
 904 struct hash<basic_string_view<char, char_traits<char> > > : __string_view_hash<char> {};
 905
 906 #if _LIBCPP_HAS_CHAR8_T
 907 template <>
 908 struct hash<basic_string_view<char8_t, char_traits<char8_t> > > : __string_view_hash<char8_t> {};
 909 #endif
 910
 911 template <>
 912 struct hash<basic_string_view<char16_t, char_traits<char16_t> > > : __string_view_hash<char16_t> {};
 913
 914 template <>
 915 struct hash<basic_string_view<char32_t, char_traits<char32_t> > > : __string_view_hash<char32_t> {};
 916
 917 #if _LIBCPP_HAS_WIDE_CHARACTERS
 918 template <>
 919 struct hash<basic_string_view<wchar_t, char_traits<wchar_t> > > : __string_view_hash<wchar_t> {};
 920 #endif
 921
 922 #if _LIBCPP_STD_VER >= 14
 923 inline namespace literals {
 924 inline namespace string_view_literals {
 925 inline _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
 930 inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<wchar_t>
 931 operator""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
 937 inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char8_t>
 938 operator""sv(const char8_t* __str, size_t __len) noexcept {
 939   return basic_string_view<char8_t>(__str, __len);
 940 }
 941 #  endif
 942
 943 inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char16_t>
 944 operator""sv(const char16_t* __str, size_t __len) noexcept {
 945   return basic_string_view<char16_t>(__str, __len);
 946 }
 947
 948 inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char32_t>
 949 operator""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