@ -18,13 +18,13 @@
// -----------------------------------------------------------------------------
//
// This header file contains functions for joining a range of elements and
// returning the result as a string. StrJoin operations are specified by passing
// a range, a separator string to use between the elements joined, and an
// optional Formatter responsible for converting each argument in the range to a
// string. If omitted, a default `AlphaNumFormatter()` is called on the elements
// to be joined, using the same formatting that `absl::StrCat()` uses. This
// package defines a number of default formatters, and you can define your own
// implementations.
// returning the result as a std::st ring. StrJoin operations are specified by
// passing a range, a separator string to use between the elements joined, and
// an optional Formatter responsible for converting each argument in the range
// to a string. If omitted, a default `AlphaNumFormatter()` is called on the
// elements to be joined, using the same formatting that `absl::StrCat()` uses.
// This package defines a number of default formatters, and you can define your
// own implementations.
//
// Ranges are specified by passing a container with `std::begin()` and
// `std::end()` iterators, container-specific `begin()` and `end()` iterators, a
@ -37,8 +37,8 @@
//
// Example:
//
// std::vector<string> v = {"foo", "bar", "baz"};
// string s = absl::StrJoin(v, "-");
// std::vector<std::st ring> v = {"foo", "bar", "baz"};
// std::st ring s = absl::StrJoin(v, "-");
// EXPECT_EQ("foo-bar-baz", s);
//
// See comments on the `absl::StrJoin()` function for more examples.
@ -66,16 +66,16 @@ namespace absl {
// -----------------------------------------------------------------------------
//
// A Formatter is a function object that is responsible for formatting its
// argument as a string and appending it to a given output string. Formatters
// may be implemented as function objects, lambdas, or normal functions. You may
// provide your own Formatter to enable `absl::StrJoin()` to work with arbitrary
// types.
// argument as a string and appending it to a given output std::st ring.
// Formatters may be implemented as function objects, lambdas, or normal
// functions. You may provide your own Formatter to enable `absl::StrJoin()` to
// work with arbitrary types.
//
// The following is an example of a custom Formatter that simply uses
// `std::to_string()` to format an integer as a string.
// `std::to_string()` to format an integer as a std::st ring.
//
// struct MyFormatter {
// void operator()(string* out, int i) const {
// void operator()(std::st ring* out, int i) const {
// out->append(std::to_string(i));
// }
// };
@ -84,7 +84,7 @@ namespace absl {
// argument to `absl::StrJoin()`:
//
// std::vector<int> v = {1, 2, 3, 4};
// string s = absl::StrJoin(v, "-", MyFormatter());
// std::st ring s = absl::StrJoin(v, "-", MyFormatter());
// EXPECT_EQ("1-2-3-4", s);
//
// The following standard formatters are provided within this file:
@ -156,7 +156,7 @@ DereferenceFormatter() {
// StrJoin()
// -----------------------------------------------------------------------------
//
// Joins a range of elements and returns the result as a string.
// Joins a range of elements and returns the result as a std::st ring.
// `absl::StrJoin()` takes a range, a separator string to use between the
// elements joined, and an optional Formatter responsible for converting each
// argument in the range to a string.
@ -167,22 +167,22 @@ DereferenceFormatter() {
// Example 1:
// // Joins a collection of strings. This pattern also works with a collection
// // of `absl::string_view` or even `const char*`.
// std::vector<string> v = {"foo", "bar", "baz"};
// string s = absl::StrJoin(v, "-");
// std::vector<std::st ring> v = {"foo", "bar", "baz"};
// std::st ring s = absl::StrJoin(v, "-");
// EXPECT_EQ("foo-bar-baz", s);
//
// Example 2:
// // Joins the values in the given `std::initializer_list<>` specified using
// // brace initialization. This pattern also works with an initializer_list
// // of ints or `absl::string_view` -- any `AlphaNum`-compatible type.
// string s = absl::StrJoin({"foo", "bar", "baz"}, "-");
// std::st ring s = absl::StrJoin({"foo", "bar", "baz"}, "-");
// EXPECT_EQ("foo-bar-baz", s);
//
// Example 3:
// // Joins a collection of ints. This pattern also works with floats,
// // doubles, int64s -- any `StrCat()`-compatible type.
// std::vector<int> v = {1, 2, 3, -4};
// string s = absl::StrJoin(v, "-");
// std::st ring s = absl::StrJoin(v, "-");
// EXPECT_EQ("1-2-3--4", s);
//
// Example 4:
@ -193,7 +193,7 @@ DereferenceFormatter() {
// // `std::vector<int*>`.
// int x = 1, y = 2, z = 3;
// std::vector<int*> v = {&x, &y, &z};
// string s = absl::StrJoin(v, "-");
// std::st ring s = absl::StrJoin(v, "-");
// EXPECT_EQ("1-2-3", s);
//
// Example 5:
@ -202,53 +202,53 @@ DereferenceFormatter() {
// v.emplace_back(new int(1));
// v.emplace_back(new int(2));
// v.emplace_back(new int(3));
// string s = absl::StrJoin(v, "-");
// std::st ring s = absl::StrJoin(v, "-");
// EXPECT_EQ("1-2-3", s);
//
// Example 6:
// // Joins a `std::map`, with each key-value pair separated by an equals
// // sign. This pattern would also work with, say, a
// // `std::vector<std::pair<>>`.
// std::map<string, int> m = {
// std::map<std::st ring, int> m = {
// std::make_pair("a", 1),
// std::make_pair("b", 2),
// std::make_pair("c", 3)};
// string s = absl::StrJoin(m, ",", absl::PairFormatter("="));
// std::st ring s = absl::StrJoin(m, ",", absl::PairFormatter("="));
// EXPECT_EQ("a=1,b=2,c=3", s);
//
// Example 7:
// // These examples show how `absl::StrJoin()` handles a few common edge
// // cases:
// std::vector<string> v_empty;
// std::vector<std::st ring> v_empty;
// EXPECT_EQ("", absl::StrJoin(v_empty, "-"));
//
// std::vector<string> v_one_item = {"foo"};
// std::vector<std::st ring> v_one_item = {"foo"};
// EXPECT_EQ("foo", absl::StrJoin(v_one_item, "-"));
//
// std::vector<string> v_empty_string = {""};
// std::vector<std::st ring> v_empty_string = {""};
// EXPECT_EQ("", absl::StrJoin(v_empty_string, "-"));
//
// std::vector<string> v_one_item_empty_string = {"a", ""};
// std::vector<std::st ring> v_one_item_empty_string = {"a", ""};
// EXPECT_EQ("a-", absl::StrJoin(v_one_item_empty_string, "-"));
//
// std::vector<string> v_two_empty_string = {"", ""};
// std::vector<std::st ring> v_two_empty_string = {"", ""};
// EXPECT_EQ("-", absl::StrJoin(v_two_empty_string, "-"));
//
// Example 8:
// // Joins a `std::tuple<T...>` of heterogeneous types, converting each to
// // a string using the `absl::AlphaNum` class.
// string s = absl::StrJoin(std::make_tuple(123, "abc", 0.456), "-");
// // a std::st ring using the `absl::AlphaNum` class.
// std::st ring s = absl::StrJoin(std::make_tuple(123, "abc", 0.456), "-");
// EXPECT_EQ("123-abc-0.456", s);
template < typename Iterator , typename Formatter >
std : : string StrJoin ( Iterator start , Iterator end , absl : : string_view sep ,
Formatter & & fmt ) {
Formatter & & fmt ) {
return strings_internal : : JoinAlgorithm ( start , end , sep , fmt ) ;
}
template < typename Range , typename Formatter >
std : : string StrJoin ( const Range & range , absl : : string_view separator ,
Formatter & & fmt ) {
Formatter & & fmt ) {
return strings_internal : : JoinRange ( range , separator , fmt ) ;
}
@ -260,7 +260,7 @@ std::string StrJoin(std::initializer_list<T> il, absl::string_view separator,
template < typename . . . T , typename Formatter >
std : : string StrJoin ( const std : : tuple < T . . . > & value , absl : : string_view separator ,
Formatter & & fmt ) {
Formatter & & fmt ) {
return strings_internal : : JoinAlgorithm ( value , separator , fmt ) ;
}
@ -280,7 +280,8 @@ std::string StrJoin(std::initializer_list<T> il, absl::string_view separator) {
}
template < typename . . . T >
std : : string StrJoin ( const std : : tuple < T . . . > & value , absl : : string_view separator ) {
std : : string StrJoin ( const std : : tuple < T . . . > & value ,
absl : : string_view separator ) {
return strings_internal : : JoinAlgorithm ( value , separator , AlphaNumFormatter ( ) ) ;
}
Abseil Team
6 years ago
committed by
Derek Mauro