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

23 files changed, 260 insertions, 260 deletions

diff --git a/library/cpp/json/yson/json2yson.cpp b/library/cpp/json/yson/json2yson.cpp
index 5030eec414..f72cb7a9ef 100644
--- a/library/cpp/json/yson/json2yson.cpp
+++ b/library/cpp/json/yson/json2yson.cpp
@@ -48,13 +48,13 @@ namespace NJson2Yson {
     }
 
     void SerializeJsonValueAsYson(const NJson::TJsonValue& inputValue, NYson::TYsonWriter* ysonWriter) {
-        NYT::TYson2JsonCallbacksAdapter adapter(ysonWriter); 
-        WriteJsonValue(inputValue, &adapter); 
-    } 
- 
+        NYT::TYson2JsonCallbacksAdapter adapter(ysonWriter);
+        WriteJsonValue(inputValue, &adapter);
+    }
+
     void SerializeJsonValueAsYson(const NJson::TJsonValue& inputValue, IOutputStream* outputStream) {
         NYson::TYsonWriter ysonWriter(outputStream, NYson::EYsonFormat::Binary, ::NYson::EYsonType::Node, false);
-        SerializeJsonValueAsYson(inputValue, &ysonWriter); 
+        SerializeJsonValueAsYson(inputValue, &ysonWriter);
     }
 
     void SerializeJsonValueAsYson(const NJson::TJsonValue& inputValue, TString& result) {
diff --git a/library/cpp/logger/log.cpp b/library/cpp/logger/log.cpp
index a69cb3bea8..e1d70cc3d2 100644
--- a/library/cpp/logger/log.cpp
+++ b/library/cpp/logger/log.cpp
@@ -1,7 +1,7 @@
 #include "log.h"
 #include "uninitialized_creator.h"
-#include "filter.h" 
-#include "null.h" 
+#include "filter.h"
+#include "null.h"
 #include "stream.h"
 #include "thread.h"
 
@@ -20,12 +20,12 @@ THolder<TLogBackend> CreateLogBackend(const TString& fname, ELogPriority priorit
 
 THolder<TLogBackend> CreateFilteredOwningThreadedLogBackend(const TString& fname, ELogPriority priority, size_t queueLen) {
     return MakeHolder<TFilteredLogBackend>(CreateOwningThreadedLogBackend(fname, queueLen), priority);
-} 
- 
+}
+
 THolder<TOwningThreadedLogBackend> CreateOwningThreadedLogBackend(const TString& fname, size_t queueLen) {
     return MakeHolder<TOwningThreadedLogBackend>(CreateLogBackend(fname, LOG_MAX_PRIORITY, false).Release(), queueLen);
-} 
- 
+}
+
 class TLog::TImpl: public TAtomicRefCount<TImpl> {
     class TPriorityLogStream final: public IOutputStream {
     public:
diff --git a/library/cpp/logger/log.h b/library/cpp/logger/log.h
index 078fa1b306..8be984ccc8 100644
--- a/library/cpp/logger/log.h
+++ b/library/cpp/logger/log.h
@@ -1,10 +1,10 @@
 #pragma once
 
-#include "backend.h" 
+#include "backend.h"
 #include "element.h"
 #include "priority.h"
-#include "record.h" 
-#include "thread.h" 
+#include "record.h"
+#include "thread.h"
 
 #include <util/generic/fwd.h>
 #include <util/generic/ptr.h>
diff --git a/library/cpp/yson_pull/range.h b/library/cpp/yson_pull/range.h
index b5d6a5be3b..f4fcf3f206 100644
--- a/library/cpp/yson_pull/range.h
+++ b/library/cpp/yson_pull/range.h
@@ -16,11 +16,11 @@ namespace NYsonPull {
         {
         }
 
-        const TEvent* Last() const noexcept { 
+        const TEvent* Last() const noexcept {
             return &Reader_.LastEvent();
         }
 
-        const TEvent* Next() { 
+        const TEvent* Next() {
             if (Y_UNLIKELY(AtEnd)) {
                 return nullptr;
             }
diff --git a/util/datetime/base.cpp b/util/datetime/base.cpp
index 6061b445d7..38ecc3ab96 100644
--- a/util/datetime/base.cpp
+++ b/util/datetime/base.cpp
@@ -250,55 +250,55 @@ void sprint_gm_date(char* buf, time_t when, long* sec) {
     struct tm theTm;
     ::Zero(theTm);
     GmTimeR(&when, &theTm);
-    DateToString(buf, theTm); 
+    DateToString(buf, theTm);
     if (sec) {
         *sec = seconds(theTm);
     }
 }
 
-void DateToString(char* buf, const struct tm& theTm) { 
-    Y_ENSURE(0 <= theTm.tm_year + 1900 && theTm.tm_year + 1900 <= 9999, "invalid year " + ToString(theTm.tm_year + 1900) + ", year should be in range [0, 9999]"); 
- 
-    sprintf(buf, "%04d%02d%02d", theTm.tm_year + 1900, theTm.tm_mon + 1, theTm.tm_mday); 
-} 
- 
-void DateToString(char* buf, time_t when, long* sec) { 
-    struct tm theTm; 
-    localtime_r(&when, &theTm); 
- 
-    DateToString(buf, theTm); 
- 
-    if (sec) { 
-        *sec = seconds(theTm); 
-    } 
-} 
- 
-TString DateToString(const struct tm& theTm) { 
-    char buf[DATE_BUF_LEN]; 
-    DateToString(buf, theTm); 
-    return buf; 
-} 
- 
-TString DateToString(time_t when, long* sec) { 
-    char buf[DATE_BUF_LEN]; 
-    DateToString(buf, when, sec); 
-    return buf; 
-} 
- 
-TString YearToString(const struct tm& theTm) { 
-    Y_ENSURE(0 <= theTm.tm_year + 1900 && theTm.tm_year + 1900 <= 9999, "invalid year " + ToString(theTm.tm_year + 1900) + ", year should be in range [0, 9999]"); 
+void DateToString(char* buf, const struct tm& theTm) {
+    Y_ENSURE(0 <= theTm.tm_year + 1900 && theTm.tm_year + 1900 <= 9999, "invalid year " + ToString(theTm.tm_year + 1900) + ", year should be in range [0, 9999]");
+
+    sprintf(buf, "%04d%02d%02d", theTm.tm_year + 1900, theTm.tm_mon + 1, theTm.tm_mday);
+}
+
+void DateToString(char* buf, time_t when, long* sec) {
+    struct tm theTm;
+    localtime_r(&when, &theTm);
+
+    DateToString(buf, theTm);
+
+    if (sec) {
+        *sec = seconds(theTm);
+    }
+}
+
+TString DateToString(const struct tm& theTm) {
+    char buf[DATE_BUF_LEN];
+    DateToString(buf, theTm);
+    return buf;
+}
+
+TString DateToString(time_t when, long* sec) {
+    char buf[DATE_BUF_LEN];
+    DateToString(buf, when, sec);
+    return buf;
+}
+
+TString YearToString(const struct tm& theTm) {
+    Y_ENSURE(0 <= theTm.tm_year + 1900 && theTm.tm_year + 1900 <= 9999, "invalid year " + ToString(theTm.tm_year + 1900) + ", year should be in range [0, 9999]");
     char buf[16];
     sprintf(buf, "%04d", theTm.tm_year + 1900);
     return buf;
-} 
- 
-TString YearToString(time_t when) { 
-    struct tm theTm; 
-    localtime_r(&when, &theTm); 
- 
-    return YearToString(theTm); 
-} 
- 
+}
+
+TString YearToString(time_t when) {
+    struct tm theTm;
+    localtime_r(&when, &theTm);
+
+    return YearToString(theTm);
+}
+
 bool sscan_date(const char* date, struct tm& theTm) {
     int year, mon, mday;
     if (sscanf(date, "%4d%2d%2d", &year, &mon, &mday) != 3) {
diff --git a/util/datetime/base.h b/util/datetime/base.h
index d1cf52c926..5e902b8f63 100644
--- a/util/datetime/base.h
+++ b/util/datetime/base.h
@@ -84,15 +84,15 @@ constexpr long TVdiff(timeval r1, timeval r2) {
 
 TString Strftime(const char* format, const struct tm* tm);
 
-// Use functions below instead of sprint_date (check IGNIETFERRO-892 for details) 
-void DateToString(char* buf, const struct tm& theTm); 
-void DateToString(char* buf, time_t when, long* sec = nullptr); 
-TString DateToString(const struct tm& theTm); 
-TString DateToString(time_t when, long* sec = nullptr); 
-// Year in format "YYYY", throws an exception if year not in range [0, 9999] 
-TString YearToString(const struct tm& theTm); 
-TString YearToString(time_t when); 
- 
+// Use functions below instead of sprint_date (check IGNIETFERRO-892 for details)
+void DateToString(char* buf, const struct tm& theTm);
+void DateToString(char* buf, time_t when, long* sec = nullptr);
+TString DateToString(const struct tm& theTm);
+TString DateToString(time_t when, long* sec = nullptr);
+// Year in format "YYYY", throws an exception if year not in range [0, 9999]
+TString YearToString(const struct tm& theTm);
+TString YearToString(time_t when);
+
 template <class S>
 class TTimeBase {
 public:
diff --git a/util/datetime/base_ut.cpp b/util/datetime/base_ut.cpp
index 783a2636dc..afc3f802eb 100644
--- a/util/datetime/base_ut.cpp
+++ b/util/datetime/base_ut.cpp
@@ -46,108 +46,108 @@ namespace {
         }
     }
 }
- 
+
 Y_UNIT_TEST_SUITE(TestSprintDate) {
     Y_UNIT_TEST(Year9999) {
-        struct tm t; 
-        t.tm_year = 9999 - 1900; 
-        t.tm_mday = 1; 
-        t.tm_mon = 10; 
- 
-        char buf[DATE_BUF_LEN]; 
-        DateToString(buf, t); 
- 
-        TString expectedDate = "99991101"; 
- 
-        UNIT_ASSERT_VALUES_EQUAL(expectedDate, ToString(buf)); 
-    } 
+        struct tm t;
+        t.tm_year = 9999 - 1900;
+        t.tm_mday = 1;
+        t.tm_mon = 10;
+
+        char buf[DATE_BUF_LEN];
+        DateToString(buf, t);
+
+        TString expectedDate = "99991101";
+
+        UNIT_ASSERT_VALUES_EQUAL(expectedDate, ToString(buf));
+    }
     Y_UNIT_TEST(YearAfter9999) {
-        struct tm t; 
-        t.tm_year = 123456 - 1900; 
-        t.tm_mday = 1; 
-        t.tm_mon = 10; 
- 
-        char buf[DATE_BUF_LEN]; 
-        UNIT_ASSERT_EXCEPTION(DateToString(buf, t), yexception); 
-    } 
+        struct tm t;
+        t.tm_year = 123456 - 1900;
+        t.tm_mday = 1;
+        t.tm_mon = 10;
+
+        char buf[DATE_BUF_LEN];
+        UNIT_ASSERT_EXCEPTION(DateToString(buf, t), yexception);
+    }
     Y_UNIT_TEST(SmallYear) {
-        struct tm t; 
-        t.tm_year = 0 - 1900; 
-        t.tm_mday = 1; 
-        t.tm_mon = 10; 
- 
-        char buf[DATE_BUF_LEN]; 
-        DateToString(buf, t); 
- 
-        const TString expectedDate = TString("00001101"); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(expectedDate, ToString(buf)); 
-    } 
+        struct tm t;
+        t.tm_year = 0 - 1900;
+        t.tm_mday = 1;
+        t.tm_mon = 10;
+
+        char buf[DATE_BUF_LEN];
+        DateToString(buf, t);
+
+        const TString expectedDate = TString("00001101");
+
+        UNIT_ASSERT_VALUES_EQUAL(expectedDate, ToString(buf));
+    }
     Y_UNIT_TEST(SmallYearAndMonth) {
-        struct tm t; 
-        t.tm_year = 99 - 1900; 
-        t.tm_mday = 1; 
-        t.tm_mon = 0; 
- 
-        char buf[DATE_BUF_LEN]; 
-        DateToString(buf, t); 
- 
-        const TString expectedDate = TString("00990101"); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(expectedDate, ToString(buf)); 
-    } 
-    Y_UNIT_TEST(FromZeroTimestamp) { 
-        const time_t timestamp = 0; 
- 
-        char buf[DATE_BUF_LEN]; 
-        DateToString(buf, timestamp); 
- 
-        const TString expectedDate = TString("19700101"); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(expectedDate, ToString(buf)); 
-    } 
-    Y_UNIT_TEST(FromTimestamp) { 
-        const time_t timestamp = 1524817858; 
- 
-        char buf[DATE_BUF_LEN]; 
-        DateToString(buf, timestamp); 
- 
-        const TString expectedDate = TString("20180427"); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(expectedDate, ToString(buf)); 
-    } 
-    Y_UNIT_TEST(FromTimestampAsTString) { 
-        const time_t timestamp = 1524817858; 
- 
-        const TString expectedDate = TString("20180427"); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(expectedDate, DateToString(timestamp)); 
-    } 
-    Y_UNIT_TEST(YearToString) { 
-        struct tm t; 
-        t.tm_year = 99 - 1900; 
-        t.tm_mday = 1; 
-        t.tm_mon = 0; 
- 
-        TString expectedYear = TString("0099"); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(expectedYear, YearToString(t)); 
-    } 
-    Y_UNIT_TEST(YearToStringBigYear) { 
-        struct tm t; 
-        t.tm_year = 123456 - 1900; 
-        t.tm_mday = 1; 
-        t.tm_mon = 0; 
- 
-        UNIT_ASSERT_EXCEPTION(YearToString(t), yexception); 
-    } 
-    Y_UNIT_TEST(YearToStringAsTimestamp) { 
-        const time_t timestamp = 1524817858; 
- 
-        const TString expectedYear = TString("2018"); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(expectedYear, YearToString(timestamp)); 
-    } 
+        struct tm t;
+        t.tm_year = 99 - 1900;
+        t.tm_mday = 1;
+        t.tm_mon = 0;
+
+        char buf[DATE_BUF_LEN];
+        DateToString(buf, t);
+
+        const TString expectedDate = TString("00990101");
+
+        UNIT_ASSERT_VALUES_EQUAL(expectedDate, ToString(buf));
+    }
+    Y_UNIT_TEST(FromZeroTimestamp) {
+        const time_t timestamp = 0;
+
+        char buf[DATE_BUF_LEN];
+        DateToString(buf, timestamp);
+
+        const TString expectedDate = TString("19700101");
+
+        UNIT_ASSERT_VALUES_EQUAL(expectedDate, ToString(buf));
+    }
+    Y_UNIT_TEST(FromTimestamp) {
+        const time_t timestamp = 1524817858;
+
+        char buf[DATE_BUF_LEN];
+        DateToString(buf, timestamp);
+
+        const TString expectedDate = TString("20180427");
+
+        UNIT_ASSERT_VALUES_EQUAL(expectedDate, ToString(buf));
+    }
+    Y_UNIT_TEST(FromTimestampAsTString) {
+        const time_t timestamp = 1524817858;
+
+        const TString expectedDate = TString("20180427");
+
+        UNIT_ASSERT_VALUES_EQUAL(expectedDate, DateToString(timestamp));
+    }
+    Y_UNIT_TEST(YearToString) {
+        struct tm t;
+        t.tm_year = 99 - 1900;
+        t.tm_mday = 1;
+        t.tm_mon = 0;
+
+        TString expectedYear = TString("0099");
+
+        UNIT_ASSERT_VALUES_EQUAL(expectedYear, YearToString(t));
+    }
+    Y_UNIT_TEST(YearToStringBigYear) {
+        struct tm t;
+        t.tm_year = 123456 - 1900;
+        t.tm_mday = 1;
+        t.tm_mon = 0;
+
+        UNIT_ASSERT_EXCEPTION(YearToString(t), yexception);
+    }
+    Y_UNIT_TEST(YearToStringAsTimestamp) {
+        const time_t timestamp = 1524817858;
+
+        const TString expectedYear = TString("2018");
+
+        UNIT_ASSERT_VALUES_EQUAL(expectedYear, YearToString(timestamp));
+    }
 }
 
 Y_UNIT_TEST_SUITE(TDateTimeTest) {
diff --git a/util/generic/array_ref.h b/util/generic/array_ref.h
index a224443bfd..1ac60ac7d3 100644
--- a/util/generic/array_ref.h
+++ b/util/generic/array_ref.h
@@ -73,7 +73,7 @@ public:
     {
     }
 
-    template <class TT, typename = std::enable_if_t<std::is_same<std::remove_const_t<T>, std::remove_const_t<TT>>::value>> 
+    template <class TT, typename = std::enable_if_t<std::is_same<std::remove_const_t<T>, std::remove_const_t<TT>>::value>>
     bool operator==(const TArrayRef<TT>& other) const noexcept {
         return (S_ == other.size()) && std::equal(begin(), end(), other.begin());
     }
diff --git a/util/generic/iterator.h b/util/generic/iterator.h
index aa141c2d5f..19e9d20976 100644
--- a/util/generic/iterator.h
+++ b/util/generic/iterator.h
@@ -5,30 +5,30 @@
 
 namespace NStlIterator {
     template <class T>
-    class TProxy { 
-    public: 
-        TProxy() = default; 
+    class TProxy {
+    public:
+        TProxy() = default;
         TProxy(T&& value)
             : Value_(std::move(value))
         {
-        } 
+        }
 
-        const T* operator->() const noexcept { 
-            return &Value_; 
-        } 
+        const T* operator->() const noexcept {
+            return &Value_;
+        }
 
-        const T& operator*() const noexcept { 
-            return Value_; 
-        } 
+        const T& operator*() const noexcept {
+            return Value_;
+        }
 
-        bool operator==(const TProxy& rhs) const { 
-            return Value_ == rhs.Value_; 
+        bool operator==(const TProxy& rhs) const {
+            return Value_ == rhs.Value_;
         }
 
-    private: 
-        T Value_; 
+    private:
+        T Value_;
     };
-} // namespace NStlIterator 
+} // namespace NStlIterator
 
 /**
  * Range adaptor that turns a derived class with a Java-style iteration
@@ -71,9 +71,9 @@ public: // TODO: private
         static constexpr bool IsNoexceptNext = noexcept(std::declval<TSlave>().Next());
 
         using difference_type = std::ptrdiff_t;
-        using pointer = decltype(std::declval<TSlave>().Next()); 
-        using reference = decltype(*std::declval<TSlave>().Next()); 
-        using value_type = std::remove_cv_t<std::remove_reference_t<reference>>; 
+        using pointer = decltype(std::declval<TSlave>().Next());
+        using reference = decltype(*std::declval<TSlave>().Next());
+        using value_type = std::remove_cv_t<std::remove_reference_t<reference>>;
         using iterator_category = std::input_iterator_tag;
 
         inline TIterator() noexcept
@@ -97,11 +97,11 @@ public: // TODO: private
         }
 
         inline pointer operator->() const noexcept {
-            return Cur_; 
+            return Cur_;
         }
 
         inline reference operator*() const noexcept {
-            return *Cur_; 
+            return *Cur_;
         }
 
         inline TIterator& operator++() noexcept(IsNoexceptNext) {
@@ -112,18 +112,18 @@ public: // TODO: private
 
     private:
         TSlave* Slave_;
-        pointer Cur_; 
+        pointer Cur_;
     };
 
 public:
-    using const_iterator = TIterator; 
-    using iterator = const_iterator; 
- 
-    inline iterator begin() const noexcept(TIterator::IsNoexceptNext) { 
+    using const_iterator = TIterator;
+    using iterator = const_iterator;
+
+    inline iterator begin() const noexcept(TIterator::IsNoexceptNext) {
         return TIterator(const_cast<TSlave*>(static_cast<const TSlave*>(this)));
     }
 
-    inline iterator end() const noexcept { 
+    inline iterator end() const noexcept {
         return TIterator();
     }
 };
diff --git a/util/generic/iterator_ut.cpp b/util/generic/iterator_ut.cpp
index 5dc085c821..00be19e10e 100644
--- a/util/generic/iterator_ut.cpp
+++ b/util/generic/iterator_ut.cpp
@@ -9,55 +9,55 @@ Y_UNIT_TEST_SUITE(TIterator) {
         UNIT_ASSERT_VALUES_EQUAL(*ToForwardIterator(std::prev(x.rend())), *x.begin());
     }
 }
- 
-Y_UNIT_TEST_SUITE(TInputRangeAdaptor) { 
+
+Y_UNIT_TEST_SUITE(TInputRangeAdaptor) {
     class TSquaresGenerator: public TInputRangeAdaptor<TSquaresGenerator> {
-    public: 
-        const i64* Next() { 
-            Current_ = State_ * State_; 
-            ++State_; 
-            // Never return nullptr => we have infinite range! 
-            return &Current_; 
-        } 
- 
-    private: 
-        i64 State_ = 0.0; 
-        i64 Current_ = 0.0; 
-    }; 
- 
-    Y_UNIT_TEST(TSquaresGenerator) { 
-        i64 cur = 0; 
-        for (i64 sqr : TSquaresGenerator{}) { 
-            UNIT_ASSERT_VALUES_EQUAL(cur * cur, sqr); 
- 
-            if (++cur > 10) { 
-                break; 
-            } 
-        } 
-    } 
- 
+    public:
+        const i64* Next() {
+            Current_ = State_ * State_;
+            ++State_;
+            // Never return nullptr => we have infinite range!
+            return &Current_;
+        }
+
+    private:
+        i64 State_ = 0.0;
+        i64 Current_ = 0.0;
+    };
+
+    Y_UNIT_TEST(TSquaresGenerator) {
+        i64 cur = 0;
+        for (i64 sqr : TSquaresGenerator{}) {
+            UNIT_ASSERT_VALUES_EQUAL(cur * cur, sqr);
+
+            if (++cur > 10) {
+                break;
+            }
+        }
+    }
+
     class TUrlPart: public TInputRangeAdaptor<TUrlPart> {
-    public: 
+    public:
         TUrlPart(const TStringBuf& url)
             : Url_(url)
         {
-        } 
- 
-        NStlIterator::TProxy<TStringBuf> Next() { 
-            return Url_.NextTok('/'); 
-        } 
- 
-    private: 
-        TStringBuf Url_; 
-    }; 
- 
-    Y_UNIT_TEST(TUrlPart) { 
+        }
+
+        NStlIterator::TProxy<TStringBuf> Next() {
+            return Url_.NextTok('/');
+        }
+
+    private:
+        TStringBuf Url_;
+    };
+
+    Y_UNIT_TEST(TUrlPart) {
         const TVector<TStringBuf> expected = {TStringBuf("yandex.ru"), TStringBuf("search?")};
-        auto expected_part = expected.begin(); 
+        auto expected_part = expected.begin();
         for (const TStringBuf& part : TUrlPart(TStringBuf("yandex.ru/search?"))) {
             UNIT_ASSERT_VALUES_EQUAL(part, *expected_part);
             ++expected_part;
-        } 
+        }
         UNIT_ASSERT(expected_part == expected.end());
-    } 
-} 
+    }
+}
diff --git a/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_iter.h b/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_iter.h
index 07b05399ec..ecfdadffeb 100644
--- a/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_iter.h
+++ b/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_iter.h
@@ -9,7 +9,7 @@ namespace NKikimr {
     class TBlobStorageGroupInfo::TIteratorBase
         : public TParentIter
     {
-        using TValue = std::remove_reference_t<decltype(*std::declval<TBaseIter>())>; 
+        using TValue = std::remove_reference_t<decltype(*std::declval<TBaseIter>())>;
 
         TBaseIter It; // iterator to current element
 
diff --git a/ydb/core/blobstorage/vdisk/common/memusage.h b/ydb/core/blobstorage/vdisk/common/memusage.h
index 21669d88b6..b045c1e3d5 100644
--- a/ydb/core/blobstorage/vdisk/common/memusage.h
+++ b/ydb/core/blobstorage/vdisk/common/memusage.h
@@ -533,12 +533,12 @@ namespace NKikimr {
 
 } // NKikimr
 
-template<typename TBase, std::enable_if_t<NKikimr::THasCapitalSwapMethod<TBase>::Value>* = nullptr> 
+template<typename TBase, std::enable_if_t<NKikimr::THasCapitalSwapMethod<TBase>::Value>* = nullptr>
 void DoSwap(NKikimr::TTrackable<TBase>& first, NKikimr::TTrackable<TBase>& second) {
     first.Swap(second);
 }
 
-template<typename TBase, std::enable_if_t<NKikimr::THasSmallSwapMethod<TBase>::Value>* = nullptr> 
+template<typename TBase, std::enable_if_t<NKikimr::THasSmallSwapMethod<TBase>::Value>* = nullptr>
 void DoSwap(NKikimr::TTrackable<TBase>& first, NKikimr::TTrackable<TBase>& second) {
     first.swap(second);
 }
diff --git a/ydb/core/mind/table_adapter.h b/ydb/core/mind/table_adapter.h
index 603d8a469d..f0ec8db1e2 100644
--- a/ydb/core/mind/table_adapter.h
+++ b/ydb/core/mind/table_adapter.h
@@ -95,7 +95,7 @@ namespace NKikimr {
         }
 
         template<typename T>
-        auto WrapTuple(const T &item, std::enable_if_t<std::is_integral<T>::value>* = nullptr) { 
+        auto WrapTuple(const T &item, std::enable_if_t<std::is_integral<T>::value>* = nullptr) {
             return std::make_tuple(item);
         }
 
@@ -185,7 +185,7 @@ namespace NKikimr {
                 op.Tag = TColumn::ColumnId;
                 op.Op = NTable::ECellOp::Set;
 
-                std::tuple_element_t<Index, std::tuple<TArgs...>> &maybe = std::get<Index>(*tuple); 
+                std::tuple_element_t<Index, std::tuple<TArgs...>> &maybe = std::get<Index>(*tuple);
                 op.Value = NIceDb::TConvertTypeValue<TColumn::ColumnType>(
                         maybe ? NIceDb::TTypeValue(*maybe) : NIceDb::TTypeValue()
                     );
@@ -477,7 +477,7 @@ namespace NKikimr {
                 struct TNotReady : yexception {};
 
                 auto processInlineTable = [&](auto (TRow::*member), const auto *inlineTable) {
-                    using TInlineTable = std::remove_pointer_t<decltype(inlineTable)>; 
+                    using TInlineTable = std::remove_pointer_t<decltype(inlineTable)>;
                     if (!FetchTable<TInlineTable>(db, param, item.*member, key)) {
                         ythrow TNotReady();
                     }
diff --git a/ydb/core/persqueue/type_codecs_defs.cpp b/ydb/core/persqueue/type_codecs_defs.cpp
index 54b3f89a90..f333be5cfc 100644
--- a/ydb/core/persqueue/type_codecs_defs.cpp
+++ b/ydb/core/persqueue/type_codecs_defs.cpp
@@ -40,8 +40,8 @@ inline void AddFixedLen(TTypeCodecs* codecs, bool initDefaults = true) {
 template <typename TType>
 void AddIntCodecs(TTypeCodecs* codecs) {
     static_assert(std::is_integral<typename TType::TValueType>::value, "Not an integral type.");
-    using TSigned = std::make_signed_t<typename TType::TValueType>; 
-    using TUnsigned = std::make_unsigned_t<typename TType::TValueType>; 
+    using TSigned = std::make_signed_t<typename TType::TValueType>;
+    using TUnsigned = std::make_unsigned_t<typename TType::TValueType>;
 
     codecs->AddCodec<TVarIntCodec<TUnsigned, true>>();
     codecs->AddCodec<TVarIntCodec<TUnsigned, false>>();
diff --git a/ydb/core/persqueue/type_coders.h b/ydb/core/persqueue/type_coders.h
index 3f8dba0283..26c2566d32 100644
--- a/ydb/core/persqueue/type_coders.h
+++ b/ydb/core/persqueue/type_coders.h
@@ -147,7 +147,7 @@ template <typename TIntType>
 class TVarIntValueCoder {
 public:
     using TType = TIntType;
-    using TSigned = std::make_signed_t<TType>; 
+    using TSigned = std::make_signed_t<TType>;
 
     inline size_t Save(TFlatBlobDataOutputStream* output, TType value) {
         const auto outValue = static_cast<i64>(value); // TODO: fix out_long(i32)
@@ -162,7 +162,7 @@ template <typename TIntType>
 class TZigZagValueCoder {
 public:
     using TType = TIntType;
-    using TSigned = std::make_signed_t<TType>; 
+    using TSigned = std::make_signed_t<TType>;
 
     inline size_t Save(TFlatBlobDataOutputStream* output, TType value) {
         const auto zigZagged = static_cast<i64>(ZigZagEncode(value));
diff --git a/ydb/core/persqueue/type_decoders.h b/ydb/core/persqueue/type_decoders.h
index 52498c3319..30a8846923 100644
--- a/ydb/core/persqueue/type_decoders.h
+++ b/ydb/core/persqueue/type_decoders.h
@@ -322,7 +322,7 @@ template <typename TIntType>
 class TZigZagValueDecoder {
 public:
     using TType = TIntType;
-    using TUnsigned = std::make_unsigned_t<TType>; 
+    using TUnsigned = std::make_unsigned_t<TType>;
 
     inline TType Peek(const char* data, const char* end) const {
         i64 value;
diff --git a/ydb/core/tablet/node_whiteboard.cpp b/ydb/core/tablet/node_whiteboard.cpp
index 06ca59d7dc..783758e99d 100644
--- a/ydb/core/tablet/node_whiteboard.cpp
+++ b/ydb/core/tablet/node_whiteboard.cpp
@@ -81,8 +81,8 @@ protected:
 
     template <typename PropertyType>
     static ui64 GetDifference(PropertyType a, PropertyType b) {
-        return static_cast<ui64>(std::abs(static_cast<std::make_signed_t<PropertyType>>(b) - 
-                                          static_cast<std::make_signed_t<PropertyType>>(a))); 
+        return static_cast<ui64>(std::abs(static_cast<std::make_signed_t<PropertyType>>(b) -
+                                          static_cast<std::make_signed_t<PropertyType>>(a)));
     }
 
     static ui64 GetDifference(double a, double b) {
diff --git a/ydb/core/tablet_flat/flat_cxx_database.h b/ydb/core/tablet_flat/flat_cxx_database.h
index 3bb740efde..27a260bcb2 100644
--- a/ydb/core/tablet_flat/flat_cxx_database.h
+++ b/ydb/core/tablet_flat/flat_cxx_database.h
@@ -573,8 +573,8 @@ auto ConvertValue(const SourceType& value) {
 template <typename ColumnType,
           typename TargetType,
           typename SourceType,
-          std::enable_if_t<!std::is_pod<SourceType>::value, bool> = true, 
-          std::enable_if_t<!std::is_pod<TargetType>::value, bool> = true, 
+          std::enable_if_t<!std::is_pod<SourceType>::value, bool> = true,
+          std::enable_if_t<!std::is_pod<TargetType>::value, bool> = true,
           typename std::enable_if<!std::is_base_of<::google::protobuf::Message, SourceType>::value, bool>::type = true,
           typename std::enable_if<!std::is_base_of<::google::protobuf::Message, TargetType>::value, bool>::type = true>
 auto ConvertValue(const SourceType& value) {
diff --git a/ydb/core/util/metrics.h b/ydb/core/util/metrics.h
index e09a488a9f..cae931733f 100644
--- a/ydb/core/util/metrics.h
+++ b/ydb/core/util/metrics.h
@@ -27,15 +27,15 @@ public:
         : Value(value)
     {}
 
-    std::make_signed_t<ValueType> Set(ValueType value) { 
-        std::make_signed_t<ValueType> diff = 
-                static_cast<std::make_signed_t<ValueType>>(value) - 
-                static_cast<std::make_signed_t<ValueType>>(Value); 
+    std::make_signed_t<ValueType> Set(ValueType value) {
+        std::make_signed_t<ValueType> diff =
+                static_cast<std::make_signed_t<ValueType>>(value) -
+                static_cast<std::make_signed_t<ValueType>>(Value);
         Value = value;
         return diff;
     }
 
-    void Increment(std::make_signed_t<ValueType> value) { Value += value; } 
+    void Increment(std::make_signed_t<ValueType> value) { Value += value; }
     ValueType GetValue() const { return Value; }
     TGaugeValue operator +(const TGaugeValue& o) const { return TGaugeValue(Value + o.GetValue()); }
     TGaugeValue operator -(const TGaugeValue& o) const { return TGaugeValue(Value - o.GetValue()); }
@@ -127,7 +127,7 @@ public:
         return accumulator * multiplicator / divider;
     }
 
-    void Increment(std::make_signed_t<ValueType> value, TInstant to = TInstant::Now()) { 
+    void Increment(std::make_signed_t<ValueType> value, TInstant to = TInstant::Now()) {
         Store(value, to);
     }
 
diff --git a/ydb/core/util/tuples.h b/ydb/core/util/tuples.h
index d039e5dfd8..0ca0689198 100644
--- a/ydb/core/util/tuples.h
+++ b/ydb/core/util/tuples.h
@@ -289,12 +289,12 @@ struct make_n_tuple<1, T> {
 // make_array(tuple<>) - converts to std::array<>
 
 template <typename T, std::size_t... I>
-std::array<std::tuple_element_t<0, T>, std::tuple_size<T>::value> tuple_to_array(std::index_sequence<I...>, const T& a) { 
+std::array<std::tuple_element_t<0, T>, std::tuple_size<T>::value> tuple_to_array(std::index_sequence<I...>, const T& a) {
     return {{std::get<I>(a)...}};
 }
 
 template <typename T>
-std::array<std::tuple_element_t<0, T>, std::tuple_size<T>::value> tuple_to_array(const T& a) { 
+std::array<std::tuple_element_t<0, T>, std::tuple_size<T>::value> tuple_to_array(const T& a) {
     return tuple_to_array(std::make_index_sequence<std::tuple_size<T>::value>(), a);
 }
 
diff --git a/ydb/library/yql/minikql/computation/mkql_computation_list_adapter.h b/ydb/library/yql/minikql/computation/mkql_computation_list_adapter.h
index 42aac044d0..2b3b7fb886 100644
--- a/ydb/library/yql/minikql/computation/mkql_computation_list_adapter.h
+++ b/ydb/library/yql/minikql/computation/mkql_computation_list_adapter.h
@@ -234,12 +234,12 @@ public:
 template<typename TVectorType>
 NUdf::TUnboxedValue CreateOwningVectorListAdapter(
     TVectorType&& list,
-    typename TVectorListAdapter<std::remove_reference_t<TVectorType>>::TItemFactory itemFactory, 
+    typename TVectorListAdapter<std::remove_reference_t<TVectorType>>::TItemFactory itemFactory,
     ui64 start, ui64 finish,
     bool reversed,
     TMemoryUsageInfo& memInfo)
 {
-    return NUdf::TUnboxedValuePod(new TOwningVectorListAdapter<std::remove_reference_t<TVectorType>>( 
+    return NUdf::TUnboxedValuePod(new TOwningVectorListAdapter<std::remove_reference_t<TVectorType>>(
         &memInfo, std::forward<TVectorType>(list), itemFactory, start, finish, reversed));
 }
 
diff --git a/ydb/library/yql/minikql/computation/presort.cpp b/ydb/library/yql/minikql/computation/presort.cpp
index aff127083b..26b96a60aa 100644
--- a/ydb/library/yql/minikql/computation/presort.cpp
+++ b/ydb/library/yql/minikql/computation/presort.cpp
@@ -68,7 +68,7 @@ TUnsigned DecodeUnsigned(TStringBuf& input) {
 template <typename TSigned, bool Desc>
 Y_FORCE_INLINE
 void EncodeSigned(TVector<ui8>& output, TSigned value) {
-    using TUnsigned = std::make_unsigned_t<TSigned>; 
+    using TUnsigned = std::make_unsigned_t<TSigned>;
     constexpr size_t size = sizeof(TUnsigned);
     constexpr TUnsigned shift = TUnsigned(1) << (size * 8 - 1);
 
@@ -78,7 +78,7 @@ void EncodeSigned(TVector<ui8>& output, TSigned value) {
 template <typename TSigned, bool Desc>
 Y_FORCE_INLINE
 TSigned DecodeSigned(TStringBuf& input) {
-    using TUnsigned = std::make_unsigned_t<TSigned>; 
+    using TUnsigned = std::make_unsigned_t<TSigned>;
     constexpr size_t size = sizeof(TUnsigned);
     constexpr TUnsigned shift = TUnsigned(1) << (size * 8 - 1);
 
diff --git a/ydb/library/yql/public/udf/udf_string_ref.h b/ydb/library/yql/public/udf/udf_string_ref.h
index 7a55059923..75a82b81e6 100644
--- a/ydb/library/yql/public/udf/udf_string_ref.h
+++ b/ydb/library/yql/public/udf/udf_string_ref.h
@@ -18,7 +18,7 @@ template<bool Const>
 class TStringRefBase
 {
 public:
-    typedef std::conditional_t<Const, const char*, char*> TDataType; 
+    typedef std::conditional_t<Const, const char*, char*> TDataType;
 
 protected:
     inline constexpr TStringRefBase() noexcept = default;