Restoring authorship annotation for <kartynnik@yandex-team.ru>. Commit 1 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 fcc5d9a2a5..1cefef2c73 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>> {