1//
2// Copyright 2017 The Abseil Authors.
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// https://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15//
16// -----------------------------------------------------------------------------
17// File: string_view.h
18// -----------------------------------------------------------------------------
19//
20// This file contains the definition of the `absl::string_view` class. A
21// `string_view` points to a contiguous span of characters, often part or all of
22// another `std::string`, double-quoted string literal, character array, or even
23// another `string_view`.
24//
25// This `absl::string_view` abstraction is designed to be a drop-in
26// replacement for the C++17 `std::string_view` abstraction.
27#ifndef ABSL_STRINGS_STRING_VIEW_H_
28#define ABSL_STRINGS_STRING_VIEW_H_
29
30#include <algorithm>
31#include <cassert>
32#include <cstddef>
33#include <cstring>
34#include <iosfwd>
35#include <iterator>
36#include <limits>
37#include <string>
38
39#include "absl/base/attributes.h"
40#include "absl/base/nullability.h"
41#include "absl/base/config.h"
42#include "absl/base/internal/throw_delegate.h"
43#include "absl/base/macros.h"
44#include "absl/base/optimization.h"
45#include "absl/base/port.h"
46
47#ifdef ABSL_USES_STD_STRING_VIEW
48
49#include <string_view> // IWYU pragma: export
50
51namespace absl {
52ABSL_NAMESPACE_BEGIN
53using string_view = std::string_view;
54ABSL_NAMESPACE_END
55} // namespace absl
56
57#else // ABSL_USES_STD_STRING_VIEW
58
59#if ABSL_HAVE_BUILTIN(__builtin_memcmp) || \
60 (defined(__GNUC__) && !defined(__clang__)) || \
61 (defined(_MSC_VER) && _MSC_VER >= 1928)
62#define ABSL_INTERNAL_STRING_VIEW_MEMCMP __builtin_memcmp
63#else // ABSL_HAVE_BUILTIN(__builtin_memcmp)
64#define ABSL_INTERNAL_STRING_VIEW_MEMCMP memcmp
65#endif // ABSL_HAVE_BUILTIN(__builtin_memcmp)
66
67namespace absl {
68ABSL_NAMESPACE_BEGIN
69
70// absl::string_view
71//
72// A `string_view` provides a lightweight view into the string data provided by
73// a `std::string`, double-quoted string literal, character array, or even
74// another `string_view`. A `string_view` does *not* own the string to which it
75// points, and that data cannot be modified through the view.
76//
77// You can use `string_view` as a function or method parameter anywhere a
78// parameter can receive a double-quoted string literal, `const char*`,
79// `std::string`, or another `absl::string_view` argument with no need to copy
80// the string data. Systematic use of `string_view` within function arguments
81// reduces data copies and `strlen()` calls.
82//
83// Because of its small size, prefer passing `string_view` by value:
84//
85// void MyFunction(absl::string_view arg);
86//
87// If circumstances require, you may also pass one by const reference:
88//
89// void MyFunction(const absl::string_view& arg); // not preferred
90//
91// Passing by value generates slightly smaller code for many architectures.
92//
93// In either case, the source data of the `string_view` must outlive the
94// `string_view` itself.
95//
96// A `string_view` is also suitable for local variables if you know that the
97// lifetime of the underlying object is longer than the lifetime of your
98// `string_view` variable. However, beware of binding a `string_view` to a
99// temporary value:
100//
101// // BAD use of string_view: lifetime problem
102// absl::string_view sv = obj.ReturnAString();
103//
104// // GOOD use of string_view: str outlives sv
105// std::string str = obj.ReturnAString();
106// absl::string_view sv = str;
107//
108// Due to lifetime issues, a `string_view` is sometimes a poor choice for a
109// return value and usually a poor choice for a data member. If you do use a
110// `string_view` this way, it is your responsibility to ensure that the object
111// pointed to by the `string_view` outlives the `string_view`.
112//
113// A `string_view` may represent a whole string or just part of a string. For
114// example, when splitting a string, `std::vector<absl::string_view>` is a
115// natural data type for the output.
116//
117// For another example, a Cord is a non-contiguous, potentially very
118// long string-like object. The Cord class has an interface that iteratively
119// provides string_view objects that point to the successive pieces of a Cord
120// object.
121//
122// When constructed from a source which is NUL-terminated, the `string_view`
123// itself will not include the NUL-terminator unless a specific size (including
124// the NUL) is passed to the constructor. As a result, common idioms that work
125// on NUL-terminated strings do not work on `string_view` objects. If you write
126// code that scans a `string_view`, you must check its length rather than test
127// for nul, for example. Note, however, that nuls may still be embedded within
128// a `string_view` explicitly.
129//
130// You may create a null `string_view` in two ways:
131//
132// absl::string_view sv;
133// absl::string_view sv(nullptr, 0);
134//
135// For the above, `sv.data() == nullptr`, `sv.length() == 0`, and
136// `sv.empty() == true`. Also, if you create a `string_view` with a non-null
137// pointer then `sv.data() != nullptr`. Thus, you can use `string_view()` to
138// signal an undefined value that is different from other `string_view` values
139// in a similar fashion to how `const char* p1 = nullptr;` is different from
140// `const char* p2 = "";`. However, in practice, it is not recommended to rely
141// on this behavior.
142//
143// Be careful not to confuse a null `string_view` with an empty one. A null
144// `string_view` is an empty `string_view`, but some empty `string_view`s are
145// not null. Prefer checking for emptiness over checking for null.
146//
147// There are many ways to create an empty string_view:
148//
149// const char* nullcp = nullptr;
150// // string_view.size() will return 0 in all cases.
151// absl::string_view();
152// absl::string_view(nullcp, 0);
153// absl::string_view("");
154// absl::string_view("", 0);
155// absl::string_view("abcdef", 0);
156// absl::string_view("abcdef" + 6, 0);
157//
158// All empty `string_view` objects whether null or not, are equal:
159//
160// absl::string_view() == absl::string_view("", 0)
161// absl::string_view(nullptr, 0) == absl::string_view("abcdef"+6, 0)
162class ABSL_ATTRIBUTE_VIEW string_view {
163 public:
164 using traits_type = std::char_traits<char>;
165 using value_type = char;
166 using pointer = absl::Nullable<char*>;
167 using const_pointer = absl::Nullable<const char*>;
168 using reference = char&;
169 using const_reference = const char&;
170 using const_iterator = absl::Nullable<const char*>;
171 using iterator = const_iterator;
172 using const_reverse_iterator = std::reverse_iterator<const_iterator>;
173 using reverse_iterator = const_reverse_iterator;
174 using size_type = size_t;
175 using difference_type = std::ptrdiff_t;
176 using absl_internal_is_view = std::true_type;
177
178 static constexpr size_type npos = static_cast<size_type>(-1);
179
180 // Null `string_view` constructor
181 constexpr string_view() noexcept : ptr_(nullptr), length_(0) {}
182
183 // Implicit constructors
184
185 template <typename Allocator>
186 string_view( // NOLINT(runtime/explicit)
187 const std::basic_string<char, std::char_traits<char>, Allocator>& str
188 ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
189 // This is implemented in terms of `string_view(p, n)` so `str.size()`
190 // doesn't need to be reevaluated after `ptr_` is set.
191 // The length check is also skipped since it is unnecessary and causes
192 // code bloat.
193 : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {}
194
195 // Implicit constructor of a `string_view` from NUL-terminated `str`. When
196 // accepting possibly null strings, use `absl::NullSafeStringView(str)`
197 // instead (see below).
198 // The length check is skipped since it is unnecessary and causes code bloat.
199 constexpr string_view( // NOLINT(runtime/explicit)
200 absl::Nonnull<const char*> str)
201 : ptr_(str), length_(str ? StrlenInternal(str) : 0) {}
202
203 // Constructor of a `string_view` from a `const char*` and length.
204 constexpr string_view(absl::Nullable<const char*> data, size_type len)
205 : ptr_(data), length_(CheckLengthInternal(len)) {}
206
207 constexpr string_view(const string_view&) noexcept = default;
208 string_view& operator=(const string_view&) noexcept = default;
209
210 // Iterators
211
212 // string_view::begin()
213 //
214 // Returns an iterator pointing to the first character at the beginning of the
215 // `string_view`, or `end()` if the `string_view` is empty.
216 constexpr const_iterator begin() const noexcept { return ptr_; }
217
218 // string_view::end()
219 //
220 // Returns an iterator pointing just beyond the last character at the end of
221 // the `string_view`. This iterator acts as a placeholder; attempting to
222 // access it results in undefined behavior.
223 constexpr const_iterator end() const noexcept { return ptr_ + length_; }
224
225 // string_view::cbegin()
226 //
227 // Returns a const iterator pointing to the first character at the beginning
228 // of the `string_view`, or `end()` if the `string_view` is empty.
229 constexpr const_iterator cbegin() const noexcept { return begin(); }
230
231 // string_view::cend()
232 //
233 // Returns a const iterator pointing just beyond the last character at the end
234 // of the `string_view`. This pointer acts as a placeholder; attempting to
235 // access its element results in undefined behavior.
236 constexpr const_iterator cend() const noexcept { return end(); }
237
238 // string_view::rbegin()
239 //
240 // Returns a reverse iterator pointing to the last character at the end of the
241 // `string_view`, or `rend()` if the `string_view` is empty.
242 const_reverse_iterator rbegin() const noexcept {
243 return const_reverse_iterator(end());
244 }
245
246 // string_view::rend()
247 //
248 // Returns a reverse iterator pointing just before the first character at the
249 // beginning of the `string_view`. This pointer acts as a placeholder;
250 // attempting to access its element results in undefined behavior.
251 const_reverse_iterator rend() const noexcept {
252 return const_reverse_iterator(begin());
253 }
254
255 // string_view::crbegin()
256 //
257 // Returns a const reverse iterator pointing to the last character at the end
258 // of the `string_view`, or `crend()` if the `string_view` is empty.
259 const_reverse_iterator crbegin() const noexcept { return rbegin(); }
260
261 // string_view::crend()
262 //
263 // Returns a const reverse iterator pointing just before the first character
264 // at the beginning of the `string_view`. This pointer acts as a placeholder;
265 // attempting to access its element results in undefined behavior.
266 const_reverse_iterator crend() const noexcept { return rend(); }
267
268 // Capacity Utilities
269
270 // string_view::size()
271 //
272 // Returns the number of characters in the `string_view`.
273 constexpr size_type size() const noexcept { return length_; }
274
275 // string_view::length()
276 //
277 // Returns the number of characters in the `string_view`. Alias for `size()`.
278 constexpr size_type length() const noexcept { return size(); }
279
280 // string_view::max_size()
281 //
282 // Returns the maximum number of characters the `string_view` can hold.
283 constexpr size_type max_size() const noexcept { return kMaxSize; }
284
285 // string_view::empty()
286 //
287 // Checks if the `string_view` is empty (refers to no characters).
288 constexpr bool empty() const noexcept { return length_ == 0; }
289
290 // string_view::operator[]
291 //
292 // Returns the ith element of the `string_view` using the array operator.
293 // Note that this operator does not perform any bounds checking.
294 constexpr const_reference operator[](size_type i) const {
295 ABSL_HARDENING_ASSERT(i < size());
296 return ptr_[i];
297 }
298
299 // string_view::at()
300 //
301 // Returns the ith element of the `string_view`. Bounds checking is performed,
302 // and an exception of type `std::out_of_range` will be thrown on invalid
303 // access.
304 constexpr const_reference at(size_type i) const {
305 if (ABSL_PREDICT_FALSE(i >= size())) {
306 base_internal::ThrowStdOutOfRange("absl::string_view::at");
307 }
308 return ptr_[i];
309 }
310
311 // string_view::front()
312 //
313 // Returns the first element of a `string_view`.
314 constexpr const_reference front() const {
315 ABSL_HARDENING_ASSERT(!empty());
316 return ptr_[0];
317 }
318
319 // string_view::back()
320 //
321 // Returns the last element of a `string_view`.
322 constexpr const_reference back() const {
323 ABSL_HARDENING_ASSERT(!empty());
324 return ptr_[size() - 1];
325 }
326
327 // string_view::data()
328 //
329 // Returns a pointer to the underlying character array (which is of course
330 // stored elsewhere). Note that `string_view::data()` may contain embedded nul
331 // characters, but the returned buffer may or may not be NUL-terminated;
332 // therefore, do not pass `data()` to a routine that expects a NUL-terminated
333 // string.
334 constexpr const_pointer data() const noexcept { return ptr_; }
335
336 // Modifiers
337
338 // string_view::remove_prefix()
339 //
340 // Removes the first `n` characters from the `string_view`. Note that the
341 // underlying string is not changed, only the view.
342 constexpr void remove_prefix(size_type n) {
343 ABSL_HARDENING_ASSERT(n <= length_);
344 ptr_ += n;
345 length_ -= n;
346 }
347
348 // string_view::remove_suffix()
349 //
350 // Removes the last `n` characters from the `string_view`. Note that the
351 // underlying string is not changed, only the view.
352 constexpr void remove_suffix(size_type n) {
353 ABSL_HARDENING_ASSERT(n <= length_);
354 length_ -= n;
355 }
356
357 // string_view::swap()
358 //
359 // Swaps this `string_view` with another `string_view`.
360 constexpr void swap(string_view& s) noexcept {
361 auto t = *this;
362 *this = s;
363 s = t;
364 }
365
366 // Explicit conversion operators
367
368 // Converts to `std::basic_string`.
369 template <typename A>
370 explicit operator std::basic_string<char, traits_type, A>() const {
371 if (!data()) return {};
372 return std::basic_string<char, traits_type, A>(data(), size());
373 }
374
375 // string_view::copy()
376 //
377 // Copies the contents of the `string_view` at offset `pos` and length `n`
378 // into `buf`.
379 size_type copy(char* buf, size_type n, size_type pos = 0) const {
380 if (ABSL_PREDICT_FALSE(pos > length_)) {
381 base_internal::ThrowStdOutOfRange("absl::string_view::copy");
382 }
383 size_type rlen = (std::min)(length_ - pos, n);
384 if (rlen > 0) {
385 const char* start = ptr_ + pos;
386 traits_type::copy(buf, start, rlen);
387 }
388 return rlen;
389 }
390
391 // string_view::substr()
392 //
393 // Returns a "substring" of the `string_view` (at offset `pos` and length
394 // `n`) as another string_view. This function throws `std::out_of_bounds` if
395 // `pos > size`.
396 // Use absl::ClippedSubstr if you need a truncating substr operation.
397 constexpr string_view substr(size_type pos = 0, size_type n = npos) const {
398 if (ABSL_PREDICT_FALSE(pos > length_)) {
399 base_internal::ThrowStdOutOfRange("absl::string_view::substr");
400 }
401 return string_view(ptr_ + pos, Min(n, length_ - pos));
402 }
403
404 // string_view::compare()
405 //
406 // Performs a lexicographical comparison between this `string_view` and
407 // another `string_view` `x`, returning a negative value if `*this` is less
408 // than `x`, 0 if `*this` is equal to `x`, and a positive value if `*this`
409 // is greater than `x`.
410 constexpr int compare(string_view x) const noexcept {
411 return CompareImpl(length_, x.length_,
412 Min(length_, x.length_) == 0
413 ? 0
414 : ABSL_INTERNAL_STRING_VIEW_MEMCMP(
415 ptr_, x.ptr_, Min(length_, x.length_)));
416 }
417
418 // Overload of `string_view::compare()` for comparing a substring of the
419 // 'string_view` and another `absl::string_view`.
420 constexpr int compare(size_type pos1, size_type count1, string_view v) const {
421 return substr(pos1, count1).compare(v);
422 }
423
424 // Overload of `string_view::compare()` for comparing a substring of the
425 // `string_view` and a substring of another `absl::string_view`.
426 constexpr int compare(size_type pos1, size_type count1, string_view v,
427 size_type pos2, size_type count2) const {
428 return substr(pos1, count1).compare(v.substr(pos2, count2));
429 }
430
431 // Overload of `string_view::compare()` for comparing a `string_view` and a
432 // a different C-style string `s`.
433 constexpr int compare(absl::Nonnull<const char*> s) const {
434 return compare(string_view(s));
435 }
436
437 // Overload of `string_view::compare()` for comparing a substring of the
438 // `string_view` and a different string C-style string `s`.
439 constexpr int compare(size_type pos1, size_type count1,
440 absl::Nonnull<const char*> s) const {
441 return substr(pos1, count1).compare(string_view(s));
442 }
443
444 // Overload of `string_view::compare()` for comparing a substring of the
445 // `string_view` and a substring of a different C-style string `s`.
446 constexpr int compare(size_type pos1, size_type count1,
447 absl::Nonnull<const char*> s, size_type count2) const {
448 return substr(pos1, count1).compare(string_view(s, count2));
449 }
450
451 // Find Utilities
452
453 // string_view::find()
454 //
455 // Finds the first occurrence of the substring `s` within the `string_view`,
456 // returning the position of the first character's match, or `npos` if no
457 // match was found.
458 size_type find(string_view s, size_type pos = 0) const noexcept;
459
460 // Overload of `string_view::find()` for finding the given character `c`
461 // within the `string_view`.
462 size_type find(char c, size_type pos = 0) const noexcept;
463
464 // Overload of `string_view::find()` for finding a substring of a different
465 // C-style string `s` within the `string_view`.
466 size_type find(absl::Nonnull<const char*> s, size_type pos,
467 size_type count) const {
468 return find(string_view(s, count), pos);
469 }
470
471 // Overload of `string_view::find()` for finding a different C-style string
472 // `s` within the `string_view`.
473 size_type find(absl::Nonnull<const char *> s, size_type pos = 0) const {
474 return find(string_view(s), pos);
475 }
476
477 // string_view::rfind()
478 //
479 // Finds the last occurrence of a substring `s` within the `string_view`,
480 // returning the position of the first character's match, or `npos` if no
481 // match was found.
482 size_type rfind(string_view s, size_type pos = npos) const noexcept;
483
484 // Overload of `string_view::rfind()` for finding the last given character `c`
485 // within the `string_view`.
486 size_type rfind(char c, size_type pos = npos) const noexcept;
487
488 // Overload of `string_view::rfind()` for finding a substring of a different
489 // C-style string `s` within the `string_view`.
490 size_type rfind(absl::Nonnull<const char*> s, size_type pos,
491 size_type count) const {
492 return rfind(string_view(s, count), pos);
493 }
494
495 // Overload of `string_view::rfind()` for finding a different C-style string
496 // `s` within the `string_view`.
497 size_type rfind(absl::Nonnull<const char*> s, size_type pos = npos) const {
498 return rfind(string_view(s), pos);
499 }
500
501 // string_view::find_first_of()
502 //
503 // Finds the first occurrence of any of the characters in `s` within the
504 // `string_view`, returning the start position of the match, or `npos` if no
505 // match was found.
506 size_type find_first_of(string_view s, size_type pos = 0) const noexcept;
507
508 // Overload of `string_view::find_first_of()` for finding a character `c`
509 // within the `string_view`.
510 size_type find_first_of(char c, size_type pos = 0) const noexcept {
511 return find(c, pos);
512 }
513
514 // Overload of `string_view::find_first_of()` for finding a substring of a
515 // different C-style string `s` within the `string_view`.
516 size_type find_first_of(absl::Nonnull<const char*> s, size_type pos,
517 size_type count) const {
518 return find_first_of(string_view(s, count), pos);
519 }
520
521 // Overload of `string_view::find_first_of()` for finding a different C-style
522 // string `s` within the `string_view`.
523 size_type find_first_of(absl::Nonnull<const char*> s,
524 size_type pos = 0) const {
525 return find_first_of(string_view(s), pos);
526 }
527
528 // string_view::find_last_of()
529 //
530 // Finds the last occurrence of any of the characters in `s` within the
531 // `string_view`, returning the start position of the match, or `npos` if no
532 // match was found.
533 size_type find_last_of(string_view s, size_type pos = npos) const noexcept;
534
535 // Overload of `string_view::find_last_of()` for finding a character `c`
536 // within the `string_view`.
537 size_type find_last_of(char c, size_type pos = npos) const noexcept {
538 return rfind(c, pos);
539 }
540
541 // Overload of `string_view::find_last_of()` for finding a substring of a
542 // different C-style string `s` within the `string_view`.
543 size_type find_last_of(absl::Nonnull<const char*> s, size_type pos,
544 size_type count) const {
545 return find_last_of(string_view(s, count), pos);
546 }
547
548 // Overload of `string_view::find_last_of()` for finding a different C-style
549 // string `s` within the `string_view`.
550 size_type find_last_of(absl::Nonnull<const char*> s,
551 size_type pos = npos) const {
552 return find_last_of(string_view(s), pos);
553 }
554
555 // string_view::find_first_not_of()
556 //
557 // Finds the first occurrence of any of the characters not in `s` within the
558 // `string_view`, returning the start position of the first non-match, or
559 // `npos` if no non-match was found.
560 size_type find_first_not_of(string_view s, size_type pos = 0) const noexcept;
561
562 // Overload of `string_view::find_first_not_of()` for finding a character
563 // that is not `c` within the `string_view`.
564 size_type find_first_not_of(char c, size_type pos = 0) const noexcept;
565
566 // Overload of `string_view::find_first_not_of()` for finding a substring of a
567 // different C-style string `s` within the `string_view`.
568 size_type find_first_not_of(absl::Nonnull<const char*> s, size_type pos,
569 size_type count) const {
570 return find_first_not_of(string_view(s, count), pos);
571 }
572
573 // Overload of `string_view::find_first_not_of()` for finding a different
574 // C-style string `s` within the `string_view`.
575 size_type find_first_not_of(absl::Nonnull<const char*> s,
576 size_type pos = 0) const {
577 return find_first_not_of(string_view(s), pos);
578 }
579
580 // string_view::find_last_not_of()
581 //
582 // Finds the last occurrence of any of the characters not in `s` within the
583 // `string_view`, returning the start position of the last non-match, or
584 // `npos` if no non-match was found.
585 size_type find_last_not_of(string_view s,
586 size_type pos = npos) const noexcept;
587
588 // Overload of `string_view::find_last_not_of()` for finding a character
589 // that is not `c` within the `string_view`.
590 size_type find_last_not_of(char c, size_type pos = npos) const noexcept;
591
592 // Overload of `string_view::find_last_not_of()` for finding a substring of a
593 // different C-style string `s` within the `string_view`.
594 size_type find_last_not_of(absl::Nonnull<const char*> s, size_type pos,
595 size_type count) const {
596 return find_last_not_of(string_view(s, count), pos);
597 }
598
599 // Overload of `string_view::find_last_not_of()` for finding a different
600 // C-style string `s` within the `string_view`.
601 size_type find_last_not_of(absl::Nonnull<const char*> s,
602 size_type pos = npos) const {
603 return find_last_not_of(string_view(s), pos);
604 }
605
606#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
607 // string_view::starts_with()
608 //
609 // Returns true if the `string_view` starts with the prefix `s`.
610 //
611 // This method only exists when targeting at least C++20.
612 // If support for C++ prior to C++20 is required, use `absl::StartsWith()`
613 // from `//absl/strings/match.h` for compatibility.
614 constexpr bool starts_with(string_view s) const noexcept {
615 return s.empty() ||
616 (size() >= s.size() &&
617 ABSL_INTERNAL_STRING_VIEW_MEMCMP(data(), s.data(), s.size()) == 0);
618 }
619
620 // Overload of `string_view::starts_with()` that returns true if `c` is the
621 // first character of the `string_view`.
622 constexpr bool starts_with(char c) const noexcept {
623 return !empty() && front() == c;
624 }
625
626 // Overload of `string_view::starts_with()` that returns true if the
627 // `string_view` starts with the C-style prefix `s`.
628 constexpr bool starts_with(const char* s) const {
629 return starts_with(string_view(s));
630 }
631
632 // string_view::ends_with()
633 //
634 // Returns true if the `string_view` ends with the suffix `s`.
635 //
636 // This method only exists when targeting at least C++20.
637 // If support for C++ prior to C++20 is required, use `absl::EndsWith()`
638 // from `//absl/strings/match.h` for compatibility.
639 constexpr bool ends_with(string_view s) const noexcept {
640 return s.empty() || (size() >= s.size() && ABSL_INTERNAL_STRING_VIEW_MEMCMP(
641 data() + (size() - s.size()),
642 s.data(), s.size()) == 0);
643 }
644
645 // Overload of `string_view::ends_with()` that returns true if `c` is the
646 // last character of the `string_view`.
647 constexpr bool ends_with(char c) const noexcept {
648 return !empty() && back() == c;
649 }
650
651 // Overload of `string_view::ends_with()` that returns true if the
652 // `string_view` ends with the C-style suffix `s`.
653 constexpr bool ends_with(const char* s) const {
654 return ends_with(string_view(s));
655 }
656#endif // ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
657
658 private:
659 // The constructor from std::string delegates to this constructor.
660 // See the comment on that constructor for the rationale.
661 struct SkipCheckLengthTag {};
662 string_view(absl::Nullable<const char*> data, size_type len,
663 SkipCheckLengthTag) noexcept
664 : ptr_(data), length_(len) {}
665
666 static constexpr size_type kMaxSize =
667 (std::numeric_limits<difference_type>::max)();
668
669 static constexpr size_type CheckLengthInternal(size_type len) {
670 ABSL_HARDENING_ASSERT(len <= kMaxSize);
671 return len;
672 }
673
674 static constexpr size_type StrlenInternal(absl::Nonnull<const char*> str) {
675#if defined(_MSC_VER) && !defined(__clang__)
676 // MSVC 2017+ can evaluate this at compile-time.
677 const char* begin = str;
678 while (*str != '\0') ++str;
679 return str - begin;
680#elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \
681 (defined(__GNUC__) && !defined(__clang__))
682 // GCC has __builtin_strlen according to
683 // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
684 // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
685 // __builtin_strlen is constexpr.
686 return __builtin_strlen(str);
687#else
688 return str ? strlen(str) : 0;
689#endif
690 }
691
692 static constexpr size_t Min(size_type length_a, size_type length_b) {
693 return length_a < length_b ? length_a : length_b;
694 }
695
696 static constexpr int CompareImpl(size_type length_a, size_type length_b,
697 int compare_result) {
698 return compare_result == 0 ? static_cast<int>(length_a > length_b) -
699 static_cast<int>(length_a < length_b)
700 : (compare_result < 0 ? -1 : 1);
701 }
702
703 absl::Nullable<const char*> ptr_;
704 size_type length_;
705};
706
707// This large function is defined inline so that in a fairly common case where
708// one of the arguments is a literal, the compiler can elide a lot of the
709// following comparisons.
710constexpr bool operator==(string_view x, string_view y) noexcept {
711 return x.size() == y.size() &&
712 (x.empty() ||
713 ABSL_INTERNAL_STRING_VIEW_MEMCMP(x.data(), y.data(), x.size()) == 0);
714}
715
716constexpr bool operator!=(string_view x, string_view y) noexcept {
717 return !(x == y);
718}
719
720constexpr bool operator<(string_view x, string_view y) noexcept {
721 return x.compare(y) < 0;
722}
723
724constexpr bool operator>(string_view x, string_view y) noexcept {
725 return y < x;
726}
727
728constexpr bool operator<=(string_view x, string_view y) noexcept {
729 return !(y < x);
730}
731
732constexpr bool operator>=(string_view x, string_view y) noexcept {
733 return !(x < y);
734}
735
736// IO Insertion Operator
737std::ostream& operator<<(std::ostream& o, string_view piece);
738
739ABSL_NAMESPACE_END
740} // namespace absl
741
742#undef ABSL_INTERNAL_STRING_VIEW_MEMCMP
743
744#endif // ABSL_USES_STD_STRING_VIEW
745
746namespace absl {
747ABSL_NAMESPACE_BEGIN
748
749// ClippedSubstr()
750//
751// Like `s.substr(pos, n)`, but clips `pos` to an upper bound of `s.size()`.
752// Provided because std::string_view::substr throws if `pos > size()`
753inline string_view ClippedSubstr(string_view s, size_t pos,
754 size_t n = string_view::npos) {
755 pos = (std::min)(a: pos, b: static_cast<size_t>(s.size()));
756 return s.substr(pos: pos, n: n);
757}
758
759// NullSafeStringView()
760//
761// Creates an `absl::string_view` from a pointer `p` even if it's null-valued.
762// This function should be used where an `absl::string_view` can be created from
763// a possibly-null pointer.
764constexpr string_view NullSafeStringView(absl::Nullable<const char*> p) {
765 return p ? string_view(p) : string_view();
766}
767
768ABSL_NAMESPACE_END
769} // namespace absl
770
771#endif // ABSL_STRINGS_STRING_VIEW_H_
772