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

5 files changed, 113 insertions, 113 deletions

diff --git a/util/memory/blob.cpp b/util/memory/blob.cpp
index 91da5cadca..ab5bb88fc1 100644
--- a/util/memory/blob.cpp
+++ b/util/memory/blob.cpp
@@ -166,7 +166,7 @@ TBlob TBlob::SubBlob(size_t begin, size_t end) const {
 }
 
 TBlob TBlob::DeepCopy() const {
-    return TBlob::Copy(Data(), Length());
+    return TBlob::Copy(Data(), Length()); 
 }
 
 template <class TCounter>
@@ -184,11 +184,11 @@ static inline TBlob CopyConstruct(const void* data, size_t len) {
     return ret;
 }
 
-TBlob TBlob::CopySingleThreaded(const void* data, size_t length) {
+TBlob TBlob::CopySingleThreaded(const void* data, size_t length) { 
     return CopyConstruct<TSimpleCounter>(data, length);
 }
 
-TBlob TBlob::Copy(const void* data, size_t length) {
+TBlob TBlob::Copy(const void* data, size_t length) { 
     return CopyConstruct<TAtomicCounter>(data, length);
 }
 
@@ -292,11 +292,11 @@ TBlob TBlob::LockedFromMemoryMap(const TMemoryMap& map, ui64 offset, size_t leng
     return ConstructFromMap<TAtomicCounter>(map, offset, length, EMappingMode::Locked);
 }
 
-TBlob TBlob::FromMemoryMapSingleThreaded(const TMemoryMap& map, ui64 offset, size_t length) {
+TBlob TBlob::FromMemoryMapSingleThreaded(const TMemoryMap& map, ui64 offset, size_t length) { 
     return ConstructFromMap<TSimpleCounter>(map, offset, length, EMappingMode::Standard);
 }
 
-TBlob TBlob::FromMemoryMap(const TMemoryMap& map, ui64 offset, size_t length) {
+TBlob TBlob::FromMemoryMap(const TMemoryMap& map, ui64 offset, size_t length) { 
     return ConstructFromMap<TAtomicCounter>(map, offset, length, EMappingMode::Standard);
 }
 
@@ -334,34 +334,34 @@ TBlob TBlob::FromFileContent(const TString& path) {
     return ConstructFromFileContent<TAtomicCounter>(file, 0, file.GetLength());
 }
 
-TBlob TBlob::FromFileContentSingleThreaded(const TFile& file) {
+TBlob TBlob::FromFileContentSingleThreaded(const TFile& file) { 
     return ConstructFromFileContent<TSimpleCounter>(file, 0, file.GetLength());
 }
 
-TBlob TBlob::FromFileContent(const TFile& file) {
+TBlob TBlob::FromFileContent(const TFile& file) { 
     return ConstructFromFileContent<TAtomicCounter>(file, 0, file.GetLength());
 }
 
-TBlob TBlob::FromFileContentSingleThreaded(const TFile& file, ui64 offset, size_t length) {
+TBlob TBlob::FromFileContentSingleThreaded(const TFile& file, ui64 offset, size_t length) { 
     return ConstructFromFileContent<TSimpleCounter>(file, offset, length);
 }
 
-TBlob TBlob::FromFileContent(const TFile& file, ui64 offset, size_t length) {
+TBlob TBlob::FromFileContent(const TFile& file, ui64 offset, size_t length) { 
     return ConstructFromFileContent<TAtomicCounter>(file, offset, length);
 }
 
 template <class TCounter>
-static inline TBlob ConstructFromBuffer(TBuffer& in) {
+static inline TBlob ConstructFromBuffer(TBuffer& in) { 
     using TBase = TBufferBlobBase<TCounter>;
-    THolder<TBase> base(new TBase(in));
-
-    TBlob ret(base->Buffer().Data(), base->Buffer().Size(), base.Get());
+    THolder<TBase> base(new TBase(in)); 
+ 
+    TBlob ret(base->Buffer().Data(), base->Buffer().Size(), base.Get()); 
     Y_UNUSED(base.Release());
-
-    return ret;
-}
-
-template <class TCounter>
+ 
+    return ret; 
+} 
+ 
+template <class TCounter> 
 static inline TBlob ConstructFromStream(IInputStream& in) {
     TBuffer buf;
 
@@ -371,7 +371,7 @@ static inline TBlob ConstructFromStream(IInputStream& in) {
         TransferData(&in, &out);
     }
 
-    return ConstructFromBuffer<TCounter>(buf);
+    return ConstructFromBuffer<TCounter>(buf); 
 }
 
 TBlob TBlob::FromStreamSingleThreaded(IInputStream& in) {
@@ -381,14 +381,14 @@ TBlob TBlob::FromStreamSingleThreaded(IInputStream& in) {
 TBlob TBlob::FromStream(IInputStream& in) {
     return ConstructFromStream<TAtomicCounter>(in);
 }
-
-TBlob TBlob::FromBufferSingleThreaded(TBuffer& in) {
-    return ConstructFromBuffer<TSimpleCounter>(in);
-}
-
-TBlob TBlob::FromBuffer(TBuffer& in) {
-    return ConstructFromBuffer<TAtomicCounter>(in);
-}
+ 
+TBlob TBlob::FromBufferSingleThreaded(TBuffer& in) { 
+    return ConstructFromBuffer<TSimpleCounter>(in); 
+} 
+ 
+TBlob TBlob::FromBuffer(TBuffer& in) { 
+    return ConstructFromBuffer<TAtomicCounter>(in); 
+} 
 
 template <class TCounter, class S>
 TBlob ConstructFromString(S&& s) {
diff --git a/util/memory/blob.h b/util/memory/blob.h
index 20c02a68df..84d4ebaa4d 100644
--- a/util/memory/blob.h
+++ b/util/memory/blob.h
@@ -7,8 +7,8 @@
 
 class TMemoryMap;
 class IInputStream;
-class TFile;
-class TBuffer;
+class TFile; 
+class TBuffer; 
 
 enum class EMappingMode {
     /// Just mmap a file allowing lazy page loading at access
@@ -289,11 +289,11 @@ public:
     /// Creates a blob with a single-threaded (non atomic) refcounter. No memory allocation, no content copy.
     /// @details The input object becomes empty.
     static TBlob FromBufferSingleThreaded(TBuffer& in);
-
+ 
     /// Creates a blob with a multi-threaded (atomic) refcounter. No memory allocation, no content copy.
     /// @details The input object becomes empty.
     static TBlob FromBuffer(TBuffer& in);
-
+ 
     /// Creates a blob from TString with a single-threaded (non atomic) refcounter.
     static TBlob FromStringSingleThreaded(const TString& s);
 
diff --git a/util/memory/blob_ut.cpp b/util/memory/blob_ut.cpp
index 023f9a0487..405717c275 100644
--- a/util/memory/blob_ut.cpp
+++ b/util/memory/blob_ut.cpp
@@ -1,7 +1,7 @@
 #include "blob.h"
 
 #include <library/cpp/testing/unittest/registar.h>
-
+ 
 #include <util/system/tempfile.h>
 #include <util/folder/path.h>
 #include <util/stream/output.h>
@@ -13,7 +13,7 @@ Y_UNIT_TEST_SUITE(TBlobTest) {
     Y_UNIT_TEST(TestSubBlob) {
         TBlob child;
         const char* p = nullptr;
-
+ 
         {
             TBlob parent = TBlob::CopySingleThreaded("0123456789", 10);
             UNIT_ASSERT_EQUAL(parent.Length(), 10);
@@ -21,12 +21,12 @@ Y_UNIT_TEST_SUITE(TBlobTest) {
             UNIT_ASSERT_EQUAL(memcmp(p, "0123456789", 10), 0);
             child = parent.SubBlob(2, 5);
         } // Don't worry about parent
-
+ 
         UNIT_ASSERT_EQUAL(child.Length(), 3);
         UNIT_ASSERT_EQUAL(memcmp(child.AsCharPtr(), "234", 3), 0);
         UNIT_ASSERT_EQUAL(p + 2, child.AsCharPtr());
     }
-
+ 
     Y_UNIT_TEST(TestFromStream) {
         TString s("sjklfgsdyutfuyas54fa78s5f89a6df790asdf7");
         TMemoryInput mi(s.data(), s.size());
diff --git a/util/memory/segmented_string_pool.h b/util/memory/segmented_string_pool.h
index a40aa408f5..bb8818e7b6 100644
--- a/util/memory/segmented_string_pool.h
+++ b/util/memory/segmented_string_pool.h
@@ -11,17 +11,17 @@
 #include <cstdio>
 #include <cstdlib>
 
-/*
- * Non-reallocated storage for the objects of POD type
- */
+/* 
+ * Non-reallocated storage for the objects of POD type 
+ */ 
 template <class T, class Alloc = std::allocator<T>>
 class segmented_pool: TNonCopyable {
-protected:
+protected: 
     Alloc seg_allocator;
     struct seg_inf {
         T* data;        // allocated chunk
-        size_t _size;   // size of allocated chunk in sizeof(T)-units
-        size_t freepos; // offset to free chunk's memory in bytes
+        size_t _size;   // size of allocated chunk in sizeof(T)-units 
+        size_t freepos; // offset to free chunk's memory in bytes 
         seg_inf()
             : data(nullptr)
             , _size(0)
@@ -38,63 +38,63 @@ protected:
     using seg_container = TVector<seg_inf>;
     using seg_iterator = typename seg_container::iterator;
     using seg_const_iterator = typename seg_container::const_iterator;
-    const size_t segment_size; // default size of a memory chunk in sizeof(T)-units
-    size_t last_free;          // size of free memory in chunk in sizeof(T)-units
-    size_t last_ins_size;      // size of memory used in chunk by the last append() in bytes
-    seg_container segs;        // array of memory chunks
-    seg_iterator curseg;       // a segment for the current insertion
-    const char* Name;          // for debug memory usage
-protected:
-    void check_capacity(size_t len) {
+    const size_t segment_size; // default size of a memory chunk in sizeof(T)-units 
+    size_t last_free;          // size of free memory in chunk in sizeof(T)-units 
+    size_t last_ins_size;      // size of memory used in chunk by the last append() in bytes 
+    seg_container segs;        // array of memory chunks 
+    seg_iterator curseg;       // a segment for the current insertion 
+    const char* Name;          // for debug memory usage 
+protected: 
+    void check_capacity(size_t len) { 
         if (Y_UNLIKELY(!last_free || len > last_free)) {
-            if (curseg != segs.end() && curseg->freepos > 0)
-                ++curseg;
-            last_free = (len > segment_size ? len : segment_size);
-            if (curseg == segs.end() || curseg->_size < last_free) {
-                segs.push_back(seg_inf(seg_allocator.allocate(last_free), last_free));
+            if (curseg != segs.end() && curseg->freepos > 0) 
+                ++curseg; 
+            last_free = (len > segment_size ? len : segment_size); 
+            if (curseg == segs.end() || curseg->_size < last_free) { 
+                segs.push_back(seg_inf(seg_allocator.allocate(last_free), last_free)); 
                 if (Y_UNLIKELY(Name))
                     printf("Pool \"%s\" was increased by %" PRISZT " bytes to %" PRISZT " Mb.\n", Name, last_free * sizeof(T), capacity() / 0x100000);
-                curseg = segs.end() - 1;
-            }
+                curseg = segs.end() - 1; 
+            } 
             Y_ASSERT(curseg->freepos == 0);
             Y_ASSERT(curseg->_size >= last_free);
-        }
-    }
+        } 
+    } 
 
-public:
+public: 
     explicit segmented_pool(size_t segsz, const char* name = nullptr)
         : segment_size(segsz)
         , last_free(0)
         , last_ins_size(0)
         , Name(name)
-    {
-        curseg = segs.begin();
-    }
-    ~segmented_pool() {
-        clear();
+    { 
+        curseg = segs.begin(); 
+    } 
+    ~segmented_pool() { 
+        clear(); 
     }
-    /* src - array of objects, len - count of elements in array */
+    /* src - array of objects, len - count of elements in array */ 
     T* append(const T* src, size_t len) {
-        check_capacity(len);
+        check_capacity(len); 
         ui8* rv = (ui8*)curseg->data + curseg->freepos;
-        last_ins_size = sizeof(T) * len;
-        if (src)
-            memcpy(rv, src, last_ins_size);
-        curseg->freepos += last_ins_size, last_free -= len;
-        return (T*)rv;
+        last_ins_size = sizeof(T) * len; 
+        if (src) 
+            memcpy(rv, src, last_ins_size); 
+        curseg->freepos += last_ins_size, last_free -= len; 
+        return (T*)rv; 
     }
     T* append() {
-        T* obj = get_raw();
+        T* obj = get_raw(); 
         new (obj) T();
-        return obj;
+        return obj; 
     }
     T* get_raw() { // append(0, 1)
-        check_capacity(1);
+        check_capacity(1); 
         ui8* rv = (ui8*)curseg->data + curseg->freepos;
-        last_ins_size = sizeof(T);
-        curseg->freepos += last_ins_size, last_free -= 1;
-        return (T*)rv;
-    }
+        last_ins_size = sizeof(T); 
+        curseg->freepos += last_ins_size, last_free -= 1; 
+        return (T*)rv; 
+    } 
     size_t get_segment_size() const {
         return segment_size;
     }
@@ -104,27 +104,27 @@ public:
                 return true;
         return false;
     }
-    size_t size() const {
-        size_t r = 0;
-        for (seg_const_iterator i = segs.begin(); i != segs.end(); ++i)
-            r += i->freepos;
-        return r;
-    }
-    size_t capacity() const {
-        return segs.size() * segment_size * sizeof(T);
-    }
-    void restart() {
+    size_t size() const { 
+        size_t r = 0; 
+        for (seg_const_iterator i = segs.begin(); i != segs.end(); ++i) 
+            r += i->freepos; 
+        return r; 
+    } 
+    size_t capacity() const { 
+        return segs.size() * segment_size * sizeof(T); 
+    } 
+    void restart() { 
         if (curseg != segs.end())
             ++curseg;
         for (seg_iterator i = segs.begin(); i != curseg; ++i)
-            i->freepos = 0;
-        curseg = segs.begin();
-        last_free = 0;
-        last_ins_size = 0;
-    }
+            i->freepos = 0; 
+        curseg = segs.begin(); 
+        last_free = 0; 
+        last_ins_size = 0; 
+    } 
     void clear() {
-        for (seg_iterator i = segs.begin(); i != segs.end(); ++i)
-            seg_allocator.deallocate(i->data, i->_size);
+        for (seg_iterator i = segs.begin(); i != segs.end(); ++i) 
+            seg_allocator.deallocate(i->data, i->_size); 
         segs.clear();
         curseg = segs.begin();
         last_free = 0;
@@ -132,25 +132,25 @@ public:
     }
     void undo_last_append() {
         Y_ASSERT(curseg != segs.end()); // do not use before append()
-        if (last_ins_size) {
+        if (last_ins_size) { 
             Y_ASSERT(last_ins_size <= curseg->freepos);
-            curseg->freepos -= last_ins_size;
-            last_free += last_ins_size / sizeof(T);
+            curseg->freepos -= last_ins_size; 
+            last_free += last_ins_size / sizeof(T); 
             last_ins_size = 0;
         }
     }
-    void alloc_first_seg() {
+    void alloc_first_seg() { 
         Y_ASSERT(capacity() == 0);
-        check_capacity(segment_size);
+        check_capacity(segment_size); 
         Y_ASSERT(capacity() == segment_size * sizeof(T));
-    }
+    } 
 };
 
 class segmented_string_pool: public segmented_pool<char> {
-private:
+private: 
     using _Base = segmented_pool<char>;
 
-public:
+public: 
     segmented_string_pool()
         : segmented_string_pool(1024 * 1024)
     {
@@ -162,8 +162,8 @@ public:
     }
     char* append(const char* src) {
         Y_ASSERT(src);
-        return _Base::append(src, strlen(src) + 1);
-    }
+        return _Base::append(src, strlen(src) + 1); 
+    } 
     char* append(const char* src, size_t len) {
         char* rv = _Base::append(nullptr, len + 1);
         if (src)
@@ -174,16 +174,16 @@ public:
     char* Append(const TStringBuf s) {
         return append(s.data(), s.size());
     }
-    void align_4() {
-        size_t t = (curseg->freepos + 3) & ~3;
-        last_free -= t - curseg->freepos;
-        curseg->freepos = t;
-    }
+    void align_4() { 
+        size_t t = (curseg->freepos + 3) & ~3; 
+        last_free -= t - curseg->freepos; 
+        curseg->freepos = t; 
+    } 
     char* Allocate(size_t len) {
         return append(nullptr, len);
     }
-};
-
+}; 
+ 
 template <typename T, typename C>
 inline T* pool_push(segmented_pool<C>& pool, const T* v) {
     static_assert(sizeof(C) == 1, "only char type supported");
diff --git a/util/memory/segpool_alloc.h b/util/memory/segpool_alloc.h
index 1a83b7a543..78a7bad222 100644
--- a/util/memory/segpool_alloc.h
+++ b/util/memory/segpool_alloc.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "segmented_string_pool.h"
+#include "segmented_string_pool.h" 
 
 /**
   This is a partially implemented allocator class that uses segmented_pool