grpc 1.51.0-x86_64-linux → 1.52.0-x86_64-linux

data/third_party/abseil-cpp/absl/strings/internal/str_split_internal.h

@@ -1,430 +0,0 @@
-// 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.
-//
-
-// This file declares INTERNAL parts of the Split API that are inline/templated
-// or otherwise need to be available at compile time. The main abstractions
-// defined in here are
-//
-//   - ConvertibleToStringView
-//   - SplitIterator<>
-//   - Splitter<>
-//
-// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including
-// absl/strings/str_split.h.
-//
-// IWYU pragma: private, include "absl/strings/str_split.h"
-
-#ifndef ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
-#define ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
-
-#include <array>
-#include <initializer_list>
-#include <iterator>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include "absl/base/macros.h"
-#include "absl/base/port.h"
-#include "absl/meta/type_traits.h"
-#include "absl/strings/string_view.h"
-
-#ifdef _GLIBCXX_DEBUG
-#include "absl/strings/internal/stl_type_traits.h"
-#endif  // _GLIBCXX_DEBUG
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// This class is implicitly constructible from everything that absl::string_view
-// is implicitly constructible from, except for rvalue strings.  This means it
-// can be used as a function parameter in places where passing a temporary
-// string might cause memory lifetime issues.
-class ConvertibleToStringView {
- public:
-  ConvertibleToStringView(const char* s)  // NOLINT(runtime/explicit)
-      : value_(s) {}
-  ConvertibleToStringView(char* s) : value_(s) {}  // NOLINT(runtime/explicit)
-  ConvertibleToStringView(absl::string_view s)     // NOLINT(runtime/explicit)
-      : value_(s) {}
-  ConvertibleToStringView(const std::string& s)  // NOLINT(runtime/explicit)
-      : value_(s) {}
-
-  // Disable conversion from rvalue strings.
-  ConvertibleToStringView(std::string&& s) = delete;
-  ConvertibleToStringView(const std::string&& s) = delete;
-
-  absl::string_view value() const { return value_; }
-
- private:
-  absl::string_view value_;
-};
-
-// An iterator that enumerates the parts of a string from a Splitter. The text
-// to be split, the Delimiter, and the Predicate are all taken from the given
-// Splitter object. Iterators may only be compared if they refer to the same
-// Splitter instance.
-//
-// This class is NOT part of the public splitting API.
-template <typename Splitter>
-class SplitIterator {
- public:
-  using iterator_category = std::input_iterator_tag;
-  using value_type = absl::string_view;
-  using difference_type = ptrdiff_t;
-  using pointer = const value_type*;
-  using reference = const value_type&;
-
-  enum State { kInitState, kLastState, kEndState };
-  SplitIterator(State state, const Splitter* splitter)
-      : pos_(0),
-        state_(state),
-        splitter_(splitter),
-        delimiter_(splitter->delimiter()),
-        predicate_(splitter->predicate()) {
-    // Hack to maintain backward compatibility. This one block makes it so an
-    // empty absl::string_view whose .data() happens to be nullptr behaves
-    // *differently* from an otherwise empty absl::string_view whose .data() is
-    // not nullptr. This is an undesirable difference in general, but this
-    // behavior is maintained to avoid breaking existing code that happens to
-    // depend on this old behavior/bug. Perhaps it will be fixed one day. The
-    // difference in behavior is as follows:
-    //   Split(absl::string_view(""), '-');  // {""}
-    //   Split(absl::string_view(), '-');    // {}
-    if (splitter_->text().data() == nullptr) {
-      state_ = kEndState;
-      pos_ = splitter_->text().size();
-      return;
-    }
-
-    if (state_ == kEndState) {
-      pos_ = splitter_->text().size();
-    } else {
-      ++(*this);
-    }
-  }
-
-  bool at_end() const { return state_ == kEndState; }
-
-  reference operator*() const { return curr_; }
-  pointer operator->() const { return &curr_; }
-
-  SplitIterator& operator++() {
-    do {
-      if (state_ == kLastState) {
-        state_ = kEndState;
-        return *this;
-      }
-      const absl::string_view text = splitter_->text();
-      const absl::string_view d = delimiter_.Find(text, pos_);
-      if (d.data() == text.data() + text.size()) state_ = kLastState;
-      curr_ = text.substr(pos_, d.data() - (text.data() + pos_));
-      pos_ += curr_.size() + d.size();
-    } while (!predicate_(curr_));
-    return *this;
-  }
-
-  SplitIterator operator++(int) {
-    SplitIterator old(*this);
-    ++(*this);
-    return old;
-  }
-
-  friend bool operator==(const SplitIterator& a, const SplitIterator& b) {
-    return a.state_ == b.state_ && a.pos_ == b.pos_;
-  }
-
-  friend bool operator!=(const SplitIterator& a, const SplitIterator& b) {
-    return !(a == b);
-  }
-
- private:
-  size_t pos_;
-  State state_;
-  absl::string_view curr_;
-  const Splitter* splitter_;
-  typename Splitter::DelimiterType delimiter_;
-  typename Splitter::PredicateType predicate_;
-};
-
-// HasMappedType<T>::value is true iff there exists a type T::mapped_type.
-template <typename T, typename = void>
-struct HasMappedType : std::false_type {};
-template <typename T>
-struct HasMappedType<T, absl::void_t<typename T::mapped_type>>
-    : std::true_type {};
-
-// HasValueType<T>::value is true iff there exists a type T::value_type.
-template <typename T, typename = void>
-struct HasValueType : std::false_type {};
-template <typename T>
-struct HasValueType<T, absl::void_t<typename T::value_type>> : std::true_type {
-};
-
-// HasConstIterator<T>::value is true iff there exists a type T::const_iterator.
-template <typename T, typename = void>
-struct HasConstIterator : std::false_type {};
-template <typename T>
-struct HasConstIterator<T, absl::void_t<typename T::const_iterator>>
-    : std::true_type {};
-
-// HasEmplace<T>::value is true iff there exists a method T::emplace().
-template <typename T, typename = void>
-struct HasEmplace : std::false_type {};
-template <typename T>
-struct HasEmplace<T, absl::void_t<decltype(std::declval<T>().emplace())>>
-    : std::true_type {};
-
-// IsInitializerList<T>::value is true iff T is an std::initializer_list. More
-// details below in Splitter<> where this is used.
-std::false_type IsInitializerListDispatch(...);  // default: No
-template <typename T>
-std::true_type IsInitializerListDispatch(std::initializer_list<T>*);
-template <typename T>
-struct IsInitializerList
-    : decltype(IsInitializerListDispatch(static_cast<T*>(nullptr))) {};
-
-// A SplitterIsConvertibleTo<C>::type alias exists iff the specified condition
-// is true for type 'C'.
-//
-// Restricts conversion to container-like types (by testing for the presence of
-// a const_iterator member type) and also to disable conversion to an
-// std::initializer_list (which also has a const_iterator). Otherwise, code
-// compiled in C++11 will get an error due to ambiguous conversion paths (in
-// C++11 std::vector<T>::operator= is overloaded to take either a std::vector<T>
-// or an std::initializer_list<T>).
-
-template <typename C, bool has_value_type, bool has_mapped_type>
-struct SplitterIsConvertibleToImpl : std::false_type {};
-
-template <typename C>
-struct SplitterIsConvertibleToImpl<C, true, false>
-    : std::is_constructible<typename C::value_type, absl::string_view> {};
-
-template <typename C>
-struct SplitterIsConvertibleToImpl<C, true, true>
-    : absl::conjunction<
-          std::is_constructible<typename C::key_type, absl::string_view>,
-          std::is_constructible<typename C::mapped_type, absl::string_view>> {};
-
-template <typename C>
-struct SplitterIsConvertibleTo
-    : SplitterIsConvertibleToImpl<
-          C,
-#ifdef _GLIBCXX_DEBUG
-          !IsStrictlyBaseOfAndConvertibleToSTLContainer<C>::value &&
-#endif  // _GLIBCXX_DEBUG
-              !IsInitializerList<
-                  typename std::remove_reference<C>::type>::value &&
-              HasValueType<C>::value && HasConstIterator<C>::value,
-          HasMappedType<C>::value> {
-};
-
-// This class implements the range that is returned by absl::StrSplit(). This
-// class has templated conversion operators that allow it to be implicitly
-// converted to a variety of types that the caller may have specified on the
-// left-hand side of an assignment.
-//
-// The main interface for interacting with this class is through its implicit
-// conversion operators. However, this class may also be used like a container
-// in that it has .begin() and .end() member functions. It may also be used
-// within a range-for loop.
-//
-// Output containers can be collections of any type that is constructible from
-// an absl::string_view.
-//
-// An Predicate functor may be supplied. This predicate will be used to filter
-// the split strings: only strings for which the predicate returns true will be
-// kept. A Predicate object is any unary functor that takes an absl::string_view
-// and returns bool.
-//
-// The StringType parameter can be either string_view or string, depending on
-// whether the Splitter refers to a string stored elsewhere, or if the string
-// resides inside the Splitter itself.
-template <typename Delimiter, typename Predicate, typename StringType>
-class Splitter {
- public:
-  using DelimiterType = Delimiter;
-  using PredicateType = Predicate;
-  using const_iterator = strings_internal::SplitIterator<Splitter>;
-  using value_type = typename std::iterator_traits<const_iterator>::value_type;
-
-  Splitter(StringType input_text, Delimiter d, Predicate p)
-      : text_(std::move(input_text)),
-        delimiter_(std::move(d)),
-        predicate_(std::move(p)) {}
-
-  absl::string_view text() const { return text_; }
-  const Delimiter& delimiter() const { return delimiter_; }
-  const Predicate& predicate() const { return predicate_; }
-
-  // Range functions that iterate the split substrings as absl::string_view
-  // objects. These methods enable a Splitter to be used in a range-based for
-  // loop.
-  const_iterator begin() const { return {const_iterator::kInitState, this}; }
-  const_iterator end() const { return {const_iterator::kEndState, this}; }
-
-  // An implicit conversion operator that is restricted to only those containers
-  // that the splitter is convertible to.
-  template <typename Container,
-            typename = typename std::enable_if<
-                SplitterIsConvertibleTo<Container>::value>::type>
-  operator Container() const {  // NOLINT(runtime/explicit)
-    return ConvertToContainer<Container, typename Container::value_type,
-                              HasMappedType<Container>::value>()(*this);
-  }
-
-  // Returns a pair with its .first and .second members set to the first two
-  // strings returned by the begin() iterator. Either/both of .first and .second
-  // will be constructed with empty strings if the iterator doesn't have a
-  // corresponding value.
-  template <typename First, typename Second>
-  operator std::pair<First, Second>() const {  // NOLINT(runtime/explicit)
-    absl::string_view first, second;
-    auto it = begin();
-    if (it != end()) {
-      first = *it;
-      if (++it != end()) {
-        second = *it;
-      }
-    }
-    return {First(first), Second(second)};
-  }
-
- private:
-  // ConvertToContainer is a functor converting a Splitter to the requested
-  // Container of ValueType. It is specialized below to optimize splitting to
-  // certain combinations of Container and ValueType.
-  //
-  // This base template handles the generic case of storing the split results in
-  // the requested non-map-like container and converting the split substrings to
-  // the requested type.
-  template <typename Container, typename ValueType, bool is_map = false>
-  struct ConvertToContainer {
-    Container operator()(const Splitter& splitter) const {
-      Container c;
-      auto it = std::inserter(c, c.end());
-      for (const auto& sp : splitter) {
-        *it++ = ValueType(sp);
-      }
-      return c;
-    }
-  };
-
-  // Partial specialization for a std::vector<absl::string_view>.
-  //
-  // Optimized for the common case of splitting to a
-  // std::vector<absl::string_view>. In this case we first split the results to
-  // a small array of absl::string_view on the stack, to reduce reallocations.
-  template <typename A>
-  struct ConvertToContainer<std::vector<absl::string_view, A>,
-                            absl::string_view, false> {
-    std::vector<absl::string_view, A> operator()(
-        const Splitter& splitter) const {
-      struct raw_view {
-        const char* data;
-        size_t size;
-        operator absl::string_view() const {  // NOLINT(runtime/explicit)
-          return {data, size};
-        }
-      };
-      std::vector<absl::string_view, A> v;
-      std::array<raw_view, 16> ar;
-      for (auto it = splitter.begin(); !it.at_end();) {
-        size_t index = 0;
-        do {
-          ar[index].data = it->data();
-          ar[index].size = it->size();
-          ++it;
-        } while (++index != ar.size() && !it.at_end());
-        v.insert(v.end(), ar.begin(), ar.begin() + index);
-      }
-      return v;
-    }
-  };
-
-  // Partial specialization for a std::vector<std::string>.
-  //
-  // Optimized for the common case of splitting to a std::vector<std::string>.
-  // In this case we first split the results to a std::vector<absl::string_view>
-  // so the returned std::vector<std::string> can have space reserved to avoid
-  // std::string moves.
-  template <typename A>
-  struct ConvertToContainer<std::vector<std::string, A>, std::string, false> {
-    std::vector<std::string, A> operator()(const Splitter& splitter) const {
-      const std::vector<absl::string_view> v = splitter;
-      return std::vector<std::string, A>(v.begin(), v.end());
-    }
-  };
-
-  // Partial specialization for containers of pairs (e.g., maps).
-  //
-  // The algorithm is to insert a new pair into the map for each even-numbered
-  // item, with the even-numbered item as the key with a default-constructed
-  // value. Each odd-numbered item will then be assigned to the last pair's
-  // value.
-  template <typename Container, typename First, typename Second>
-  struct ConvertToContainer<Container, std::pair<const First, Second>, true> {
-    using iterator = typename Container::iterator;
-
-    Container operator()(const Splitter& splitter) const {
-      Container m;
-      iterator it;
-      bool insert = true;
-      for (const absl::string_view sv : splitter) {
-        if (insert) {
-          it = InsertOrEmplace(&m, sv);
-        } else {
-          it->second = Second(sv);
-        }
-        insert = !insert;
-      }
-      return m;
-    }
-
-    // Inserts the key and an empty value into the map, returning an iterator to
-    // the inserted item. We use emplace() if available, otherwise insert().
-    template <typename M>
-    static absl::enable_if_t<HasEmplace<M>::value, iterator> InsertOrEmplace(
-        M* m, absl::string_view key) {
-      // Use piecewise_construct to support old versions of gcc in which pair
-      // constructor can't otherwise construct string from string_view.
-      return ToIter(m->emplace(std::piecewise_construct, std::make_tuple(key),
-                               std::tuple<>()));
-    }
-    template <typename M>
-    static absl::enable_if_t<!HasEmplace<M>::value, iterator> InsertOrEmplace(
-        M* m, absl::string_view key) {
-      return ToIter(m->insert(std::make_pair(First(key), Second(""))));
-    }
-
-    static iterator ToIter(std::pair<iterator, bool> pair) {
-      return pair.first;
-    }
-    static iterator ToIter(iterator iter) { return iter; }
-  };
-
-  StringType text_;
-  Delimiter delimiter_;
-  Predicate predicate_;
-};
-
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_

data/third_party/abseil-cpp/absl/strings/internal/string_constant.h

@@ -1,72 +0,0 @@
-// Copyright 2020 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.
-
-#ifndef ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
-#define ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
-
-#include "absl/meta/type_traits.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// StringConstant<T> represents a compile time string constant.
-// It can be accessed via its `absl::string_view value` static member.
-// It is guaranteed that the `string_view` returned has constant `.data()`,
-// constant `.size()` and constant `value[i]` for all `0 <= i < .size()`
-//
-// The `T` is an opaque type. It is guaranteed that different string constants
-// will have different values of `T`. This allows users to associate the string
-// constant with other static state at compile time.
-//
-// Instances should be made using the `MakeStringConstant()` factory function
-// below.
-template <typename T>
-struct StringConstant {
- private:
-  static constexpr bool TryConstexprEval(absl::string_view view) {
-    return view.empty() || 2 * view[0] != 1;
-  }
-
- public:
-  static constexpr absl::string_view value = T{}();
-  constexpr absl::string_view operator()() const { return value; }
-
-  // Check to be sure `view` points to constant data.
-  // Otherwise, it can't be constant evaluated.
-  static_assert(TryConstexprEval(value),
-                "The input string_view must point to constant data.");
-};
-
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-template <typename T>
-constexpr absl::string_view StringConstant<T>::value;
-#endif
-
-// Factory function for `StringConstant` instances.
-// It supports callables that have a constexpr default constructor and a
-// constexpr operator().
-// It must return an `absl::string_view` or `const char*` pointing to constant
-// data. This is validated at compile time.
-template <typename T>
-constexpr StringConstant<T> MakeStringConstant(T) {
-  return {};
-}
-
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_

data/third_party/abseil-cpp/absl/strings/internal/utf8.cc

@@ -1,53 +0,0 @@
-// 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.
-
-// UTF8 utilities, implemented to reduce dependencies.
-
-#include "absl/strings/internal/utf8.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-size_t EncodeUTF8Char(char *buffer, char32_t utf8_char) {
-  if (utf8_char <= 0x7F) {
-    *buffer = static_cast<char>(utf8_char);
-    return 1;
-  } else if (utf8_char <= 0x7FF) {
-    buffer[1] = static_cast<char>(0x80 | (utf8_char & 0x3F));
-    utf8_char >>= 6;
-    buffer[0] = static_cast<char>(0xC0 | utf8_char);
-    return 2;
-  } else if (utf8_char <= 0xFFFF) {
-    buffer[2] = static_cast<char>(0x80 | (utf8_char & 0x3F));
-    utf8_char >>= 6;
-    buffer[1] = static_cast<char>(0x80 | (utf8_char & 0x3F));
-    utf8_char >>= 6;
-    buffer[0] = static_cast<char>(0xE0 | utf8_char);
-    return 3;
-  } else {
-    buffer[3] = static_cast<char>(0x80 | (utf8_char & 0x3F));
-    utf8_char >>= 6;
-    buffer[2] = static_cast<char>(0x80 | (utf8_char & 0x3F));
-    utf8_char >>= 6;
-    buffer[1] = static_cast<char>(0x80 | (utf8_char & 0x3F));
-    utf8_char >>= 6;
-    buffer[0] = static_cast<char>(0xF0 | utf8_char);
-    return 4;
-  }
-}
-
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

data/third_party/abseil-cpp/absl/strings/internal/utf8.h

@@ -1,50 +0,0 @@
-// 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.
-//
-// UTF8 utilities, implemented to reduce dependencies.
-
-#ifndef ABSL_STRINGS_INTERNAL_UTF8_H_
-#define ABSL_STRINGS_INTERNAL_UTF8_H_
-
-#include <cstddef>
-#include <cstdint>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// For Unicode code points 0 through 0x10FFFF, EncodeUTF8Char writes
-// out the UTF-8 encoding into buffer, and returns the number of chars
-// it wrote.
-//
-// As described in https://tools.ietf.org/html/rfc3629#section-3 , the encodings
-// are:
-//    00 -     7F : 0xxxxxxx
-//    80 -    7FF : 110xxxxx 10xxxxxx
-//   800 -   FFFF : 1110xxxx 10xxxxxx 10xxxxxx
-// 10000 - 10FFFF : 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-//
-// Values greater than 0x10FFFF are not supported and may or may not write
-// characters into buffer, however never will more than kMaxEncodedUTF8Size
-// bytes be written, regardless of the value of utf8_char.
-enum { kMaxEncodedUTF8Size = 4 };
-size_t EncodeUTF8Char(char *buffer, char32_t utf8_char);
-
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_STRINGS_INTERNAL_UTF8_H_

data/third_party/abseil-cpp/absl/strings/match.cc

@@ -1,43 +0,0 @@
-// 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.
-
-#include "absl/strings/match.h"
-
-#include "absl/strings/internal/memutil.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-bool EqualsIgnoreCase(absl::string_view piece1,
-                      absl::string_view piece2) noexcept {
-  return (piece1.size() == piece2.size() &&
-          0 == absl::strings_internal::memcasecmp(piece1.data(), piece2.data(),
-                                                  piece1.size()));
-  // memcasecmp uses absl::ascii_tolower().
-}
-
-bool StartsWithIgnoreCase(absl::string_view text,
-                          absl::string_view prefix) noexcept {
-  return (text.size() >= prefix.size()) &&
-         EqualsIgnoreCase(text.substr(0, prefix.size()), prefix);
-}
-
-bool EndsWithIgnoreCase(absl::string_view text,
-                        absl::string_view suffix) noexcept {
-  return (text.size() >= suffix.size()) &&
-         EqualsIgnoreCase(text.substr(text.size() - suffix.size()), suffix);
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl