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

1 files changed, 64 insertions, 64 deletions

diff --git a/library/cpp/actors/util/funnel_queue.h b/library/cpp/actors/util/funnel_queue.h
index 0e21e2617c..855ed4bee1 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);
     }