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 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
177 static constexpr size_type npos = static_cast<size_type>(-1);
178
179 // Null `string_view` constructor
180 constexpr string_view() noexcept : ptr_(nullptr), length_(0) {}
181
182 // Implicit constructors
183
184 template <typename Allocator>
185 string_view( // NOLINT(runtime/explicit)
186 const std::basic_string<char, std::char_traits<char>, Allocator>& str
187 ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
188 // This is implemented in terms of `string_view(p, n)` so `str.size()`
189 // doesn't need to be reevaluated after `ptr_` is set.
190 // The length check is also skipped since it is unnecessary and causes
191 // code bloat.
192 : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {}
193
194 // Implicit constructor of a `string_view` from NUL-terminated `str`. When
195 // accepting possibly null strings, use `absl::NullSafeStringView(str)`
196 // instead (see below).
197 // The length check is skipped since it is unnecessary and causes code bloat.
198 constexpr string_view( // NOLINT(runtime/explicit)
199 absl::Nonnull<const char*> str)
200 : ptr_(str), length_(str ? StrlenInternal(str) : 0) {}
201
202 // Implicit constructor of a `string_view` from a `const char*` and length.
203 constexpr string_view(absl::Nullable<const char*> data, size_type len)
204 : ptr_(data), length_(CheckLengthInternal(len)) {}
205
206 // NOTE: Harmlessly omitted to work around gdb bug.
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 return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
296 }
297
298 // string_view::at()
299 //
300 // Returns the ith element of the `string_view`. Bounds checking is performed,
301 // and an exception of type `std::out_of_range` will be thrown on invalid
302 // access.
303 constexpr const_reference at(size_type i) const {
304 return ABSL_PREDICT_TRUE(i < size())
305 ? ptr_[i]
306 : ((void)base_internal::ThrowStdOutOfRange(
307 "absl::string_view::at"),
308 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 return ABSL_HARDENING_ASSERT(!empty()), ptr_[0];
316 }
317
318 // string_view::back()
319 //
320 // Returns the last element of a `string_view`.
321 constexpr const_reference back() const {
322 return ABSL_HARDENING_ASSERT(!empty()), ptr_[size() - 1];
323 }
324
325 // string_view::data()
326 //
327 // Returns a pointer to the underlying character array (which is of course
328 // stored elsewhere). Note that `string_view::data()` may contain embedded nul
329 // characters, but the returned buffer may or may not be NUL-terminated;
330 // therefore, do not pass `data()` to a routine that expects a NUL-terminated
331 // string.
332 constexpr const_pointer data() const noexcept { return ptr_; }
333
334 // Modifiers
335
336 // string_view::remove_prefix()
337 //
338 // Removes the first `n` characters from the `string_view`. Note that the
339 // underlying string is not changed, only the view.
340 constexpr void remove_prefix(size_type n) {
341 ABSL_HARDENING_ASSERT(n <= length_);
342 ptr_ += n;
343 length_ -= n;
344 }
345
346 // string_view::remove_suffix()
347 //
348 // Removes the last `n` characters from the `string_view`. Note that the
349 // underlying string is not changed, only the view.
350 constexpr void remove_suffix(size_type n) {
351 ABSL_HARDENING_ASSERT(n <= length_);
352 length_ -= n;
353 }
354
355 // string_view::swap()
356 //
357 // Swaps this `string_view` with another `string_view`.
358 constexpr void swap(string_view& s) noexcept {
359 auto t = *this;
360 *this = s;
361 s = t;
362 }
363
364 // Explicit conversion operators
365
366 // Converts to `std::basic_string`.
367 template <typename A>
368 explicit operator std::basic_string<char, traits_type, A>() const {
369 if (!data()) return {};
370 return std::basic_string<char, traits_type, A>(data(), size());
371 }
372
373 // string_view::copy()
374 //
375 // Copies the contents of the `string_view` at offset `pos` and length `n`
376 // into `buf`.
377 size_type copy(char* buf, size_type n, size_type pos = 0) const {
378 if (ABSL_PREDICT_FALSE(pos > length_)) {
379 base_internal::ThrowStdOutOfRange("absl::string_view::copy");
380 }
381 size_type rlen = (std::min)(length_ - pos, n);
382 if (rlen > 0) {
383 const char* start = ptr_ + pos;
384 traits_type::copy(buf, start, rlen);
385 }
386 return rlen;
387 }
388
389 // string_view::substr()
390 //
391 // Returns a "substring" of the `string_view` (at offset `pos` and length
392 // `n`) as another string_view. This function throws `std::out_of_bounds` if
393 // `pos > size`.
394 // Use absl::ClippedSubstr if you need a truncating substr operation.
395 constexpr string_view substr(size_type pos = 0, size_type n = npos) const {
396 return ABSL_PREDICT_FALSE(pos > length_)
397 ? (base_internal::ThrowStdOutOfRange(
398 "absl::string_view::substr"),
399 string_view())
400 : string_view(ptr_ + pos, Min(n, length_ - pos));
401 }
402
403 // string_view::compare()
404 //
405 // Performs a lexicographical comparison between this `string_view` and
406 // another `string_view` `x`, returning a negative value if `*this` is less
407 // than `x`, 0 if `*this` is equal to `x`, and a positive value if `*this`
408 // is greater than `x`.
409 constexpr int compare(string_view x) const noexcept {
410 return CompareImpl(length_, x.length_,
411 Min(length_, x.length_) == 0
412 ? 0
413 : ABSL_INTERNAL_STRING_VIEW_MEMCMP(
414 ptr_, x.ptr_, Min(length_, x.length_)));
415 }
416
417 // Overload of `string_view::compare()` for comparing a substring of the
418 // 'string_view` and another `absl::string_view`.
419 constexpr int compare(size_type pos1, size_type count1, string_view v) const {
420 return substr(pos1, count1).compare(v);
421 }
422
423 // Overload of `string_view::compare()` for comparing a substring of the
424 // `string_view` and a substring of another `absl::string_view`.
425 constexpr int compare(size_type pos1, size_type count1, string_view v,
426 size_type pos2, size_type count2) const {
427 return substr(pos1, count1).compare(v.substr(pos2, count2));
428 }
429
430 // Overload of `string_view::compare()` for comparing a `string_view` and a
431 // a different C-style string `s`.
432 constexpr int compare(absl::Nonnull<const char*> s) const {
433 return compare(string_view(s));
434 }
435
436 // Overload of `string_view::compare()` for comparing a substring of the
437 // `string_view` and a different string C-style string `s`.
438 constexpr int compare(size_type pos1, size_type count1,
439 absl::Nonnull<const char*> s) const {
440 return substr(pos1, count1).compare(string_view(s));
441 }
442
443 // Overload of `string_view::compare()` for comparing a substring of the
444 // `string_view` and a substring of a different C-style string `s`.
445 constexpr int compare(size_type pos1, size_type count1,
446 absl::Nonnull<const char*> s, size_type count2) const {
447 return substr(pos1, count1).compare(string_view(s, count2));
448 }
449
450 // Find Utilities
451
452 // string_view::find()
453 //
454 // Finds the first occurrence of the substring `s` within the `string_view`,
455 // returning the position of the first character's match, or `npos` if no
456 // match was found.
457 size_type find(string_view s, size_type pos = 0) const noexcept;
458
459 // Overload of `string_view::find()` for finding the given character `c`
460 // within the `string_view`.
461 size_type find(char c, size_type pos = 0) const noexcept;
462
463 // Overload of `string_view::find()` for finding a substring of a different
464 // C-style string `s` within the `string_view`.
465 size_type find(absl::Nonnull<const char*> s, size_type pos,
466 size_type count) const {
467 return find(string_view(s, count), pos);
468 }
469
470 // Overload of `string_view::find()` for finding a different C-style string
471 // `s` within the `string_view`.
472 size_type find(absl::Nonnull<const char *> s, size_type pos = 0) const {
473 return find(string_view(s), pos);
474 }
475
476 // string_view::rfind()
477 //
478 // Finds the last occurrence of a substring `s` within the `string_view`,
479 // returning the position of the first character's match, or `npos` if no
480 // match was found.
481 size_type rfind(string_view s, size_type pos = npos) const noexcept;
482
483 // Overload of `string_view::rfind()` for finding the last given character `c`
484 // within the `string_view`.
485 size_type rfind(char c, size_type pos = npos) const noexcept;
486
487 // Overload of `string_view::rfind()` for finding a substring of a different
488 // C-style string `s` within the `string_view`.
489 size_type rfind(absl::Nonnull<const char*> s, size_type pos,
490 size_type count) const {
491 return rfind(string_view(s, count), pos);
492 }
493
494 // Overload of `string_view::rfind()` for finding a different C-style string
495 // `s` within the `string_view`.
496 size_type rfind(absl::Nonnull<const char*> s, size_type pos = npos) const {
497 return rfind(string_view(s), pos);
498 }
499
500 // string_view::find_first_of()
501 //
502 // Finds the first occurrence of any of the characters in `s` within the
503 // `string_view`, returning the start position of the match, or `npos` if no
504 // match was found.
505 size_type find_first_of(string_view s, size_type pos = 0) const noexcept;
506
507 // Overload of `string_view::find_first_of()` for finding a character `c`
508 // within the `string_view`.
509 size_type find_first_of(char c, size_type pos = 0) const noexcept {
510 return find(c, pos);
511 }
512
513 // Overload of `string_view::find_first_of()` for finding a substring of a
514 // different C-style string `s` within the `string_view`.
515 size_type find_first_of(absl::Nonnull<const char*> s, size_type pos,
516 size_type count) const {
517 return find_first_of(string_view(s, count), pos);
518 }
519
520 // Overload of `string_view::find_first_of()` for finding a different C-style
521 // string `s` within the `string_view`.
522 size_type find_first_of(absl::Nonnull<const char*> s,
523 size_type pos = 0) const {
524 return find_first_of(string_view(s), pos);
525 }
526
527 // string_view::find_last_of()
528 //
529 // Finds the last occurrence of any of the characters in `s` within the
530 // `string_view`, returning the start position of the match, or `npos` if no
531 // match was found.
532 size_type find_last_of(string_view s, size_type pos = npos) const noexcept;
533
534 // Overload of `string_view::find_last_of()` for finding a character `c`
535 // within the `string_view`.
536 size_type find_last_of(char c, size_type pos = npos) const noexcept {
537 return rfind(c, pos);
538 }
539
540 // Overload of `string_view::find_last_of()` for finding a substring of a
541 // different C-style string `s` within the `string_view`.
542 size_type find_last_of(absl::Nonnull<const char*> s, size_type pos,
543 size_type count) const {
544 return find_last_of(string_view(s, count), pos);
545 }
546
547 // Overload of `string_view::find_last_of()` for finding a different C-style
548 // string `s` within the `string_view`.
549 size_type find_last_of(absl::Nonnull<const char*> s,
550 size_type pos = npos) const {
551 return find_last_of(string_view(s), pos);
552 }
553
554 // string_view::find_first_not_of()
555 //
556 // Finds the first occurrence of any of the characters not in `s` within the
557 // `string_view`, returning the start position of the first non-match, or
558 // `npos` if no non-match was found.
559 size_type find_first_not_of(string_view s, size_type pos = 0) const noexcept;
560
561 // Overload of `string_view::find_first_not_of()` for finding a character
562 // that is not `c` within the `string_view`.
563 size_type find_first_not_of(char c, size_type pos = 0) const noexcept;
564
565 // Overload of `string_view::find_first_not_of()` for finding a substring of a
566 // different C-style string `s` within the `string_view`.
567 size_type find_first_not_of(absl::Nonnull<const char*> s, size_type pos,
568 size_type count) const {
569 return find_first_not_of(string_view(s, count), pos);
570 }
571
572 // Overload of `string_view::find_first_not_of()` for finding a different
573 // C-style string `s` within the `string_view`.
574 size_type find_first_not_of(absl::Nonnull<const char*> s,
575 size_type pos = 0) const {
576 return find_first_not_of(string_view(s), pos);
577 }
578
579 // string_view::find_last_not_of()
580 //
581 // Finds the last occurrence of any of the characters not in `s` within the
582 // `string_view`, returning the start position of the last non-match, or
583 // `npos` if no non-match was found.
584 size_type find_last_not_of(string_view s,
585 size_type pos = npos) const noexcept;
586
587 // Overload of `string_view::find_last_not_of()` for finding a character
588 // that is not `c` within the `string_view`.
589 size_type find_last_not_of(char c, size_type pos = npos) const noexcept;
590
591 // Overload of `string_view::find_last_not_of()` for finding a substring of a
592 // different C-style string `s` within the `string_view`.
593 size_type find_last_not_of(absl::Nonnull<const char*> s, size_type pos,
594 size_type count) const {
595 return find_last_not_of(string_view(s, count), pos);
596 }
597
598 // Overload of `string_view::find_last_not_of()` for finding a different
599 // C-style string `s` within the `string_view`.
600 size_type find_last_not_of(absl::Nonnull<const char*> s,
601 size_type pos = npos) const {
602 return find_last_not_of(string_view(s), pos);
603 }
604
605#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
606 // string_view::starts_with()
607 //
608 // Returns true if the `string_view` starts with the prefix `s`.
609 //
610 // This method only exists when targeting at least C++20.
611 // If support for C++ prior to C++20 is required, use `absl::StartsWith()`
612 // from `//absl/strings/match.h` for compatibility.
613 constexpr bool starts_with(string_view s) const noexcept {
614 return s.empty() ||
615 (size() >= s.size() &&
616 ABSL_INTERNAL_STRING_VIEW_MEMCMP(data(), s.data(), s.size()) == 0);
617 }
618
619 // Overload of `string_view::starts_with()` that returns true if `c` is the
620 // first character of the `string_view`.
621 constexpr bool starts_with(char c) const noexcept {
622 return !empty() && front() == c;
623 }
624
625 // Overload of `string_view::starts_with()` that returns true if the
626 // `string_view` starts with the C-style prefix `s`.
627 constexpr bool starts_with(const char* s) const {
628 return starts_with(string_view(s));
629 }
630
631 // string_view::ends_with()
632 //
633 // Returns true if the `string_view` ends with the suffix `s`.
634 //
635 // This method only exists when targeting at least C++20.
636 // If support for C++ prior to C++20 is required, use `absl::EndsWith()`
637 // from `//absl/strings/match.h` for compatibility.
638 constexpr bool ends_with(string_view s) const noexcept {
639 return s.empty() || (size() >= s.size() && ABSL_INTERNAL_STRING_VIEW_MEMCMP(
640 data() + (size() - s.size()),
641 s.data(), s.size()) == 0);
642 }
643
644 // Overload of `string_view::ends_with()` that returns true if `c` is the
645 // last character of the `string_view`.
646 constexpr bool ends_with(char c) const noexcept {
647 return !empty() && back() == c;
648 }
649
650 // Overload of `string_view::ends_with()` that returns true if the
651 // `string_view` ends with the C-style suffix `s`.
652 constexpr bool ends_with(const char* s) const {
653 return ends_with(string_view(s));
654 }
655#endif // ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
656
657 private:
658 // The constructor from std::string delegates to this constructor.
659 // See the comment on that constructor for the rationale.
660 struct SkipCheckLengthTag {};
661 string_view(absl::Nullable<const char*> data, size_type len,
662 SkipCheckLengthTag) noexcept
663 : ptr_(data), length_(len) {}
664
665 static constexpr size_type kMaxSize =
666 (std::numeric_limits<difference_type>::max)();
667
668 static constexpr size_type CheckLengthInternal(size_type len) {
669 return ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
670 }
671
672 static constexpr size_type StrlenInternal(absl::Nonnull<const char*> str) {
673#if defined(_MSC_VER) && _MSC_VER >= 1910 && !defined(__clang__)
674 // MSVC 2017+ can evaluate this at compile-time.
675 const char* begin = str;
676 while (*str != '\0') ++str;
677 return str - begin;
678#elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \
679 (defined(__GNUC__) && !defined(__clang__))
680 // GCC has __builtin_strlen according to
681 // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
682 // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
683 // __builtin_strlen is constexpr.
684 return __builtin_strlen(str);
685#else
686 return str ? strlen(str) : 0;
687#endif
688 }
689
690 static constexpr size_t Min(size_type length_a, size_type length_b) {
691 return length_a < length_b ? length_a : length_b;
692 }
693
694 static constexpr int CompareImpl(size_type length_a, size_type length_b,
695 int compare_result) {
696 return compare_result == 0 ? static_cast<int>(length_a > length_b) -
697 static_cast<int>(length_a < length_b)
698 : (compare_result < 0 ? -1 : 1);
699 }
700
701 absl::Nullable<const char*> ptr_;
702 size_type length_;
703};
704
705// This large function is defined inline so that in a fairly common case where
706// one of the arguments is a literal, the compiler can elide a lot of the
707// following comparisons.
708constexpr bool operator==(string_view x, string_view y) noexcept {
709 return x.size() == y.size() &&
710 (x.empty() ||
711 ABSL_INTERNAL_STRING_VIEW_MEMCMP(x.data(), y.data(), x.size()) == 0);
712}
713
714constexpr bool operator!=(string_view x, string_view y) noexcept {
715 return !(x == y);
716}
717
718constexpr bool operator<(string_view x, string_view y) noexcept {
719 return x.compare(y) < 0;
720}
721
722constexpr bool operator>(string_view x, string_view y) noexcept {
723 return y < x;
724}
725
726constexpr bool operator<=(string_view x, string_view y) noexcept {
727 return !(y < x);
728}
729
730constexpr bool operator>=(string_view x, string_view y) noexcept {
731 return !(x < y);
732}
733
734// IO Insertion Operator
735std::ostream& operator<<(std::ostream& o, string_view piece);
736
737ABSL_NAMESPACE_END
738} // namespace absl
739
740#undef ABSL_INTERNAL_STRING_VIEW_MEMCMP
741
742#endif // ABSL_USES_STD_STRING_VIEW
743
744namespace absl {
745ABSL_NAMESPACE_BEGIN
746
747// ClippedSubstr()
748//
749// Like `s.substr(pos, n)`, but clips `pos` to an upper bound of `s.size()`.
750// Provided because std::string_view::substr throws if `pos > size()`
751inline string_view ClippedSubstr(string_view s, size_t pos,
752 size_t n = string_view::npos) {
753 pos = (std::min)(a: pos, b: static_cast<size_t>(s.size()));
754 return s.substr(pos: pos, n: n);
755}
756
757// NullSafeStringView()
758//
759// Creates an `absl::string_view` from a pointer `p` even if it's null-valued.
760// This function should be used where an `absl::string_view` can be created from
761// a possibly-null pointer.
762constexpr string_view NullSafeStringView(absl::Nullable<const char*> p) {
763 return p ? string_view(p) : string_view();
764}
765
766ABSL_NAMESPACE_END
767} // namespace absl
768
769#endif // ABSL_STRINGS_STRING_VIEW_H_
770