Debian Codegraph @

libcxx/include/__cxx03/string_view

raw
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___CXX03_STRING_VIEW
11 #define _LIBCPP___CXX03_STRING_VIEW
12
13 // clang-format off
14
15 /*
16
17 string_view synopsis
18
19 #include <__cxx03/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 <__cxx03/__algorithm/min.h>
209 #include <__cxx03/__assert>
210 #include <__cxx03/__config>
211 #include <__cxx03/__functional/hash.h>
212 #include <__cxx03/__functional/unary_function.h>
213 #include <__cxx03/__fwd/ostream.h>
214 #include <__cxx03/__fwd/string_view.h>
215 #include <__cxx03/__iterator/bounded_iter.h>
216 #include <__cxx03/__iterator/iterator_traits.h>
217 #include <__cxx03/__iterator/reverse_iterator.h>
218 #include <__cxx03/__iterator/wrap_iter.h>
219 #include <__cxx03/__memory/pointer_traits.h>
220 #include <__cxx03/__string/char_traits.h>
221 #include <__cxx03/__type_traits/is_array.h>
222 #include <__cxx03/__type_traits/is_convertible.h>
223 #include <__cxx03/__type_traits/is_same.h>
224 #include <__cxx03/__type_traits/is_standard_layout.h>
225 #include <__cxx03/__type_traits/is_trivial.h>
226 #include <__cxx03/__type_traits/remove_cvref.h>
227 #include <__cxx03/__type_traits/remove_reference.h>
228 #include <__cxx03/__type_traits/type_identity.h>
229 #include <__cxx03/cstddef>
230 #include <__cxx03/iosfwd>
231 #include <__cxx03/limits>
232 #include <__cxx03/stdexcept>
233 #include <__cxx03/version>
234
235 // standard-mandated includes
236
237 // [iterator.range]
238 #include <__cxx03/__iterator/access.h>
239
240 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
241 # pragma GCC system_header
242 #endif
243
244 _LIBCPP_PUSH_MACROS
245 #include <__cxx03/__undef_macros>
246
247 _LIBCPP_BEGIN_NAMESPACE_STD
248
249 // TODO: This is a workaround for some vendors to carry a downstream diff to accept `nullptr` in
250 // string_view constructors. This can be refactored when this exact form isn't needed anymore.
251 template <class _Traits>
252 _LIBCPP_HIDE_FROM_ABI inline size_t __char_traits_length_checked(const typename _Traits::char_type* __s) _NOEXCEPT {
253 // This needs to be a single statement for C++11 constexpr
254 return _LIBCPP_ASSERT_NON_NULL(
255 __s != nullptr, "null pointer passed to non-null argument of char_traits<...>::length"),
256 _Traits::length(__s);
257 }
258
259 template <class _CharT, class _Traits>
260 class basic_string_view {
261 public:
262 // types
263 using traits_type = _Traits;
264 using value_type = _CharT;
265 using pointer = _CharT*;
266 using const_pointer = const _CharT*;
267 using reference = _CharT&;
268 using const_reference = const _CharT&;
269 #if defined(_LIBCPP_ABI_BOUNDED_ITERATORS)
270 using const_iterator = __bounded_iter<const_pointer>;
271 #elif defined(_LIBCPP_ABI_USE_WRAP_ITER_IN_STD_STRING_VIEW)
272 using const_iterator = __wrap_iter<const_pointer>;
273 #else
274 using const_iterator = const_pointer;
275 #endif
276 using iterator = const_iterator;
277 using const_reverse_iterator = std::reverse_iterator<const_iterator>;
278 using reverse_iterator = const_reverse_iterator;
279 using size_type = size_t;
280 using difference_type = ptrdiff_t;
281 static const size_type npos = -1; // size_type(-1);
282
283 static_assert(!is_array<value_type>::value, "Character type of basic_string_view must not be an array");
284 static_assert(is_standard_layout<value_type>::value, "Character type of basic_string_view must be standard-layout");
285 static_assert(is_trivial<value_type>::value, "Character type of basic_string_view must be trivial");
286 static_assert(is_same<_CharT, typename traits_type::char_type>::value,
287 "traits_type::char_type must be the same type as CharT");
288
289 // [string.view.cons], construct/copy
290 _LIBCPP_HIDE_FROM_ABI basic_string_view() _NOEXCEPT : __data_(nullptr), __size_(0) {}
291
292 _LIBCPP_HIDE_FROM_ABI basic_string_view(const basic_string_view&) _NOEXCEPT = default;
293
294 _LIBCPP_HIDE_FROM_ABI basic_string_view& operator=(const basic_string_view&) _NOEXCEPT = default;
295
296 _LIBCPP_HIDE_FROM_ABI basic_string_view(const _CharT* __s, size_type __len) _NOEXCEPT
297 : __data_(__s),
298 __size_(__len) {}
299
300 _LIBCPP_HIDE_FROM_ABI basic_string_view(const _CharT* __s)
301 : __data_(__s), __size_(std::__char_traits_length_checked<_Traits>(__s)) {}
302
303 // [string.view.iterators], iterators
304 _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return cbegin(); }
305
306 _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return cend(); }
307
308 _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT {
309 #ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
310 return std::__make_bounded_iter(data(), data(), data() + size());
311 #else
312 return const_iterator(__data_);
313 #endif
314 }
315
316 _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT {
317 #ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
318 return std::__make_bounded_iter(data() + size(), data(), data() + size());
319 #else
320 return const_iterator(__data_ + __size_);
321 #endif
322 }
323
324 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(cend()); }
325
326 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
327
328 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return const_reverse_iterator(cend()); }
329
330 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
331
332 // [string.view.capacity], capacity
333 _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __size_; }
334
335 _LIBCPP_HIDE_FROM_ABI size_type length() const _NOEXCEPT { return __size_; }
336
337 _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
338 return numeric_limits<size_type>::max() / sizeof(value_type);
339 }
340
341 _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __size_ == 0; }
342
343 // [string.view.access], element access
344 _LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __pos) const _NOEXCEPT {
345 return _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__pos < size(), "string_view[] index out of bounds"), __data_[__pos];
346 }
347
348 _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __pos) const {
349 return __pos >= size() ? (__throw_out_of_range("string_view::at"), __data_[0]) : __data_[__pos];
350 }
351
352 _LIBCPP_HIDE_FROM_ABI const_reference front() const _NOEXCEPT {
353 return _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string_view::front(): string is empty"), __data_[0];
354 }
355
356 _LIBCPP_HIDE_FROM_ABI const_reference back() const _NOEXCEPT {
357 return _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string_view::back(): string is empty"), __data_[__size_ - 1];
358 }
359
360 _LIBCPP_HIDE_FROM_ABI const_pointer data() const _NOEXCEPT { return __data_; }
361
362 // [string.view.modifiers], modifiers:
363 _LIBCPP_HIDE_FROM_ABI void remove_prefix(size_type __n) _NOEXCEPT {
364 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n <= size(), "remove_prefix() can't remove more than size()");
365 __data_ += __n;
366 __size_ -= __n;
367 }
368
369 _LIBCPP_HIDE_FROM_ABI void remove_suffix(size_type __n) _NOEXCEPT {
370 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n <= size(), "remove_suffix() can't remove more than size()");
371 __size_ -= __n;
372 }
373
374 _LIBCPP_HIDE_FROM_ABI void swap(basic_string_view& __other) _NOEXCEPT {
375 const value_type* __p = __data_;
376 __data_ = __other.__data_;
377 __other.__data_ = __p;
378
379 size_type __sz = __size_;
380 __size_ = __other.__size_;
381 __other.__size_ = __sz;
382 }
383
384 _LIBCPP_HIDE_FROM_ABI size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const {
385 if (__pos > size())
386 __throw_out_of_range("string_view::copy");
387 size_type __rlen = std::min(__n, size() - __pos);
388 _Traits::copy(__s, data() + __pos, __rlen);
389 return __rlen;
390 }
391
392 _LIBCPP_HIDE_FROM_ABI basic_string_view substr(size_type __pos = 0, size_type __n = npos) const {
393 return __pos > size() ? (__throw_out_of_range("string_view::substr"), basic_string_view())
394 : basic_string_view(data() + __pos, std::min(__n, size() - __pos));
395 }
396
397 int compare(basic_string_view __sv) const _NOEXCEPT {
398 size_type __rlen = std::min(size(), __sv.size());
399 int __retval = _Traits::compare(data(), __sv.data(), __rlen);
400 if (__retval == 0) // first __rlen chars matched
401 __retval = size() == __sv.size() ? 0 : (size() < __sv.size() ? -1 : 1);
402 return __retval;
403 }
404
405 _LIBCPP_HIDE_FROM_ABI int compare(size_type __pos1, size_type __n1, basic_string_view __sv) const {
406 return substr(__pos1, __n1).compare(__sv);
407 }
408
409 _LIBCPP_HIDE_FROM_ABI int
410 compare(size_type __pos1, size_type __n1, basic_string_view __sv, size_type __pos2, size_type __n2) const {
411 return substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
412 }
413
414 _LIBCPP_HIDE_FROM_ABI int compare(const _CharT* __s) const _NOEXCEPT { return compare(basic_string_view(__s)); }
415
416 _LIBCPP_HIDE_FROM_ABI int compare(size_type __pos1, size_type __n1, const _CharT* __s) const {
417 return substr(__pos1, __n1).compare(basic_string_view(__s));
418 }
419
420 _LIBCPP_HIDE_FROM_ABI int compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const {
421 return substr(__pos1, __n1).compare(basic_string_view(__s, __n2));
422 }
423
424 // find
425 _LIBCPP_HIDE_FROM_ABI size_type find(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT {
426 _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
427 return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __s.data(), __pos, __s.size());
428 }
429
430 _LIBCPP_HIDE_FROM_ABI size_type find(_CharT __c, size_type __pos = 0) const _NOEXCEPT {
431 return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
432 }
433
434 _LIBCPP_HIDE_FROM_ABI size_type find(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
435 _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find(): received nullptr");
436 return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
437 }
438
439 _LIBCPP_HIDE_FROM_ABI size_type find(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT {
440 _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find(): received nullptr");
441 return std::__str_find<value_type, size_type, traits_type, npos>(
442 data(), size(), __s, __pos, traits_type::length(__s));
443 }
444
445 // rfind
446 _LIBCPP_HIDE_FROM_ABI size_type rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT {
447 _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
448 return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __s.data(), __pos, __s.size());
449 }
450
451 _LIBCPP_HIDE_FROM_ABI size_type rfind(_CharT __c, size_type __pos = npos) const _NOEXCEPT {
452 return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
453 }
454
455 _LIBCPP_HIDE_FROM_ABI size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
456 _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::rfind(): received nullptr");
457 return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
458 }
459
460 _LIBCPP_HIDE_FROM_ABI size_type rfind(const _CharT* __s, size_type __pos = npos) const _NOEXCEPT {
461 _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::rfind(): received nullptr");
462 return std::__str_rfind<value_type, size_type, traits_type, npos>(
463 data(), size(), __s, __pos, traits_type::length(__s));
464 }
465
466 // find_first_of
467 _LIBCPP_HIDE_FROM_ABI size_type find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT {
468 _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): received nullptr");
469 return std::__str_find_first_of<value_type, size_type, traits_type, npos>(
470 data(), size(), __s.data(), __pos, __s.size());
471 }
472
473 _LIBCPP_HIDE_FROM_ABI size_type find_first_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT {
474 return find(__c, __pos);
475 }
476
477 _LIBCPP_HIDE_FROM_ABI size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
478 _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_first_of(): received nullptr");
479 return std::__str_find_first_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
480 }
481
482 _LIBCPP_HIDE_FROM_ABI size_type find_first_of(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT {
483 _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_first_of(): received nullptr");
484 return std::__str_find_first_of<value_type, size_type, traits_type, npos>(
485 data(), size(), __s, __pos, traits_type::length(__s));
486 }
487
488 // find_last_of
489 _LIBCPP_HIDE_FROM_ABI size_type find_last_of(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT {
490 _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): received nullptr");
491 return std::__str_find_last_of<value_type, size_type, traits_type, npos>(
492 data(), size(), __s.data(), __pos, __s.size());
493 }
494
495 _LIBCPP_HIDE_FROM_ABI size_type find_last_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT {
496 return rfind(__c, __pos);
497 }
498
499 _LIBCPP_HIDE_FROM_ABI size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
500 _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_last_of(): received nullptr");
501 return std::__str_find_last_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
502 }
503
504 _LIBCPP_HIDE_FROM_ABI size_type find_last_of(const _CharT* __s, size_type __pos = npos) const _NOEXCEPT {
505 _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_last_of(): received nullptr");
506 return std::__str_find_last_of<value_type, size_type, traits_type, npos>(
507 data(), size(), __s, __pos, traits_type::length(__s));
508 }
509
510 // find_first_not_of
511 _LIBCPP_HIDE_FROM_ABI size_type find_first_not_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT {
512 _LIBCPP_ASSERT_NON_NULL(
513 __s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): received nullptr");
514 return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(
515 data(), size(), __s.data(), __pos, __s.size());
516 }
517
518 _LIBCPP_HIDE_FROM_ABI size_type find_first_not_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT {
519 return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
520 }
521
522 _LIBCPP_HIDE_FROM_ABI size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
523 _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): received nullptr");
524 return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
525 }
526
527 _LIBCPP_HIDE_FROM_ABI size_type find_first_not_of(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT {
528 _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_first_not_of(): received nullptr");
529 return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(
530 data(), size(), __s, __pos, traits_type::length(__s));
531 }
532
533 // find_last_not_of
534 _LIBCPP_HIDE_FROM_ABI size_type find_last_not_of(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT {
535 _LIBCPP_ASSERT_NON_NULL(
536 __s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): received nullptr");
537 return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(
538 data(), size(), __s.data(), __pos, __s.size());
539 }
540
541 _LIBCPP_HIDE_FROM_ABI size_type find_last_not_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT {
542 return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
543 }
544
545 _LIBCPP_HIDE_FROM_ABI size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
546 _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): received nullptr");
547 return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
548 }
549
550 _LIBCPP_HIDE_FROM_ABI size_type find_last_not_of(const _CharT* __s, size_type __pos = npos) const _NOEXCEPT {
551 _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_last_not_of(): received nullptr");
552 return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(
553 data(), size(), __s, __pos, traits_type::length(__s));
554 }
555
556 private:
557 const value_type* __data_;
558 size_type __size_;
559 };
560 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_string_view);
561
562 // operator ==
563
564 template <class _CharT, class _Traits>
565 _LIBCPP_HIDE_FROM_ABI bool
566 operator==(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
567 if (__lhs.size() != __rhs.size())
568 return false;
569 return __lhs.compare(__rhs) == 0;
570 }
571
572 // The dummy default template parameters are used to work around a MSVC issue with mangling, see VSO-409326 for details.
573 // This applies to the other sufficient overloads below for the other comparison operators.
574 template <class _CharT, class _Traits, int = 1>
575 _LIBCPP_HIDE_FROM_ABI bool operator==(basic_string_view<_CharT, _Traits> __lhs,
576 __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
577 if (__lhs.size() != __rhs.size())
578 return false;
579 return __lhs.compare(__rhs) == 0;
580 }
581
582 template <class _CharT, class _Traits, int = 2>
583 _LIBCPP_HIDE_FROM_ABI bool operator==(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
584 basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
585 if (__lhs.size() != __rhs.size())
586 return false;
587 return __lhs.compare(__rhs) == 0;
588 }
589
590 // operator !=
591 template <class _CharT, class _Traits>
592 _LIBCPP_HIDE_FROM_ABI bool
593 operator!=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
594 if (__lhs.size() != __rhs.size())
595 return true;
596 return __lhs.compare(__rhs) != 0;
597 }
598
599 template <class _CharT, class _Traits, int = 1>
600 _LIBCPP_HIDE_FROM_ABI bool operator!=(basic_string_view<_CharT, _Traits> __lhs,
601 __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
602 if (__lhs.size() != __rhs.size())
603 return true;
604 return __lhs.compare(__rhs) != 0;
605 }
606
607 template <class _CharT, class _Traits, int = 2>
608 _LIBCPP_HIDE_FROM_ABI bool operator!=(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
609 basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
610 if (__lhs.size() != __rhs.size())
611 return true;
612 return __lhs.compare(__rhs) != 0;
613 }
614
615 // operator <
616 template <class _CharT, class _Traits>
617 _LIBCPP_HIDE_FROM_ABI bool
618 operator<(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
619 return __lhs.compare(__rhs) < 0;
620 }
621
622 template <class _CharT, class _Traits, int = 1>
623 _LIBCPP_HIDE_FROM_ABI bool operator<(basic_string_view<_CharT, _Traits> __lhs,
624 __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
625 return __lhs.compare(__rhs) < 0;
626 }
627
628 template <class _CharT, class _Traits, int = 2>
629 _LIBCPP_HIDE_FROM_ABI bool operator<(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
630 basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
631 return __lhs.compare(__rhs) < 0;
632 }
633
634 // operator >
635 template <class _CharT, class _Traits>
636 _LIBCPP_HIDE_FROM_ABI bool
637 operator>(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
638 return __lhs.compare(__rhs) > 0;
639 }
640
641 template <class _CharT, class _Traits, int = 1>
642 _LIBCPP_HIDE_FROM_ABI bool operator>(basic_string_view<_CharT, _Traits> __lhs,
643 __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
644 return __lhs.compare(__rhs) > 0;
645 }
646
647 template <class _CharT, class _Traits, int = 2>
648 _LIBCPP_HIDE_FROM_ABI bool operator>(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
649 basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
650 return __lhs.compare(__rhs) > 0;
651 }
652
653 // operator <=
654 template <class _CharT, class _Traits>
655 _LIBCPP_HIDE_FROM_ABI bool
656 operator<=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
657 return __lhs.compare(__rhs) <= 0;
658 }
659
660 template <class _CharT, class _Traits, int = 1>
661 _LIBCPP_HIDE_FROM_ABI bool operator<=(basic_string_view<_CharT, _Traits> __lhs,
662 __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
663 return __lhs.compare(__rhs) <= 0;
664 }
665
666 template <class _CharT, class _Traits, int = 2>
667 _LIBCPP_HIDE_FROM_ABI bool operator<=(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
668 basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
669 return __lhs.compare(__rhs) <= 0;
670 }
671
672 // operator >=
673 template <class _CharT, class _Traits>
674 _LIBCPP_HIDE_FROM_ABI bool
675 operator>=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
676 return __lhs.compare(__rhs) >= 0;
677 }
678
679 template <class _CharT, class _Traits, int = 1>
680 _LIBCPP_HIDE_FROM_ABI bool operator>=(basic_string_view<_CharT, _Traits> __lhs,
681 __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
682 return __lhs.compare(__rhs) >= 0;
683 }
684
685 template <class _CharT, class _Traits, int = 2>
686 _LIBCPP_HIDE_FROM_ABI bool operator>=(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
687 basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
688 return __lhs.compare(__rhs) >= 0;
689 }
690
691 template <class _CharT, class _Traits>
692 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
693 operator<<(basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT, _Traits> __str);
694
695 // [string.view.hash]
696 template <class _CharT>
697 struct __string_view_hash : public __unary_function<basic_string_view<_CharT, char_traits<_CharT> >, size_t> {
698 _LIBCPP_HIDE_FROM_ABI size_t operator()(const basic_string_view<_CharT, char_traits<_CharT> > __val) const _NOEXCEPT {
699 return std::__do_string_hash(__val.data(), __val.data() + __val.size());
700 }
701 };
702
703 template <>
704 struct hash<basic_string_view<char, char_traits<char> > > : __string_view_hash<char> {};
705
706 #ifndef _LIBCPP_HAS_NO_CHAR8_T
707 template <>
708 struct hash<basic_string_view<char8_t, char_traits<char8_t> > > : __string_view_hash<char8_t> {};
709 #endif
710
711 template <>
712 struct hash<basic_string_view<char16_t, char_traits<char16_t> > > : __string_view_hash<char16_t> {};
713
714 template <>
715 struct hash<basic_string_view<char32_t, char_traits<char32_t> > > : __string_view_hash<char32_t> {};
716
717 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
718 template <>
719 struct hash<basic_string_view<wchar_t, char_traits<wchar_t> > > : __string_view_hash<wchar_t> {};
720 #endif
721
722 _LIBCPP_END_NAMESPACE_STD
723
724 _LIBCPP_POP_MACROS
725
726 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES)
727 # include <__cxx03/algorithm>
728 # include <__cxx03/cstdlib>
729 # include <__cxx03/iterator>
730 # include <__cxx03/type_traits>
731 #endif
732
733 #endif // _LIBCPP___CXX03_STRING_VIEW