Restoring authorship annotation for <somov@yandex-team.ru>. Commit 2 of 2.

1 files changed, 36 insertions, 36 deletions

diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.h
index c9019646d7..42c85616a0 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.h
@@ -17,7 +17,7 @@
 // File: str_replace.h
 // -----------------------------------------------------------------------------
 //
-// This file defines `y_absl::StrReplaceAll()`, a general-purpose string 
+// This file defines `y_absl::StrReplaceAll()`, a general-purpose string
 // replacement function designed for large, arbitrary text substitutions,
 // especially on strings which you are receiving from some other system for
 // further processing (e.g. processing regular expressions, escaping HTML
@@ -25,11 +25,11 @@
 // one substitution is being performed, or when substitution is rare.
 //
 // If the string being modified is known at compile-time, and the substitutions
-// vary, `y_absl::Substitute()` may be a better choice. 
+// vary, `y_absl::Substitute()` may be a better choice.
 //
 // Example:
 //
-// TString html_escaped = y_absl::StrReplaceAll(user_input, { 
+// TString html_escaped = y_absl::StrReplaceAll(user_input, {
 //                                                {"&", "&"},
 //                                                {"<", "&lt;"},
 //                                                {">", "&gt;"},
@@ -42,10 +42,10 @@
 #include <utility>
 #include <vector>
 
-#include "y_absl/base/attributes.h" 
-#include "y_absl/strings/string_view.h" 
+#include "y_absl/base/attributes.h"
+#include "y_absl/strings/string_view.h"
 
-namespace y_absl { 
+namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 
 // StrReplaceAll()
@@ -59,15 +59,15 @@ ABSL_NAMESPACE_BEGIN
 //
 // Example:
 //
-//   TString s = y_absl::StrReplaceAll( 
+//   TString s = y_absl::StrReplaceAll(
 //       "$who bought $count #Noun. Thanks $who!",
-//       {{"$count", y_absl::StrCat(5)}, 
+//       {{"$count", y_absl::StrCat(5)},
 //        {"$who", "Bob"},
 //        {"#Noun", "Apples"}});
 //   EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
-ABSL_MUST_USE_RESULT TString StrReplaceAll( 
-    y_absl::string_view s, 
-    std::initializer_list<std::pair<y_absl::string_view, y_absl::string_view>> 
+ABSL_MUST_USE_RESULT TString StrReplaceAll(
+    y_absl::string_view s,
+    std::initializer_list<std::pair<y_absl::string_view, y_absl::string_view>>
         replacements);
 
 // Overload of `StrReplaceAll()` to accept a container of key/value replacement
@@ -76,25 +76,25 @@ ABSL_MUST_USE_RESULT TString StrReplaceAll(
 //
 // Examples:
 //
-//   std::map<const y_absl::string_view, const y_absl::string_view> replacements; 
+//   std::map<const y_absl::string_view, const y_absl::string_view> replacements;
 //   replacements["$who"] = "Bob";
 //   replacements["$count"] = "5";
 //   replacements["#Noun"] = "Apples";
-//   TString s = y_absl::StrReplaceAll( 
+//   TString s = y_absl::StrReplaceAll(
 //       "$who bought $count #Noun. Thanks $who!",
 //       replacements);
 //   EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
 //
 //   // A std::vector of std::pair elements can be more efficient.
-//   std::vector<std::pair<const y_absl::string_view, TString>> replacements; 
+//   std::vector<std::pair<const y_absl::string_view, TString>> replacements;
 //   replacements.push_back({"&", "&amp;"});
 //   replacements.push_back({"<", "&lt;"});
 //   replacements.push_back({">", "&gt;"});
-//   TString s = y_absl::StrReplaceAll("if (ptr < &foo)", 
+//   TString s = y_absl::StrReplaceAll("if (ptr < &foo)",
 //                                  replacements);
 //   EXPECT_EQ("if (ptr &lt; &amp;foo)", s);
 template <typename StrToStrMapping>
-TString StrReplaceAll(y_absl::string_view s, 
+TString StrReplaceAll(y_absl::string_view s,
                           const StrToStrMapping& replacements);
 
 // Overload of `StrReplaceAll()` to replace character sequences within a given
@@ -103,17 +103,17 @@ TString StrReplaceAll(y_absl::string_view s,
 //
 // Example:
 //
-//   TString s = TString("$who bought $count #Noun. Thanks $who!"); 
+//   TString s = TString("$who bought $count #Noun. Thanks $who!");
 //   int count;
-//   count = y_absl::StrReplaceAll({{"$count", y_absl::StrCat(5)}, 
+//   count = y_absl::StrReplaceAll({{"$count", y_absl::StrCat(5)},
 //                               {"$who", "Bob"},
 //                               {"#Noun", "Apples"}}, &s);
 //  EXPECT_EQ(count, 4);
 //  EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
 int StrReplaceAll(
-    std::initializer_list<std::pair<y_absl::string_view, y_absl::string_view>> 
+    std::initializer_list<std::pair<y_absl::string_view, y_absl::string_view>>
         replacements,
-    TString* target); 
+    TString* target);
 
 // Overload of `StrReplaceAll()` to replace patterns within a given output
 // string *in place* with replacements provided within a container of key/value
@@ -121,25 +121,25 @@ int StrReplaceAll(
 //
 // Example:
 //
-//   TString s = TString("if (ptr < &foo)"); 
-//   int count = y_absl::StrReplaceAll({{"&", "&amp;"}, 
+//   TString s = TString("if (ptr < &foo)");
+//   int count = y_absl::StrReplaceAll({{"&", "&amp;"},
 //                                    {"<", "&lt;"},
 //                                    {">", "&gt;"}}, &s);
 //  EXPECT_EQ(count, 2);
 //  EXPECT_EQ("if (ptr &lt; &amp;foo)", s);
 template <typename StrToStrMapping>
-int StrReplaceAll(const StrToStrMapping& replacements, TString* target); 
+int StrReplaceAll(const StrToStrMapping& replacements, TString* target);
 
 // Implementation details only, past this point.
 namespace strings_internal {
 
 struct ViableSubstitution {
-  y_absl::string_view old; 
-  y_absl::string_view replacement; 
+  y_absl::string_view old;
+  y_absl::string_view replacement;
   size_t offset;
 
-  ViableSubstitution(y_absl::string_view old_str, 
-                     y_absl::string_view replacement_str, size_t offset_val) 
+  ViableSubstitution(y_absl::string_view old_str,
+                     y_absl::string_view replacement_str, size_t offset_val)
       : old(old_str), replacement(replacement_str), offset(offset_val) {}
 
   // One substitution occurs "before" another (takes priority) if either
@@ -156,13 +156,13 @@ struct ViableSubstitution {
 // overhead of such a queue isn't worth it.
 template <typename StrToStrMapping>
 std::vector<ViableSubstitution> FindSubstitutions(
-    y_absl::string_view s, const StrToStrMapping& replacements) { 
+    y_absl::string_view s, const StrToStrMapping& replacements) {
   std::vector<ViableSubstitution> subs;
   subs.reserve(replacements.size());
 
   for (const auto& rep : replacements) {
     using std::get;
-    y_absl::string_view old(get<0>(rep)); 
+    y_absl::string_view old(get<0>(rep));
 
     size_t pos = s.find(old);
     if (pos == s.npos) continue;
@@ -184,28 +184,28 @@ std::vector<ViableSubstitution> FindSubstitutions(
   return subs;
 }
 
-int ApplySubstitutions(y_absl::string_view s, 
+int ApplySubstitutions(y_absl::string_view s,
                        std::vector<ViableSubstitution>* subs_ptr,
-                       TString* result_ptr); 
+                       TString* result_ptr);
 
 }  // namespace strings_internal
 
 template <typename StrToStrMapping>
-TString StrReplaceAll(y_absl::string_view s, 
+TString StrReplaceAll(y_absl::string_view s,
                           const StrToStrMapping& replacements) {
   auto subs = strings_internal::FindSubstitutions(s, replacements);
-  TString result; 
+  TString result;
   result.reserve(s.size());
   strings_internal::ApplySubstitutions(s, &subs, &result);
   return result;
 }
 
 template <typename StrToStrMapping>
-int StrReplaceAll(const StrToStrMapping& replacements, TString* target) { 
+int StrReplaceAll(const StrToStrMapping& replacements, TString* target) {
   auto subs = strings_internal::FindSubstitutions(*target, replacements);
   if (subs.empty()) return 0;
 
-  TString result; 
+  TString result;
   result.reserve(target->size());
   int substitutions =
       strings_internal::ApplySubstitutions(*target, &subs, &result);
@@ -214,6 +214,6 @@ int StrReplaceAll(const StrToStrMapping& replacements, TString* target) {
 }
 
 ABSL_NAMESPACE_END
-}  // namespace y_absl 
+}  // namespace y_absl
 
 #endif  // ABSL_STRINGS_STR_REPLACE_H_