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

3 files changed, 50 insertions, 50 deletions

diff --git a/util/generic/flags.h b/util/generic/flags.h
index 246434e5a8..a1f5921d42 100644
--- a/util/generic/flags.h
+++ b/util/generic/flags.h
@@ -107,11 +107,11 @@ public:
     }
 
     constexpr friend bool operator==(TEnum l, TFlags r) {
-        return static_cast<TInt>(l) == r.Value_; 
+        return static_cast<TInt>(l) == r.Value_;
     }
 
     constexpr friend bool operator==(TFlags l, TEnum r) {
-        return l.Value_ == static_cast<TInt>(r); 
+        return l.Value_ == static_cast<TInt>(r);
     }
 
     constexpr friend bool operator!=(TFlags l, TFlags r) {
@@ -119,11 +119,11 @@ public:
     }
 
     constexpr friend bool operator!=(TEnum l, TFlags r) {
-        return static_cast<TInt>(l) != r.Value_; 
+        return static_cast<TInt>(l) != r.Value_;
     }
 
     constexpr friend bool operator!=(TFlags l, TEnum r) {
-        return l.Value_ != static_cast<TInt>(r); 
+        return l.Value_ != static_cast<TInt>(r);
     }
 
     TFlags& operator&=(TFlags mask) {
@@ -168,15 +168,15 @@ public:
         return Value_;
     }
 
-    constexpr bool HasFlags(TFlags flags) const { 
-        return (Value_ & flags.Value_) == flags.Value_; 
-    } 
- 
-    TFlags RemoveFlags(TFlags flags) { 
-        Value_ &= ~flags.Value_; 
-        return *this; 
-    } 
- 
+    constexpr bool HasFlags(TFlags flags) const {
+        return (Value_ & flags.Value_) == flags.Value_;
+    }
+
+    TFlags RemoveFlags(TFlags flags) {
+        Value_ &= ~flags.Value_;
+        return *this;
+    }
+
     friend IOutputStream& operator<<(IOutputStream& stream, const TFlags& flags) {
         ::NPrivate::PrintFlags(stream, static_cast<ui64>(flags.Value_), sizeof(TInt));
         return stream;
diff --git a/util/generic/flags_ut.cpp b/util/generic/flags_ut.cpp
index e115ffabe8..5377c6a058 100644
--- a/util/generic/flags_ut.cpp
+++ b/util/generic/flags_ut.cpp
@@ -34,36 +34,36 @@ namespace {
 Y_UNIT_TEST_SUITE(TFlagsTest) {
     template <class Enum>
     void TestEnum() {
-        { 
-            auto i = Enum::Test1 | Enum::Test2; 
-
-            UNIT_ASSERT((std::is_same<decltype(i), TFlags<Enum>>::value)); 
-            UNIT_ASSERT((std::is_same<decltype(~i), TFlags<Enum>>::value)); 
-            UNIT_ASSERT(!(std::is_same<decltype(i), int>::value)); 
-            UNIT_ASSERT_VALUES_EQUAL(sizeof(Enum), sizeof(TFlags<Enum>)); 
-
-            UNIT_ASSERT(i.HasFlags(Enum::Test1)); 
-            UNIT_ASSERT(i.HasFlags(Enum::Test4) == false); 
-            UNIT_ASSERT(i.HasFlags(Enum::Test1 | Enum::Test4) == false); 
- 
-            i |= Enum::Test4; 
-            i ^= Enum::Test2; 
-            UNIT_ASSERT_EQUAL(i, Enum::Test4 | Enum::Test1); 
-            UNIT_ASSERT_EQUAL(i & Enum::Test1, i & ~Enum::Test4); 
-            UNIT_ASSERT(i & Enum::Test4); 
-            UNIT_ASSERT_UNEQUAL(i, ~i); 
-            UNIT_ASSERT_EQUAL(i, ~~i); 
-        } 
-        { 
-            auto i = Enum::Test1 | Enum::Test2; 
-            i.RemoveFlags(Enum::Test1); 
-            UNIT_ASSERT_EQUAL(i, TFlags<Enum>(Enum::Test2)); 
-        } 
-        { 
-            auto i = Enum::Test1 | Enum::Test2; 
-            i.RemoveFlags(Enum::Test1 | Enum::Test2); 
-            UNIT_ASSERT_EQUAL(i, TFlags<Enum>()); 
-        } 
+        {
+            auto i = Enum::Test1 | Enum::Test2;
+
+            UNIT_ASSERT((std::is_same<decltype(i), TFlags<Enum>>::value));
+            UNIT_ASSERT((std::is_same<decltype(~i), TFlags<Enum>>::value));
+            UNIT_ASSERT(!(std::is_same<decltype(i), int>::value));
+            UNIT_ASSERT_VALUES_EQUAL(sizeof(Enum), sizeof(TFlags<Enum>));
+
+            UNIT_ASSERT(i.HasFlags(Enum::Test1));
+            UNIT_ASSERT(i.HasFlags(Enum::Test4) == false);
+            UNIT_ASSERT(i.HasFlags(Enum::Test1 | Enum::Test4) == false);
+
+            i |= Enum::Test4;
+            i ^= Enum::Test2;
+            UNIT_ASSERT_EQUAL(i, Enum::Test4 | Enum::Test1);
+            UNIT_ASSERT_EQUAL(i & Enum::Test1, i & ~Enum::Test4);
+            UNIT_ASSERT(i & Enum::Test4);
+            UNIT_ASSERT_UNEQUAL(i, ~i);
+            UNIT_ASSERT_EQUAL(i, ~~i);
+        }
+        {
+            auto i = Enum::Test1 | Enum::Test2;
+            i.RemoveFlags(Enum::Test1);
+            UNIT_ASSERT_EQUAL(i, TFlags<Enum>(Enum::Test2));
+        }
+        {
+            auto i = Enum::Test1 | Enum::Test2;
+            i.RemoveFlags(Enum::Test1 | Enum::Test2);
+            UNIT_ASSERT_EQUAL(i, TFlags<Enum>());
+        }
     }
 
     Y_UNIT_TEST(TestFlags) {
diff --git a/util/system/atomic_ops.h b/util/system/atomic_ops.h
index 6ee569cb68..76766b4a0a 100644
--- a/util/system/atomic_ops.h
+++ b/util/system/atomic_ops.h
@@ -131,10 +131,10 @@ inline void AtomicSet(T* volatile& target, T* value) {
     AtomicSet(*AsAtomicPtr(&target), reinterpret_cast<TAtomicBase>(value));
 }
 
-using TNullPtr = decltype(nullptr); 
- 
+using TNullPtr = decltype(nullptr);
+
 template <typename T>
-inline void AtomicSet(T* volatile& target, TNullPtr) { 
+inline void AtomicSet(T* volatile& target, TNullPtr) {
     AtomicSet(*AsAtomicPtr(&target), 0);
 }
 
@@ -144,7 +144,7 @@ inline T* AtomicSwap(T* volatile* target, T* exchange) {
 }
 
 template <typename T>
-inline T* AtomicSwap(T* volatile* target, TNullPtr) { 
+inline T* AtomicSwap(T* volatile* target, TNullPtr) {
     return reinterpret_cast<T*>(AtomicSwap(AsAtomicPtr(target), 0));
 }
 
@@ -159,7 +159,7 @@ inline T* AtomicGetAndCas(T* volatile* target, T* exchange, T* compare) {
 }
 
 template <typename T>
-inline bool AtomicCas(T* volatile* target, T* exchange, TNullPtr) { 
+inline bool AtomicCas(T* volatile* target, T* exchange, TNullPtr) {
     return AtomicCas(AsAtomicPtr(target), reinterpret_cast<TAtomicBase>(exchange), 0);
 }
 
@@ -169,7 +169,7 @@ inline T* AtomicGetAndCas(T* volatile* target, T* exchange, TNullPtr) {
 }
 
 template <typename T>
-inline bool AtomicCas(T* volatile* target, TNullPtr, T* compare) { 
+inline bool AtomicCas(T* volatile* target, TNullPtr, T* compare) {
     return AtomicCas(AsAtomicPtr(target), 0, reinterpret_cast<TAtomicBase>(compare));
 }
 
@@ -179,7 +179,7 @@ inline T* AtomicGetAndCas(T* volatile* target, TNullPtr, T* compare) {
 }
 
 template <typename T>
-inline bool AtomicCas(T* volatile* target, TNullPtr, TNullPtr) { 
+inline bool AtomicCas(T* volatile* target, TNullPtr, TNullPtr) {
     return AtomicCas(AsAtomicPtr(target), 0, 0);
 }