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

1 files changed, 52 insertions, 52 deletions

diff --git a/library/cpp/threading/future/legacy_future.h b/library/cpp/threading/future/legacy_future.h
index c699aadf5c..6f1eabad73 100644
--- a/library/cpp/threading/future/legacy_future.h
+++ b/library/cpp/threading/future/legacy_future.h
@@ -4,79 +4,79 @@
 #include "future.h"
 
 #include <util/thread/factory.h>
- 
+
 #include <functional>
- 
+
 namespace NThreading {
     template <typename TR, bool IgnoreException>
     class TLegacyFuture: public IThreadFactory::IThreadAble, TNonCopyable {
-    public: 
-        typedef TR(TFunctionSignature)(); 
-        using TFunctionObjectType = std::function<TFunctionSignature>; 
-        using TResult = typename TFunctionObjectType::result_type; 
+    public:
+        typedef TR(TFunctionSignature)();
+        using TFunctionObjectType = std::function<TFunctionSignature>;
+        using TResult = typename TFunctionObjectType::result_type;
 
-    private: 
-        TFunctionObjectType Func_; 
-        TPromise<TResult> Result_; 
+    private:
+        TFunctionObjectType Func_;
+        TPromise<TResult> Result_;
         THolder<IThreadFactory::IThread> Thread_;
 
-    public: 
+    public:
         inline TLegacyFuture(const TFunctionObjectType func, IThreadFactory* pool = SystemThreadFactory())
-            : Func_(func) 
-            , Result_(NewPromise<TResult>()) 
-            , Thread_(pool->Run(this)) 
-        { 
-        } 
+            : Func_(func)
+            , Result_(NewPromise<TResult>())
+            , Thread_(pool->Run(this))
+        {
+        }
 
-        inline ~TLegacyFuture() override { 
-            this->Join(); 
-        } 
+        inline ~TLegacyFuture() override {
+            this->Join();
+        }
 
-        inline TResult Get() { 
-            this->Join(); 
-            return Result_.GetValue(); 
-        } 
+        inline TResult Get() {
+            this->Join();
+            return Result_.GetValue();
+        }
 
-    private: 
-        inline void Join() { 
-            if (Thread_) { 
-                Thread_->Join(); 
-                Thread_.Destroy(); 
-            } 
+    private:
+        inline void Join() {
+            if (Thread_) {
+                Thread_->Join();
+                Thread_.Destroy();
+            }
         }
 
-        template <typename Result, bool IgnoreException_> 
-        struct TExecutor { 
-            static void SetPromise(TPromise<Result>& promise, const TFunctionObjectType& func) { 
-                if (IgnoreException_) { 
-                    try { 
-                        promise.SetValue(func()); 
-                    } catch (...) { 
-                    } 
-                } else { 
+        template <typename Result, bool IgnoreException_>
+        struct TExecutor {
+            static void SetPromise(TPromise<Result>& promise, const TFunctionObjectType& func) {
+                if (IgnoreException_) {
+                    try {
+                        promise.SetValue(func());
+                    } catch (...) {
+                    }
+                } else {
                     promise.SetValue(func());
                 }
             }
-        }; 
+        };
 
-        template <bool IgnoreException_> 
-        struct TExecutor<void, IgnoreException_> { 
-            static void SetPromise(TPromise<void>& promise, const TFunctionObjectType& func) { 
-                if (IgnoreException_) { 
-                    try { 
-                        func(); 
-                        promise.SetValue(); 
-                    } catch (...) { 
-                    } 
-                } else { 
+        template <bool IgnoreException_>
+        struct TExecutor<void, IgnoreException_> {
+            static void SetPromise(TPromise<void>& promise, const TFunctionObjectType& func) {
+                if (IgnoreException_) {
+                    try {
+                        func();
+                        promise.SetValue();
+                    } catch (...) {
+                    }
+                } else {
                     func();
                     promise.SetValue();
                 }
             }
-        }; 
- 
-        void DoExecute() override { 
-            TExecutor<TResult, IgnoreException>::SetPromise(Result_, Func_); 
+        };
+
+        void DoExecute() override {
+            TExecutor<TResult, IgnoreException>::SetPromise(Result_, Func_);
         }
     };