Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 2 of 2.

6 files changed, 169 insertions, 169 deletions

diff --git a/library/cpp/actors/util/funnel_queue.h b/library/cpp/actors/util/funnel_queue.h
index 855ed4bee1..0e21e2617c 100644
--- a/library/cpp/actors/util/funnel_queue.h
+++ b/library/cpp/actors/util/funnel_queue.h
@@ -3,33 +3,33 @@
 #include <util/system/atomic.h>
 #include <util/generic/noncopyable.h>
 
-template <typename ElementType> 
-class TFunnelQueue: private TNonCopyable { 
+template <typename ElementType>
+class TFunnelQueue: private TNonCopyable {
 public:
     TFunnelQueue() noexcept
-        : Front(nullptr) 
-        , Back(nullptr) 
-    { 
-    } 
+        : Front(nullptr)
+        , Back(nullptr)
+    {
+    }
 
-    virtual ~TFunnelQueue() noexcept { 
+    virtual ~TFunnelQueue() noexcept {
         for (auto entry = Front; entry; entry = DeleteEntry(entry))
             continue;
     }
 
     /// Push element. Can be used from many threads. Return true if is first element.
     bool
-    Push(ElementType&& element) noexcept { 
-        TEntry* const next = NewEntry(static_cast<ElementType&&>(element)); 
-        TEntry* const prev = AtomicSwap(&Back, next); 
+    Push(ElementType&& element) noexcept {
+        TEntry* const next = NewEntry(static_cast<ElementType&&>(element));
+        TEntry* const prev = AtomicSwap(&Back, next);
         AtomicSet(prev ? prev->Next : Front, next);
         return !prev;
     }
 
     /// Extract top element. Must be used only from one thread. Return true if have more.
     bool
-    Pop() noexcept { 
-        if (TEntry* const top = AtomicGet(Front)) { 
+    Pop() noexcept {
+        if (TEntry* const top = AtomicGet(Front)) {
             const auto last = AtomicCas(&Back, nullptr, top);
             if (last) // This is last element in queue. Queue is empty now.
                 AtomicCas(&Front, nullptr, top);
@@ -51,42 +51,42 @@ public:
 
     /// Peek top element. Must be used only from one thread.
     ElementType&
-    Top() const noexcept { 
+    Top() const noexcept {
         return AtomicGet(Front)->Data;
     }
 
     bool
-    IsEmpty() const noexcept { 
+    IsEmpty() const noexcept {
         return !AtomicGet(Front);
     }
 
 protected:
-    class TEntry: private TNonCopyable { 
-        friend class TFunnelQueue; 
- 
+    class TEntry: private TNonCopyable {
+        friend class TFunnelQueue;
+
     private:
         explicit TEntry(ElementType&& element) noexcept
-            : Data(static_cast<ElementType&&>(element)) 
-            , Next(nullptr) 
-        { 
-        } 
+            : Data(static_cast<ElementType&&>(element))
+            , Next(nullptr)
+        {
+        }
 
-        ~TEntry() noexcept { 
-        } 
+        ~TEntry() noexcept {
+        }
 
     public:
         ElementType Data;
-        TEntry* volatile Next; 
+        TEntry* volatile Next;
     };
 
-    TEntry* volatile Front; 
-    TEntry* volatile Back; 
+    TEntry* volatile Front;
+    TEntry* volatile Back;
 
-    virtual TEntry* NewEntry(ElementType&& element) noexcept { 
+    virtual TEntry* NewEntry(ElementType&& element) noexcept {
         return new TEntry(static_cast<ElementType&&>(element));
     }
 
-    virtual TEntry* DeleteEntry(TEntry* entry) noexcept { 
+    virtual TEntry* DeleteEntry(TEntry* entry) noexcept {
         const auto next = entry->Next;
         delete entry;
         return next;
@@ -147,36 +147,36 @@ public:
     using const_iterator = TConstEntryIter;
     using iterator = TEntryIter;
 
-    iterator begin() { 
-        return {AtomicGet(Front)}; 
-    } 
-    const_iterator cbegin() { 
-        return {AtomicGet(Front)}; 
-    } 
-    const_iterator begin() const { 
-        return {AtomicGet(Front)}; 
-    } 
-
-    iterator end() { 
-        return {nullptr}; 
-    } 
-    const_iterator cend() { 
-        return {nullptr}; 
-    } 
-    const_iterator end() const { 
-        return {nullptr}; 
-    } 
+    iterator begin() {
+        return {AtomicGet(Front)};
+    }
+    const_iterator cbegin() {
+        return {AtomicGet(Front)};
+    }
+    const_iterator begin() const {
+        return {AtomicGet(Front)};
+    }
+
+    iterator end() {
+        return {nullptr};
+    }
+    const_iterator cend() {
+        return {nullptr};
+    }
+    const_iterator end() const {
+        return {nullptr};
+    }
 };
 
-template <typename ElementType> 
-class TPooledFunnelQueue: public TFunnelQueue<ElementType> { 
+template <typename ElementType>
+class TPooledFunnelQueue: public TFunnelQueue<ElementType> {
 public:
     TPooledFunnelQueue() noexcept
         : Stack(nullptr)
-    { 
-    } 
+    {
+    }
 
-    virtual ~TPooledFunnelQueue() noexcept override { 
+    virtual ~TPooledFunnelQueue() noexcept override {
         for (auto entry = TBase::Front; entry; entry = TBase::DeleteEntry(entry))
             continue;
         for (auto entry = Stack; entry; entry = TBase::DeleteEntry(entry))
@@ -187,10 +187,10 @@ public:
 private:
     typedef TFunnelQueue<ElementType> TBase;
 
-    typename TBase::TEntry* volatile Stack; 
+    typename TBase::TEntry* volatile Stack;
 
 protected:
-    virtual typename TBase::TEntry* NewEntry(ElementType&& element) noexcept override { 
+    virtual typename TBase::TEntry* NewEntry(ElementType&& element) noexcept override {
         while (const auto top = AtomicGet(Stack))
             if (AtomicCas(&Stack, top->Next, top)) {
                 top->Data = static_cast<ElementType&&>(element);
@@ -201,37 +201,37 @@ protected:
         return TBase::NewEntry(static_cast<ElementType&&>(element));
     }
 
-    virtual typename TBase::TEntry* DeleteEntry(typename TBase::TEntry* entry) noexcept override { 
+    virtual typename TBase::TEntry* DeleteEntry(typename TBase::TEntry* entry) noexcept override {
         entry->Data = ElementType();
         const auto next = entry->Next;
-        do 
-            AtomicSet(entry->Next, AtomicGet(Stack)); 
+        do
+            AtomicSet(entry->Next, AtomicGet(Stack));
         while (!AtomicCas(&Stack, entry, entry->Next));
         return next;
     }
 };
 
-template <typename ElementType, template <typename T> class TQueueType = TFunnelQueue> 
-class TCountedFunnelQueue: public TQueueType<ElementType> { 
+template <typename ElementType, template <typename T> class TQueueType = TFunnelQueue>
+class TCountedFunnelQueue: public TQueueType<ElementType> {
 public:
     TCountedFunnelQueue() noexcept
         : Count(0)
-    { 
-    } 
+    {
+    }
 
-    TAtomicBase GetSize() const noexcept { 
+    TAtomicBase GetSize() const noexcept {
         return AtomicGet(Count);
     }
 
 private:
     typedef TQueueType<ElementType> TBase;
 
-    virtual typename TBase::TEntry* NewEntry(ElementType&& element) noexcept override { 
+    virtual typename TBase::TEntry* NewEntry(ElementType&& element) noexcept override {
         AtomicAdd(Count, 1);
         return TBase::NewEntry(static_cast<ElementType&&>(element));
     }
 
-    virtual typename TBase::TEntry* DeleteEntry(typename TBase::TEntry* entry) noexcept override { 
+    virtual typename TBase::TEntry* DeleteEntry(typename TBase::TEntry* entry) noexcept override {
         AtomicSub(Count, 1);
         return TBase::DeleteEntry(entry);
     }
diff --git a/library/cpp/actors/util/queue_chunk.h b/library/cpp/actors/util/queue_chunk.h
index b56f0c1d5c..8a4e02d8cb 100644
--- a/library/cpp/actors/util/queue_chunk.h
+++ b/library/cpp/actors/util/queue_chunk.h
@@ -5,7 +5,7 @@
 template <typename T, ui32 TSize, typename TDerived>
 struct TQueueChunkDerived {
     static const ui32 EntriesCount = (TSize - sizeof(TQueueChunkDerived*)) / sizeof(T);
-    static_assert(EntriesCount > 0, "expect EntriesCount > 0"); 
+    static_assert(EntriesCount > 0, "expect EntriesCount > 0");
 
     volatile T Entries[EntriesCount];
     TDerived* volatile Next;
@@ -18,7 +18,7 @@ struct TQueueChunkDerived {
 template <typename T, ui32 TSize>
 struct TQueueChunk {
     static const ui32 EntriesCount = (TSize - sizeof(TQueueChunk*)) / sizeof(T);
-    static_assert(EntriesCount > 0, "expect EntriesCount > 0"); 
+    static_assert(EntriesCount > 0, "expect EntriesCount > 0");
 
     volatile T Entries[EntriesCount];
     TQueueChunk* volatile Next;
diff --git a/library/cpp/actors/util/recentwnd.h b/library/cpp/actors/util/recentwnd.h
index 6135814f50..ba1ede6f29 100644
--- a/library/cpp/actors/util/recentwnd.h
+++ b/library/cpp/actors/util/recentwnd.h
@@ -1,15 +1,15 @@
 #pragma once
- 
+
 #include <util/generic/deque.h>
 
 template <typename TElem,
           template <typename, typename...> class TContainer = TDeque>
 class TRecentWnd {
 public:
-    TRecentWnd(ui32 wndSize) 
-        : MaxWndSize_(wndSize) 
-    { 
-    } 
+    TRecentWnd(ui32 wndSize)
+        : MaxWndSize_(wndSize)
+    {
+    }
 
     void Push(const TElem& elem) {
         if (Window_.size() == MaxWndSize_)
@@ -23,27 +23,27 @@ public:
         Window_.emplace_back(std::move(elem));
     }
 
-    TElem& Last() { 
-        return Window_.back(); 
-    } 
-    const TElem& Last() const { 
-        return Window_.back(); 
-    } 
-    bool Full() const { 
-        return Window_.size() == MaxWndSize_; 
-    } 
-    ui64 Size() const { 
-        return Window_.size(); 
-    } 
+    TElem& Last() {
+        return Window_.back();
+    }
+    const TElem& Last() const {
+        return Window_.back();
+    }
+    bool Full() const {
+        return Window_.size() == MaxWndSize_;
+    }
+    ui64 Size() const {
+        return Window_.size();
+    }
 
     using const_iterator = typename TContainer<TElem>::const_iterator;
 
-    const_iterator begin() { 
-        return Window_.begin(); 
-    } 
-    const_iterator end() { 
-        return Window_.end(); 
-    } 
+    const_iterator begin() {
+        return Window_.begin();
+    }
+    const_iterator end() {
+        return Window_.end();
+    }
 
     void Reset(ui32 wndSize = 0) {
         Window_.clear();
@@ -60,7 +60,7 @@ public:
                           Window_.begin() + Window_.size() - MaxWndSize_);
         }
     }
- 
+
 private:
     TContainer<TElem> Window_;
     ui32 MaxWndSize_;
diff --git a/library/cpp/actors/util/rope.h b/library/cpp/actors/util/rope.h
index 305a035448..f5595efbaa 100644
--- a/library/cpp/actors/util/rope.h
+++ b/library/cpp/actors/util/rope.h
@@ -574,7 +574,7 @@ public:
     TRope(TString s) {
         if (s) {
             Size = s.size();
-            s.reserve(32); 
+            s.reserve(32);
             Chain.PutToEnd(std::move(s));
         }
     }
diff --git a/library/cpp/actors/util/threadparkpad.cpp b/library/cpp/actors/util/threadparkpad.cpp
index 471be44031..74069ff15b 100644
--- a/library/cpp/actors/util/threadparkpad.cpp
+++ b/library/cpp/actors/util/threadparkpad.cpp
@@ -6,143 +6,143 @@
 #include "futex.h"
 
 namespace NActors {
-    class TThreadParkPad::TImpl { 
-        volatile bool Interrupted; 
-        int Futex; 
-
-    public: 
-        TImpl() 
-            : Interrupted(false) 
-            , Futex(0) 
-        { 
-        } 
-        ~TImpl() { 
-        } 
+    class TThreadParkPad::TImpl {
+        volatile bool Interrupted;
+        int Futex;
+
+    public:
+        TImpl()
+            : Interrupted(false)
+            , Futex(0)
+        {
+        }
+        ~TImpl() {
+        }
 
         bool Park() noexcept {
-            __atomic_fetch_sub(&Futex, 1, __ATOMIC_SEQ_CST); 
-            while (__atomic_load_n(&Futex, __ATOMIC_ACQUIRE) == -1) 
-                SysFutex(&Futex, FUTEX_WAIT_PRIVATE, -1, nullptr, nullptr, 0); 
-            return IsInterrupted(); 
-        } 
+            __atomic_fetch_sub(&Futex, 1, __ATOMIC_SEQ_CST);
+            while (__atomic_load_n(&Futex, __ATOMIC_ACQUIRE) == -1)
+                SysFutex(&Futex, FUTEX_WAIT_PRIVATE, -1, nullptr, nullptr, 0);
+            return IsInterrupted();
+        }
 
         void Unpark() noexcept {
-            const int old = __atomic_fetch_add(&Futex, 1, __ATOMIC_SEQ_CST); 
-            if (old == -1) 
-                SysFutex(&Futex, FUTEX_WAKE_PRIVATE, -1, nullptr, nullptr, 0); 
-        } 
+            const int old = __atomic_fetch_add(&Futex, 1, __ATOMIC_SEQ_CST);
+            if (old == -1)
+                SysFutex(&Futex, FUTEX_WAKE_PRIVATE, -1, nullptr, nullptr, 0);
+        }
 
         void Interrupt() noexcept {
-            __atomic_store_n(&Interrupted, true, __ATOMIC_SEQ_CST); 
-            Unpark(); 
-        } 
+            __atomic_store_n(&Interrupted, true, __ATOMIC_SEQ_CST);
+            Unpark();
+        }
 
         bool IsInterrupted() const noexcept {
-            return __atomic_load_n(&Interrupted, __ATOMIC_ACQUIRE); 
-        } 
-    }; 
+            return __atomic_load_n(&Interrupted, __ATOMIC_ACQUIRE);
+        }
+    };
 
 #elif defined _win32_
 #include <util/generic/bt_exception.h>
 #include <util/generic/yexception.h>
 
 namespace NActors {
-    class TThreadParkPad::TImpl { 
+    class TThreadParkPad::TImpl {
         TAtomic Interrupted;
-        HANDLE EvHandle; 
-
-    public: 
-        TImpl() 
-            : Interrupted(false) 
-        { 
-            EvHandle = ::CreateEvent(0, false, false, 0); 
-            if (!EvHandle) 
-                ythrow TWithBackTrace<yexception>() << "::CreateEvent failed"; 
-        } 
+        HANDLE EvHandle;
+
+    public:
+        TImpl()
+            : Interrupted(false)
+        {
+            EvHandle = ::CreateEvent(0, false, false, 0);
+            if (!EvHandle)
+                ythrow TWithBackTrace<yexception>() << "::CreateEvent failed";
+        }
         ~TImpl() {
-            if (EvHandle) 
-                ::CloseHandle(EvHandle); 
-        } 
+            if (EvHandle)
+                ::CloseHandle(EvHandle);
+        }
 
         bool Park() noexcept {
-            ::WaitForSingleObject(EvHandle, INFINITE); 
+            ::WaitForSingleObject(EvHandle, INFINITE);
             return AtomicGet(Interrupted);
-        } 
+        }
 
         void Unpark() noexcept {
-            ::SetEvent(EvHandle); 
-        } 
+            ::SetEvent(EvHandle);
+        }
 
         void Interrupt() noexcept {
             AtomicSet(Interrupted, true);
-            Unpark(); 
-        } 
+            Unpark();
+        }
 
         bool IsInterrupted() const noexcept {
             return AtomicGet(Interrupted);
-        } 
-    }; 
+        }
+    };
 
 #else
 
 #include <util/system/event.h>
 
 namespace NActors {
-    class TThreadParkPad::TImpl { 
+    class TThreadParkPad::TImpl {
         TAtomic Interrupted;
         TSystemEvent Ev;
 
-    public: 
-        TImpl() 
-            : Interrupted(false) 
+    public:
+        TImpl()
+            : Interrupted(false)
             , Ev(TSystemEvent::rAuto)
-        { 
-        } 
+        {
+        }
         ~TImpl() {
-        } 
+        }
 
         bool Park() noexcept {
-            Ev.Wait(); 
+            Ev.Wait();
             return AtomicGet(Interrupted);
-        } 
- 
+        }
+
         void Unpark() noexcept {
-            Ev.Signal(); 
-        } 
- 
+            Ev.Signal();
+        }
+
         void Interrupt() noexcept {
             AtomicSet(Interrupted, true);
-            Unpark(); 
-        } 
- 
+            Unpark();
+        }
+
         bool IsInterrupted() const noexcept {
             return AtomicGet(Interrupted);
-        } 
-    }; 
-#endif 
- 
-    TThreadParkPad::TThreadParkPad() 
-        : Impl(new TThreadParkPad::TImpl()) 
+        }
+    };
+#endif
+
+    TThreadParkPad::TThreadParkPad()
+        : Impl(new TThreadParkPad::TImpl())
     {
     }
- 
+
     TThreadParkPad::~TThreadParkPad() {
     }
 
     bool TThreadParkPad::Park() noexcept {
-        return Impl->Park(); 
+        return Impl->Park();
     }
 
     void TThreadParkPad::Unpark() noexcept {
-        Impl->Unpark(); 
+        Impl->Unpark();
     }
 
     void TThreadParkPad::Interrupt() noexcept {
-        Impl->Interrupt(); 
+        Impl->Interrupt();
     }
 
     bool TThreadParkPad::Interrupted() const noexcept {
-        return Impl->IsInterrupted(); 
+        return Impl->IsInterrupted();
     }
 
 }
diff --git a/library/cpp/actors/util/unordered_cache.h b/library/cpp/actors/util/unordered_cache.h
index 44ed04c01f..76f036c0cf 100644
--- a/library/cpp/actors/util/unordered_cache.h
+++ b/library/cpp/actors/util/unordered_cache.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "defs.h"
-#include "queue_chunk.h" 
+#include "queue_chunk.h"
 
 template <typename T, ui32 Size = 512, ui32 ConcurrencyFactor = 1, typename TChunk = TQueueChunk<T, Size>>
 class TUnorderedCache : TNonCopyable {
@@ -30,7 +30,7 @@ private:
     TReadSlot ReadSlots[Concurrency];
     TWriteSlot WriteSlots[Concurrency];
 
-    static_assert(sizeof(TChunk*) == sizeof(TAtomic), "expect sizeof(TChunk*) == sizeof(TAtomic)"); 
+    static_assert(sizeof(TChunk*) == sizeof(TAtomic), "expect sizeof(TChunk*) == sizeof(TAtomic)");
 
 private:
     struct TLockedWriter {