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

1 files changed, 68 insertions, 68 deletions

diff --git a/library/cpp/containers/stack_vector/stack_vec.h b/library/cpp/containers/stack_vector/stack_vec.h
index 1cefef2c73..fcc5d9a2a5 100644
--- a/library/cpp/containers/stack_vector/stack_vec.h
+++ b/library/cpp/containers/stack_vector/stack_vec.h
@@ -1,22 +1,22 @@
-#pragma once 
- 
-#include <util/generic/vector.h> 
+#pragma once
+
+#include <util/generic/vector.h>
 #include <util/ysaveload.h>
- 
+
 #include <type_traits>
 
-// A vector preallocated on the stack. 
-// After exceeding the preconfigured stack space falls back to the heap. 
+// A vector preallocated on the stack.
+// After exceeding the preconfigured stack space falls back to the heap.
 // Publicly inherits TVector, but disallows swap (and hence shrink_to_fit, also operator= is reimplemented via copying).
-// 
-// Inspired by: http://qt-project.org/doc/qt-4.8/qvarlengtharray.html#details 
- 
+//
+// Inspired by: http://qt-project.org/doc/qt-4.8/qvarlengtharray.html#details
+
 template <typename T, size_t CountOnStack = 256, bool UseFallbackAlloc = true, class Alloc = std::allocator<T>>
-class TStackVec; 
- 
+class TStackVec;
+
 template <typename T, class Alloc = std::allocator<T>>
 using TSmallVec = TStackVec<T, 16, true, Alloc>;
- 
+
 template <typename T, size_t CountOnStack = 256>
 using TStackOnlyVec = TStackVec<T, CountOnStack, false>;
 
@@ -24,27 +24,27 @@ namespace NPrivate {
     template <class Alloc, class StackAlloc, typename T, typename U>
     struct TRebind {
         typedef TReboundAllocator<Alloc, U> other;
-    }; 
- 
+    };
+
     template <class Alloc, class StackAlloc, typename T>
     struct TRebind<Alloc, StackAlloc, T, T> {
-        typedef StackAlloc other; 
-    }; 
- 
+        typedef StackAlloc other;
+    };
+
     template <typename T, size_t CountOnStack, bool UseFallbackAlloc, class Alloc = std::allocator<T>>
     class TStackBasedAllocator: public Alloc {
-    public: 
+    public:
         typedef TStackBasedAllocator<T, CountOnStack, UseFallbackAlloc, Alloc> TSelf;
- 
+
         using typename Alloc::difference_type;
-        using typename Alloc::size_type; 
+        using typename Alloc::size_type;
         using typename Alloc::value_type;
- 
+
         template <class U>
         struct rebind: public ::NPrivate::TRebind<Alloc, TSelf, T, U> {
-        }; 
- 
-    public: 
+        };
+
+    public:
         TStackBasedAllocator() = default;
 
         template <
@@ -61,26 +61,26 @@ namespace NPrivate {
             if (!IsStorageUsed && CountOnStack >= n) {
                 IsStorageUsed = true;
                 return reinterpret_cast<T*>(&StackBasedStorage[0]);
-            } else { 
+            } else {
                 if constexpr (!UseFallbackAlloc) {
                     Y_FAIL(
                             "Stack storage overflow. Capacity: %d, requested: %d", (int)CountOnStack, int(n));
                 }
                 return FallbackAllocator().allocate(n);
-            } 
-        } 
- 
+            }
+        }
+
         void deallocate(T* p, size_type n) {
             if (p >= reinterpret_cast<T*>(&StackBasedStorage[0]) &&
                     p < reinterpret_cast<T*>(&StackBasedStorage[CountOnStack])) {
                 Y_VERIFY(IsStorageUsed);
                 IsStorageUsed = false;
-            } else { 
+            } else {
                 FallbackAllocator().deallocate(p, n);
-            } 
-        } 
- 
-    private: 
+            }
+        }
+
+    private:
         std::aligned_storage_t<sizeof(T), alignof(T)> StackBasedStorage[CountOnStack];
         bool IsStorageUsed = false;
 
@@ -88,53 +88,53 @@ namespace NPrivate {
         Alloc& FallbackAllocator() noexcept {
             return static_cast<Alloc&>(*this);
         }
-    }; 
+    };
 }
- 
+
 template <typename T, size_t CountOnStack, bool UseFallbackAlloc, class Alloc>
 class TStackVec: public TVector<T, ::NPrivate::TStackBasedAllocator<T, CountOnStack, UseFallbackAlloc, TReboundAllocator<Alloc, T>>> {
 private:
     using TBase = TVector<T, ::NPrivate::TStackBasedAllocator<T, CountOnStack, UseFallbackAlloc, TReboundAllocator<Alloc, T>>>;
     using TAllocator = typename TBase::allocator_type;
 
-public: 
+public:
     using typename TBase::const_iterator;
     using typename TBase::const_reverse_iterator;
-    using typename TBase::iterator; 
-    using typename TBase::reverse_iterator; 
+    using typename TBase::iterator;
+    using typename TBase::reverse_iterator;
     using typename TBase::size_type;
-    using typename TBase::value_type; 
- 
-public: 
+    using typename TBase::value_type;
+
+public:
     TStackVec(const TAllocator& alloc = TAllocator())
         : TBase(alloc)
-    { 
-        TBase::reserve(CountOnStack); 
-    } 
- 
+    {
+        TBase::reserve(CountOnStack);
+    }
+
     explicit TStackVec(size_type count, const TAllocator& alloc = TAllocator())
         : TBase(alloc)
-    { 
-        if (count <= CountOnStack) { 
-            TBase::reserve(CountOnStack); 
-        } 
-        TBase::resize(count); 
-    } 
- 
+    {
+        if (count <= CountOnStack) {
+            TBase::reserve(CountOnStack);
+        }
+        TBase::resize(count);
+    }
+
     TStackVec(size_type count, const T& val, const TAllocator& alloc = TAllocator())
         : TBase(alloc)
-    { 
-        if (count <= CountOnStack) { 
-            TBase::reserve(CountOnStack); 
-        } 
-        TBase::assign(count, val); 
-    } 
- 
+    {
+        if (count <= CountOnStack) {
+            TBase::reserve(CountOnStack);
+        }
+        TBase::assign(count, val);
+    }
+
     TStackVec(const TStackVec& src)
         : TStackVec(src.begin(), src.end())
-    { 
-    } 
- 
+    {
+    }
+
     template <class A>
     TStackVec(const TVector<T, A>& src)
         : TStackVec(src.begin(), src.end())
@@ -166,14 +166,14 @@ public:
         }
     }
 
-public: 
+public:
     void swap(TStackVec&) = delete;
-    void shrink_to_fit() = delete; 
- 
+    void shrink_to_fit() = delete;
+
     TStackVec& operator=(const TStackVec& src) {
         TBase::assign(src.begin(), src.end());
-        return *this; 
-    } 
+        return *this;
+    }
 
     template <class A>
     TStackVec& operator=(const TVector<T, A>& src) {
@@ -185,7 +185,7 @@ public:
         TBase::assign(il.begin(), il.end());
         return *this;
     }
-}; 
+};
 
 template <typename T, size_t CountOnStack, class Alloc>
 class TSerializer<TStackVec<T, CountOnStack, true, Alloc>>: public TVectorSerializer<TStackVec<T, CountOnStack, true, Alloc>> {