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

library/cpp/accurate_accumulate/accurate_accumulate.h

@@ -42,24 +42,24 @@ public:
     template <typename TFloatType>
     inline bool operator<(const TKahanAccumulator<TFloatType>& other) const {
         return Get() < other.Get();
-    } 
- 
-    template <typename TFloatType> 
+    }
+
+    template <typename TFloatType>
     inline bool operator<=(const TKahanAccumulator<TFloatType>& other) const {
-        return !(other < *this); 
-    } 
- 
-    template <typename TFloatType> 
+        return !(other < *this);
+    }
+
+    template <typename TFloatType>
     inline bool operator>(const TKahanAccumulator<TFloatType>& other) const {
-        return other < *this; 
-    } 
- 
-    template <typename TFloatType> 
+        return other < *this;
+    }
+
+    template <typename TFloatType>
     inline bool operator>=(const TKahanAccumulator<TFloatType>& other) const {
-        return !(*this < other); 
-    } 
- 
-    template <typename TFloatType> 
+        return !(*this < other);
+    }
+
+    template <typename TFloatType>
     inline TKahanAccumulator& operator+=(const TFloatType x) {
         const TValueType y = TValueType(x) - Compensation_;
         const TValueType t = Sum_ + y;

library/cpp/cgiparam/cgiparam_ut.cpp

@@ -205,16 +205,16 @@ Y_UNIT_TEST_SUITE(TCgiParametersTest) {
 
     Y_UNIT_TEST(TestContInit) {
         TCgiParameters c = {std::make_pair("a", "a1"), std::make_pair("b", "b1"), std::make_pair("a", "a2")};
- 
-        UNIT_ASSERT_VALUES_EQUAL(c.NumOfValues("a"), 2u); 
-        UNIT_ASSERT_VALUES_EQUAL(c.NumOfValues("b"), 1u); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(c.Get("b"), "b1"); 
-        UNIT_ASSERT_VALUES_EQUAL(c.Get("a", 0), "a1"); 
-        UNIT_ASSERT_VALUES_EQUAL(c.Get("a", 1), "a2"); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(c.Print(), "a=a1&a=a2&b=b1"); 
-    } 
+
+        UNIT_ASSERT_VALUES_EQUAL(c.NumOfValues("a"), 2u);
+        UNIT_ASSERT_VALUES_EQUAL(c.NumOfValues("b"), 1u);
+
+        UNIT_ASSERT_VALUES_EQUAL(c.Get("b"), "b1");
+        UNIT_ASSERT_VALUES_EQUAL(c.Get("a", 0), "a1");
+        UNIT_ASSERT_VALUES_EQUAL(c.Get("a", 1), "a2");
+
+        UNIT_ASSERT_VALUES_EQUAL(c.Print(), "a=a1&a=a2&b=b1");
+    }
 
     Y_UNIT_TEST(TestPrintAsQuote) {
         TCgiParameters c = {

library/cpp/deprecated/split/delim_string_iter.h

@@ -22,13 +22,13 @@ public:
     }
 
     inline TDelimStringIter(TStringBuf str, TStringBuf delim)
-        : IsValid(true) 
+        : IsValid(true)
         , Str(str)
-        , Delim(delim) 
-    { 
+        , Delim(delim)
+    {
         UpdateCurrent();
-    } 
- 
+    }
+
     inline TDelimStringIter()
         : IsValid(false)
     {

library/cpp/getopt/small/opt2.cpp

@@ -248,13 +248,13 @@ unsigned long Opt2::UInt(char opt, const char* help, unsigned long def, bool req
     return rv;
 }
 
-// Add user defined error message and set error flag 
-void Opt2::AddError(const char* message) { 
-    HasErrors = true; 
+// Add user defined error message and set error flag
+void Opt2::AddError(const char* message) {
+    HasErrors = true;
     if (message)
-        UserErrorMessages.push_back(message); 
-} 
- 
+        UserErrorMessages.push_back(message);
+}
+
 int Opt2::AutoUsage(const char* free_arg_names) {
     if (!HasErrors)
         return 0;

library/cpp/getopt/small/opt2.h

@@ -107,9 +107,9 @@ public:
     // For options w/o parameters
     bool Has(char opt, const char* helpUsage);
 
-    // Add user defined error message and set error flag 
+    // Add user defined error message and set error flag
     void AddError(const char* message = nullptr);
- 
+
 public:
     // non-option args
     TVector<char*> Pos;

util/charset/unidata.h

@@ -400,22 +400,22 @@ inline bool IsPrint(wchar32 ch) {
     return IsAlnum(ch) || IsPunct(ch) || IsSymbol(ch) || IsBlank(ch);
 }
 
-inline bool IsRomanDigit(wchar32 ch) { 
-    if (NUnicode::CharHasType(ch, SHIFT(Nl_LETTER)) && 0x2160 <= ch && ch <= 0x2188) 
-        return true; 
-    if (ch < 127) { 
-        switch (static_cast<char>(::ToLower(ch))) { 
-            case 'i': 
-            case 'v': 
-            case 'x': 
-            case 'l': 
-            case 'c': 
-            case 'd': 
-            case 'm': 
-                return true; 
-        } 
-    } 
-    return false; 
-} 
- 
+inline bool IsRomanDigit(wchar32 ch) {
+    if (NUnicode::CharHasType(ch, SHIFT(Nl_LETTER)) && 0x2160 <= ch && ch <= 0x2188)
+        return true;
+    if (ch < 127) {
+        switch (static_cast<char>(::ToLower(ch))) {
+            case 'i':
+            case 'v':
+            case 'x':
+            case 'l':
+            case 'c':
+            case 'd':
+            case 'm':
+                return true;
+        }
+    }
+    return false;
+}
+
 #undef SHIFT

util/generic/xrange.h

@@ -20,7 +20,7 @@
 
 namespace NPrivate {
     template <typename T>
-    class TSimpleXRange { 
+    class TSimpleXRange {
         using TDiff = decltype(T() - T());
 
     public:
@@ -125,21 +125,21 @@ namespace NPrivate {
         T Finish;
     };
 
-    template <typename T> 
-    class TSteppedXRange { 
-        using TDiff = decltype(T() - T()); 
+    template <typename T>
+    class TSteppedXRange {
+        using TDiff = decltype(T() - T());
 
-    public: 
+    public:
         constexpr TSteppedXRange(T start, T finish, TDiff step) noexcept
             : Start_(start)
             , Step_(step)
             , Finish_(CalcRealFinish(Start_, finish, Step_))
         {
             static_assert(std::is_integral<T>::value || std::is_pointer<T>::value, "T should be integral type or pointer");
-        } 
- 
+        }
+
         class TIterator {
-        public: 
+        public:
             using value_type = T;
             using difference_type = TDiff;
             using pointer = const T*;
@@ -150,16 +150,16 @@ namespace NPrivate {
                 : Value_(value)
                 , Parent_(&parent)
             {
-            } 
- 
+            }
+
             constexpr T operator*() const noexcept {
-                return Value_; 
-            } 
- 
+                return Value_;
+            }
+
             constexpr bool operator!=(const TIterator& other) const noexcept {
-                return Value_ != other.Value_; 
-            } 
- 
+                return Value_ != other.Value_;
+            }
+
             constexpr bool operator==(const TIterator& other) const noexcept {
                 return Value_ == other.Value_;
             }
@@ -167,8 +167,8 @@ namespace NPrivate {
             TIterator& operator++() noexcept {
                 Value_ += Parent_->Step_;
                 return *this;
-            } 
- 
+            }
+
             TIterator& operator--() noexcept {
                 Value_ -= Parent_->Step_;
                 return *this;
@@ -200,34 +200,34 @@ namespace NPrivate {
                 return *this;
             }
 
-        private: 
-            T Value_; 
+        private:
+            T Value_;
             const TSteppedXRange* Parent_;
-        }; 
- 
+        };
+
         using value_type = T;
         using iterator = TIterator;
         using const_iterator = TIterator;
 
         constexpr TIterator begin() const noexcept {
-            return TIterator(Start_, *this); 
-        } 
- 
+            return TIterator(Start_, *this);
+        }
+
         constexpr TIterator end() const noexcept {
-            return TIterator(Finish_, *this); 
-        } 
- 
-        static T CalcRealFinish(T start, T expFinish, TDiff step) { 
+            return TIterator(Finish_, *this);
+        }
+
+        static T CalcRealFinish(T start, T expFinish, TDiff step) {
             Y_ASSERT(step != 0);
-            if (step > 0) { 
-                if (expFinish > start) { 
-                    return start + step * ((expFinish - 1 - start) / step + 1); 
-                } 
-                return start; 
-            } 
-            return start - TSteppedXRange<TDiff>::CalcRealFinish(0, start - expFinish, -step); 
-        } 
- 
+            if (step > 0) {
+                if (expFinish > start) {
+                    return start + step * ((expFinish - 1 - start) / step + 1);
+                }
+                return start;
+            }
+            return start - TSteppedXRange<TDiff>::CalcRealFinish(0, start - expFinish, -step);
+        }
+
         constexpr T size() const noexcept {
             return (Finish_ - Start_) / Step_;
         }
@@ -237,12 +237,12 @@ namespace NPrivate {
             return Container(begin(), end());
         }
 
-    private: 
-        const T Start_; 
-        const TDiff Step_; 
-        const T Finish_; 
-    }; 
- 
+    private:
+        const T Start_;
+        const TDiff Step_;
+        const T Finish_;
+    };
+
 }
 
 /**
@@ -250,11 +250,11 @@ namespace NPrivate {
  *
  * @param step must be non-zero
  */
-template <typename T> 
+template <typename T>
 constexpr ::NPrivate::TSteppedXRange<T> xrange(T start, T finish, decltype(T() - T()) step) noexcept {
     return {start, finish, step};
-} 
- 
+}
+
 /// generate sequence [start; finish)
 template <typename T>
 constexpr ::NPrivate::TSimpleXRange<T> xrange(T start, T finish) noexcept {

util/generic/xrange_ut.cpp

@@ -31,26 +31,26 @@ Y_UNIT_TEST_SUITE(XRange) {
     }
 
     void TestSteppedXRangeImpl(int begin, int end, int step, const TVector<int>& expected) {
-        size_t expInd = 0; 
+        size_t expInd = 0;
         for (auto i : xrange(begin, end, step)) {
-            UNIT_ASSERT(expInd < expected.size()); 
-            UNIT_ASSERT_VALUES_EQUAL(i, expected[expInd]); 
-            ++expInd; 
-        } 
-        UNIT_ASSERT_VALUES_EQUAL(expInd, expected.size()); 
-    } 
- 
+            UNIT_ASSERT(expInd < expected.size());
+            UNIT_ASSERT_VALUES_EQUAL(i, expected[expInd]);
+            ++expInd;
+        }
+        UNIT_ASSERT_VALUES_EQUAL(expInd, expected.size());
+    }
+
     Y_UNIT_TEST(IncrementWorks) {
         TestXRangeImpl(0, 10);
         TestXRangeImpl(10, 20);
     }
- 
+
     Y_UNIT_TEST(DecrementWorks) {
         TestSteppedXRangeImpl(10, 0, -1, {10, 9, 8, 7, 6, 5, 4, 3, 2, 1});
         TestSteppedXRangeImpl(10, -1, -1, {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0});
         TestSteppedXRangeImpl(20, 9, -1, {20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10});
-    } 
- 
+    }
+
     Y_UNIT_TEST(StepWorks) {
         TestSteppedXRangeImpl(0, 0, 1, {});
         TestSteppedXRangeImpl(0, 9, 3, {0, 3, 6});
@@ -62,22 +62,22 @@ Y_UNIT_TEST_SUITE(XRange) {
         TestSteppedXRangeImpl(15, 0, -4, {15, 11, 7, 3});
         TestSteppedXRangeImpl(15, -1, -4, {15, 11, 7, 3});
         TestSteppedXRangeImpl(15, -2, -4, {15, 11, 7, 3, -1});
-    } 
- 
+    }
+
     Y_UNIT_TEST(PointersWorks) {
         TVector<size_t> data = {3, 1, 4, 1, 5, 9, 2, 6};
-        const size_t digSumExpected = Accumulate(data.begin(), data.end(), static_cast<size_t>(0)); 
-        size_t digSumByIt = 0; 
+        const size_t digSumExpected = Accumulate(data.begin(), data.end(), static_cast<size_t>(0));
+        size_t digSumByIt = 0;
         for (auto ptr : xrange(data.begin(), data.end())) {
-            digSumByIt += *ptr; 
-        } 
-        UNIT_ASSERT_VALUES_EQUAL(digSumByIt, digSumExpected); 
-        size_t digSumByPtr = 0; 
+            digSumByIt += *ptr;
+        }
+        UNIT_ASSERT_VALUES_EQUAL(digSumByIt, digSumExpected);
+        size_t digSumByPtr = 0;
         for (auto ptr : xrange(&data[0], &data[0] + data.size())) {
-            digSumByPtr += *ptr; 
-        } 
-        UNIT_ASSERT_VALUES_EQUAL(digSumByPtr, digSumExpected); 
-    } 
+            digSumByPtr += *ptr;
+        }
+        UNIT_ASSERT_VALUES_EQUAL(digSumByPtr, digSumExpected);
+    }
 
     Y_UNIT_TEST(SizeMethodCheck) {
         UNIT_ASSERT_VALUES_EQUAL(xrange(5).size(), 5);

util/stream/pipe.cpp

@@ -82,40 +82,40 @@ void TPipeOutput::Close() {
     }
 }
 
-TPipedBase::TPipedBase(PIPEHANDLE fd) 
-    : Handle_(fd) 
-{ 
-} 
- 
+TPipedBase::TPipedBase(PIPEHANDLE fd)
+    : Handle_(fd)
+{
+}
+
 TPipedBase::~TPipedBase() {
     if (Handle_.IsOpen()) {
-        Handle_.Close(); 
+        Handle_.Close();
     }
-} 
- 
+}
+
 TPipedInput::TPipedInput(PIPEHANDLE fd)
-    : TPipedBase(fd) 
-{ 
-} 
- 
+    : TPipedBase(fd)
+{
+}
+
 TPipedInput::~TPipedInput() = default;
- 
-size_t TPipedInput::DoRead(void* buf, size_t len) { 
+
+size_t TPipedInput::DoRead(void* buf, size_t len) {
     if (!Handle_.IsOpen()) {
-        return 0; 
+        return 0;
     }
     return Handle_.Read(buf, len);
-} 
- 
-TPipedOutput::TPipedOutput(PIPEHANDLE fd) 
-    : TPipedBase(fd) 
-{ 
-} 
- 
+}
+
+TPipedOutput::TPipedOutput(PIPEHANDLE fd)
+    : TPipedBase(fd)
+{
+}
+
 TPipedOutput::~TPipedOutput() = default;
- 
-void TPipedOutput::DoWrite(const void* buf, size_t len) { 
-    if (!Handle_.IsOpen() || static_cast<ssize_t>(len) != Handle_.Write(buf, len)) { 
-        ythrow TSystemError() << "pipe writing failed"; 
-    } 
-} 
+
+void TPipedOutput::DoWrite(const void* buf, size_t len) {
+    if (!Handle_.IsOpen() || static_cast<ssize_t>(len) != Handle_.Write(buf, len)) {
+        ythrow TSystemError() << "pipe writing failed";
+    }
+}

util/stream/pipe.h

@@ -76,15 +76,15 @@ private:
     void DoWrite(const void* buf, size_t len) override;
 };
 
-class TPipedBase { 
+class TPipedBase {
 protected:
     TPipedBase(PIPEHANDLE fd);
     virtual ~TPipedBase();
 
 protected:
     TPipeHandle Handle_;
-}; 
- 
+};
+
 /**
  * Input stream that binds to a standard output stream of an existing process.
  */
@@ -92,11 +92,11 @@ class TPipedInput: public TPipedBase, public IInputStream {
 public:
     TPipedInput(PIPEHANDLE fd);
     ~TPipedInput() override;
- 
+
 private:
     size_t DoRead(void* buf, size_t len) override;
-}; 
- 
+};
+
 /**
  * Output stream that binds to a standard input stream of an existing process.
  */
@@ -104,9 +104,9 @@ class TPipedOutput: public TPipedBase, public IOutputStream {
 public:
     TPipedOutput(PIPEHANDLE fd);
     ~TPipedOutput() override;
- 
+
 private:
     void DoWrite(const void* buf, size_t len) override;
-}; 
- 
+};
+
 /** @} */