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

15 files changed, 82 insertions, 82 deletions

diff --git a/library/cpp/threading/equeue/equeue.cpp b/library/cpp/threading/equeue/equeue.cpp
index 54a848e912..4a708ef3ad 100644
--- a/library/cpp/threading/equeue/equeue.cpp
+++ b/library/cpp/threading/equeue/equeue.cpp
@@ -71,10 +71,10 @@ void TElasticQueue::Start(size_t threadCount, size_t maxQueueSize) {
     SlaveQueue_->Start(threadCount, maxQueueSize);
 }
 
-void TElasticQueue::Stop() noexcept {
+void TElasticQueue::Stop() noexcept { 
     return SlaveQueue_->Stop();
 }
 
-size_t TElasticQueue::Size() const noexcept {
+size_t TElasticQueue::Size() const noexcept { 
     return SlaveQueue_->Size();
 }
diff --git a/library/cpp/threading/equeue/equeue.h b/library/cpp/threading/equeue/equeue.h
index 40dd342585..ff735399e6 100644
--- a/library/cpp/threading/equeue/equeue.h
+++ b/library/cpp/threading/equeue/equeue.h
@@ -1,11 +1,11 @@
 #pragma once
 
-#include <util/thread/pool.h>
+#include <util/thread/pool.h> 
 #include <util/system/atomic.h>
 #include <util/generic/ptr.h>
 
 //actual queue limit will be (maxQueueSize - numBusyThreads) or 0
-class TElasticQueue: public IThreadPool {
+class TElasticQueue: public IThreadPool { 
 public:
     explicit TElasticQueue(THolder<IThreadPool> slaveQueue);
 
@@ -21,7 +21,7 @@ private:
 
     bool TryIncCounter();
 private:
-    THolder<IThreadPool> SlaveQueue_;
+    THolder<IThreadPool> SlaveQueue_; 
     size_t MaxQueueSize_ = 0;
     TAtomic ObjectCount_ = 0;
     TAtomic GuardCount_ = 0;
diff --git a/library/cpp/threading/equeue/equeue_ut.cpp b/library/cpp/threading/equeue/equeue_ut.cpp
index 9cf2aced44..d08a94848b 100644
--- a/library/cpp/threading/equeue/equeue_ut.cpp
+++ b/library/cpp/threading/equeue/equeue_ut.cpp
@@ -95,7 +95,7 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
         Counters.Reset();
         TryCounter = 0;
 
-        struct TSender: public IThreadFactory::IThreadAble {
+        struct TSender: public IThreadFactory::IThreadAble { 
             void DoExecute() override {
                 while ((size_t)AtomicIncrement(TryCounter) <= N) {
                     if (!TryAdd()) {
@@ -108,9 +108,9 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
         {
             TQueueSetup setup;
 
-            TVector< TAutoPtr<IThreadFactory::IThread> > senders;
+            TVector< TAutoPtr<IThreadFactory::IThread> > senders; 
             for (size_t i = 0; i < ThreadCount; ++i) {
-                senders.push_back(::SystemThreadFactory()->Run(&sender));
+                senders.push_back(::SystemThreadFactory()->Run(&sender)); 
             }
 
             for (size_t i = 0; i < senders.size(); ++i) {
diff --git a/library/cpp/threading/future/async.h b/library/cpp/threading/future/async.h
index 8543fdd5c6..a7e84cc29b 100644
--- a/library/cpp/threading/future/async.h
+++ b/library/cpp/threading/future/async.h
@@ -3,7 +3,7 @@
 #include "future.h"
 
 #include <util/generic/function.h>
-#include <util/thread/pool.h>
+#include <util/thread/pool.h> 
 
 namespace NThreading {
     /**
@@ -18,7 +18,7 @@ namespace NThreading {
  * unittest.
  */
     template <typename Func>
-    TFuture<TFutureType<TFunctionResult<Func>>> Async(Func&& func, IThreadPool& queue) {
+    TFuture<TFutureType<TFunctionResult<Func>>> Async(Func&& func, IThreadPool& queue) { 
         auto promise = NewPromise<TFutureType<TFunctionResult<Func>>>();
         auto lambda = [promise, func = std::forward<Func>(func)]() mutable {
             NImpl::SetValue(promise, func);
diff --git a/library/cpp/threading/future/async_ut.cpp b/library/cpp/threading/future/async_ut.cpp
index a3699744e4..6901ed2621 100644
--- a/library/cpp/threading/future/async_ut.cpp
+++ b/library/cpp/threading/future/async_ut.cpp
@@ -36,7 +36,7 @@ Y_UNIT_TEST_SUITE(Async) {
     }
 
     Y_UNIT_TEST(WorksWithIMtpQueue) {
-        auto queue = MakeHolder<TThreadPool>();
+        auto queue = MakeHolder<TThreadPool>(); 
         queue->Start(1);
 
         auto future = NThreading::Async([]() { return 5; }, *queue);
@@ -46,7 +46,7 @@ Y_UNIT_TEST_SUITE(Async) {
 
     Y_UNIT_TEST(ProperlyDeducesFutureType) {
         // Compileability test
-        auto queue = CreateThreadPool(1);
+        auto queue = CreateThreadPool(1); 
 
         NThreading::TFuture<void> f1 = NThreading::Async([]() {}, *queue);
         NThreading::TFuture<int> f2 = NThreading::Async([]() { return 5; }, *queue);
diff --git a/library/cpp/threading/future/legacy_future.h b/library/cpp/threading/future/legacy_future.h
index 6f1eabad73..5240f92992 100644
--- a/library/cpp/threading/future/legacy_future.h
+++ b/library/cpp/threading/future/legacy_future.h
@@ -3,13 +3,13 @@
 #include "fwd.h"
 #include "future.h"
 
-#include <util/thread/factory.h>
+#include <util/thread/factory.h> 
 
 #include <functional>
 
 namespace NThreading {
     template <typename TR, bool IgnoreException>
-    class TLegacyFuture: public IThreadFactory::IThreadAble, TNonCopyable {
+    class TLegacyFuture: public IThreadFactory::IThreadAble, TNonCopyable { 
     public:
         typedef TR(TFunctionSignature)();
         using TFunctionObjectType = std::function<TFunctionSignature>;
@@ -18,10 +18,10 @@ namespace NThreading {
     private:
         TFunctionObjectType Func_;
         TPromise<TResult> Result_;
-        THolder<IThreadFactory::IThread> Thread_;
+        THolder<IThreadFactory::IThread> Thread_; 
 
     public:
-        inline TLegacyFuture(const TFunctionObjectType func, IThreadFactory* pool = SystemThreadFactory())
+        inline TLegacyFuture(const TFunctionObjectType func, IThreadFactory* pool = SystemThreadFactory()) 
             : Func_(func)
             , Result_(NewPromise<TResult>())
             , Thread_(pool->Run(this))
diff --git a/library/cpp/threading/future/legacy_future_ut.cpp b/library/cpp/threading/future/legacy_future_ut.cpp
index ff63db1725..873c913d82 100644
--- a/library/cpp/threading/future/legacy_future_ut.cpp
+++ b/library/cpp/threading/future/legacy_future_ut.cpp
@@ -43,7 +43,7 @@ namespace NThreading {
             TLegacyFuture<int> f11(std::bind(&TSampleClass::Calc, TSampleClass(3)));
             UNIT_ASSERT_VALUES_EQUAL(4, f11.Get());
 
-            TLegacyFuture<int> f12(std::bind(&TSampleClass::Calc, TSampleClass(3)), SystemThreadFactory());
+            TLegacyFuture<int> f12(std::bind(&TSampleClass::Calc, TSampleClass(3)), SystemThreadFactory()); 
             UNIT_ASSERT_VALUES_EQUAL(4, f12.Get());
 
             TSampleClass c(5);
@@ -51,17 +51,17 @@ namespace NThreading {
             TLegacyFuture<int> f21(std::bind(&TSampleClass::Calc, std::ref(c)));
             UNIT_ASSERT_VALUES_EQUAL(6, f21.Get());
 
-            TLegacyFuture<int> f22(std::bind(&TSampleClass::Calc, std::ref(c)), SystemThreadFactory());
+            TLegacyFuture<int> f22(std::bind(&TSampleClass::Calc, std::ref(c)), SystemThreadFactory()); 
             UNIT_ASSERT_VALUES_EQUAL(6, f22.Get());
         }
 
-        struct TSomeThreadPool: public IThreadFactory {};
+        struct TSomeThreadPool: public IThreadFactory {}; 
 
         Y_UNIT_TEST(TestFunction) {
             std::function<int()> f((&intf));
 
             UNIT_ASSERT_VALUES_EQUAL(17, TLegacyFuture<int>(f).Get());
-            UNIT_ASSERT_VALUES_EQUAL(17, TLegacyFuture<int>(f, SystemThreadFactory()).Get());
+            UNIT_ASSERT_VALUES_EQUAL(17, TLegacyFuture<int>(f, SystemThreadFactory()).Get()); 
 
             if (false) {
                 TSomeThreadPool* q = nullptr;
diff --git a/library/cpp/threading/future/wait/wait-inl.h b/library/cpp/threading/future/wait/wait-inl.h
index 2753d5446c..a80b65a933 100644
--- a/library/cpp/threading/future/wait/wait-inl.h
+++ b/library/cpp/threading/future/wait/wait-inl.h
@@ -6,31 +6,31 @@
 
 namespace NThreading {
     namespace NImpl {
-        template <typename TContainer>
-        TVector<TFuture<void>> ToVoidFutures(const TContainer& futures) {
-            TVector<TFuture<void>> voidFutures;
-            voidFutures.reserve(futures.size());
+        template <typename TContainer> 
+        TVector<TFuture<void>> ToVoidFutures(const TContainer& futures) { 
+            TVector<TFuture<void>> voidFutures; 
+            voidFutures.reserve(futures.size()); 
 
-            for (const auto& future: futures) {
-                voidFutures.push_back(future.IgnoreResult());
+            for (const auto& future: futures) { 
+                voidFutures.push_back(future.IgnoreResult()); 
             }
 
-            return voidFutures;
+            return voidFutures; 
         }
     }
 
     template <typename TContainer>
-    [[nodiscard]] NImpl::EnableGenericWait<TContainer> WaitAll(const TContainer& futures) {
-        return WaitAll(NImpl::ToVoidFutures(futures));
+    [[nodiscard]] NImpl::EnableGenericWait<TContainer> WaitAll(const TContainer& futures) { 
+        return WaitAll(NImpl::ToVoidFutures(futures)); 
     }
 
     template <typename TContainer>
-    [[nodiscard]] NImpl::EnableGenericWait<TContainer> WaitExceptionOrAll(const TContainer& futures) {
-        return WaitExceptionOrAll(NImpl::ToVoidFutures(futures));
+    [[nodiscard]] NImpl::EnableGenericWait<TContainer> WaitExceptionOrAll(const TContainer& futures) { 
+        return WaitExceptionOrAll(NImpl::ToVoidFutures(futures)); 
     }
 
     template <typename TContainer>
-    [[nodiscard]] NImpl::EnableGenericWait<TContainer> WaitAny(const TContainer& futures) {
-        return WaitAny(NImpl::ToVoidFutures(futures));
+    [[nodiscard]] NImpl::EnableGenericWait<TContainer> WaitAny(const TContainer& futures) { 
+        return WaitAny(NImpl::ToVoidFutures(futures)); 
     }
 }
diff --git a/library/cpp/threading/future/wait/wait.cpp b/library/cpp/threading/future/wait/wait.cpp
index a173833a7f..cc33f3189c 100644
--- a/library/cpp/threading/future/wait/wait.cpp
+++ b/library/cpp/threading/future/wait/wait.cpp
@@ -1,17 +1,17 @@
-#include "wait.h"
+#include "wait.h" 
 
 #include "wait_group.h"
 #include "wait_policy.h"
 
 namespace NThreading {
-    namespace {
+    namespace { 
         template <class WaitPolicy>
-        TFuture<void> WaitGeneric(const TFuture<void>& f1) {
+        TFuture<void> WaitGeneric(const TFuture<void>& f1) { 
             return f1;
         }
 
         template <class WaitPolicy>
-        TFuture<void> WaitGeneric(const TFuture<void>& f1, const TFuture<void>& f2) {
+        TFuture<void> WaitGeneric(const TFuture<void>& f1, const TFuture<void>& f2) { 
             TWaitGroup<WaitPolicy> wg;
 
             wg.Add(f1).Add(f2);
@@ -19,13 +19,13 @@ namespace NThreading {
             return std::move(wg).Finish();
         }
 
-        template <class WaitPolicy>
-        TFuture<void> WaitGeneric(TArrayRef<const TFuture<void>> futures) {
+        template <class WaitPolicy> 
+        TFuture<void> WaitGeneric(TArrayRef<const TFuture<void>> futures) { 
             if (futures.empty()) {
                 return MakeFuture();
             }
             if (futures.size() == 1) {
-                return futures.front();
+                return futures.front(); 
             }
 
             TWaitGroup<WaitPolicy> wg;
@@ -39,44 +39,44 @@ namespace NThreading {
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    TFuture<void> WaitAll(const TFuture<void>& f1) {
-        return WaitGeneric<TWaitPolicy::TAll>(f1);
+    TFuture<void> WaitAll(const TFuture<void>& f1) { 
+        return WaitGeneric<TWaitPolicy::TAll>(f1); 
     }
 
-    TFuture<void> WaitAll(const TFuture<void>& f1, const TFuture<void>& f2) {
-        return WaitGeneric<TWaitPolicy::TAll>(f1, f2);
+    TFuture<void> WaitAll(const TFuture<void>& f1, const TFuture<void>& f2) { 
+        return WaitGeneric<TWaitPolicy::TAll>(f1, f2); 
     }
 
-    TFuture<void> WaitAll(TArrayRef<const TFuture<void>> futures) {
-        return WaitGeneric<TWaitPolicy::TAll>(futures);
+    TFuture<void> WaitAll(TArrayRef<const TFuture<void>> futures) { 
+        return WaitGeneric<TWaitPolicy::TAll>(futures); 
     }
 
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    TFuture<void> WaitExceptionOrAll(const TFuture<void>& f1) {
-        return WaitGeneric<TWaitPolicy::TExceptionOrAll>(f1);
+    TFuture<void> WaitExceptionOrAll(const TFuture<void>& f1) { 
+        return WaitGeneric<TWaitPolicy::TExceptionOrAll>(f1); 
     }
 
-    TFuture<void> WaitExceptionOrAll(const TFuture<void>& f1, const TFuture<void>& f2) {
-        return WaitGeneric<TWaitPolicy::TExceptionOrAll>(f1, f2);
+    TFuture<void> WaitExceptionOrAll(const TFuture<void>& f1, const TFuture<void>& f2) { 
+        return WaitGeneric<TWaitPolicy::TExceptionOrAll>(f1, f2); 
     }
 
-    TFuture<void> WaitExceptionOrAll(TArrayRef<const TFuture<void>> futures) {
-        return WaitGeneric<TWaitPolicy::TExceptionOrAll>(futures);
+    TFuture<void> WaitExceptionOrAll(TArrayRef<const TFuture<void>> futures) { 
+        return WaitGeneric<TWaitPolicy::TExceptionOrAll>(futures); 
     }
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    TFuture<void> WaitAny(const TFuture<void>& f1) {
-        return WaitGeneric<TWaitPolicy::TAny>(f1);
+    TFuture<void> WaitAny(const TFuture<void>& f1) { 
+        return WaitGeneric<TWaitPolicy::TAny>(f1); 
     }
 
-    TFuture<void> WaitAny(const TFuture<void>& f1, const TFuture<void>& f2) {
-        return WaitGeneric<TWaitPolicy::TAny>(f1, f2);
+    TFuture<void> WaitAny(const TFuture<void>& f1, const TFuture<void>& f2) { 
+        return WaitGeneric<TWaitPolicy::TAny>(f1, f2); 
     }
 
-    TFuture<void> WaitAny(TArrayRef<const TFuture<void>> futures) {
-        return WaitGeneric<TWaitPolicy::TAny>(futures);
+    TFuture<void> WaitAny(TArrayRef<const TFuture<void>> futures) { 
+        return WaitGeneric<TWaitPolicy::TAny>(futures); 
     }
 }
diff --git a/library/cpp/threading/future/wait/wait.h b/library/cpp/threading/future/wait/wait.h
index 6ff7d57baa..ade4c9a3ad 100644
--- a/library/cpp/threading/future/wait/wait.h
+++ b/library/cpp/threading/future/wait/wait.h
@@ -5,35 +5,35 @@
 #include <library/cpp/threading/future/core/future.h>
 #include <library/cpp/threading/future/wait/wait_group.h>
 
-#include <util/generic/array_ref.h>
-
+#include <util/generic/array_ref.h> 
+ 
 namespace NThreading {
-    namespace NImpl {
-        template <class TContainer>
-        using EnableGenericWait = std::enable_if_t<
-            !std::is_convertible_v<TContainer, TArrayRef<const TFuture<void>>>,
-            TFuture<void>>;
-    }
+    namespace NImpl { 
+        template <class TContainer> 
+        using EnableGenericWait = std::enable_if_t< 
+            !std::is_convertible_v<TContainer, TArrayRef<const TFuture<void>>>, 
+            TFuture<void>>; 
+    } 
     // waits for all futures
     [[nodiscard]] TFuture<void> WaitAll(const TFuture<void>& f1);
     [[nodiscard]] TFuture<void> WaitAll(const TFuture<void>& f1, const TFuture<void>& f2);
-    [[nodiscard]] TFuture<void> WaitAll(TArrayRef<const TFuture<void>> futures);
+    [[nodiscard]] TFuture<void> WaitAll(TArrayRef<const TFuture<void>> futures); 
     template <typename TContainer>
-    [[nodiscard]] NImpl::EnableGenericWait<TContainer> WaitAll(const TContainer& futures);
+    [[nodiscard]] NImpl::EnableGenericWait<TContainer> WaitAll(const TContainer& futures); 
 
     // waits for the first exception or for all futures
     [[nodiscard]] TFuture<void> WaitExceptionOrAll(const TFuture<void>& f1);
     [[nodiscard]] TFuture<void> WaitExceptionOrAll(const TFuture<void>& f1, const TFuture<void>& f2);
-    [[nodiscard]] TFuture<void> WaitExceptionOrAll(TArrayRef<const TFuture<void>> futures);
+    [[nodiscard]] TFuture<void> WaitExceptionOrAll(TArrayRef<const TFuture<void>> futures); 
     template <typename TContainer>
-    [[nodiscard]] NImpl::EnableGenericWait<TContainer> WaitExceptionOrAll(const TContainer& futures);
+    [[nodiscard]] NImpl::EnableGenericWait<TContainer> WaitExceptionOrAll(const TContainer& futures); 
 
     // waits for any future
     [[nodiscard]] TFuture<void> WaitAny(const TFuture<void>& f1);
     [[nodiscard]] TFuture<void> WaitAny(const TFuture<void>& f1, const TFuture<void>& f2);
-    [[nodiscard]] TFuture<void> WaitAny(TArrayRef<const TFuture<void>> futures);
+    [[nodiscard]] TFuture<void> WaitAny(TArrayRef<const TFuture<void>> futures); 
     template <typename TContainer>
-    [[nodiscard]] NImpl::EnableGenericWait<TContainer> WaitAny(const TContainer& futures);
+    [[nodiscard]] NImpl::EnableGenericWait<TContainer> WaitAny(const TContainer& futures); 
 }
 
 #define INCLUDE_FUTURE_INL_H
diff --git a/library/cpp/threading/light_rw_lock/ut/rwlock_ut.cpp b/library/cpp/threading/light_rw_lock/ut/rwlock_ut.cpp
index e82063d959..bf5b734411 100644
--- a/library/cpp/threading/light_rw_lock/ut/rwlock_ut.cpp
+++ b/library/cpp/threading/light_rw_lock/ut/rwlock_ut.cpp
@@ -2,7 +2,7 @@
 #include <library/cpp/testing/unittest/registar.h>
 #include <util/random/random.h>
 #include <util/system/atomic.h>
-#include <util/thread/pool.h>
+#include <util/thread/pool.h> 
 
 class TRWMutexTest: public TTestBase {
     UNIT_TEST_SUITE(TRWMutexTest);
@@ -116,7 +116,7 @@ private:
 #undef RUN_CYCLE
 private:
     TSharedData Data_;
-    TThreadPool Q_;
+    TThreadPool Q_; 
 };
 
 UNIT_TEST_SUITE_REGISTRATION(TRWMutexTest)
diff --git a/library/cpp/threading/local_executor/local_executor.cpp b/library/cpp/threading/local_executor/local_executor.cpp
index 1d3fbb4bf4..528f35a74d 100644
--- a/library/cpp/threading/local_executor/local_executor.cpp
+++ b/library/cpp/threading/local_executor/local_executor.cpp
@@ -166,7 +166,7 @@ void* NPar::TLocalExecutor::TImpl::HostWorkerThread(void* p) {
     static const int FAST_ITERATIONS = 200;
 
     auto* const ctx = (TImpl*)p;
-    TThread::SetCurrentThreadName("ParLocalExecutor");
+    TThread::SetCurrentThreadName("ParLocalExecutor"); 
     ctx->WorkerThreadId = AtomicAdd(ctx->ThreadId, 1);
     for (bool cont = true; cont;) {
         TSingleJob job;
diff --git a/library/cpp/threading/poor_man_openmp/thread_helper.h b/library/cpp/threading/poor_man_openmp/thread_helper.h
index 0ecee0590b..d1744f217d 100644
--- a/library/cpp/threading/poor_man_openmp/thread_helper.h
+++ b/library/cpp/threading/poor_man_openmp/thread_helper.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <util/thread/pool.h>
+#include <util/thread/pool.h> 
 #include <util/generic/utility.h>
 #include <util/generic/yexception.h>
 #include <util/system/info.h>
@@ -17,7 +17,7 @@ public:
     TMtpQueueHelper() {
         SetThreadCount(NSystemInfo::CachedNumberOfCpus());
     }
-    IThreadPool* Get() {
+    IThreadPool* Get() { 
         return q.Get();
     }
     size_t GetThreadCount() {
@@ -25,14 +25,14 @@ public:
     }
     void SetThreadCount(size_t threads) {
         ThreadCount = threads;
-        q = CreateThreadPool(ThreadCount);
+        q = CreateThreadPool(ThreadCount); 
     }
 
     static TMtpQueueHelper& Instance();
 
 private:
     size_t ThreadCount;
-    TAutoPtr<IThreadPool> q;
+    TAutoPtr<IThreadPool> q; 
 };
 
 namespace NYmp {
@@ -49,7 +49,7 @@ namespace NYmp {
         chunkSize = Max<size_t>(chunkSize, 1);
 
         size_t threadCount = TMtpQueueHelper::Instance().GetThreadCount();
-        IThreadPool* queue = TMtpQueueHelper::Instance().Get();
+        IThreadPool* queue = TMtpQueueHelper::Instance().Get(); 
         TCondVar cv;
         TMutex mutex;
         TAtomic counter = threadCount;
diff --git a/library/cpp/threading/skip_list/perf/main.cpp b/library/cpp/threading/skip_list/perf/main.cpp
index 4ad52049e7..8194a660cb 100644
--- a/library/cpp/threading/skip_list/perf/main.cpp
+++ b/library/cpp/threading/skip_list/perf/main.cpp
@@ -198,7 +198,7 @@ namespace {
             }
 
             for (size_t i = 0; i < tests.size(); ++i) {
-                if (!AllTests.contains(tests[i])) {
+                if (!AllTests.contains(tests[i])) { 
                     LogError() << "unknown test name: " << tests[i] << Endl;
                     return false;
                 }
diff --git a/library/cpp/threading/task_scheduler/task_scheduler.cpp b/library/cpp/threading/task_scheduler/task_scheduler.cpp
index 174dde4bf7..d428a0f8a3 100644
--- a/library/cpp/threading/task_scheduler/task_scheduler.cpp
+++ b/library/cpp/threading/task_scheduler/task_scheduler.cpp
@@ -21,7 +21,7 @@ public:
     TString DebugState = "?";
     TString DebugId = "";
 private:
-    void* ThreadProc() noexcept override {
+    void* ThreadProc() noexcept override { 
         Scheduler_.WorkerFunc(this);
         return nullptr;
     }