Memory reference tracking restyling

1 files changed, 37 insertions, 27 deletions

diff --git a/library/cpp/yt/memory/shared_range.h b/library/cpp/yt/memory/shared_range.h
index 17e55e760e..592902fe7a 100644
--- a/library/cpp/yt/memory/shared_range.h
+++ b/library/cpp/yt/memory/shared_range.h
@@ -15,13 +15,20 @@ class TCompactVector;
 
 ////////////////////////////////////////////////////////////////////////////////
 
-DECLARE_REFCOUNTED_STRUCT(ISharedRangeHolder)
+struct TSharedRangeHolderCloneOptions
+{
+    bool KeepMemoryReferenceTracking = true;
+};
+
+DECLARE_REFCOUNTED_STRUCT(TSharedRangeHolder)
 
-struct ISharedRangeHolder
+struct TSharedRangeHolder
     : public TRefCounted
-{ };
+{
+    virtual TSharedRangeHolderPtr Clone(const TSharedRangeHolderCloneOptions& /*options*/);
+};
 
-DEFINE_REFCOUNTED_TYPE(ISharedRangeHolder)
+DEFINE_REFCOUNTED_TYPE(TSharedRangeHolder)
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -36,39 +43,39 @@ public:
     { }
 
     //! Constructs a TSharedRange from TRange.
-    TSharedRange(TRange<T> range, ISharedRangeHolderPtr holder)
+    TSharedRange(TRange<T> range, TSharedRangeHolderPtr holder)
         : TRange<T>(range)
         , Holder_(std::move(holder))
     { }
 
     //! Constructs a TSharedRange from a pointer and length.
-    TSharedRange(const T* data, size_t length, ISharedRangeHolderPtr holder)
+    TSharedRange(const T* data, size_t length, TSharedRangeHolderPtr holder)
         : TRange<T>(data, length)
         , Holder_(std::move(holder))
     { }
 
     //! Constructs a TSharedRange from a range.
-    TSharedRange(const T* begin, const T* end, ISharedRangeHolderPtr holder)
+    TSharedRange(const T* begin, const T* end, TSharedRangeHolderPtr holder)
         : TRange<T>(begin, end)
         , Holder_(std::move(holder))
     { }
 
     //! Constructs a TSharedRange from a TCompactVector.
     template <size_t N>
-    TSharedRange(const TCompactVector<T, N>& elements, ISharedRangeHolderPtr holder)
+    TSharedRange(const TCompactVector<T, N>& elements, TSharedRangeHolderPtr holder)
         : TRange<T>(elements)
         , Holder_(std::move(holder))
     { }
 
     //! Constructs a TSharedRange from an std::vector.
-    TSharedRange(const std::vector<T>& elements, ISharedRangeHolderPtr holder)
+    TSharedRange(const std::vector<T>& elements, TSharedRangeHolderPtr holder)
         : TRange<T>(elements)
         , Holder_(std::move(holder))
     { }
 
     //! Constructs a TSharedRange from a C array.
     template <size_t N>
-    TSharedRange(const T (& elements)[N], ISharedRangeHolderPtr holder)
+    TSharedRange(const T (& elements)[N], TSharedRangeHolderPtr holder)
         : TRange<T>(elements)
         , Holder_(std::move(holder))
     { }
@@ -95,29 +102,32 @@ public:
         return TSharedRange<T>(begin, end, Holder_);
     }
 
-    const ISharedRangeHolderPtr& GetHolder() const
+    const TSharedRangeHolderPtr& GetHolder() const
     {
         return Holder_;
     }
 
-    ISharedRangeHolderPtr&& ReleaseHolder()
+    TSharedRangeHolderPtr&& ReleaseHolder()
     {
         return std::move(Holder_);
     }
 
 protected:
-    ISharedRangeHolderPtr Holder_;
+    TSharedRangeHolderPtr Holder_;
 
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
+//! Constructs a combined holder from a vector of typed holders.
+TSharedRangeHolderPtr MakeCompositeSharedRangeHolder(std::vector<TSharedRangeHolderPtr> holders);
+
 //! Constructs a combined holder instance by taking ownership of a given list of holders.
 template <class... THolders>
-ISharedRangeHolderPtr MakeSharedRangeHolder(THolders&&... holders)
+TSharedRangeHolderPtr MakeSharedRangeHolder(THolders&&... holders)
 {
     struct THolder
-        : public ISharedRangeHolder
+        : public TSharedRangeHolder
     {
         std::tuple<typename std::decay<THolders>::type...> Holders;
     };
@@ -131,7 +141,7 @@ template <class T, class TContainer, class... THolders>
 TSharedRange<T> DoMakeSharedRange(TContainer&& elements, THolders&&... holders)
 {
     struct THolder
-        : public ISharedRangeHolder
+        : public TSharedRangeHolder
     {
         typename std::decay<TContainer>::type Elements;
         std::tuple<typename std::decay<THolders>::type...> Holders;
@@ -174,7 +184,7 @@ TSharedRange<T> MakeSharedRange(TRange<T> range, THolders&&... holders)
 }
 
 template <class T, class THolder>
-TSharedRange<T> MakeSharedRange(TRange<T> range, ISharedRangeHolderPtr holder)
+TSharedRange<T> MakeSharedRange(TRange<T> range, TSharedRangeHolderPtr holder)
 {
     return TSharedRange<T>(range, std::move(holder));
 }
@@ -200,39 +210,39 @@ public:
     { }
 
     //! Constructs a TSharedMutableRange from TMutableRange.
-    TSharedMutableRange(TMutableRange<T> range, ISharedRangeHolderPtr holder)
+    TSharedMutableRange(TMutableRange<T> range, TSharedRangeHolderPtr holder)
         : TMutableRange<T>(range)
         , Holder_(std::move(holder))
     { }
 
     //! Constructs a TSharedMutableRange from a pointer and length.
-    TSharedMutableRange(T* data, size_t length, ISharedRangeHolderPtr holder)
+    TSharedMutableRange(T* data, size_t length, TSharedRangeHolderPtr holder)
         : TMutableRange<T>(data, length)
         , Holder_(std::move(holder))
     { }
 
     //! Constructs a TSharedMutableRange from a range.
-    TSharedMutableRange(T* begin, T* end, ISharedRangeHolderPtr holder)
+    TSharedMutableRange(T* begin, T* end, TSharedRangeHolderPtr holder)
         : TMutableRange<T>(begin, end)
         , Holder_(std::move(holder))
     { }
 
     //! Constructs a TSharedMutableRange from a TCompactVector.
     template <size_t N>
-    TSharedMutableRange(TCompactVector<T, N>& elements, ISharedRangeHolderPtr holder)
+    TSharedMutableRange(TCompactVector<T, N>& elements, TSharedRangeHolderPtr holder)
         : TMutableRange<T>(elements)
         , Holder_(std::move(holder))
     { }
 
     //! Constructs a TSharedMutableRange from an std::vector.
-    TSharedMutableRange(std::vector<T>& elements, ISharedRangeHolderPtr holder)
+    TSharedMutableRange(std::vector<T>& elements, TSharedRangeHolderPtr holder)
         : TMutableRange<T>(elements)
         , Holder_(std::move(holder))
     { }
 
     //! Constructs a TSharedMutableRange from a C array.
     template <size_t N>
-    TSharedMutableRange(T (& elements)[N], ISharedRangeHolderPtr holder)
+    TSharedMutableRange(T (& elements)[N], TSharedRangeHolderPtr holder)
         : TMutableRange<T>(elements)
         , Holder_(std::move(holder))
     { }
@@ -259,25 +269,25 @@ public:
         return TSharedMutableRange<T>(begin, end, Holder_);
     }
 
-    ISharedRangeHolderPtr GetHolder() const
+    TSharedRangeHolderPtr GetHolder() const
     {
         return Holder_;
     }
 
-    ISharedRangeHolderPtr&& ReleaseHolder()
+    TSharedRangeHolderPtr&& ReleaseHolder()
     {
         return std::move(Holder_);
     }
 
 protected:
-    ISharedRangeHolderPtr Holder_;
+    TSharedRangeHolderPtr Holder_;
 };
 
 template <class T, class TContainer, class... THolders>
 TSharedMutableRange<T> DoMakeSharedMutableRange(TContainer&& elements, THolders&&... holders)
 {
     struct THolder
-        : public ISharedRangeHolder
+        : public TSharedRangeHolder
     {
         typename std::decay<TContainer>::type Elements;
         std::tuple<typename std::decay<THolders>::type...> Holders;