From 5aa5d282eac56a21e74611c1cdbaa97bb5db2dca Mon Sep 17 00:00:00 2001 From: Vincent Ambo Date: Tue, 8 Feb 2022 02:05:36 +0300 Subject: chore(3p/abseil_cpp): unvendor abseil_cpp we weren't actually using these sources anymore, okay? Change-Id: If701571d9716de308d3512e1eb22c35db0877a66 Reviewed-on: https://cl.tvl.fyi/c/depot/+/5248 Tested-by: BuildkiteCI Reviewed-by: grfn Autosubmit: tazjin --- third_party/abseil_cpp/absl/strings/str_split.h | 548 ------------------------ 1 file changed, 548 deletions(-) delete mode 100644 third_party/abseil_cpp/absl/strings/str_split.h (limited to 'third_party/abseil_cpp/absl/strings/str_split.h') diff --git a/third_party/abseil_cpp/absl/strings/str_split.h b/third_party/abseil_cpp/absl/strings/str_split.h deleted file mode 100644 index bfbca422a8dc..000000000000 --- a/third_party/abseil_cpp/absl/strings/str_split.h +++ /dev/null @@ -1,548 +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. -// -// ----------------------------------------------------------------------------- -// File: str_split.h -// ----------------------------------------------------------------------------- -// -// This file contains functions for splitting strings. It defines the main -// `StrSplit()` function, several delimiters for determining the boundaries on -// which to split the string, and predicates for filtering delimited results. -// `StrSplit()` adapts the returned collection to the type specified by the -// caller. -// -// Example: -// -// // Splits the given string on commas. Returns the results in a -// // vector of strings. -// std::vector v = absl::StrSplit("a,b,c", ','); -// // Can also use "," -// // v[0] == "a", v[1] == "b", v[2] == "c" -// -// See StrSplit() below for more information. -#ifndef ABSL_STRINGS_STR_SPLIT_H_ -#define ABSL_STRINGS_STR_SPLIT_H_ - -#include -#include -#include -#include -#include -#include -#include - -#include "absl/base/internal/raw_logging.h" -#include "absl/base/macros.h" -#include "absl/strings/internal/str_split_internal.h" -#include "absl/strings/string_view.h" -#include "absl/strings/strip.h" - -namespace absl { -ABSL_NAMESPACE_BEGIN - -//------------------------------------------------------------------------------ -// Delimiters -//------------------------------------------------------------------------------ -// -// `StrSplit()` uses delimiters to define the boundaries between elements in the -// provided input. Several `Delimiter` types are defined below. If a string -// (`const char*`, `std::string`, or `absl::string_view`) is passed in place of -// an explicit `Delimiter` object, `StrSplit()` treats it the same way as if it -// were passed a `ByString` delimiter. -// -// A `Delimiter` is an object with a `Find()` function that knows how to find -// the first occurrence of itself in a given `absl::string_view`. -// -// The following `Delimiter` types are available for use within `StrSplit()`: -// -// - `ByString` (default for string arguments) -// - `ByChar` (default for a char argument) -// - `ByAnyChar` -// - `ByLength` -// - `MaxSplits` -// -// A Delimiter's `Find()` member function will be passed an input `text` that is -// to be split and a position (`pos`) to begin searching for the next delimiter -// in `text`. The returned absl::string_view should refer to the next occurrence -// (after `pos`) of the represented delimiter; this returned absl::string_view -// represents the next location where the input `text` should be broken. -// -// The returned absl::string_view may be zero-length if the Delimiter does not -// represent a part of the string (e.g., a fixed-length delimiter). If no -// delimiter is found in the input `text`, a zero-length absl::string_view -// referring to `text.end()` should be returned (e.g., -// `text.substr(text.size())`). It is important that the returned -// absl::string_view always be within the bounds of the input `text` given as an -// argument--it must not refer to a string that is physically located outside of -// the given string. -// -// The following example is a simple Delimiter object that is created with a -// single char and will look for that char in the text passed to the `Find()` -// function: -// -// struct SimpleDelimiter { -// const char c_; -// explicit SimpleDelimiter(char c) : c_(c) {} -// absl::string_view Find(absl::string_view text, size_t pos) { -// auto found = text.find(c_, pos); -// if (found == absl::string_view::npos) -// return text.substr(text.size()); -// -// return text.substr(found, 1); -// } -// }; - -// ByString -// -// A sub-string delimiter. If `StrSplit()` is passed a string in place of a -// `Delimiter` object, the string will be implicitly converted into a -// `ByString` delimiter. -// -// Example: -// -// // Because a string literal is converted to an `absl::ByString`, -// // the following two splits are equivalent. -// -// std::vector v1 = absl::StrSplit("a, b, c", ", "); -// -// using absl::ByString; -// std::vector v2 = absl::StrSplit("a, b, c", -// ByString(", ")); -// // v[0] == "a", v[1] == "b", v[2] == "c" -class ByString { - public: - explicit ByString(absl::string_view sp); - absl::string_view Find(absl::string_view text, size_t pos) const; - - private: - const std::string delimiter_; -}; - -// ByChar -// -// A single character delimiter. `ByChar` is functionally equivalent to a -// 1-char string within a `ByString` delimiter, but slightly more efficient. -// -// Example: -// -// // Because a char literal is converted to a absl::ByChar, -// // the following two splits are equivalent. -// std::vector v1 = absl::StrSplit("a,b,c", ','); -// using absl::ByChar; -// std::vector v2 = absl::StrSplit("a,b,c", ByChar(',')); -// // v[0] == "a", v[1] == "b", v[2] == "c" -// -// `ByChar` is also the default delimiter if a single character is given -// as the delimiter to `StrSplit()`. For example, the following calls are -// equivalent: -// -// std::vector v = absl::StrSplit("a-b", '-'); -// -// using absl::ByChar; -// std::vector v = absl::StrSplit("a-b", ByChar('-')); -// -class ByChar { - public: - explicit ByChar(char c) : c_(c) {} - absl::string_view Find(absl::string_view text, size_t pos) const; - - private: - char c_; -}; - -// ByAnyChar -// -// A delimiter that will match any of the given byte-sized characters within -// its provided string. -// -// Note: this delimiter works with single-byte string data, but does not work -// with variable-width encodings, such as UTF-8. -// -// Example: -// -// using absl::ByAnyChar; -// std::vector v = absl::StrSplit("a,b=c", ByAnyChar(",=")); -// // v[0] == "a", v[1] == "b", v[2] == "c" -// -// If `ByAnyChar` is given the empty string, it behaves exactly like -// `ByString` and matches each individual character in the input string. -// -class ByAnyChar { - public: - explicit ByAnyChar(absl::string_view sp); - absl::string_view Find(absl::string_view text, size_t pos) const; - - private: - const std::string delimiters_; -}; - -// ByLength -// -// A delimiter for splitting into equal-length strings. The length argument to -// the constructor must be greater than 0. -// -// Note: this delimiter works with single-byte string data, but does not work -// with variable-width encodings, such as UTF-8. -// -// Example: -// -// using absl::ByLength; -// std::vector v = absl::StrSplit("123456789", ByLength(3)); - -// // v[0] == "123", v[1] == "456", v[2] == "789" -// -// Note that the string does not have to be a multiple of the fixed split -// length. In such a case, the last substring will be shorter. -// -// using absl::ByLength; -// std::vector v = absl::StrSplit("12345", ByLength(2)); -// -// // v[0] == "12", v[1] == "34", v[2] == "5" -class ByLength { - public: - explicit ByLength(ptrdiff_t length); - absl::string_view Find(absl::string_view text, size_t pos) const; - - private: - const ptrdiff_t length_; -}; - -namespace strings_internal { - -// A traits-like metafunction for selecting the default Delimiter object type -// for a particular Delimiter type. The base case simply exposes type Delimiter -// itself as the delimiter's Type. However, there are specializations for -// string-like objects that map them to the ByString delimiter object. -// This allows functions like absl::StrSplit() and absl::MaxSplits() to accept -// string-like objects (e.g., ',') as delimiter arguments but they will be -// treated as if a ByString delimiter was given. -template -struct SelectDelimiter { - using type = Delimiter; -}; - -template <> -struct SelectDelimiter { - using type = ByChar; -}; -template <> -struct SelectDelimiter { - using type = ByString; -}; -template <> -struct SelectDelimiter { - using type = ByString; -}; -template <> -struct SelectDelimiter { - using type = ByString; -}; -template <> -struct SelectDelimiter { - using type = ByString; -}; - -// Wraps another delimiter and sets a max number of matches for that delimiter. -template -class MaxSplitsImpl { - public: - MaxSplitsImpl(Delimiter delimiter, int limit) - : delimiter_(delimiter), limit_(limit), count_(0) {} - absl::string_view Find(absl::string_view text, size_t pos) { - if (count_++ == limit_) { - return absl::string_view(text.data() + text.size(), - 0); // No more matches. - } - return delimiter_.Find(text, pos); - } - - private: - Delimiter delimiter_; - const int limit_; - int count_; -}; - -} // namespace strings_internal - -// MaxSplits() -// -// A delimiter that limits the number of matches which can occur to the passed -// `limit`. The last element in the returned collection will contain all -// remaining unsplit pieces, which may contain instances of the delimiter. -// The collection will contain at most `limit` + 1 elements. -// Example: -// -// using absl::MaxSplits; -// std::vector v = absl::StrSplit("a,b,c", MaxSplits(',', 1)); -// -// // v[0] == "a", v[1] == "b,c" -template -inline strings_internal::MaxSplitsImpl< - typename strings_internal::SelectDelimiter::type> -MaxSplits(Delimiter delimiter, int limit) { - typedef - typename strings_internal::SelectDelimiter::type DelimiterType; - return strings_internal::MaxSplitsImpl( - DelimiterType(delimiter), limit); -} - -//------------------------------------------------------------------------------ -// Predicates -//------------------------------------------------------------------------------ -// -// Predicates filter the results of a `StrSplit()` by determining whether or not -// a resultant element is included in the result set. A predicate may be passed -// as an optional third argument to the `StrSplit()` function. -// -// Predicates are unary functions (or functors) that take a single -// `absl::string_view` argument and return a bool indicating whether the -// argument should be included (`true`) or excluded (`false`). -// -// Predicates are useful when filtering out empty substrings. By default, empty -// substrings may be returned by `StrSplit()`, which is similar to the way split -// functions work in other programming languages. - -// AllowEmpty() -// -// Always returns `true`, indicating that all strings--including empty -// strings--should be included in the split output. This predicate is not -// strictly needed because this is the default behavior of `StrSplit()`; -// however, it might be useful at some call sites to make the intent explicit. -// -// Example: -// -// std::vector v = absl::StrSplit(" a , ,,b,", ',', AllowEmpty()); -// -// // v[0] == " a ", v[1] == " ", v[2] == "", v[3] = "b", v[4] == "" -struct AllowEmpty { - bool operator()(absl::string_view) const { return true; } -}; - -// SkipEmpty() -// -// Returns `false` if the given `absl::string_view` is empty, indicating that -// `StrSplit()` should omit the empty string. -// -// Example: -// -// std::vector v = absl::StrSplit(",a,,b,", ',', SkipEmpty()); -// -// // v[0] == "a", v[1] == "b" -// -// Note: `SkipEmpty()` does not consider a string containing only whitespace -// to be empty. To skip such whitespace as well, use the `SkipWhitespace()` -// predicate. -struct SkipEmpty { - bool operator()(absl::string_view sp) const { return !sp.empty(); } -}; - -// SkipWhitespace() -// -// Returns `false` if the given `absl::string_view` is empty *or* contains only -// whitespace, indicating that `StrSplit()` should omit the string. -// -// Example: -// -// std::vector v = absl::StrSplit(" a , ,,b,", -// ',', SkipWhitespace()); -// // v[0] == " a ", v[1] == "b" -// -// // SkipEmpty() would return whitespace elements -// std::vector v = absl::StrSplit(" a , ,,b,", ',', SkipEmpty()); -// // v[0] == " a ", v[1] == " ", v[2] == "b" -struct SkipWhitespace { - bool operator()(absl::string_view sp) const { - sp = absl::StripAsciiWhitespace(sp); - return !sp.empty(); - } -}; - -template -using EnableSplitIfString = - typename std::enable_if::value || - std::is_same::value, - int>::type; - -//------------------------------------------------------------------------------ -// StrSplit() -//------------------------------------------------------------------------------ - -// StrSplit() -// -// Splits a given string based on the provided `Delimiter` object, returning the -// elements within the type specified by the caller. Optionally, you may pass a -// `Predicate` to `StrSplit()` indicating whether to include or exclude the -// resulting element within the final result set. (See the overviews for -// Delimiters and Predicates above.) -// -// Example: -// -// std::vector v = absl::StrSplit("a,b,c,d", ','); -// // v[0] == "a", v[1] == "b", v[2] == "c", v[3] == "d" -// -// You can also provide an explicit `Delimiter` object: -// -// Example: -// -// using absl::ByAnyChar; -// std::vector v = absl::StrSplit("a,b=c", ByAnyChar(",=")); -// // v[0] == "a", v[1] == "b", v[2] == "c" -// -// See above for more information on delimiters. -// -// By default, empty strings are included in the result set. You can optionally -// include a third `Predicate` argument to apply a test for whether the -// resultant element should be included in the result set: -// -// Example: -// -// std::vector v = absl::StrSplit(" a , ,,b,", -// ',', SkipWhitespace()); -// // v[0] == " a ", v[1] == "b" -// -// See above for more information on predicates. -// -//------------------------------------------------------------------------------ -// StrSplit() Return Types -//------------------------------------------------------------------------------ -// -// The `StrSplit()` function adapts the returned collection to the collection -// specified by the caller (e.g. `std::vector` above). The returned collections -// may contain `std::string`, `absl::string_view` (in which case the original -// string being split must ensure that it outlives the collection), or any -// object that can be explicitly created from an `absl::string_view`. This -// behavior works for: -// -// 1) All standard STL containers including `std::vector`, `std::list`, -// `std::deque`, `std::set`,`std::multiset`, 'std::map`, and `std::multimap` -// 2) `std::pair` (which is not actually a container). See below. -// -// Example: -// -// // The results are returned as `absl::string_view` objects. Note that we -// // have to ensure that the input string outlives any results. -// std::vector v = absl::StrSplit("a,b,c", ','); -// -// // Stores results in a std::set, which also performs -// // de-duplication and orders the elements in ascending order. -// std::set a = absl::StrSplit("b,a,c,a,b", ','); -// // v[0] == "a", v[1] == "b", v[2] = "c" -// -// // `StrSplit()` can be used within a range-based for loop, in which case -// // each element will be of type `absl::string_view`. -// std::vector v; -// for (const auto sv : absl::StrSplit("a,b,c", ',')) { -// if (sv != "b") v.emplace_back(sv); -// } -// // v[0] == "a", v[1] == "c" -// -// // Stores results in a map. The map implementation assumes that the input -// // is provided as a series of key/value pairs. For example, the 0th element -// // resulting from the split will be stored as a key to the 1st element. If -// // an odd number of elements are resolved, the last element is paired with -// // a default-constructed value (e.g., empty string). -// std::map m = absl::StrSplit("a,b,c", ','); -// // m["a"] == "b", m["c"] == "" // last component value equals "" -// -// Splitting to `std::pair` is an interesting case because it can hold only two -// elements and is not a collection type. When splitting to a `std::pair` the -// first two split strings become the `std::pair` `.first` and `.second` -// members, respectively. The remaining split substrings are discarded. If there -// are less than two split substrings, the empty string is used for the -// corresponding -// `std::pair` member. -// -// Example: -// -// // Stores first two split strings as the members in a std::pair. -// std::pair p = absl::StrSplit("a,b,c", ','); -// // p.first == "a", p.second == "b" // "c" is omitted. -// -// The `StrSplit()` function can be used multiple times to perform more -// complicated splitting logic, such as intelligently parsing key-value pairs. -// -// Example: -// -// // The input string "a=b=c,d=e,f=,g" becomes -// // { "a" => "b=c", "d" => "e", "f" => "", "g" => "" } -// std::map m; -// for (absl::string_view sp : absl::StrSplit("a=b=c,d=e,f=,g", ',')) { -// m.insert(absl::StrSplit(sp, absl::MaxSplits('=', 1))); -// } -// EXPECT_EQ("b=c", m.find("a")->second); -// EXPECT_EQ("e", m.find("d")->second); -// EXPECT_EQ("", m.find("f")->second); -// EXPECT_EQ("", m.find("g")->second); -// -// WARNING: Due to a legacy bug that is maintained for backward compatibility, -// splitting the following empty string_views produces different results: -// -// absl::StrSplit(absl::string_view(""), '-'); // {""} -// absl::StrSplit(absl::string_view(), '-'); // {}, but should be {""} -// -// Try not to depend on this distinction because the bug may one day be fixed. -template -strings_internal::Splitter< - typename strings_internal::SelectDelimiter::type, AllowEmpty, - absl::string_view> -StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d) { - using DelimiterType = - typename strings_internal::SelectDelimiter::type; - return strings_internal::Splitter( - text.value(), DelimiterType(d), AllowEmpty()); -} - -template = 0> -strings_internal::Splitter< - typename strings_internal::SelectDelimiter::type, AllowEmpty, - std::string> -StrSplit(StringType&& text, Delimiter d) { - using DelimiterType = - typename strings_internal::SelectDelimiter::type; - return strings_internal::Splitter( - std::move(text), DelimiterType(d), AllowEmpty()); -} - -template -strings_internal::Splitter< - typename strings_internal::SelectDelimiter::type, Predicate, - absl::string_view> -StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d, - Predicate p) { - using DelimiterType = - typename strings_internal::SelectDelimiter::type; - return strings_internal::Splitter( - text.value(), DelimiterType(d), std::move(p)); -} - -template = 0> -strings_internal::Splitter< - typename strings_internal::SelectDelimiter::type, Predicate, - std::string> -StrSplit(StringType&& text, Delimiter d, Predicate p) { - using DelimiterType = - typename strings_internal::SelectDelimiter::type; - return strings_internal::Splitter( - std::move(text), DelimiterType(d), std::move(p)); -} - -ABSL_NAMESPACE_END -} // namespace absl - -#endif // ABSL_STRINGS_STR_SPLIT_H_ -- cgit 1.4.1