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

1 files changed, 71 insertions, 71 deletions

diff --git a/library/cpp/threading/future/core/future.h b/library/cpp/threading/future/core/future.h
index 2dfc4e0f25..2e82bb953e 100644
--- a/library/cpp/threading/future/core/future.h
+++ b/library/cpp/threading/future/core/future.h
@@ -1,26 +1,26 @@
-#pragma once 
- 
+#pragma once
+
 #include "fwd.h"
 
-#include <util/datetime/base.h> 
-#include <util/generic/function.h> 
+#include <util/datetime/base.h>
+#include <util/generic/function.h>
 #include <util/generic/maybe.h>
-#include <util/generic/ptr.h> 
-#include <util/generic/vector.h> 
-#include <util/generic/yexception.h> 
-#include <util/system/event.h> 
-#include <util/system/spinlock.h> 
- 
+#include <util/generic/ptr.h>
+#include <util/generic/vector.h>
+#include <util/generic/yexception.h>
+#include <util/system/event.h>
+#include <util/system/spinlock.h>
+
 namespace NThreading {
     ////////////////////////////////////////////////////////////////////////////////
- 
+
     struct TFutureException: public yexception {};
- 
+
     // creates unset promise
     template <typename T>
     TPromise<T> NewPromise();
     TPromise<void> NewPromise();
- 
+
     // creates preset future
     template <typename T>
     TFuture<T> MakeFuture(const T& value);
@@ -31,18 +31,18 @@ namespace NThreading {
     template <typename T>
     TFuture<T> MakeErrorFuture(std::exception_ptr exception);
     TFuture<void> MakeFuture();
- 
+
     ////////////////////////////////////////////////////////////////////////////////
- 
+
     namespace NImpl {
         template <typename T>
         class TFutureState;
- 
+
         template <typename T>
         struct TFutureType {
             using TType = T;
         };
- 
+
         template <typename T>
         struct TFutureType<TFuture<T>> {
             using TType = typename TFutureType<T>::TType;
@@ -54,10 +54,10 @@ namespace NThreading {
             using TType = decltype(std::declval<F&>()(std::declval<const TFuture<T>&>()));
         };
     }
- 
+
     template <typename F>
     using TFutureType = typename NImpl::TFutureType<F>::TType;
- 
+
     template <typename F, typename T>
     using TFutureCallResult = typename NImpl::TFutureCallResult<F, T>::TType;
 
@@ -65,14 +65,14 @@ namespace NThreading {
     class TFutureStateId;
 
     ////////////////////////////////////////////////////////////////////////////////
- 
+
     template <typename T>
     class TFuture {
         using TFutureState = NImpl::TFutureState<T>;
- 
+
     private:
         TIntrusivePtr<TFutureState> State;
- 
+
     public:
         using value_type = T;
 
@@ -80,29 +80,29 @@ namespace NThreading {
         TFuture(const TFuture<T>& other) noexcept = default;
         TFuture(TFuture<T>&& other) noexcept = default;
         TFuture(const TIntrusivePtr<TFutureState>& state) noexcept;
- 
+
         TFuture<T>& operator=(const TFuture<T>& other) noexcept = default;
         TFuture<T>& operator=(TFuture<T>&& other) noexcept = default;
         void Swap(TFuture<T>& other);
- 
+
         bool Initialized() const;
- 
+
         bool HasValue() const;
         const T& GetValue(TDuration timeout = TDuration::Zero()) const;
         const T& GetValueSync() const;
         T ExtractValue(TDuration timeout = TDuration::Zero());
         T ExtractValueSync();
- 
+
         void TryRethrow() const;
         bool HasException() const;
- 
+
         void Wait() const;
         bool Wait(TDuration timeout) const;
         bool Wait(TInstant deadline) const;
- 
+
         template <typename F>
         const TFuture<T>& Subscribe(F&& callback) const;
- 
+
         // precondition: EnsureInitialized() passes
         // postcondition: std::terminate is highly unlikely
         template <typename F>
@@ -110,9 +110,9 @@ namespace NThreading {
 
         template <typename F>
         TFuture<TFutureType<TFutureCallResult<F, T>>> Apply(F&& func) const;
- 
+
         TFuture<void> IgnoreResult() const;
- 
+
         //! If the future is initialized returns the future state identifier. Otherwise returns an empty optional
         /** The state identifier is guaranteed to be unique during the future state lifetime and could be reused after its death
         **/
@@ -120,16 +120,16 @@ namespace NThreading {
 
         void EnsureInitialized() const;
     };
- 
+
     ////////////////////////////////////////////////////////////////////////////////
- 
+
     template <>
     class TFuture<void> {
         using TFutureState = NImpl::TFutureState<void>;
- 
+
     private:
         TIntrusivePtr<TFutureState> State = nullptr;
- 
+
     public:
         using value_type = void;
 
@@ -137,27 +137,27 @@ namespace NThreading {
         TFuture(const TFuture<void>& other) noexcept = default;
         TFuture(TFuture<void>&& other) noexcept = default;
         TFuture(const TIntrusivePtr<TFutureState>& state) noexcept;
- 
+
         TFuture<void>& operator=(const TFuture<void>& other) noexcept = default;
         TFuture<void>& operator=(TFuture<void>&& other) noexcept = default;
         void Swap(TFuture<void>& other);
- 
+
         bool Initialized() const;
- 
+
         bool HasValue() const;
         void GetValue(TDuration timeout = TDuration::Zero()) const;
         void GetValueSync() const;
- 
+
         void TryRethrow() const;
         bool HasException() const;
- 
+
         void Wait() const;
         bool Wait(TDuration timeout) const;
         bool Wait(TInstant deadline) const;
- 
+
         template <typename F>
         const TFuture<void>& Subscribe(F&& callback) const;
- 
+
         // precondition: EnsureInitialized() passes
         // postcondition: std::terminate is highly unlikely
         template <typename F>
@@ -165,10 +165,10 @@ namespace NThreading {
 
         template <typename F>
         TFuture<TFutureType<TFutureCallResult<F, void>>> Apply(F&& func) const;
- 
+
         template <typename R>
         TFuture<R> Return(const R& value) const;
- 
+
         TFuture<void> IgnoreResult() const {
             return *this;
         }
@@ -180,35 +180,35 @@ namespace NThreading {
 
         void EnsureInitialized() const;
     };
- 
+
     ////////////////////////////////////////////////////////////////////////////////
- 
+
     template <typename T>
     class TPromise {
         using TFutureState = NImpl::TFutureState<T>;
- 
+
     private:
         TIntrusivePtr<TFutureState> State = nullptr;
- 
+
     public:
         TPromise() noexcept = default;
         TPromise(const TPromise<T>& other) noexcept = default;
         TPromise(TPromise<T>&& other) noexcept = default;
         TPromise(const TIntrusivePtr<TFutureState>& state) noexcept;
- 
+
         TPromise<T>& operator=(const TPromise<T>& other) noexcept = default;
         TPromise<T>& operator=(TPromise<T>&& other) noexcept = default;
         void Swap(TPromise<T>& other);
- 
+
         bool Initialized() const;
- 
+
         bool HasValue() const;
         const T& GetValue() const;
         T ExtractValue();
- 
+
         void SetValue(const T& value);
         void SetValue(T&& value);
- 
+
         bool TrySetValue(const T& value);
         bool TrySetValue(T&& value);
 
@@ -217,56 +217,56 @@ namespace NThreading {
         void SetException(const TString& e);
         void SetException(std::exception_ptr e);
         bool TrySetException(std::exception_ptr e);
- 
+
         TFuture<T> GetFuture() const;
         operator TFuture<T>() const;
- 
+
     private:
         void EnsureInitialized() const;
     };
- 
+
     ////////////////////////////////////////////////////////////////////////////////
- 
+
     template <>
     class TPromise<void> {
         using TFutureState = NImpl::TFutureState<void>;
- 
+
     private:
         TIntrusivePtr<TFutureState> State;
- 
+
     public:
         TPromise() noexcept = default;
         TPromise(const TPromise<void>& other) noexcept = default;
         TPromise(TPromise<void>&& other) noexcept = default;
         TPromise(const TIntrusivePtr<TFutureState>& state) noexcept;
- 
+
         TPromise<void>& operator=(const TPromise<void>& other) noexcept = default;
         TPromise<void>& operator=(TPromise<void>&& other) noexcept = default;
         void Swap(TPromise<void>& other);
- 
+
         bool Initialized() const;
- 
+
         bool HasValue() const;
         void GetValue() const;
- 
+
         void SetValue();
         bool TrySetValue();
- 
+
         void TryRethrow() const;
         bool HasException() const;
         void SetException(const TString& e);
         void SetException(std::exception_ptr e);
         bool TrySetException(std::exception_ptr e);
- 
+
         TFuture<void> GetFuture() const;
         operator TFuture<void>() const;
- 
+
     private:
         void EnsureInitialized() const;
     };
- 
+
 }
- 
-#define INCLUDE_FUTURE_INL_H 
-#include "future-inl.h" 
-#undef INCLUDE_FUTURE_INL_H 
+
+#define INCLUDE_FUTURE_INL_H
+#include "future-inl.h"
+#undef INCLUDE_FUTURE_INL_H