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

11 files changed, 138 insertions, 138 deletions

diff --git a/util/datetime/parser.rl6 b/util/datetime/parser.rl6
index 1f5e430c5c..931f09eae1 100644
--- a/util/datetime/parser.rl6
+++ b/util/datetime/parser.rl6
@@ -773,8 +773,8 @@ bool TDurationParser::ParsePart(const char* input, size_t len) {
     return cs != %%{ write error; }%%;
 }
 
-static inline ui64 DecPower(ui64 part, i32 power) { 
-    if (power >= 0) 
+static inline ui64 DecPower(ui64 part, i32 power) {
+    if (power >= 0)
         return part * Power(10, power);
     return part / Power(10, -power);
 }
diff --git a/util/datetime/parser_ut.cpp b/util/datetime/parser_ut.cpp
index 7c031e46a7..61364af997 100644
--- a/util/datetime/parser_ut.cpp
+++ b/util/datetime/parser_ut.cpp
@@ -587,11 +587,11 @@ Y_UNIT_TEST_SUITE(TDurationParseTest) {
         UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(7196400), TDuration::Parse("1.999h"));
         UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(7199640), TDuration::Parse("1.9999h"));
 
-        UNIT_ASSERT_EQUAL(TDuration::Minutes(15), TDuration::Parse("15m")); 
-        UNIT_ASSERT_EQUAL(TDuration::Hours(10), TDuration::Parse("10h")); 
-        UNIT_ASSERT_EQUAL(TDuration::Days(365), TDuration::Parse("365d")); 
-        UNIT_ASSERT_EQUAL(TDuration::Hours(36), TDuration::Parse("1.5d")); 
- 
+        UNIT_ASSERT_EQUAL(TDuration::Minutes(15), TDuration::Parse("15m"));
+        UNIT_ASSERT_EQUAL(TDuration::Hours(10), TDuration::Parse("10h"));
+        UNIT_ASSERT_EQUAL(TDuration::Days(365), TDuration::Parse("365d"));
+        UNIT_ASSERT_EQUAL(TDuration::Hours(36), TDuration::Parse("1.5d"));
+
         UNIT_ASSERT_VALUES_EQUAL(TDuration::Hours(24), TDuration::Parse("1d"));
         UNIT_ASSERT_VALUES_EQUAL(TDuration::Hours(36), TDuration::Parse("1.5d"));
         UNIT_ASSERT_VALUES_EQUAL(TDuration::Minutes(2448), TDuration::Parse("1.7d"));
@@ -618,10 +618,10 @@ Y_UNIT_TEST_SUITE(TDurationParseTest) {
 
         UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(112), TDuration::Parse("112"));
         UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(14456), TDuration::Parse("14456us"));
- 
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(1), TDuration::Parse("1000ns")); 
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(1), TDuration::Parse("0.000001s")); 
- 
-        UNIT_ASSERT_EQUAL(TDuration(), TDuration::Parse("10ns")); // TDuration has 1us precision. 
+
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(1), TDuration::Parse("1000ns"));
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(1), TDuration::Parse("0.000001s"));
+
+        UNIT_ASSERT_EQUAL(TDuration(), TDuration::Parse("10ns")); // TDuration has 1us precision.
     }
 }
diff --git a/util/generic/vector.h b/util/generic/vector.h
index 1725aa22b4..a5b258955a 100644
--- a/util/generic/vector.h
+++ b/util/generic/vector.h
@@ -124,7 +124,7 @@ public:
     }
 #endif
 
-    inline void crop(size_type size) { 
+    inline void crop(size_type size) {
         if (this->size() > size) {
             this->erase(this->begin() + size, this->end());
         }
diff --git a/util/stream/hex.cpp b/util/stream/hex.cpp
index 6d91cbe1cf..1c05330504 100644
--- a/util/stream/hex.cpp
+++ b/util/stream/hex.cpp
@@ -1,30 +1,30 @@
-#include "hex.h" 
- 
+#include "hex.h"
+
 #include "output.h"
-#include <util/string/hex.h> 
- 
+#include <util/string/hex.h>
+
 void HexEncode(const void* in, size_t len, IOutputStream& out) {
-    static const size_t NUM_OF_BYTES = 32; 
-    char buffer[NUM_OF_BYTES * 2]; 
- 
-    auto current = static_cast<const char*>(in); 
-    for (size_t take = 0; len; current += take, len -= take) { 
-        take = Min(NUM_OF_BYTES, len); 
-        HexEncode(current, take, buffer); 
-        out.Write(buffer, take * 2); 
-    } 
-} 
- 
+    static const size_t NUM_OF_BYTES = 32;
+    char buffer[NUM_OF_BYTES * 2];
+
+    auto current = static_cast<const char*>(in);
+    for (size_t take = 0; len; current += take, len -= take) {
+        take = Min(NUM_OF_BYTES, len);
+        HexEncode(current, take, buffer);
+        out.Write(buffer, take * 2);
+    }
+}
+
 void HexDecode(const void* in, size_t len, IOutputStream& out) {
     Y_ENSURE(!(len & 1), TStringBuf("Odd buffer length passed to HexDecode"));
- 
-    static const size_t NUM_OF_BYTES = 32; 
-    char buffer[NUM_OF_BYTES]; 
- 
-    auto current = static_cast<const char*>(in); 
-    for (size_t take = 0; len; current += take, len -= take) { 
-        take = Min(NUM_OF_BYTES * 2, len); 
-        HexDecode(current, take, buffer); 
-        out.Write(buffer, take / 2); 
-    } 
-} 
+
+    static const size_t NUM_OF_BYTES = 32;
+    char buffer[NUM_OF_BYTES];
+
+    auto current = static_cast<const char*>(in);
+    for (size_t take = 0; len; current += take, len -= take) {
+        take = Min(NUM_OF_BYTES * 2, len);
+        HexDecode(current, take, buffer);
+        out.Write(buffer, take / 2);
+    }
+}
diff --git a/util/stream/hex.h b/util/stream/hex.h
index 68451d781f..a018933b1b 100644
--- a/util/stream/hex.h
+++ b/util/stream/hex.h
@@ -1,8 +1,8 @@
-#pragma once 
- 
-#include <util/system/types.h> 
- 
+#pragma once
+
+#include <util/system/types.h>
+
 class IOutputStream;
- 
+
 void HexEncode(const void* in, size_t len, IOutputStream& out);
 void HexDecode(const void* in, size_t len, IOutputStream& out);
diff --git a/util/stream/hex_ut.cpp b/util/stream/hex_ut.cpp
index 1a6bf5a6d3..5074a0b616 100644
--- a/util/stream/hex_ut.cpp
+++ b/util/stream/hex_ut.cpp
@@ -1,29 +1,29 @@
-#include "hex.h" 
- 
+#include "hex.h"
+
 #include <library/cpp/testing/unittest/registar.h>
 #include "str.h"
- 
+
 Y_UNIT_TEST_SUITE(THexCodingTest) {
     void TestImpl(const TString& data) {
         TString encoded;
-        TStringOutput encodedOut(encoded); 
+        TStringOutput encodedOut(encoded);
         HexEncode(data.data(), data.size(), encodedOut);
- 
+
         UNIT_ASSERT_EQUAL(encoded.size(), data.size() * 2);
- 
+
         TString decoded;
-        TStringOutput decodedOut(decoded); 
+        TStringOutput decodedOut(decoded);
         HexDecode(encoded.data(), encoded.size(), decodedOut);
- 
-        UNIT_ASSERT_EQUAL(decoded, data); 
-    } 
- 
+
+        UNIT_ASSERT_EQUAL(decoded, data);
+    }
+
     Y_UNIT_TEST(TestEncodeDecodeToStream) {
         TString data = "100ABAcaba500,$%0987123456   \n\t\x01\x02\x03.";
-        TestImpl(data); 
-    } 
- 
+        TestImpl(data);
+    }
+
     Y_UNIT_TEST(TestEmpty) {
-        TestImpl(""); 
-    } 
-} 
+        TestImpl("");
+    }
+}
diff --git a/util/string/escape.cpp b/util/string/escape.cpp
index bbe8bbd0d2..cd09a7dbd0 100644
--- a/util/string/escape.cpp
+++ b/util/string/escape.cpp
@@ -242,9 +242,9 @@ static TStr& DoUnescapeC(const TChar* p, size_t sz, TStr& res) {
                 default:
                     res.append(*p);
                     break;
-                case 'a': 
-                    res.append('\a'); 
-                    break; 
+                case 'a':
+                    res.append('\a');
+                    break;
                 case 'b':
                     res.append('\b');
                     break;
@@ -260,9 +260,9 @@ static TStr& DoUnescapeC(const TChar* p, size_t sz, TStr& res) {
                 case 't':
                     res.append('\t');
                     break;
-                case 'v': 
-                    res.append('\v'); 
-                    break; 
+                case 'v':
+                    res.append('\v');
+                    break;
                 case 'u': {
                     ui16 cp[2];
 
@@ -318,13 +318,13 @@ static TStr& DoUnescapeC(const TChar* p, size_t sz, TStr& res) {
             }
 
             ++p;
-        } else { 
+        } else {
             const auto r = std::basic_string_view<TChar>(p, pe - p).find('\\');
             const auto n = r != std::string::npos ? p + r : pe;
 
             res.append(p, n);
             p = n;
-        } 
+        }
     }
 
     return res;
@@ -363,43 +363,43 @@ template TUtf16String& UnescapeCImpl<TUtf16String::TChar>(const TUtf16String::TC
 
 template char* UnescapeC<char>(const char* str, size_t len, char* buf);
 
-template <class TChar> 
-size_t UnescapeCCharLen(const TChar* begin, const TChar* end) { 
+template <class TChar>
+size_t UnescapeCCharLen(const TChar* begin, const TChar* end) {
     if (begin >= end) {
-        return 0; 
+        return 0;
     }
     if (*begin != '\\') {
-        return 1; 
+        return 1;
     }
     if (++begin == end) {
-        return 1; 
+        return 1;
     }
- 
-    switch (*begin) { 
-        default: 
-            return 2; 
-        case 'u': 
-            return CountHex<4>(begin + 1, end) == 4 ? 6 : 2; 
-        case 'U': 
-            return CountHex<8>(begin + 1, end) == 8 ? 10 : 2; 
-        case 'x': 
-            return 2 + CountHex<2>(begin + 1, end); 
-        case '0': 
-        case '1': 
-        case '2': 
-        case '3': 
-            return 1 + CountOct<3>(begin, end); // >= 2 
-        case '4': 
-        case '5': 
-        case '6': 
-        case '7': 
-            return 1 + CountOct<2>(begin, end); // >= 2 
-    } 
-} 
- 
-template size_t UnescapeCCharLen<char>(const char* begin, const char* end); 
+
+    switch (*begin) {
+        default:
+            return 2;
+        case 'u':
+            return CountHex<4>(begin + 1, end) == 4 ? 6 : 2;
+        case 'U':
+            return CountHex<8>(begin + 1, end) == 8 ? 10 : 2;
+        case 'x':
+            return 2 + CountHex<2>(begin + 1, end);
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+            return 1 + CountOct<3>(begin, end); // >= 2
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+            return 1 + CountOct<2>(begin, end); // >= 2
+    }
+}
+
+template size_t UnescapeCCharLen<char>(const char* begin, const char* end);
 template size_t UnescapeCCharLen<TUtf16String::TChar>(const TUtf16String::TChar* begin, const TUtf16String::TChar* end);
- 
+
 TString& EscapeC(const TStringBuf str, TString& s) {
     return EscapeC(str.data(), str.size(), s);
 }
diff --git a/util/string/escape.h b/util/string/escape.h
index 9ab9cf574d..b01be65b0e 100644
--- a/util/string/escape.h
+++ b/util/string/escape.h
@@ -61,10 +61,10 @@ TUtf16String& UnescapeC(const TWtringBuf str, TUtf16String& res);
 
 TString UnescapeC(const TStringBuf str);
 TUtf16String UnescapeC(const TWtringBuf wtr);
- 
-/// Returns number of chars in escape sequence. 
-///   - 0, if begin >= end 
-///   - 1, if [begin, end) starts with an unescaped char 
-///   - at least 2 (including '\'), if [begin, end) starts with an escaped symbol 
-template <class TChar> 
-size_t UnescapeCCharLen(const TChar* begin, const TChar* end); 
+
+/// Returns number of chars in escape sequence.
+///   - 0, if begin >= end
+///   - 1, if [begin, end) starts with an unescaped char
+///   - at least 2 (including '\'), if [begin, end) starts with an escaped symbol
+template <class TChar>
+size_t UnescapeCCharLen(const TChar* begin, const TChar* end);
diff --git a/util/string/escape_ut.cpp b/util/string/escape_ut.cpp
index c3e6e3a05b..cd38ecffd3 100644
--- a/util/string/escape_ut.cpp
+++ b/util/string/escape_ut.cpp
@@ -103,33 +103,33 @@ Y_UNIT_TEST_SUITE(TEscapeCTest) {
         // UNIT_ASSERT_VALUES_EQUAL("[x]?z", EscapeC(TString("??(x??)?z")));
         UNIT_ASSERT_VALUES_EQUAL("\\x3F?x\\x3F\\x3F?z", EscapeC(TString("??x???z")));
     }
- 
+
     Y_UNIT_TEST(TestUnescapeCCharLen) {
-        auto test = [](const char* str, size_t len) { 
-            UNIT_ASSERT_EQUAL(UnescapeCCharLen(str, str + strlen(str)), len); 
-        }; 
- 
-        test("", 0); 
-        test("abc", 1); 
-        test("\\", 1); 
-        test("\\\\", 2); 
-        test("\\#", 2); 
-        test("\\n10", 2); 
-        test("\\r\\n", 2); 
-        test("\\x05abc", 4); 
-        test("\\u11117777", 6); 
-        test("\\u123yyy", 2); 
-        test("\\U11117777cccc", 10); 
-        test("\\U111yyy", 2); 
-        test("\\0\\1", 2); 
-        test("\\01\\1", 3); 
-        test("\\012\\1", 4); 
-        test("\\0123\\1", 4); 
-        test("\\4\\1", 2); 
-        test("\\40\\1", 3); 
-        test("\\400\\1", 3); 
-        test("\\4xxx", 2); 
-    } 
+        auto test = [](const char* str, size_t len) {
+            UNIT_ASSERT_EQUAL(UnescapeCCharLen(str, str + strlen(str)), len);
+        };
+
+        test("", 0);
+        test("abc", 1);
+        test("\\", 1);
+        test("\\\\", 2);
+        test("\\#", 2);
+        test("\\n10", 2);
+        test("\\r\\n", 2);
+        test("\\x05abc", 4);
+        test("\\u11117777", 6);
+        test("\\u123yyy", 2);
+        test("\\U11117777cccc", 10);
+        test("\\U111yyy", 2);
+        test("\\0\\1", 2);
+        test("\\01\\1", 3);
+        test("\\012\\1", 4);
+        test("\\0123\\1", 4);
+        test("\\4\\1", 2);
+        test("\\40\\1", 3);
+        test("\\400\\1", 3);
+        test("\\4xxx", 2);
+    }
 
     Y_UNIT_TEST(TestUnbounded) {
         char buf[100000];
diff --git a/util/string/hex.cpp b/util/string/hex.cpp
index 75aa031639..667397987f 100644
--- a/util/string/hex.cpp
+++ b/util/string/hex.cpp
@@ -56,8 +56,8 @@ TString HexEncode(const void* in, size_t len) {
 TString HexDecode(const void* in, size_t len) {
     TString ret;
 
-    ret.ReserveAndResize(len >> 1); 
-    HexDecode(in, len, ret.begin()); 
+    ret.ReserveAndResize(len >> 1);
+    HexDecode(in, len, ret.begin());
 
     return ret;
 }
diff --git a/util/string/hex.h b/util/string/hex.h
index 81f9dd42ec..af3d2d528f 100644
--- a/util/string/hex.h
+++ b/util/string/hex.h
@@ -32,8 +32,8 @@ TString HexEncode(const void* in, size_t len);
 
 inline TString HexEncode(const TStringBuf h) {
     return HexEncode(h.data(), h.size());
-} 
- 
+}
+
 //! Convert a hex string @c in of @c len chars (case-insensitive) to array of ints stored at @c ptr and return this array.
 /*! @note len must be even (len % 2 == 0), otherwise an exception will be thrown.
  *  @return @c ptr, which is an array of chars, where each char holds the numeric value
@@ -52,8 +52,8 @@ void* HexDecode(const void* in, size_t len, void* ptr);
  * @example HexDecode("beef", 4) => {190, 239}
  */
 TString HexDecode(const void* in, size_t len);
- 
+
 //! Convert an ASCII hex-string (case-insensitive) to the binary form. Note that h.Size() must be even (+h % 2 == 0).
 inline TString HexDecode(const TStringBuf h) {
     return HexDecode(h.data(), h.size());
-} 
+}