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

1 files changed, 237 insertions, 237 deletions

diff --git a/library/cpp/yt/memory/ref.cpp b/library/cpp/yt/memory/ref.cpp
index 18113e8570..e8ff42e976 100644
--- a/library/cpp/yt/memory/ref.cpp
+++ b/library/cpp/yt/memory/ref.cpp
@@ -1,25 +1,25 @@
 #include "ref.h"
-#include "blob.h" 
+#include "blob.h"
+
+#include <library/cpp/ytalloc/api/ytalloc.h>
+
+#include <util/system/info.h>
 
-#include <library/cpp/ytalloc/api/ytalloc.h> 
- 
-#include <util/system/info.h> 
- 
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-namespace NDetail { 
- 
+namespace NDetail {
+
 // N.B. We would prefer these arrays to be zero sized
 // but zero sized arrays are not supported in MSVC.
 const char EmptyRefData[1] = {0};
 char MutableEmptyRefData[1] = {0};
- 
-} // namespace NDetail 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
+
+} // namespace NDetail
+
+////////////////////////////////////////////////////////////////////////////////
+
 class TBlobHolder
     : public TRefCounted
 {
@@ -71,19 +71,19 @@ private:
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class TDerived> 
-class TAllocationHolderBase 
+template <class TDerived>
+class TAllocationHolderBase
     : public TRefCounted
 {
 public:
-    TAllocationHolderBase(size_t size, TRefCountedTypeCookie cookie) 
+    TAllocationHolderBase(size_t size, TRefCountedTypeCookie cookie)
         : Size_(size)
 #ifdef YT_ENABLE_REF_COUNTED_TRACKING
         , Cookie_(cookie)
 #endif
-    { } 
- 
-    ~TAllocationHolderBase() 
+    { }
+
+    ~TAllocationHolderBase()
     {
 #ifdef YT_ENABLE_REF_COUNTED_TRACKING
         TRefCountedTrackerFacade::FreeTagInstance(Cookie_);
@@ -93,25 +93,25 @@ public:
 
     TMutableRef GetRef()
     {
-        return TMutableRef(static_cast<TDerived*>(this)->GetBegin(), Size_); 
+        return TMutableRef(static_cast<TDerived*>(this)->GetBegin(), Size_);
     }
 
-protected: 
+protected:
     const size_t Size_;
 #ifdef YT_ENABLE_REF_COUNTED_TRACKING
     const TRefCountedTypeCookie Cookie_;
 #endif
- 
-    void Initialize(bool initializeStorage) 
-    { 
-        if (initializeStorage) { 
-            ::memset(static_cast<TDerived*>(this)->GetBegin(), 0, Size_); 
-        } 
-#ifdef YT_ENABLE_REF_COUNTED_TRACKING 
-        TRefCountedTrackerFacade::AllocateTagInstance(Cookie_); 
-        TRefCountedTrackerFacade::AllocateSpace(Cookie_, Size_); 
-#endif 
-    } 
+
+    void Initialize(bool initializeStorage)
+    {
+        if (initializeStorage) {
+            ::memset(static_cast<TDerived*>(this)->GetBegin(), 0, Size_);
+        }
+#ifdef YT_ENABLE_REF_COUNTED_TRACKING
+        TRefCountedTrackerFacade::AllocateTagInstance(Cookie_);
+        TRefCountedTrackerFacade::AllocateSpace(Cookie_, Size_);
+#endif
+    }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -119,171 +119,171 @@ protected:
 class TDefaultAllocationHolder
     : public TAllocationHolderBase<TDefaultAllocationHolder>
     , public TWithExtraSpace<TDefaultAllocationHolder>
-{ 
-public: 
+{
+public:
     TDefaultAllocationHolder(size_t size, bool initializeStorage, TRefCountedTypeCookie cookie)
-        : TAllocationHolderBase(size, cookie) 
-    { 
-        Initialize(initializeStorage); 
-    } 
- 
-    char* GetBegin() 
-    { 
-        return static_cast<char*>(GetExtraSpacePtr()); 
-    } 
-}; 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-class TPageAlignedAllocationHolder 
-    : public TAllocationHolderBase<TPageAlignedAllocationHolder> 
-{ 
-public: 
-    TPageAlignedAllocationHolder(size_t size, bool initializeStorage, TRefCountedTypeCookie cookie) 
-        : TAllocationHolderBase(size, cookie) 
-        , Begin_(static_cast<char*>(NYTAlloc::AllocatePageAligned(size))) 
-    { 
-        Initialize(initializeStorage); 
-    } 
- 
-    ~TPageAlignedAllocationHolder() 
-    { 
-        NYTAlloc::Free(Begin_); 
-    } 
- 
-    char* GetBegin() 
-    { 
-        return Begin_; 
-    } 
- 
-private: 
-    char* const Begin_; 
-}; 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-TRef TRef::FromBlob(const TBlob& blob) 
-{ 
-    return TRef(blob.Begin(), blob.Size()); 
-} 
- 
-bool TRef::AreBitwiseEqual(TRef lhs, TRef rhs) 
-{ 
-    if (lhs.Size() != rhs.Size()) { 
-        return false; 
-    } 
-    if (lhs.Size() == 0) { 
-        return true; 
-    } 
-    return ::memcmp(lhs.Begin(), rhs.Begin(), lhs.Size()) == 0; 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-TMutableRef TMutableRef::FromBlob(TBlob& blob) 
-{ 
-    return TMutableRef(blob.Begin(), blob.Size()); 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-TSharedRef TSharedRef::FromString(TString str, TRefCountedTypeCookie tagCookie) 
-{ 
-    auto holder = New<TStringHolder>(std::move(str), tagCookie); 
+        : TAllocationHolderBase(size, cookie)
+    {
+        Initialize(initializeStorage);
+    }
+
+    char* GetBegin()
+    {
+        return static_cast<char*>(GetExtraSpacePtr());
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+class TPageAlignedAllocationHolder
+    : public TAllocationHolderBase<TPageAlignedAllocationHolder>
+{
+public:
+    TPageAlignedAllocationHolder(size_t size, bool initializeStorage, TRefCountedTypeCookie cookie)
+        : TAllocationHolderBase(size, cookie)
+        , Begin_(static_cast<char*>(NYTAlloc::AllocatePageAligned(size)))
+    {
+        Initialize(initializeStorage);
+    }
+
+    ~TPageAlignedAllocationHolder()
+    {
+        NYTAlloc::Free(Begin_);
+    }
+
+    char* GetBegin()
+    {
+        return Begin_;
+    }
+
+private:
+    char* const Begin_;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+TRef TRef::FromBlob(const TBlob& blob)
+{
+    return TRef(blob.Begin(), blob.Size());
+}
+
+bool TRef::AreBitwiseEqual(TRef lhs, TRef rhs)
+{
+    if (lhs.Size() != rhs.Size()) {
+        return false;
+    }
+    if (lhs.Size() == 0) {
+        return true;
+    }
+    return ::memcmp(lhs.Begin(), rhs.Begin(), lhs.Size()) == 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TMutableRef TMutableRef::FromBlob(TBlob& blob)
+{
+    return TMutableRef(blob.Begin(), blob.Size());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TSharedRef TSharedRef::FromString(TString str, TRefCountedTypeCookie tagCookie)
+{
+    auto holder = New<TStringHolder>(std::move(str), tagCookie);
     auto ref = TRef::FromString(holder->String());
-    return TSharedRef(ref, std::move(holder)); 
-} 
- 
-TSharedRef TSharedRef::FromBlob(TBlob&& blob) 
-{ 
-    auto ref = TRef::FromBlob(blob); 
-    auto holder = New<TBlobHolder>(std::move(blob)); 
-    return TSharedRef(ref, std::move(holder)); 
-} 
- 
-TSharedRef TSharedRef::MakeCopy(TRef ref, TRefCountedTypeCookie tagCookie) 
-{ 
-    if (!ref) { 
-        return {}; 
-    } 
+    return TSharedRef(ref, std::move(holder));
+}
+
+TSharedRef TSharedRef::FromBlob(TBlob&& blob)
+{
+    auto ref = TRef::FromBlob(blob);
+    auto holder = New<TBlobHolder>(std::move(blob));
+    return TSharedRef(ref, std::move(holder));
+}
+
+TSharedRef TSharedRef::MakeCopy(TRef ref, TRefCountedTypeCookie tagCookie)
+{
+    if (!ref) {
+        return {};
+    }
     if (ref.Empty()) {
-        return TSharedRef::MakeEmpty(); 
+        return TSharedRef::MakeEmpty();
     }
     auto result = TSharedMutableRef::Allocate(ref.Size(), false, tagCookie);
     ::memcpy(result.Begin(), ref.Begin(), ref.Size());
     return result;
-} 
- 
-std::vector<TSharedRef> TSharedRef::Split(size_t partSize) const 
-{ 
-    YT_VERIFY(partSize > 0); 
-    std::vector<TSharedRef> result; 
-    result.reserve(Size() / partSize + 1); 
-    auto sliceBegin = Begin(); 
-    while (sliceBegin < End()) { 
-        auto sliceEnd = sliceBegin + partSize; 
-        if (sliceEnd < sliceBegin || sliceEnd > End()) { 
-            sliceEnd = End(); 
-        } 
-        result.push_back(Slice(sliceBegin, sliceEnd)); 
-        sliceBegin = sliceEnd; 
-    } 
-    return result; 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-TSharedMutableRef TSharedMutableRef::Allocate(size_t size, bool initializeStorage, TRefCountedTypeCookie tagCookie) 
-{ 
+}
+
+std::vector<TSharedRef> TSharedRef::Split(size_t partSize) const
+{
+    YT_VERIFY(partSize > 0);
+    std::vector<TSharedRef> result;
+    result.reserve(Size() / partSize + 1);
+    auto sliceBegin = Begin();
+    while (sliceBegin < End()) {
+        auto sliceEnd = sliceBegin + partSize;
+        if (sliceEnd < sliceBegin || sliceEnd > End()) {
+            sliceEnd = End();
+        }
+        result.push_back(Slice(sliceBegin, sliceEnd));
+        sliceBegin = sliceEnd;
+    }
+    return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TSharedMutableRef TSharedMutableRef::Allocate(size_t size, bool initializeStorage, TRefCountedTypeCookie tagCookie)
+{
     auto holder = NewWithExtraSpace<TDefaultAllocationHolder>(size, size, initializeStorage, tagCookie);
-    auto ref = holder->GetRef(); 
-    return TSharedMutableRef(ref, std::move(holder)); 
-} 
- 
-TSharedMutableRef TSharedMutableRef::AllocatePageAligned(size_t size, bool initializeStorage, TRefCountedTypeCookie tagCookie) 
-{ 
-    auto holder = New<TPageAlignedAllocationHolder>(size, initializeStorage, tagCookie); 
-    auto ref = holder->GetRef(); 
-    return TSharedMutableRef(ref, std::move(holder)); 
-} 
- 
-TSharedMutableRef TSharedMutableRef::FromBlob(TBlob&& blob) 
-{ 
-    auto ref = TMutableRef::FromBlob(blob); 
-    auto holder = New<TBlobHolder>(std::move(blob)); 
-    return TSharedMutableRef(ref, std::move(holder)); 
-} 
- 
-TSharedMutableRef TSharedMutableRef::MakeCopy(TRef ref, TRefCountedTypeCookie tagCookie) 
-{ 
-    if (!ref) { 
-        return {}; 
-    } 
+    auto ref = holder->GetRef();
+    return TSharedMutableRef(ref, std::move(holder));
+}
+
+TSharedMutableRef TSharedMutableRef::AllocatePageAligned(size_t size, bool initializeStorage, TRefCountedTypeCookie tagCookie)
+{
+    auto holder = New<TPageAlignedAllocationHolder>(size, initializeStorage, tagCookie);
+    auto ref = holder->GetRef();
+    return TSharedMutableRef(ref, std::move(holder));
+}
+
+TSharedMutableRef TSharedMutableRef::FromBlob(TBlob&& blob)
+{
+    auto ref = TMutableRef::FromBlob(blob);
+    auto holder = New<TBlobHolder>(std::move(blob));
+    return TSharedMutableRef(ref, std::move(holder));
+}
+
+TSharedMutableRef TSharedMutableRef::MakeCopy(TRef ref, TRefCountedTypeCookie tagCookie)
+{
+    if (!ref) {
+        return {};
+    }
     if (ref.Empty()) {
-        return TSharedMutableRef::MakeEmpty(); 
+        return TSharedMutableRef::MakeEmpty();
     }
     auto result = Allocate(ref.Size(), false, tagCookie);
     ::memcpy(result.Begin(), ref.Begin(), ref.Size());
     return result;
-} 
- 
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
-TString ToString(TRef ref) 
-{ 
+TString ToString(TRef ref)
+{
     return TString(ref.Begin(), ref.End());
-} 
- 
+}
+
 TString ToString(const TMutableRef& ref)
 {
     return ToString(TRef(ref));
 }
 
-TString ToString(const TSharedRef& ref) 
-{ 
-    return ToString(TRef(ref)); 
-} 
- 
+TString ToString(const TSharedRef& ref)
+{
+    return ToString(TRef(ref));
+}
+
 TString ToString(const TSharedMutableRef& ref)
 {
     return ToString(TRef(ref));
@@ -298,23 +298,23 @@ size_t GetPageSize()
 size_t RoundUpToPage(size_t bytes)
 {
     static const size_t PageSize = NSystemInfo::GetPageSize();
-    YT_ASSERT((PageSize & (PageSize - 1)) == 0); 
+    YT_ASSERT((PageSize & (PageSize - 1)) == 0);
     return (bytes + PageSize - 1) & (~(PageSize - 1));
 }
 
-size_t GetByteSize(const TSharedRefArray& array) 
-{ 
-    size_t size = 0; 
-    if (array) { 
-        for (const auto& part : array) { 
-            size += part.Size(); 
-        } 
-    } 
-    return size; 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
+size_t GetByteSize(const TSharedRefArray& array)
+{
+    size_t size = 0;
+    if (array) {
+        for (const auto& part : array) {
+            size += part.Size();
+        }
+    }
+    return size;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 i64 TSharedRefArray::ByteSize() const
 {
     i64 result = 0;
@@ -326,53 +326,53 @@ i64 TSharedRefArray::ByteSize() const
     return result;
 }
 
-std::vector<TSharedRef> TSharedRefArray::ToVector() const 
-{ 
-    if (!Impl_) { 
-        return {}; 
-    } 
- 
-    return std::vector<TSharedRef>(Begin(), End()); 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-TSharedRefArrayBuilder::TSharedRefArrayBuilder( 
-    size_t size, 
-    size_t poolCapacity, 
-    TRefCountedTypeCookie tagCookie) 
-    : AllocationCapacity_(poolCapacity) 
-    , Impl_(TSharedRefArray::NewImpl( 
-        size, 
-        poolCapacity, 
-        tagCookie, 
-        size)) 
-    , CurrentAllocationPtr_(Impl_->GetBeginAllocationPtr()) 
-{ } 
- 
-void TSharedRefArrayBuilder::Add(TSharedRef part) 
-{ 
-    YT_ASSERT(CurrentPartIndex_ < Impl_->Size()); 
-    Impl_->MutableBegin()[CurrentPartIndex_++] = std::move(part); 
-} 
- 
-TMutableRef TSharedRefArrayBuilder::AllocateAndAdd(size_t size) 
-{ 
-    YT_ASSERT(CurrentPartIndex_ < Impl_->Size()); 
-    YT_ASSERT(CurrentAllocationPtr_ + size <= Impl_->GetBeginAllocationPtr() + AllocationCapacity_); 
-    TMutableRef ref(CurrentAllocationPtr_, size); 
-    CurrentAllocationPtr_ += size; 
+std::vector<TSharedRef> TSharedRefArray::ToVector() const
+{
+    if (!Impl_) {
+        return {};
+    }
+
+    return std::vector<TSharedRef>(Begin(), End());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TSharedRefArrayBuilder::TSharedRefArrayBuilder(
+    size_t size,
+    size_t poolCapacity,
+    TRefCountedTypeCookie tagCookie)
+    : AllocationCapacity_(poolCapacity)
+    , Impl_(TSharedRefArray::NewImpl(
+        size,
+        poolCapacity,
+        tagCookie,
+        size))
+    , CurrentAllocationPtr_(Impl_->GetBeginAllocationPtr())
+{ }
+
+void TSharedRefArrayBuilder::Add(TSharedRef part)
+{
+    YT_ASSERT(CurrentPartIndex_ < Impl_->Size());
+    Impl_->MutableBegin()[CurrentPartIndex_++] = std::move(part);
+}
+
+TMutableRef TSharedRefArrayBuilder::AllocateAndAdd(size_t size)
+{
+    YT_ASSERT(CurrentPartIndex_ < Impl_->Size());
+    YT_ASSERT(CurrentAllocationPtr_ + size <= Impl_->GetBeginAllocationPtr() + AllocationCapacity_);
+    TMutableRef ref(CurrentAllocationPtr_, size);
+    CurrentAllocationPtr_ += size;
     TRefCountedPtr holder(Impl_.Get(), false);
-    TSharedRef sharedRef(ref, std::move(holder)); 
-    Add(std::move(sharedRef)); 
-    return ref; 
-} 
- 
-TSharedRefArray TSharedRefArrayBuilder::Finish() 
-{ 
-    return TSharedRefArray(std::move(Impl_)); 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
+    TSharedRef sharedRef(ref, std::move(holder));
+    Add(std::move(sharedRef));
+    return ref;
+}
+
+TSharedRefArray TSharedRefArrayBuilder::Finish()
+{
+    return TSharedRefArray(std::move(Impl_));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 } // namespace NYT