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

contrib/python/ya.make

@@ -662,7 +662,7 @@ RECURSE(
     ndg-httpsclient
     nest-asyncio
     nested-diff
-    netaddr
+    netaddr 
     netifaces
     networkx
     nltk

library/cpp/containers/intrusive_rb_tree/fuzz/rb_tree_fuzzing.cpp

@@ -1,65 +1,65 @@
 #include <library/cpp/containers/intrusive_rb_tree/rb_tree.h>
-
-#include <util/generic/deque.h>
-#include <stdint.h>
-#include <stddef.h>
-
-struct TCmp {
-    template <class T>
-    static inline bool Compare(const T& l, const T& r) {
-        return l.N < r.N;
-    }
-
-    template <class T>
+ 
+#include <util/generic/deque.h> 
+#include <stdint.h> 
+#include <stddef.h> 
+ 
+struct TCmp { 
+    template <class T> 
+    static inline bool Compare(const T& l, const T& r) { 
+        return l.N < r.N; 
+    } 
+ 
+    template <class T> 
     static inline bool Compare(const T& l, ui8 r) {
-        return l.N < r;
-    }
-
-    template <class T>
+        return l.N < r; 
+    } 
+ 
+    template <class T> 
     static inline bool Compare(ui8 l, const T& r) {
-        return l < r.N;
-    }
-};
-
-class TNode: public TRbTreeItem<TNode, TCmp> {
-public:
+        return l < r.N; 
+    } 
+}; 
+ 
+class TNode: public TRbTreeItem<TNode, TCmp> { 
+public: 
     inline TNode(ui8 n) noexcept
-        : N(n)
-    {
-    }
-
+        : N(n) 
+    { 
+    } 
+ 
     ui8 N;
-};
-
-using TTree = TRbTree<TNode, TCmp>;
-
+}; 
+ 
+using TTree = TRbTree<TNode, TCmp>; 
+ 
 extern "C" int LLVMFuzzerTestOneInput(const ui8* data, size_t size) {
     TDeque<TNode> records;
     const ui8 half = 128u;
-    TTree tree;
-    for (size_t i = 0; i < size; ++i) {
-        if (data[i] / half == 0) {
-            records.emplace_back(data[i] % half);
-            tree.Insert(&records.back());
-        } else {
-            auto* ptr = tree.Find(data[i] % half);
-            if (ptr != nullptr) {
-                tree.Erase(ptr);
-            }
-        }
-        auto check = [](const TNode& node) {
-            size_t childrens = 1;
-            if (node.Left_) {
-                Y_ENSURE(static_cast<const TNode*>(node.Left_)->N <= node.N);
-                childrens += node.Left_->Children_;
-            }
-            if (node.Right_) {
-                Y_ENSURE(node.N <= static_cast<const TNode*>(node.Right_)->N);
-                childrens += node.Right_->Children_;
-            }
-            Y_ENSURE(childrens == node.Children_);
-        };
-        tree.ForEach(check);
-    }
-    return 0;
-}
+    TTree tree; 
+    for (size_t i = 0; i < size; ++i) { 
+        if (data[i] / half == 0) { 
+            records.emplace_back(data[i] % half); 
+            tree.Insert(&records.back()); 
+        } else { 
+            auto* ptr = tree.Find(data[i] % half); 
+            if (ptr != nullptr) { 
+                tree.Erase(ptr); 
+            } 
+        } 
+        auto check = [](const TNode& node) { 
+            size_t childrens = 1; 
+            if (node.Left_) { 
+                Y_ENSURE(static_cast<const TNode*>(node.Left_)->N <= node.N); 
+                childrens += node.Left_->Children_; 
+            } 
+            if (node.Right_) { 
+                Y_ENSURE(node.N <= static_cast<const TNode*>(node.Right_)->N); 
+                childrens += node.Right_->Children_; 
+            } 
+            Y_ENSURE(childrens == node.Children_); 
+        }; 
+        tree.ForEach(check); 
+    } 
+    return 0; 
+} 

library/cpp/containers/intrusive_rb_tree/fuzz/ya.make

@@ -1,20 +1,20 @@
-FUZZ()
-
+FUZZ() 
+ 
 OWNER(
     g:util
     mikari
 )
+ 
+SIZE(LARGE) 
 
-SIZE(LARGE)
-
-TAG(ya:fat)
-
-PEERDIR(
+TAG(ya:fat) 
+ 
+PEERDIR( 
     library/cpp/containers/intrusive_rb_tree
-)
-
-SRCS(
-    rb_tree_fuzzing.cpp
-)
-
-END()
+) 
+ 
+SRCS( 
+    rb_tree_fuzzing.cpp 
+) 
+ 
+END() 

library/cpp/containers/intrusive_rb_tree/rb_tree.h

@@ -67,8 +67,8 @@ public:
 
     static void Rebalance(TBasePtr x, TBasePtr& root);
     static TBasePtr RebalanceForErase(TBasePtr z, TBasePtr& root, TBasePtr& leftmost, TBasePtr& rightmost);
-    static void DecrementChildrenUntilRoot(TBasePtr x, TBasePtr root);
-    static void RecalcChildren(TBasePtr x);
+    static void DecrementChildrenUntilRoot(TBasePtr x, TBasePtr root); 
+    static void RecalcChildren(TBasePtr x); 
 
     static TBasePtr IncrementNode(TBasePtr);
     static TBasePtr DecrementNode(TBasePtr);
@@ -610,21 +610,21 @@ void TRbGlobal<TDummy>::Rebalance(TRbTreeNodeBase* x, TRbTreeNodeBase*& root) {
 }
 
 template <class TDummy>
-void TRbGlobal<TDummy>::RecalcChildren(TRbTreeNodeBase* x) {
-    x->Children_ = ((x->Left_) ? x->Left_->Children_ : 0) + ((x->Right_) ? x->Right_->Children_ : 0) + 1;
-}
-
-template <class TDummy>
-void TRbGlobal<TDummy>::DecrementChildrenUntilRoot(TRbTreeNodeBase* x, TRbTreeNodeBase* root) {
-    auto* ptr = x;
-    --ptr->Children_;
-    while (ptr != root) {
-        ptr = ptr->Parent_;
-        --ptr->Children_;
-    }
-}
-
-template <class TDummy>
+void TRbGlobal<TDummy>::RecalcChildren(TRbTreeNodeBase* x) { 
+    x->Children_ = ((x->Left_) ? x->Left_->Children_ : 0) + ((x->Right_) ? x->Right_->Children_ : 0) + 1; 
+} 
+ 
+template <class TDummy> 
+void TRbGlobal<TDummy>::DecrementChildrenUntilRoot(TRbTreeNodeBase* x, TRbTreeNodeBase* root) { 
+    auto* ptr = x; 
+    --ptr->Children_; 
+    while (ptr != root) { 
+        ptr = ptr->Parent_; 
+        --ptr->Children_; 
+    } 
+} 
+ 
+template <class TDummy> 
 TRbTreeNodeBase* TRbGlobal<TDummy>::RebalanceForErase(TRbTreeNodeBase* z,
                                                       TRbTreeNodeBase*& root,
                                                       TRbTreeNodeBase*& leftmost,
@@ -665,14 +665,14 @@ TRbTreeNodeBase* TRbGlobal<TDummy>::RebalanceForErase(TRbTreeNodeBase* z,
             z->Parent_->Right_ = y;
         y->Parent_ = z->Parent_;
         DoSwap(y->Color_, z->Color_);
-
-        RecalcChildren(y);
-        if (x_parent != y) {
-            --x_parent->Children_;
-        }
-        if (x_parent != root) {
-            DecrementChildrenUntilRoot(x_parent->Parent_, root);
-        }
+ 
+        RecalcChildren(y); 
+        if (x_parent != y) { 
+            --x_parent->Children_; 
+        } 
+        if (x_parent != root) { 
+            DecrementChildrenUntilRoot(x_parent->Parent_, root); 
+        } 
         y = z;
         // y now points to node to be actually deleted
     } else {

library/cpp/containers/intrusive_rb_tree/rb_tree_ut.cpp

@@ -43,8 +43,8 @@ class TRedBlackTreeTest: public TTestBase {
     UNIT_TEST(TestFind)
     UNIT_TEST(TestStress)
     UNIT_TEST(TestGettingIndexWithDifferentValues)
-    UNIT_TEST(TestCheckChildrenAfterErase)
-    UNIT_TEST(TestGettingIndexWithDifferentValuesAfterErase)
+    UNIT_TEST(TestCheckChildrenAfterErase) 
+    UNIT_TEST(TestGettingIndexWithDifferentValuesAfterErase) 
     UNIT_TEST(TestGettingIndexWithEqualValues)
     UNIT_TEST(TestLessCountOnEmptyTree)
     UNIT_TEST_SUITE_END();
@@ -104,77 +104,77 @@ private:
         }
     }
 
-    inline void TestCheckChildrenAfterErase() {
+    inline void TestCheckChildrenAfterErase() { 
         TVector<TSimpleSharedPtr<TNode>> nodes;
-        size_t N = 1000;
-
-        for (size_t i = 0; i < N; ++i) {
-            nodes.push_back(new TNode(int(i)));
-        }
-
-        TTree tree;
-        Shuffle(nodes.begin(), nodes.end());
-
-        for (size_t i = 0; i < N; ++i) {
-            tree.Insert(nodes[i].Get());
-        }
-        auto checker = [](const TTree& tree) {
-            for (auto node = tree.Begin(); node != tree.End(); ++node) {
-                size_t childrens = 1;
-                if (node->Left_) {
-                    childrens += node->Left_->Children_;
-                }
-                if (node->Right_) {
-                    childrens += node->Right_->Children_;
-                }
-                UNIT_ASSERT_VALUES_EQUAL(childrens, node->Children_);
-            }
-        };
-
-        for (auto node : nodes) {
-            tree.Erase(node.Get());
-            checker(tree);
-        }
-    }
-
-    inline void TestGettingIndexWithDifferentValuesAfterErase() {
+        size_t N = 1000; 
+ 
+        for (size_t i = 0; i < N; ++i) { 
+            nodes.push_back(new TNode(int(i))); 
+        } 
+ 
+        TTree tree; 
+        Shuffle(nodes.begin(), nodes.end()); 
+ 
+        for (size_t i = 0; i < N; ++i) { 
+            tree.Insert(nodes[i].Get()); 
+        } 
+        auto checker = [](const TTree& tree) { 
+            for (auto node = tree.Begin(); node != tree.End(); ++node) { 
+                size_t childrens = 1; 
+                if (node->Left_) { 
+                    childrens += node->Left_->Children_; 
+                } 
+                if (node->Right_) { 
+                    childrens += node->Right_->Children_; 
+                } 
+                UNIT_ASSERT_VALUES_EQUAL(childrens, node->Children_); 
+            } 
+        }; 
+ 
+        for (auto node : nodes) { 
+            tree.Erase(node.Get()); 
+            checker(tree); 
+        } 
+    } 
+ 
+    inline void TestGettingIndexWithDifferentValuesAfterErase() { 
         TVector<TSimpleSharedPtr<TNode>> nodes;
-        size_t N = 1000;
-
-        for (size_t i = 0; i < N; ++i) {
-            nodes.push_back(new TNode(int(i)));
-        }
-
-        TTree tree;
-        Shuffle(nodes.begin(), nodes.end());
-
-        for (size_t i = 0; i < N; ++i) {
-            tree.Insert(nodes[i].Get());
-        }
-        {
-            size_t index = 0;
-            for (auto node = tree.Begin(); node != tree.End(); ++node, ++index) {
-                UNIT_ASSERT_VALUES_EQUAL(tree.GetIndex(&*node), index);
-                UNIT_ASSERT_VALUES_EQUAL(tree.ByIndex(index)->N, node->N);
-                UNIT_ASSERT_VALUES_EQUAL(node->N, index);
-            }
-        }
-
-        for (size_t i = 1; i < N; i += 2) {
-            auto* node = tree.Find(i);
-            UNIT_ASSERT_VALUES_EQUAL(node->N, i);
-            tree.Erase(node);
-        }
-        {
-            size_t index = 0;
-            for (auto node = tree.Begin(); node != tree.End(); ++node, ++index) {
-                UNIT_ASSERT_VALUES_EQUAL(tree.GetIndex(&*node), index);
-                UNIT_ASSERT_VALUES_EQUAL(tree.ByIndex(index)->N, node->N);
-                UNIT_ASSERT_VALUES_EQUAL(node->N, 2 * index);
-            }
-        }
-    }
-
+        size_t N = 1000; 
+ 
+        for (size_t i = 0; i < N; ++i) { 
+            nodes.push_back(new TNode(int(i))); 
+        } 
+ 
+        TTree tree; 
+        Shuffle(nodes.begin(), nodes.end()); 
+ 
+        for (size_t i = 0; i < N; ++i) { 
+            tree.Insert(nodes[i].Get()); 
+        } 
+        { 
+            size_t index = 0; 
+            for (auto node = tree.Begin(); node != tree.End(); ++node, ++index) { 
+                UNIT_ASSERT_VALUES_EQUAL(tree.GetIndex(&*node), index); 
+                UNIT_ASSERT_VALUES_EQUAL(tree.ByIndex(index)->N, node->N); 
+                UNIT_ASSERT_VALUES_EQUAL(node->N, index); 
+            } 
+        } 
+ 
+        for (size_t i = 1; i < N; i += 2) { 
+            auto* node = tree.Find(i); 
+            UNIT_ASSERT_VALUES_EQUAL(node->N, i); 
+            tree.Erase(node); 
+        } 
+        { 
+            size_t index = 0; 
+            for (auto node = tree.Begin(); node != tree.End(); ++node, ++index) { 
+                UNIT_ASSERT_VALUES_EQUAL(tree.GetIndex(&*node), index); 
+                UNIT_ASSERT_VALUES_EQUAL(tree.ByIndex(index)->N, node->N); 
+                UNIT_ASSERT_VALUES_EQUAL(node->N, 2 * index); 
+            } 
+        } 
+    } 
+ 
     inline void TestGettingIndexWithEqualValues() {
         TVector<TSimpleSharedPtr<TNode>> nodes;
         size_t N = 1000;

library/cpp/iterator/mapped.h

@@ -29,7 +29,7 @@ public:
     using iterator_category = std::conditional_t<NIteratorPrivate::HasRandomAccess<TIterator>(),
         std::random_access_iterator_tag, std::input_iterator_tag>;
 
-    TMappedIterator(TIterator it, TMapper mapper)
+    TMappedIterator(TIterator it, TMapper mapper) 
         : Iter(it)
         , Mapper(std::move(mapper))
     {
@@ -89,11 +89,11 @@ public:
 
 private:
     TIterator Iter;
-    TMapper Mapper;
+    TMapper Mapper; 
 };
 
 
-template <class TContainer, class TMapper>
+template <class TContainer, class TMapper> 
 class TInputMappedRange {
 protected:
     using TContainerStorage = TAutoEmbedOrPtrPolicy<TContainer>;
@@ -101,27 +101,27 @@ protected:
     using TMapperWrapper = std::reference_wrapper<std::remove_reference_t<TMapper>>;
     using TInternalIterator = decltype(std::begin(std::declval<TContainer&>()));
     using TIterator = TMappedIterator<TInternalIterator, TMapperWrapper>;
-public:
+public: 
     using iterator = TIterator;
     using const_iterator = TIterator;
     using value_type = typename TIterator::value_type;
     using reference = typename TIterator::reference;
     using const_reference = typename TIterator::reference;
-
+ 
     TInputMappedRange(TContainer&& container, TMapper&& mapper)
         : Container(std::forward<TContainer>(container))
         , Mapper(std::forward<TMapper>(mapper))
-    {
-    }
-
+    { 
+    } 
+ 
     TIterator begin() const {
         return {std::begin(*Container.Ptr()), {*Mapper.Ptr()}};
-    }
-
+    } 
+ 
     TIterator end() const {
         return {std::end(*Container.Ptr()), {*Mapper.Ptr()}};
-    }
-
+    } 
+ 
     bool empty() const {
         return std::begin(*Container.Ptr()) == std::end(*Container.Ptr());
     }
@@ -130,7 +130,7 @@ protected:
     mutable TContainerStorage Container;
     mutable TMapperStorage Mapper;
 };
-
+ 
 
 template <class TContainer, class TMapper>
 class TRandomAccessMappedRange : public TInputMappedRange<TContainer, TMapper> {
@@ -150,36 +150,36 @@ public:
     TRandomAccessMappedRange(TContainer&& container, TMapper&& mapper)
         : TBase(std::forward<TContainer>(container), std::forward<TMapper>(mapper))
     {
-    }
-
+    } 
+ 
     using TBase::begin;
     using TBase::end;
     using TBase::empty;
 
-    size_type size() const {
+    size_type size() const { 
         return std::end(*this->Container.Ptr()) - std::begin(*this->Container.Ptr());
-    }
-
-    const_reference operator[](size_t at) const {
+    } 
+ 
+    const_reference operator[](size_t at) const { 
         Y_ASSERT(at < this->size());
-
+ 
         return *(this->begin() + at);
-    }
-
-    reference operator[](size_t at) {
+    } 
+ 
+    reference operator[](size_t at) { 
         Y_ASSERT(at < this->size());
-
+ 
         return *(this->begin() + at);
-    }
-};
-
+    } 
+}; 
+ 
 template <class TIterator, class TMapper>
-TMappedIterator<TIterator, TMapper> MakeMappedIterator(TIterator iter, TMapper mapper) {
-    return {iter, mapper};
+TMappedIterator<TIterator, TMapper> MakeMappedIterator(TIterator iter, TMapper mapper) { 
+    return {iter, mapper}; 
 }
 
 template <class TIterator, class TMapper>
-auto MakeMappedRange(TIterator begin, TIterator end, TMapper mapper) {
+auto MakeMappedRange(TIterator begin, TIterator end, TMapper mapper) { 
     return MakeIteratorRange(MakeMappedIterator(begin, mapper), MakeMappedIterator(end, mapper));
 }
 

library/cpp/iterator/ut/mapped_ut.cpp

@@ -55,7 +55,7 @@ TEST(TIterator, TOwningMappedMethodTest) {
     for (int& y : range) {
         y += 7;
     }
-
+ 
     EXPECT_EQ(*range.begin(), 10);
     EXPECT_EQ(*(range.begin() + 1), 10);
 }

library/cpp/logger/global/global.cpp

@@ -16,8 +16,8 @@ void DoInitGlobalLog(const TString& logType, const int logLevel, const bool rota
                 (ELogPriority)logLevel,
                 threaded)),
         std::move(formatter));
-}
-
+} 
+ 
 void DoInitGlobalLog(THolder<TLogBackend> backend, THolder<ILoggerFormatter> formatter) {
     DoInitGlobalLog(THolder(new TGlobalLog(std::move(backend))), std::move(formatter));
 }

library/cpp/logger/global/global.h

@@ -23,11 +23,11 @@ public:
         : TLog(logType, priority)
     {
     }
-
+ 
     TGlobalLog(THolder<TLogBackend> backend)
         : TLog(std::move(backend))
-    {
-    }
+    { 
+    } 
 };
 
 template <>
@@ -39,11 +39,11 @@ public:
         : TLog(logType, priority)
     {
     }
-
+ 
     TNullLog(THolder<TLogBackend> backend)
         : TLog(std::move(backend))
-    {
-    }
+    { 
+    } 
 };
 
 template <>

library/cpp/logger/log.cpp

@@ -3,7 +3,7 @@
 #include "filter.h"
 #include "null.h"
 #include "stream.h"
-#include "thread.h"
+#include "thread.h" 
 
 #include <util/string/cast.h>
 #include <util/stream/printf.h>
@@ -16,8 +16,8 @@ THolder<TLogBackend> CreateLogBackend(const TString& fname, ELogPriority priorit
     TLogBackendCreatorUninitialized creator;
     creator.InitCustom(fname, priority, threaded);
     return creator.CreateLogBackend();
-}
-
+} 
+ 
 THolder<TLogBackend> CreateFilteredOwningThreadedLogBackend(const TString& fname, ELogPriority priority, size_t queueLen) {
     return MakeHolder<TFilteredLogBackend>(CreateOwningThreadedLogBackend(fname, queueLen), priority);
 }
@@ -230,9 +230,9 @@ void TLog::Write(ELogPriority priority, const char* data, size_t len) const {
     if (Formatter_) {
         const auto formated = Formatter_(priority, TStringBuf{data, len});
         Impl_->WriteData(priority, formated.data(), formated.size());
-    } else {
-        Impl_->WriteData(priority, data, len);
-    }
+    } else { 
+        Impl_->WriteData(priority, data, len); 
+    } 
 }
 
 void TLog::Write(ELogPriority priority, const TStringBuf data) const {
@@ -240,12 +240,12 @@ void TLog::Write(ELogPriority priority, const TStringBuf data) const {
 }
 
 void TLog::Write(const char* data, size_t len) const {
-    Write(Impl_->DefaultPriority(), data, len);
+    Write(Impl_->DefaultPriority(), data, len); 
 }
-
-void TLog::SetFormatter(TLogFormatter formatter) noexcept {
+ 
+void TLog::SetFormatter(TLogFormatter formatter) noexcept { 
     Formatter_ = std::move(formatter);
-}
+} 
 
 size_t TLog::BackEndQueueSize() const {
     return Impl_->BackEndQueueSize();