| 
					
				 | 
			
			
				@@ -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::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. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 // 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 // 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::string> v = {"foo", "bar", "baz"}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+//   std::string 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::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. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 // 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 // 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::string. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 // 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 //   struct MyFormatter { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-//     void operator()(string* out, int i) const { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+//     void operator()(std::string* 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::string 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::string. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 // `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::string> v = {"foo", "bar", "baz"}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+//   std::string 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::string 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::string 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::string 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::string 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::string, 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::string 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::string> v_empty; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 //   EXPECT_EQ("", absl::StrJoin(v_empty, "-")); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 // 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-//   std::vector<string> v_one_item = {"foo"}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+//   std::vector<std::string> v_one_item = {"foo"}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 //   EXPECT_EQ("foo", absl::StrJoin(v_one_item, "-")); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 // 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-//   std::vector<string> v_empty_string = {""}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+//   std::vector<std::string> v_empty_string = {""}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 //   EXPECT_EQ("", absl::StrJoin(v_empty_string, "-")); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 // 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-//   std::vector<string> v_one_item_empty_string = {"a", ""}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+//   std::vector<std::string> 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::string> 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::string using the `absl::AlphaNum` class. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+//   std::string 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()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 |