Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

2 files changed, 91 insertions, 91 deletions

diff --git a/library/cpp/cache/thread_safe_cache.h b/library/cpp/cache/thread_safe_cache.h
index 99659a5194c..71e14427173 100644
--- a/library/cpp/cache/thread_safe_cache.h
+++ b/library/cpp/cache/thread_safe_cache.h
@@ -1,11 +1,11 @@
-#pragma once 
- 
-#include "cache.h" 
- 
-#include <util/generic/singleton.h> 
-#include <util/system/rwlock.h> 
- 
-namespace NPrivate { 
+#pragma once
+
+#include "cache.h"
+
+#include <util/generic/singleton.h>
+#include <util/system/rwlock.h>
+
+namespace NPrivate {
     // We are interested in getters promotion policy _here_ because of Read-Write-Lock optimizations.
     enum class EGettersPromotionPolicy {
         Promoted,   // LRU, TLRU, MRU, etc.
@@ -13,29 +13,29 @@ namespace NPrivate {
     };
 
     template <class Key, class Value, template <class, class> class List, EGettersPromotionPolicy GettersPromotionPolicy, class... TArgs>
-    class TThreadSafeCache { 
-    public: 
+    class TThreadSafeCache {
+    public:
         using TPtr = TAtomicSharedPtr<Value>;
 
-        class ICallbacks { 
-        public: 
-            using TKey = Key; 
-            using TValue = Value; 
+        class ICallbacks {
+        public:
+            using TKey = Key;
+            using TValue = Value;
             using TOwner = TThreadSafeCache<Key, Value, List, GettersPromotionPolicy, TArgs...>;
- 
-        public: 
+
+        public:
             virtual ~ICallbacks() = default;
-            virtual TKey GetKey(TArgs... args) const = 0; 
-            virtual TValue* CreateObject(TArgs... args) const = 0; 
-        }; 
- 
-    public: 
+            virtual TKey GetKey(TArgs... args) const = 0;
+            virtual TValue* CreateObject(TArgs... args) const = 0;
+        };
+
+    public:
         TThreadSafeCache(const ICallbacks& callbacks, size_t maxSize = Max<size_t>())
-            : Callbacks(callbacks) 
+            : Callbacks(callbacks)
             , Cache(maxSize)
         {
         }
- 
+
         bool Insert(const Key& key, const TPtr& value) {
             if (!Contains(key)) {
                 TWriteGuard w(Mutex);
@@ -51,17 +51,17 @@ namespace NPrivate {
 
         const TPtr Get(TArgs... args) const {
             return GetValue<true>(args...);
-        } 
- 
+        }
+
         const TPtr GetUnsafe(TArgs... args) const {
             return GetValue<false>(args...);
         }
 
-        void Clear() { 
-            TWriteGuard w(Mutex); 
-            Cache.Clear(); 
-        } 
- 
+        void Clear() {
+            TWriteGuard w(Mutex);
+            Cache.Clear();
+        }
+
         void Erase(TArgs... args) {
             Key key = Callbacks.GetKey(args...);
             if (!Contains(key)) {
@@ -83,19 +83,19 @@ namespace NPrivate {
 
         template <class TCallbacks>
         static const TPtr Get(TArgs... args) {
-            return TThreadSafeCacheSingleton<TCallbacks>::Get(args...); 
-        } 
- 
+            return TThreadSafeCacheSingleton<TCallbacks>::Get(args...);
+        }
+
         template <class TCallbacks>
         static const TPtr Erase(TArgs... args) {
             return TThreadSafeCacheSingleton<TCallbacks>::Erase(args...);
         }
 
         template <class TCallbacks>
-        static void Clear() { 
-            return TThreadSafeCacheSingleton<TCallbacks>::Clear(); 
-        } 
- 
+        static void Clear() {
+            return TThreadSafeCacheSingleton<TCallbacks>::Clear();
+        }
+
         size_t GetMaxSize() const {
             TReadGuard w(Mutex);
             return Cache.GetMaxSize();
@@ -106,7 +106,7 @@ namespace NPrivate {
             Cache.SetMaxSize(newSize);
         }
 
-    private: 
+    private:
         template <bool AllowNullValues>
         const TPtr GetValue(TArgs... args) const {
             Key key = Callbacks.GetKey(args...);
@@ -136,53 +136,53 @@ namespace NPrivate {
 
     private:
         using TInternalCache = TCache<Key, TPtr, List<Key, TPtr>, TNoopDelete>;
- 
-        template <class TCallbacks> 
-        class TThreadSafeCacheSingleton { 
-        public: 
+
+        template <class TCallbacks>
+        class TThreadSafeCacheSingleton {
+        public:
             static const TPtr Get(TArgs... args) {
-                return Singleton<TThreadSafeCacheSingleton>()->Cache.Get(args...); 
-            } 
- 
+                return Singleton<TThreadSafeCacheSingleton>()->Cache.Get(args...);
+            }
+
             static const TPtr Erase(TArgs... args) {
                 return Singleton<TThreadSafeCacheSingleton>()->Cache.Erase(args...);
             }
 
-            static void Clear() { 
-                return Singleton<TThreadSafeCacheSingleton>()->Cache.Clear(); 
-            } 
- 
-            TThreadSafeCacheSingleton() 
-                : Cache(Callbacks) 
+            static void Clear() {
+                return Singleton<TThreadSafeCacheSingleton>()->Cache.Clear();
+            }
+
+            TThreadSafeCacheSingleton()
+                : Cache(Callbacks)
             {
             }
- 
-        private: 
-            TCallbacks Callbacks; 
-            typename TCallbacks::TOwner Cache; 
-        }; 
- 
-    private: 
-        TRWMutex Mutex; 
-        const ICallbacks& Callbacks; 
+
+        private:
+            TCallbacks Callbacks;
+            typename TCallbacks::TOwner Cache;
+        };
+
+    private:
+        TRWMutex Mutex;
+        const ICallbacks& Callbacks;
         mutable TInternalCache Cache;
-    }; 
- 
-    struct TLWHelper { 
-        template <class TValue> 
-        struct TConstWeighter { 
-            static int Weight(const TValue& /*value*/) { 
-                return 0; 
-            } 
-        }; 
- 
-        template <class TKey, class TValue> 
+    };
+
+    struct TLWHelper {
+        template <class TValue>
+        struct TConstWeighter {
+            static int Weight(const TValue& /*value*/) {
+                return 0;
+            }
+        };
+
+        template <class TKey, class TValue>
         using TListType = TLWList<TKey, TValue, int, TConstWeighter<TValue>>;
- 
-        template <class TKey, class TValue, class... TArgs> 
+
+        template <class TKey, class TValue, class... TArgs>
         using TCache = TThreadSafeCache<TKey, TValue, TListType, EGettersPromotionPolicy::Unpromoted, TArgs...>;
-    }; 
- 
+    };
+
     struct TLRUHelper {
         template <class TKey, class TValue>
         using TListType = TLRUList<TKey, TValue>;
@@ -191,10 +191,10 @@ namespace NPrivate {
         using TCache = TThreadSafeCache<TKey, TValue, TListType, EGettersPromotionPolicy::Promoted, TArgs...>;
     };
 
-} 
- 
-template <class TKey, class TValue, class... TArgs> 
-using TThreadSafeCache = typename NPrivate::TLWHelper::template TCache<TKey, TValue, TArgs...>; 
+}
+
+template <class TKey, class TValue, class... TArgs>
+using TThreadSafeCache = typename NPrivate::TLWHelper::template TCache<TKey, TValue, TArgs...>;
 
 template <class TKey, class TValue, class... TArgs>
 using TThreadSafeLRUCache = typename NPrivate::TLRUHelper::template TCache<TKey, TValue, TArgs...>;
diff --git a/library/cpp/cache/ut/cache_ut.cpp b/library/cpp/cache/ut/cache_ut.cpp
index c3b984995e4..329872cfdee 100644
--- a/library/cpp/cache/ut/cache_ut.cpp
+++ b/library/cpp/cache/ut/cache_ut.cpp
@@ -356,30 +356,30 @@ Y_UNIT_TEST_SUITE(TCacheTest) {
         UNIT_ASSERT(s.Find(1) != s.End()); // Key 2 should have been deleted
     }
 }
- 
+
 Y_UNIT_TEST_SUITE(TThreadSafeCacheTest) {
     typedef TThreadSafeCache<ui32, TString, ui32> TCache;
- 
-    const char* VALS[] = {"abcd", "defg", "hjkl"}; 
- 
+
+    const char* VALS[] = {"abcd", "defg", "hjkl"};
+
     class TCallbacks: public TCache::ICallbacks {
-    public: 
+    public:
         TKey GetKey(ui32 i) const override {
-            return i; 
-        } 
+            return i;
+        }
         TValue* CreateObject(ui32 i) const override {
             Creations++;
             return new TString(VALS[i]);
-        } 
+        }
 
         mutable i32 Creations = 0;
-    }; 
- 
+    };
+
     Y_UNIT_TEST(SimpleTest) {
         for (ui32 i = 0; i < Y_ARRAY_SIZE(VALS); ++i) {
             const TString data = *TCache::Get<TCallbacks>(i);
             UNIT_ASSERT(data == VALS[i]);
-        } 
+        }
     }
 
     Y_UNIT_TEST(InsertUpdateTest) {
@@ -404,7 +404,7 @@ Y_UNIT_TEST_SUITE(TThreadSafeCacheTest) {
         UNIT_ASSERT(callbacks.Creations == 0);
         UNIT_ASSERT(*item == "hjk");
     }
-} 
+}
 
 Y_UNIT_TEST_SUITE(TThreadSafeCacheUnsafeTest) {
     typedef TThreadSafeCache<ui32, TString, ui32> TCache;