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

5 files changed, 93 insertions, 93 deletions

diff --git a/library/cpp/binsaver/bin_saver.h b/library/cpp/binsaver/bin_saver.h
index 412424889f..6ba6364626 100644
--- a/library/cpp/binsaver/bin_saver.h
+++ b/library/cpp/binsaver/bin_saver.h
@@ -46,7 +46,7 @@ namespace NBinSaverInternals {
 struct IBinSaver {
 public:
     typedef unsigned char chunk_id;
-    typedef ui32 TStoredSize; // changing this will break compatibility
+    typedef ui32 TStoredSize; // changing this will break compatibility 
 
 private:
     // This overload is required to avoid infinite recursion when overriding serialization in derived classes:
@@ -85,20 +85,20 @@ private:
     // vector
     template <class T, class TA>
     void DoVector(TVector<T, TA>& data) {
-        TStoredSize nSize;
+        TStoredSize nSize; 
         if (IsReading()) {
             data.clear();
             Add(2, &nSize);
             data.resize(nSize);
         } else {
-            nSize = data.size();
-            CheckOverflow(nSize, data.size());
+            nSize = data.size(); 
+            CheckOverflow(nSize, data.size()); 
             Add(2, &nSize);
         }
-        for (TStoredSize i = 0; i < nSize; i++)
+        for (TStoredSize i = 0; i < nSize; i++) 
             Add(1, &data[i]);
     }
-
+ 
     template <class T, int N>
     void DoArray(T (&data)[N]) {
         for (size_t i = 0; i < N; i++) {
@@ -108,16 +108,16 @@ private:
 
     template <typename TLarge>
     void CheckOverflow(TStoredSize nSize, TLarge origSize) {
-        if (nSize != origSize) {
-            fprintf(stderr, "IBinSaver: object size is too large to be serialized (%" PRIu32 " != %" PRIu64 ")\n", nSize, (ui64)origSize);
-            abort();
-        }
-    }
-
+        if (nSize != origSize) { 
+            fprintf(stderr, "IBinSaver: object size is too large to be serialized (%" PRIu32 " != %" PRIu64 ")\n", nSize, (ui64)origSize); 
+            abort(); 
+        } 
+    } 
+ 
     template <class T, class TA>
     void DoDataVector(TVector<T, TA>& data) {
-        TStoredSize nSize = data.size();
-        CheckOverflow(nSize, data.size());
+        TStoredSize nSize = data.size(); 
+        CheckOverflow(nSize, data.size()); 
         Add(1, &nSize);
         if (IsReading()) {
             data.clear();
@@ -131,22 +131,22 @@ private:
     void DoAnyMap(AM& data) {
         if (IsReading()) {
             data.clear();
-            TStoredSize nSize;
+            TStoredSize nSize; 
             Add(3, &nSize);
             TVector<typename AM::key_type, typename std::allocator_traits<typename AM::allocator_type>::template rebind_alloc<typename AM::key_type>> indices;
             indices.resize(nSize);
-            for (TStoredSize i = 0; i < nSize; ++i)
+            for (TStoredSize i = 0; i < nSize; ++i) 
                 Add(1, &indices[i]);
-            for (TStoredSize i = 0; i < nSize; ++i)
+            for (TStoredSize i = 0; i < nSize; ++i) 
                 Add(2, &data[indices[i]]);
         } else {
-            TStoredSize nSize = data.size();
-            CheckOverflow(nSize, data.size());
+            TStoredSize nSize = data.size(); 
+            CheckOverflow(nSize, data.size()); 
             Add(3, &nSize);
 
             TVector<typename AM::key_type, typename std::allocator_traits<typename AM::allocator_type>::template rebind_alloc<typename AM::key_type>> indices;
             indices.resize(nSize);
-            TStoredSize i = 1;
+            TStoredSize i = 1; 
             for (auto pos = data.begin(); pos != data.end(); ++pos, ++i)
                 indices[nSize - i] = pos->first;
             for (TStoredSize j = 0; j < nSize; ++j)
@@ -161,21 +161,21 @@ private:
     void DoAnyMultiMap(AMM& data) {
         if (IsReading()) {
             data.clear();
-            TStoredSize nSize;
+            TStoredSize nSize; 
             Add(3, &nSize);
             TVector<typename AMM::key_type, typename std::allocator_traits<typename AMM::allocator_type>::template rebind_alloc<typename AMM::key_type>> indices;
             indices.resize(nSize);
-            for (TStoredSize i = 0; i < nSize; ++i)
+            for (TStoredSize i = 0; i < nSize; ++i) 
                 Add(1, &indices[i]);
-            for (TStoredSize i = 0; i < nSize; ++i) {
+            for (TStoredSize i = 0; i < nSize; ++i) { 
                 std::pair<typename AMM::key_type, typename AMM::mapped_type> valToInsert;
                 valToInsert.first = indices[i];
                 Add(2, &valToInsert.second);
                 data.insert(valToInsert);
             }
         } else {
-            TStoredSize nSize = data.size();
-            CheckOverflow(nSize, data.size());
+            TStoredSize nSize = data.size(); 
+            CheckOverflow(nSize, data.size()); 
             Add(3, &nSize);
             for (auto pos = data.begin(); pos != data.end(); ++pos)
                 Add(1, (typename AMM::key_type*)(&pos->first));
@@ -188,16 +188,16 @@ private:
     void DoAnySet(T& data) {
         if (IsReading()) {
             data.clear();
-            TStoredSize nSize;
+            TStoredSize nSize; 
             Add(2, &nSize);
-            for (TStoredSize i = 0; i < nSize; ++i) {
+            for (TStoredSize i = 0; i < nSize; ++i) { 
                 typename T::value_type member;
                 Add(1, &member);
                 data.insert(member);
             }
         } else {
-            TStoredSize nSize = data.size();
-            CheckOverflow(nSize, data.size());
+            TStoredSize nSize = data.size(); 
+            CheckOverflow(nSize, data.size()); 
             Add(2, &nSize);
             for (const auto& elem : data) {
                 auto member = elem;
@@ -231,15 +231,15 @@ private:
     template <class TStringType>
     void DataChunkStr(TStringType& data, i64 elemSize) {
         if (bRead) {
-            TStoredSize nCount = 0;
-            File.Read(&nCount, sizeof(TStoredSize));
+            TStoredSize nCount = 0; 
+            File.Read(&nCount, sizeof(TStoredSize)); 
             data.resize(nCount);
             if (nCount)
                 File.Read(&*data.begin(), nCount * elemSize);
         } else {
-            TStoredSize nCount = data.size();
-            CheckOverflow(nCount, data.size());
-            File.Write(&nCount, sizeof(TStoredSize));
+            TStoredSize nCount = data.size(); 
+            CheckOverflow(nCount, data.size()); 
+            File.Write(&nCount, sizeof(TStoredSize)); 
             File.Write(data.c_str(), nCount * elemSize);
         }
     }
@@ -254,10 +254,10 @@ private:
     }
 
     void DataChunk(void* pData, i64 nSize) {
-        i64 chunkSize = 1 << 30;
-        for (i64 offset = 0; offset < nSize; offset += chunkSize) {
+        i64 chunkSize = 1 << 30; 
+        for (i64 offset = 0; offset < nSize; offset += chunkSize) { 
             void* ptr = (char*)pData + offset;
-            i64 size = offset + chunkSize < nSize ? chunkSize : (nSize - offset);
+            i64 size = offset + chunkSize < nSize ? chunkSize : (nSize - offset); 
             if (bRead)
                 File.Read(ptr, size);
             else
diff --git a/library/cpp/binsaver/blob_io.h b/library/cpp/binsaver/blob_io.h
index abe518ef30..e83e00bc4c 100644
--- a/library/cpp/binsaver/blob_io.h
+++ b/library/cpp/binsaver/blob_io.h
@@ -7,7 +7,7 @@
 
 class TYaBlobStream: public IBinaryStream {
     TBlob Blob;
-    i64 Pos;
+    i64 Pos; 
 
     int WriteImpl(const void*, int) override {
         Y_ASSERT(0);
@@ -16,7 +16,7 @@ class TYaBlobStream: public IBinaryStream {
     int ReadImpl(void* userBuffer, int size) override {
         if (size == 0)
             return 0;
-        i64 res = Min<i64>(Blob.Length() - Pos, size);
+        i64 res = Min<i64>(Blob.Length() - Pos, size); 
         if (res)
             memcpy(userBuffer, ((const char*)Blob.Data()) + Pos, res);
         Pos += res;
diff --git a/library/cpp/binsaver/buffered_io.cpp b/library/cpp/binsaver/buffered_io.cpp
index dd88b04bc5..da9cef5da4 100644
--- a/library/cpp/binsaver/buffered_io.cpp
+++ b/library/cpp/binsaver/buffered_io.cpp
@@ -3,37 +3,37 @@
 i64 IBinaryStream::LongWrite(const void* userBuffer, i64 size) {
     Y_VERIFY(size >= 0, "IBinaryStream::Write() called with a negative buffer size.");
 
-    i64 leftToWrite = size;
-    while (leftToWrite != 0) {
-        int writeSz = static_cast<int>(Min<i64>(leftToWrite, std::numeric_limits<int>::max()));
-        int written = WriteImpl(userBuffer, writeSz);
+    i64 leftToWrite = size; 
+    while (leftToWrite != 0) { 
+        int writeSz = static_cast<int>(Min<i64>(leftToWrite, std::numeric_limits<int>::max())); 
+        int written = WriteImpl(userBuffer, writeSz); 
         Y_ASSERT(written <= writeSz);
-        leftToWrite -= written;
-        // Assumption: if WriteImpl(buf, writeSz) returns < writeSz, the stream is
-        // full and there's no sense in continuing.
-        if (written < writeSz)
-            break;
-    }
+        leftToWrite -= written; 
+        // Assumption: if WriteImpl(buf, writeSz) returns < writeSz, the stream is 
+        // full and there's no sense in continuing. 
+        if (written < writeSz) 
+            break; 
+    } 
     Y_ASSERT(size >= leftToWrite);
-    return size - leftToWrite;
-}
-
+    return size - leftToWrite; 
+} 
+ 
 i64 IBinaryStream::LongRead(void* userBuffer, i64 size) {
     Y_VERIFY(size >= 0, "IBinaryStream::Read() called with a negative buffer size.");
-
-    i64 leftToRead = size;
-    while (leftToRead != 0) {
-        int readSz = static_cast<int>(Min<i64>(leftToRead, std::numeric_limits<int>::max()));
-        int read = ReadImpl(userBuffer, readSz);
+ 
+    i64 leftToRead = size; 
+    while (leftToRead != 0) { 
+        int readSz = static_cast<int>(Min<i64>(leftToRead, std::numeric_limits<int>::max())); 
+        int read = ReadImpl(userBuffer, readSz); 
         Y_ASSERT(read <= readSz);
-        leftToRead -= read;
-        // Assumption: if ReadImpl(buf, readSz) returns < readSz, the stream is
-        // full and there's no sense in continuing.
-        if (read < readSz) {
-            memset(static_cast<char*>(userBuffer) + (size - leftToRead), 0, leftToRead);
-            break;
-        }
-    }
+        leftToRead -= read; 
+        // Assumption: if ReadImpl(buf, readSz) returns < readSz, the stream is 
+        // full and there's no sense in continuing. 
+        if (read < readSz) { 
+            memset(static_cast<char*>(userBuffer) + (size - leftToRead), 0, leftToRead); 
+            break; 
+        } 
+    } 
     Y_ASSERT(size >= leftToRead);
-    return size - leftToRead;
-}
+    return size - leftToRead; 
+} 
diff --git a/library/cpp/binsaver/buffered_io.h b/library/cpp/binsaver/buffered_io.h
index 75465c9c5c..80ad1a0937 100644
--- a/library/cpp/binsaver/buffered_io.h
+++ b/library/cpp/binsaver/buffered_io.h
@@ -1,37 +1,37 @@
 #pragma once
 
 #include <util/system/yassert.h>
-#include <util/generic/utility.h>
-#include <util/generic/ylimits.h>
+#include <util/generic/utility.h> 
+#include <util/generic/ylimits.h> 
 #include <string.h>
 
 struct IBinaryStream {
     virtual ~IBinaryStream() = default;
     ;
-
+ 
     inline i64 Write(const void* userBuffer, i64 size) {
-        if (size <= Max<int>()) {
-            return WriteImpl(userBuffer, static_cast<int>(size));
-        } else {
-            return LongWrite(userBuffer, size);
-        }
-    }
-
+        if (size <= Max<int>()) { 
+            return WriteImpl(userBuffer, static_cast<int>(size)); 
+        } else { 
+            return LongWrite(userBuffer, size); 
+        } 
+    } 
+ 
     inline i64 Read(void* userBuffer, i64 size) {
-        if (size <= Max<int>()) {
-            return ReadImpl(userBuffer, static_cast<int>(size));
-        } else {
-            return LongRead(userBuffer, size);
-        }
-    }
-
+        if (size <= Max<int>()) { 
+            return ReadImpl(userBuffer, static_cast<int>(size)); 
+        } else { 
+            return LongRead(userBuffer, size); 
+        } 
+    } 
+ 
     virtual bool IsValid() const = 0;
     virtual bool IsFailed() const = 0;
-
-private:
+ 
+private: 
     virtual int WriteImpl(const void* userBuffer, int size) = 0;
     virtual int ReadImpl(void* userBuffer, int size) = 0;
-
+ 
     i64 LongRead(void* userBuffer, i64 size);
     i64 LongWrite(const void* userBuffer, i64 size);
 };
@@ -39,7 +39,7 @@ private:
 template <int N_SIZE = 16384>
 class TBufferedStream {
     char Buf[N_SIZE];
-    i64 Pos, BufSize;
+    i64 Pos, BufSize; 
     IBinaryStream& Stream;
     bool bIsReading, bIsEof, bFailed;
 
@@ -49,13 +49,13 @@ class TBufferedStream {
             return;
         }
         char* dst = (char*)userBuffer;
-        i64 leftBytes = BufSize - Pos;
+        i64 leftBytes = BufSize - Pos; 
         memcpy(dst, Buf + Pos, leftBytes);
         dst += leftBytes;
         size -= leftBytes;
         Pos = BufSize = 0;
         if (size > N_SIZE) {
-            i64 n = Stream.Read(dst, size);
+            i64 n = Stream.Read(dst, size); 
             bFailed = Stream.IsFailed();
             if (n != size) {
                 bIsEof = true;
diff --git a/library/cpp/binsaver/mem_io.h b/library/cpp/binsaver/mem_io.h
index 2a9e36fe68..5b8696cc76 100644
--- a/library/cpp/binsaver/mem_io.h
+++ b/library/cpp/binsaver/mem_io.h
@@ -83,18 +83,18 @@ namespace NMemIoInternals {
             , ShrinkOnRead(shrinkOnRead)
         {
             Y_ASSERT(!data->empty());
-        }
+        } 
 
         ~THugeMemoryStream() override {
         } // keep gcc happy
 
         bool IsValid() const override {
             return true;
-        }
+        } 
         bool IsFailed() const override {
             return false;
         }
-
+ 
     private:
         int WriteImpl(const void* userDataArg, int sizeArg) override {
             if (sizeArg == 0)