| // |
| // Copyright 2017 The Abseil Authors. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| // ----------------------------------------------------------------------------- |
| // File: string_view.h |
| // ----------------------------------------------------------------------------- |
| // |
| // This file contains the definition of the `absl::string_view` class. A |
| // `string_view` points to a contiguous span of characters, often part or all of |
| // another `std::string`, double-quoted string literal, character array, or even |
| // another `string_view`. |
| // |
| // This `absl::string_view` abstraction is designed to be a drop-in |
| // replacement for the C++17 `std::string_view` abstraction. |
| #ifndef ABSL_STRINGS_STRING_VIEW_H_ |
| #define ABSL_STRINGS_STRING_VIEW_H_ |
| |
| #include <algorithm> |
| #include <cassert> |
| #include <cstddef> |
| #include <cstring> |
| #include <iosfwd> |
| #include <iterator> |
| #include <limits> |
| #include <string> |
| |
| #include "absl/base/attributes.h" |
| #include "absl/base/nullability.h" |
| #include "absl/base/config.h" |
| #include "absl/base/internal/throw_delegate.h" |
| #include "absl/base/macros.h" |
| #include "absl/base/optimization.h" |
| #include "absl/base/port.h" |
| |
| #ifdef ABSL_USES_STD_STRING_VIEW |
| |
| #include <string_view> // IWYU pragma: export |
| |
| namespace absl { |
| ABSL_NAMESPACE_BEGIN |
| using string_view = std::string_view; |
| ABSL_NAMESPACE_END |
| } // namespace absl |
| |
| #else // ABSL_USES_STD_STRING_VIEW |
| |
| #if ABSL_HAVE_BUILTIN(__builtin_memcmp) || \ |
| (defined(__GNUC__) && !defined(__clang__)) || \ |
| (defined(_MSC_VER) && _MSC_VER >= 1928) |
| #define ABSL_INTERNAL_STRING_VIEW_MEMCMP __builtin_memcmp |
| #else // ABSL_HAVE_BUILTIN(__builtin_memcmp) |
| #define ABSL_INTERNAL_STRING_VIEW_MEMCMP memcmp |
| #endif // ABSL_HAVE_BUILTIN(__builtin_memcmp) |
| |
| namespace absl { |
| ABSL_NAMESPACE_BEGIN |
| |
| // absl::string_view |
| // |
| // A `string_view` provides a lightweight view into the string data provided by |
| // a `std::string`, double-quoted string literal, character array, or even |
| // another `string_view`. A `string_view` does *not* own the string to which it |
| // points, and that data cannot be modified through the view. |
| // |
| // You can use `string_view` as a function or method parameter anywhere a |
| // parameter can receive a double-quoted string literal, `const char*`, |
| // `std::string`, or another `absl::string_view` argument with no need to copy |
| // the string data. Systematic use of `string_view` within function arguments |
| // reduces data copies and `strlen()` calls. |
| // |
| // Because of its small size, prefer passing `string_view` by value: |
| // |
| // void MyFunction(absl::string_view arg); |
| // |
| // If circumstances require, you may also pass one by const reference: |
| // |
| // void MyFunction(const absl::string_view& arg); // not preferred |
| // |
| // Passing by value generates slightly smaller code for many architectures. |
| // |
| // In either case, the source data of the `string_view` must outlive the |
| // `string_view` itself. |
| // |
| // A `string_view` is also suitable for local variables if you know that the |
| // lifetime of the underlying object is longer than the lifetime of your |
| // `string_view` variable. However, beware of binding a `string_view` to a |
| // temporary value: |
| // |
| // // BAD use of string_view: lifetime problem |
| // absl::string_view sv = obj.ReturnAString(); |
| // |
| // // GOOD use of string_view: str outlives sv |
| // std::string str = obj.ReturnAString(); |
| // absl::string_view sv = str; |
| // |
| // Due to lifetime issues, a `string_view` is sometimes a poor choice for a |
| // return value and usually a poor choice for a data member. If you do use a |
| // `string_view` this way, it is your responsibility to ensure that the object |
| // pointed to by the `string_view` outlives the `string_view`. |
| // |
| // A `string_view` may represent a whole string or just part of a string. For |
| // example, when splitting a string, `std::vector<absl::string_view>` is a |
| // natural data type for the output. |
| // |
| // For another example, a Cord is a non-contiguous, potentially very |
| // long string-like object. The Cord class has an interface that iteratively |
| // provides string_view objects that point to the successive pieces of a Cord |
| // object. |
| // |
| // When constructed from a source which is NUL-terminated, the `string_view` |
| // itself will not include the NUL-terminator unless a specific size (including |
| // the NUL) is passed to the constructor. As a result, common idioms that work |
| // on NUL-terminated strings do not work on `string_view` objects. If you write |
| // code that scans a `string_view`, you must check its length rather than test |
| // for nul, for example. Note, however, that nuls may still be embedded within |
| // a `string_view` explicitly. |
| // |
| // You may create a null `string_view` in two ways: |
| // |
| // absl::string_view sv; |
| // absl::string_view sv(nullptr, 0); |
| // |
| // For the above, `sv.data() == nullptr`, `sv.length() == 0`, and |
| // `sv.empty() == true`. Also, if you create a `string_view` with a non-null |
| // pointer then `sv.data() != nullptr`. Thus, you can use `string_view()` to |
| // signal an undefined value that is different from other `string_view` values |
| // in a similar fashion to how `const char* p1 = nullptr;` is different from |
| // `const char* p2 = "";`. However, in practice, it is not recommended to rely |
| // on this behavior. |
| // |
| // Be careful not to confuse a null `string_view` with an empty one. A null |
| // `string_view` is an empty `string_view`, but some empty `string_view`s are |
| // not null. Prefer checking for emptiness over checking for null. |
| // |
| // There are many ways to create an empty string_view: |
| // |
| // const char* nullcp = nullptr; |
| // // string_view.size() will return 0 in all cases. |
| // absl::string_view(); |
| // absl::string_view(nullcp, 0); |
| // absl::string_view(""); |
| // absl::string_view("", 0); |
| // absl::string_view("abcdef", 0); |
| // absl::string_view("abcdef" + 6, 0); |
| // |
| // All empty `string_view` objects whether null or not, are equal: |
| // |
| // absl::string_view() == absl::string_view("", 0) |
| // absl::string_view(nullptr, 0) == absl::string_view("abcdef"+6, 0) |
| class string_view { |
| public: |
| using traits_type = std::char_traits<char>; |
| using value_type = char; |
| using pointer = absl::Nullable<char*>; |
| using const_pointer = absl::Nullable<const char*>; |
| using reference = char&; |
| using const_reference = const char&; |
| using const_iterator = absl::Nullable<const char*>; |
| using iterator = const_iterator; |
| using const_reverse_iterator = std::reverse_iterator<const_iterator>; |
| using reverse_iterator = const_reverse_iterator; |
| using size_type = size_t; |
| using difference_type = std::ptrdiff_t; |
| |
| static constexpr size_type npos = static_cast<size_type>(-1); |
| |
| // Null `string_view` constructor |
| constexpr string_view() noexcept : ptr_(nullptr), length_(0) {} |
| |
| // Implicit constructors |
| |
| template <typename Allocator> |
| string_view( // NOLINT(runtime/explicit) |
| const std::basic_string<char, std::char_traits<char>, Allocator>& str |
| ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept |
| // This is implemented in terms of `string_view(p, n)` so `str.size()` |
| // doesn't need to be reevaluated after `ptr_` is set. |
| // The length check is also skipped since it is unnecessary and causes |
| // code bloat. |
| : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {} |
| |
| // Implicit constructor of a `string_view` from NUL-terminated `str`. When |
| // accepting possibly null strings, use `absl::NullSafeStringView(str)` |
| // instead (see below). |
| // The length check is skipped since it is unnecessary and causes code bloat. |
| constexpr string_view( // NOLINT(runtime/explicit) |
| absl::Nonnull<const char*> str) |
| : ptr_(str), length_(str ? StrlenInternal(str) : 0) {} |
| |
| // Implicit constructor of a `string_view` from a `const char*` and length. |
| constexpr string_view(absl::Nullable<const char*> data, size_type len) |
| : ptr_(data), length_(CheckLengthInternal(len)) {} |
| |
| // NOTE: Harmlessly omitted to work around gdb bug. |
| // constexpr string_view(const string_view&) noexcept = default; |
| // string_view& operator=(const string_view&) noexcept = default; |
| |
| // Iterators |
| |
| // string_view::begin() |
| // |
| // Returns an iterator pointing to the first character at the beginning of the |
| // `string_view`, or `end()` if the `string_view` is empty. |
| constexpr const_iterator begin() const noexcept { return ptr_; } |
| |
| // string_view::end() |
| // |
| // Returns an iterator pointing just beyond the last character at the end of |
| // the `string_view`. This iterator acts as a placeholder; attempting to |
| // access it results in undefined behavior. |
| constexpr const_iterator end() const noexcept { return ptr_ + length_; } |
| |
| // string_view::cbegin() |
| // |
| // Returns a const iterator pointing to the first character at the beginning |
| // of the `string_view`, or `end()` if the `string_view` is empty. |
| constexpr const_iterator cbegin() const noexcept { return begin(); } |
| |
| // string_view::cend() |
| // |
| // Returns a const iterator pointing just beyond the last character at the end |
| // of the `string_view`. This pointer acts as a placeholder; attempting to |
| // access its element results in undefined behavior. |
| constexpr const_iterator cend() const noexcept { return end(); } |
| |
| // string_view::rbegin() |
| // |
| // Returns a reverse iterator pointing to the last character at the end of the |
| // `string_view`, or `rend()` if the `string_view` is empty. |
| const_reverse_iterator rbegin() const noexcept { |
| return const_reverse_iterator(end()); |
| } |
| |
| // string_view::rend() |
| // |
| // Returns a reverse iterator pointing just before the first character at the |
| // beginning of the `string_view`. This pointer acts as a placeholder; |
| // attempting to access its element results in undefined behavior. |
| const_reverse_iterator rend() const noexcept { |
| return const_reverse_iterator(begin()); |
| } |
| |
| // string_view::crbegin() |
| // |
| // Returns a const reverse iterator pointing to the last character at the end |
| // of the `string_view`, or `crend()` if the `string_view` is empty. |
| const_reverse_iterator crbegin() const noexcept { return rbegin(); } |
| |
| // string_view::crend() |
| // |
| // Returns a const reverse iterator pointing just before the first character |
| // at the beginning of the `string_view`. This pointer acts as a placeholder; |
| // attempting to access its element results in undefined behavior. |
| const_reverse_iterator crend() const noexcept { return rend(); } |
| |
| // Capacity Utilities |
| |
| // string_view::size() |
| // |
| // Returns the number of characters in the `string_view`. |
| constexpr size_type size() const noexcept { return length_; } |
| |
| // string_view::length() |
| // |
| // Returns the number of characters in the `string_view`. Alias for `size()`. |
| constexpr size_type length() const noexcept { return size(); } |
| |
| // string_view::max_size() |
| // |
| // Returns the maximum number of characters the `string_view` can hold. |
| constexpr size_type max_size() const noexcept { return kMaxSize; } |
| |
| // string_view::empty() |
| // |
| // Checks if the `string_view` is empty (refers to no characters). |
| constexpr bool empty() const noexcept { return length_ == 0; } |
| |
| // string_view::operator[] |
| // |
| // Returns the ith element of the `string_view` using the array operator. |
| // Note that this operator does not perform any bounds checking. |
| constexpr const_reference operator[](size_type i) const { |
| return ABSL_HARDENING_ASSERT(i < size()), ptr_[i]; |
| } |
| |
| // string_view::at() |
| // |
| // Returns the ith element of the `string_view`. Bounds checking is performed, |
| // and an exception of type `std::out_of_range` will be thrown on invalid |
| // access. |
| constexpr const_reference at(size_type i) const { |
| return ABSL_PREDICT_TRUE(i < size()) |
| ? ptr_[i] |
| : ((void)base_internal::ThrowStdOutOfRange( |
| "absl::string_view::at"), |
| ptr_[i]); |
| } |
| |
| // string_view::front() |
| // |
| // Returns the first element of a `string_view`. |
| constexpr const_reference front() const { |
| return ABSL_HARDENING_ASSERT(!empty()), ptr_[0]; |
| } |
| |
| // string_view::back() |
| // |
| // Returns the last element of a `string_view`. |
| constexpr const_reference back() const { |
| return ABSL_HARDENING_ASSERT(!empty()), ptr_[size() - 1]; |
| } |
| |
| // string_view::data() |
| // |
| // Returns a pointer to the underlying character array (which is of course |
| // stored elsewhere). Note that `string_view::data()` may contain embedded nul |
| // characters, but the returned buffer may or may not be NUL-terminated; |
| // therefore, do not pass `data()` to a routine that expects a NUL-terminated |
| // string. |
| constexpr const_pointer data() const noexcept { return ptr_; } |
| |
| // Modifiers |
| |
| // string_view::remove_prefix() |
| // |
| // Removes the first `n` characters from the `string_view`. Note that the |
| // underlying string is not changed, only the view. |
| constexpr void remove_prefix(size_type n) { |
| ABSL_HARDENING_ASSERT(n <= length_); |
| ptr_ += n; |
| length_ -= n; |
| } |
| |
| // string_view::remove_suffix() |
| // |
| // Removes the last `n` characters from the `string_view`. Note that the |
| // underlying string is not changed, only the view. |
| constexpr void remove_suffix(size_type n) { |
| ABSL_HARDENING_ASSERT(n <= length_); |
| length_ -= n; |
| } |
| |
| // string_view::swap() |
| // |
| // Swaps this `string_view` with another `string_view`. |
| constexpr void swap(string_view& s) noexcept { |
| auto t = *this; |
| *this = s; |
| s = t; |
| } |
| |
| // Explicit conversion operators |
| |
| // Converts to `std::basic_string`. |
| template <typename A> |
| explicit operator std::basic_string<char, traits_type, A>() const { |
| if (!data()) return {}; |
| return std::basic_string<char, traits_type, A>(data(), size()); |
| } |
| |
| // string_view::copy() |
| // |
| // Copies the contents of the `string_view` at offset `pos` and length `n` |
| // into `buf`. |
| size_type copy(char* buf, size_type n, size_type pos = 0) const { |
| if (ABSL_PREDICT_FALSE(pos > length_)) { |
| base_internal::ThrowStdOutOfRange("absl::string_view::copy"); |
| } |
| size_type rlen = (std::min)(length_ - pos, n); |
| if (rlen > 0) { |
| const char* start = ptr_ + pos; |
| traits_type::copy(buf, start, rlen); |
| } |
| return rlen; |
| } |
| |
| // string_view::substr() |
| // |
| // Returns a "substring" of the `string_view` (at offset `pos` and length |
| // `n`) as another string_view. This function throws `std::out_of_bounds` if |
| // `pos > size`. |
| // Use absl::ClippedSubstr if you need a truncating substr operation. |
| constexpr string_view substr(size_type pos = 0, size_type n = npos) const { |
| return ABSL_PREDICT_FALSE(pos > length_) |
| ? (base_internal::ThrowStdOutOfRange( |
| "absl::string_view::substr"), |
| string_view()) |
| : string_view(ptr_ + pos, Min(n, length_ - pos)); |
| } |
| |
| // string_view::compare() |
| // |
| // Performs a lexicographical comparison between this `string_view` and |
| // another `string_view` `x`, returning a negative value if `*this` is less |
| // than `x`, 0 if `*this` is equal to `x`, and a positive value if `*this` |
| // is greater than `x`. |
| constexpr int compare(string_view x) const noexcept { |
| return CompareImpl(length_, x.length_, |
| Min(length_, x.length_) == 0 |
| ? 0 |
| : ABSL_INTERNAL_STRING_VIEW_MEMCMP( |
| ptr_, x.ptr_, Min(length_, x.length_))); |
| } |
| |
| // Overload of `string_view::compare()` for comparing a substring of the |
| // 'string_view` and another `absl::string_view`. |
| constexpr int compare(size_type pos1, size_type count1, string_view v) const { |
| return substr(pos1, count1).compare(v); |
| } |
| |
| // Overload of `string_view::compare()` for comparing a substring of the |
| // `string_view` and a substring of another `absl::string_view`. |
| constexpr int compare(size_type pos1, size_type count1, string_view v, |
| size_type pos2, size_type count2) const { |
| return substr(pos1, count1).compare(v.substr(pos2, count2)); |
| } |
| |
| // Overload of `string_view::compare()` for comparing a `string_view` and a |
| // a different C-style string `s`. |
| constexpr int compare(absl::Nonnull<const char*> s) const { |
| return compare(string_view(s)); |
| } |
| |
| // Overload of `string_view::compare()` for comparing a substring of the |
| // `string_view` and a different string C-style string `s`. |
| constexpr int compare(size_type pos1, size_type count1, |
| absl::Nonnull<const char*> s) const { |
| return substr(pos1, count1).compare(string_view(s)); |
| } |
| |
| // Overload of `string_view::compare()` for comparing a substring of the |
| // `string_view` and a substring of a different C-style string `s`. |
| constexpr int compare(size_type pos1, size_type count1, |
| absl::Nonnull<const char*> s, size_type count2) const { |
| return substr(pos1, count1).compare(string_view(s, count2)); |
| } |
| |
| // Find Utilities |
| |
| // string_view::find() |
| // |
| // Finds the first occurrence of the substring `s` within the `string_view`, |
| // returning the position of the first character's match, or `npos` if no |
| // match was found. |
| size_type find(string_view s, size_type pos = 0) const noexcept; |
| |
| // Overload of `string_view::find()` for finding the given character `c` |
| // within the `string_view`. |
| size_type find(char c, size_type pos = 0) const noexcept; |
| |
| // Overload of `string_view::find()` for finding a substring of a different |
| // C-style string `s` within the `string_view`. |
| size_type find(absl::Nonnull<const char*> s, size_type pos, |
| size_type count) const { |
| return find(string_view(s, count), pos); |
| } |
| |
| // Overload of `string_view::find()` for finding a different C-style string |
| // `s` within the `string_view`. |
| size_type find(absl::Nonnull<const char *> s, size_type pos = 0) const { |
| return find(string_view(s), pos); |
| } |
| |
| // string_view::rfind() |
| // |
| // Finds the last occurrence of a substring `s` within the `string_view`, |
| // returning the position of the first character's match, or `npos` if no |
| // match was found. |
| size_type rfind(string_view s, size_type pos = npos) const noexcept; |
| |
| // Overload of `string_view::rfind()` for finding the last given character `c` |
| // within the `string_view`. |
| size_type rfind(char c, size_type pos = npos) const noexcept; |
| |
| // Overload of `string_view::rfind()` for finding a substring of a different |
| // C-style string `s` within the `string_view`. |
| size_type rfind(absl::Nonnull<const char*> s, size_type pos, |
| size_type count) const { |
| return rfind(string_view(s, count), pos); |
| } |
| |
| // Overload of `string_view::rfind()` for finding a different C-style string |
| // `s` within the `string_view`. |
| size_type rfind(absl::Nonnull<const char*> s, size_type pos = npos) const { |
| return rfind(string_view(s), pos); |
| } |
| |
| // string_view::find_first_of() |
| // |
| // Finds the first occurrence of any of the characters in `s` within the |
| // `string_view`, returning the start position of the match, or `npos` if no |
| // match was found. |
| size_type find_first_of(string_view s, size_type pos = 0) const noexcept; |
| |
| // Overload of `string_view::find_first_of()` for finding a character `c` |
| // within the `string_view`. |
| size_type find_first_of(char c, size_type pos = 0) const noexcept { |
| return find(c, pos); |
| } |
| |
| // Overload of `string_view::find_first_of()` for finding a substring of a |
| // different C-style string `s` within the `string_view`. |
| size_type find_first_of(absl::Nonnull<const char*> s, size_type pos, |
| size_type count) const { |
| return find_first_of(string_view(s, count), pos); |
| } |
| |
| // Overload of `string_view::find_first_of()` for finding a different C-style |
| // string `s` within the `string_view`. |
| size_type find_first_of(absl::Nonnull<const char*> s, |
| size_type pos = 0) const { |
| return find_first_of(string_view(s), pos); |
| } |
| |
| // string_view::find_last_of() |
| // |
| // Finds the last occurrence of any of the characters in `s` within the |
| // `string_view`, returning the start position of the match, or `npos` if no |
| // match was found. |
| size_type find_last_of(string_view s, size_type pos = npos) const noexcept; |
| |
| // Overload of `string_view::find_last_of()` for finding a character `c` |
| // within the `string_view`. |
| size_type find_last_of(char c, size_type pos = npos) const noexcept { |
| return rfind(c, pos); |
| } |
| |
| // Overload of `string_view::find_last_of()` for finding a substring of a |
| // different C-style string `s` within the `string_view`. |
| size_type find_last_of(absl::Nonnull<const char*> s, size_type pos, |
| size_type count) const { |
| return find_last_of(string_view(s, count), pos); |
| } |
| |
| // Overload of `string_view::find_last_of()` for finding a different C-style |
| // string `s` within the `string_view`. |
| size_type find_last_of(absl::Nonnull<const char*> s, |
| size_type pos = npos) const { |
| return find_last_of(string_view(s), pos); |
| } |
| |
| // string_view::find_first_not_of() |
| // |
| // Finds the first occurrence of any of the characters not in `s` within the |
| // `string_view`, returning the start position of the first non-match, or |
| // `npos` if no non-match was found. |
| size_type find_first_not_of(string_view s, size_type pos = 0) const noexcept; |
| |
| // Overload of `string_view::find_first_not_of()` for finding a character |
| // that is not `c` within the `string_view`. |
| size_type find_first_not_of(char c, size_type pos = 0) const noexcept; |
| |
| // Overload of `string_view::find_first_not_of()` for finding a substring of a |
| // different C-style string `s` within the `string_view`. |
| size_type find_first_not_of(absl::Nonnull<const char*> s, size_type pos, |
| size_type count) const { |
| return find_first_not_of(string_view(s, count), pos); |
| } |
| |
| // Overload of `string_view::find_first_not_of()` for finding a different |
| // C-style string `s` within the `string_view`. |
| size_type find_first_not_of(absl::Nonnull<const char*> s, |
| size_type pos = 0) const { |
| return find_first_not_of(string_view(s), pos); |
| } |
| |
| // string_view::find_last_not_of() |
| // |
| // Finds the last occurrence of any of the characters not in `s` within the |
| // `string_view`, returning the start position of the last non-match, or |
| // `npos` if no non-match was found. |
| size_type find_last_not_of(string_view s, |
| size_type pos = npos) const noexcept; |
| |
| // Overload of `string_view::find_last_not_of()` for finding a character |
| // that is not `c` within the `string_view`. |
| size_type find_last_not_of(char c, size_type pos = npos) const noexcept; |
| |
| // Overload of `string_view::find_last_not_of()` for finding a substring of a |
| // different C-style string `s` within the `string_view`. |
| size_type find_last_not_of(absl::Nonnull<const char*> s, size_type pos, |
| size_type count) const { |
| return find_last_not_of(string_view(s, count), pos); |
| } |
| |
| // Overload of `string_view::find_last_not_of()` for finding a different |
| // C-style string `s` within the `string_view`. |
| size_type find_last_not_of(absl::Nonnull<const char*> s, |
| size_type pos = npos) const { |
| return find_last_not_of(string_view(s), pos); |
| } |
| |
| #if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L |
| // string_view::starts_with() |
| // |
| // Returns true if the `string_view` starts with the prefix `s`. |
| // |
| // This method only exists when targeting at least C++20. |
| // If support for C++ prior to C++20 is required, use `absl::StartsWith()` |
| // from `//absl/strings/match.h` for compatibility. |
| constexpr bool starts_with(string_view s) const noexcept { |
| return s.empty() || |
| (size() >= s.size() && |
| ABSL_INTERNAL_STRING_VIEW_MEMCMP(data(), s.data(), s.size()) == 0); |
| } |
| |
| // Overload of `string_view::starts_with()` that returns true if `c` is the |
| // first character of the `string_view`. |
| constexpr bool starts_with(char c) const noexcept { |
| return !empty() && front() == c; |
| } |
| |
| // Overload of `string_view::starts_with()` that returns true if the |
| // `string_view` starts with the C-style prefix `s`. |
| constexpr bool starts_with(const char* s) const { |
| return starts_with(string_view(s)); |
| } |
| |
| // string_view::ends_with() |
| // |
| // Returns true if the `string_view` ends with the suffix `s`. |
| // |
| // This method only exists when targeting at least C++20. |
| // If support for C++ prior to C++20 is required, use `absl::EndsWith()` |
| // from `//absl/strings/match.h` for compatibility. |
| constexpr bool ends_with(string_view s) const noexcept { |
| return s.empty() || (size() >= s.size() && ABSL_INTERNAL_STRING_VIEW_MEMCMP( |
| data() + (size() - s.size()), |
| s.data(), s.size()) == 0); |
| } |
| |
| // Overload of `string_view::ends_with()` that returns true if `c` is the |
| // last character of the `string_view`. |
| constexpr bool ends_with(char c) const noexcept { |
| return !empty() && back() == c; |
| } |
| |
| // Overload of `string_view::ends_with()` that returns true if the |
| // `string_view` ends with the C-style suffix `s`. |
| constexpr bool ends_with(const char* s) const { |
| return ends_with(string_view(s)); |
| } |
| #endif // ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L |
| |
| private: |
| // The constructor from std::string delegates to this constructor. |
| // See the comment on that constructor for the rationale. |
| struct SkipCheckLengthTag {}; |
| string_view(absl::Nullable<const char*> data, size_type len, |
| SkipCheckLengthTag) noexcept |
| : ptr_(data), length_(len) {} |
| |
| static constexpr size_type kMaxSize = |
| (std::numeric_limits<difference_type>::max)(); |
| |
| static constexpr size_type CheckLengthInternal(size_type len) { |
| return ABSL_HARDENING_ASSERT(len <= kMaxSize), len; |
| } |
| |
| static constexpr size_type StrlenInternal(absl::Nonnull<const char*> str) { |
| #if defined(_MSC_VER) && _MSC_VER >= 1910 && !defined(__clang__) |
| // MSVC 2017+ can evaluate this at compile-time. |
| const char* begin = str; |
| while (*str != '\0') ++str; |
| return str - begin; |
| #elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \ |
| (defined(__GNUC__) && !defined(__clang__)) |
| // GCC has __builtin_strlen according to |
| // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but |
| // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above. |
| // __builtin_strlen is constexpr. |
| return __builtin_strlen(str); |
| #else |
| return str ? strlen(str) : 0; |
| #endif |
| } |
| |
| static constexpr size_t Min(size_type length_a, size_type length_b) { |
| return length_a < length_b ? length_a : length_b; |
| } |
| |
| static constexpr int CompareImpl(size_type length_a, size_type length_b, |
| int compare_result) { |
| return compare_result == 0 ? static_cast<int>(length_a > length_b) - |
| static_cast<int>(length_a < length_b) |
| : (compare_result < 0 ? -1 : 1); |
| } |
| |
| absl::Nullable<const char*> ptr_; |
| size_type length_; |
| }; |
| |
| // This large function is defined inline so that in a fairly common case where |
| // one of the arguments is a literal, the compiler can elide a lot of the |
| // following comparisons. |
| constexpr bool operator==(string_view x, string_view y) noexcept { |
| return x.size() == y.size() && |
| (x.empty() || |
| ABSL_INTERNAL_STRING_VIEW_MEMCMP(x.data(), y.data(), x.size()) == 0); |
| } |
| |
| constexpr bool operator!=(string_view x, string_view y) noexcept { |
| return !(x == y); |
| } |
| |
| constexpr bool operator<(string_view x, string_view y) noexcept { |
| return x.compare(y) < 0; |
| } |
| |
| constexpr bool operator>(string_view x, string_view y) noexcept { |
| return y < x; |
| } |
| |
| constexpr bool operator<=(string_view x, string_view y) noexcept { |
| return !(y < x); |
| } |
| |
| constexpr bool operator>=(string_view x, string_view y) noexcept { |
| return !(x < y); |
| } |
| |
| // IO Insertion Operator |
| std::ostream& operator<<(std::ostream& o, string_view piece); |
| |
| ABSL_NAMESPACE_END |
| } // namespace absl |
| |
| #undef ABSL_INTERNAL_STRING_VIEW_MEMCMP |
| |
| #endif // ABSL_USES_STD_STRING_VIEW |
| |
| namespace absl { |
| ABSL_NAMESPACE_BEGIN |
| |
| // ClippedSubstr() |
| // |
| // Like `s.substr(pos, n)`, but clips `pos` to an upper bound of `s.size()`. |
| // Provided because std::string_view::substr throws if `pos > size()` |
| inline string_view ClippedSubstr(string_view s, size_t pos, |
| size_t n = string_view::npos) { |
| pos = (std::min)(pos, static_cast<size_t>(s.size())); |
| return s.substr(pos, n); |
| } |
| |
| // NullSafeStringView() |
| // |
| // Creates an `absl::string_view` from a pointer `p` even if it's null-valued. |
| // This function should be used where an `absl::string_view` can be created from |
| // a possibly-null pointer. |
| constexpr string_view NullSafeStringView(absl::Nullable<const char*> p) { |
| return p ? string_view(p) : string_view(); |
| } |
| |
| ABSL_NAMESPACE_END |
| } // namespace absl |
| |
| #endif // ABSL_STRINGS_STRING_VIEW_H_ |