From 027e9a8f1eb4a1064edc8462d03704cc56cc603b Mon Sep 17 00:00:00 2001
From: vng <viktor.govako@gmail.com>
Date: Thu, 23 Jul 2015 19:24:58 +0300
Subject: [PATCH] [mwm set] Avoid shared_ptr for MwmValue instances.

---
 indexer/mwm_set.cpp | 30 +++++++++++++++++-------------
 indexer/mwm_set.hpp | 20 ++++++++++----------
 2 files changed, 27 insertions(+), 23 deletions(-)

diff --git a/indexer/mwm_set.cpp b/indexer/mwm_set.cpp
index de4cca4335..fde4d1f85f 100644
--- a/indexer/mwm_set.cpp
+++ b/indexer/mwm_set.cpp
@@ -43,16 +43,17 @@ MwmSet::MwmHandle::MwmHandle(MwmSet & mwmSet, MwmId const & mwmId)
 {
 }
 
-MwmSet::MwmHandle::MwmHandle(MwmSet & mwmSet, MwmId const & mwmId, TMwmValueBasePtr value)
+MwmSet::MwmHandle::MwmHandle(MwmSet & mwmSet, MwmId const & mwmId, TMwmValuePtr value)
     : m_mwmSet(&mwmSet), m_mwmId(mwmId), m_value(value)
 {
 }
 
 MwmSet::MwmHandle::MwmHandle(MwmHandle && handle)
-    : m_mwmSet(handle.m_mwmSet), m_mwmId(handle.m_mwmId), m_value(move(handle.m_value))
+    : m_mwmSet(handle.m_mwmSet), m_mwmId(handle.m_mwmId), m_value(handle.m_value)
 {
   handle.m_mwmSet = nullptr;
   handle.m_mwmId.Reset();
+  handle.m_value = nullptr;
 }
 
 MwmSet::MwmHandle::~MwmHandle()
@@ -188,13 +189,13 @@ void MwmSet::GetMwmsInfo(vector<shared_ptr<MwmInfo>> & info) const
   }
 }
 
-MwmSet::TMwmValueBasePtr MwmSet::LockValue(MwmId const & id)
+MwmSet::TMwmValuePtr MwmSet::LockValue(MwmId const & id)
 {
   lock_guard<mutex> lock(m_lock);
   return LockValueImpl(id);
 }
 
-MwmSet::TMwmValueBasePtr MwmSet::LockValueImpl(MwmId const & id)
+MwmSet::TMwmValuePtr MwmSet::LockValueImpl(MwmId const & id)
 {
   CHECK(id.IsAlive(), (id));
   shared_ptr<MwmInfo> info = id.GetInfo();
@@ -211,26 +212,25 @@ MwmSet::TMwmValueBasePtr MwmSet::LockValueImpl(MwmId const & id)
   {
     if (it->first == id)
     {
-      TMwmValueBasePtr result = it->second;
+      TMwmValuePtr result = it->second;
       m_cache.erase(it);
       return result;
     }
   }
 
-  return TMwmValueBasePtr(CreateValue(*info));
+  return TMwmValuePtr(CreateValue(*info));
 }
 
-void MwmSet::UnlockValue(MwmId const & id, TMwmValueBasePtr p)
+void MwmSet::UnlockValue(MwmId const & id, TMwmValuePtr p)
 {
   lock_guard<mutex> lock(m_lock);
   UnlockValueImpl(id, p);
 }
 
-void MwmSet::UnlockValueImpl(MwmId const & id, TMwmValueBasePtr p)
+void MwmSet::UnlockValueImpl(MwmId const & id, TMwmValuePtr p)
 {
-  ASSERT(id.IsAlive(), ());
-  ASSERT(p.get() != nullptr, (id));
-  if (!id.IsAlive() || p.get() == nullptr)
+  ASSERT(id.IsAlive() && p, (id));
+  if (!id.IsAlive() || !p)
     return;
 
   shared_ptr<MwmInfo> const & info = id.GetInfo();
@@ -248,7 +248,9 @@ void MwmSet::UnlockValueImpl(MwmId const & id, TMwmValueBasePtr p)
     if (m_cache.size() > m_cacheSize)
     {
       ASSERT_EQUAL(m_cache.size(), m_cacheSize + 1, ());
+      auto p = m_cache.front();
       m_cache.pop_front();
+      delete p.second;
     }
   }
 }
@@ -289,7 +291,7 @@ MwmSet::MwmHandle MwmSet::GetMwmHandleById(MwmId const & id)
 
 MwmSet::MwmHandle MwmSet::GetMwmHandleByIdImpl(MwmId const & id)
 {
-  TMwmValueBasePtr value(nullptr);
+  TMwmValuePtr value(nullptr);
   if (id.IsAlive())
     value = LockValueImpl(id);
   return MwmHandle(*this, id, value);
@@ -297,13 +299,15 @@ MwmSet::MwmHandle MwmSet::GetMwmHandleByIdImpl(MwmId const & id)
 
 void MwmSet::ClearCacheImpl(CacheType::iterator beg, CacheType::iterator end)
 {
+  for (auto i = beg; i != end; ++i)
+    delete i->second;
   m_cache.erase(beg, end);
 }
 
 void MwmSet::ClearCache(MwmId const & id)
 {
   ClearCacheImpl(RemoveIfKeepValid(m_cache.begin(), m_cache.end(),
-  [&id] (pair<MwmSet::MwmId, MwmSet::TMwmValueBasePtr> const & p)
+  [&id] (pair<MwmSet::MwmId, MwmSet::TMwmValuePtr> const & p)
   {
     return (p.first == id);
   }),
diff --git a/indexer/mwm_set.hpp b/indexer/mwm_set.hpp
index a63a24905a..67e00fb6c5 100644
--- a/indexer/mwm_set.hpp
+++ b/indexer/mwm_set.hpp
@@ -112,7 +112,7 @@ public:
     virtual ~MwmValueBase() = default;
   };
 
-  using TMwmValueBasePtr = shared_ptr<MwmValueBase>;
+  using TMwmValuePtr = MwmValueBase *;
 
   // Mwm handle, which is used to refer to mwm and prevent it from
   // deletion when its FileContainer is used.
@@ -128,10 +128,10 @@ public:
     template <typename T>
     inline T * GetValue() const
     {
-      return static_cast<T *>(m_value.get());
+      return static_cast<T *>(m_value);
     }
 
-    inline bool IsAlive() const { return m_value.get() != nullptr; }
+    inline bool IsAlive() const { return m_value; }
     inline MwmId const & GetId() const { return m_mwmId; }
     shared_ptr<MwmInfo> const & GetInfo() const;
 
@@ -140,11 +140,11 @@ public:
   private:
     friend class MwmSet;
 
-    MwmHandle(MwmSet & mwmSet, MwmId const & mwmId, TMwmValueBasePtr value);
+    MwmHandle(MwmSet & mwmSet, MwmId const & mwmId, TMwmValuePtr value);
 
     MwmSet * m_mwmSet;
     MwmId m_mwmId;
-    TMwmValueBasePtr m_value;
+    TMwmValuePtr m_value;
 
     DISALLOW_COPY(MwmHandle);
   };
@@ -215,15 +215,15 @@ protected:
   virtual MwmValueBase * CreateValue(MwmInfo & info) const = 0;
 
 private:
-  typedef deque<pair<MwmId, TMwmValueBasePtr>> CacheType;
+  typedef deque<pair<MwmId, TMwmValuePtr>> CacheType;
 
   /// @precondition This function is always called under mutex m_lock.
   MwmHandle GetMwmHandleByIdImpl(MwmId const & id);
 
-  TMwmValueBasePtr LockValue(MwmId const & id);
-  TMwmValueBasePtr LockValueImpl(MwmId const & id);
-  void UnlockValue(MwmId const & id, TMwmValueBasePtr p);
-  void UnlockValueImpl(MwmId const & id, TMwmValueBasePtr p);
+  TMwmValuePtr LockValue(MwmId const & id);
+  TMwmValuePtr LockValueImpl(MwmId const & id);
+  void UnlockValue(MwmId const & id, TMwmValuePtr p);
+  void UnlockValueImpl(MwmId const & id, TMwmValuePtr p);
 
   /// Do the cleaning for [beg, end) without acquiring the mutex.
   /// @precondition This function is always called under mutex m_lock.