refactoring

Author: hzhdlrp

libraries/multi-index-lru/include/userver/multi-index-lru/container.hpp

@@ -110,6 +110,11 @@ class Container {
         return container_.template get<Tag>();
     }
 
+    template <typename IterT>
+    auto project_to_sequenced(IterT it) {
+        return container_.template project<0>(it);
+    }
+
     template <typename V, typename I, typename A>
     friend class ExpirableContainer;
 };

libraries/multi-index-lru/include/userver/multi-index-lru/expirable_container.hpp

@@ -7,7 +7,7 @@
 #include <cassert> 
 #include <shared_mutex>
 #include <mutex>
-#include <optional>
+#include <vector>
 
 #include "impl/mpl_helpers.hpp"
 #include "container.hpp"
@@ -63,19 +63,33 @@ class ExpirableContainer {
     bool insert(Value&& value) { return emplace(std::move(value)).second; }
 
     template <typename Tag, typename Key>
-    std::optional<Value> get(const Key& key) {
+    std::vector<Value> get(const Key& key) {
+        auto now = std::chrono::steady_clock::now();
         std::lock_guard<userver::engine::SharedMutex> lock(mutex_);
-        auto it = find<Tag, Key>(lock, key);
-        if (it == end<Tag>()) {
-            return std::nullopt;
+        
+        std::vector<Value> result;
+        auto& index = container_.template get_index<Tag>();
+        
+        if constexpr (impl::is_unique_index<decltype(index)>::value) {
+            auto it = find<Tag, Key>(lock, key, now);
+            if (it != container_.template end<Tag>()) {
+                result.push_back(it->value);
+            }
+        } else {
+            auto range = find_range<Tag, Key>(lock, key, now);
+            for (auto it = range.first; it != range.second; ++it) {
+                result.push_back(it->value);
+            }
         }
-        return *it;
+        
+        return result;
     }
 
     template <typename Tag, typename Key>
     bool contains(const Key& key) {
+        auto now = std::chrono::steady_clock::now();
         std::lock_guard<userver::engine::SharedMutex> lock(mutex_);
-        return this->template find<Tag, Key>(lock, key) != container_.template end<Tag>();
+        return find<Tag, Key>(lock, key, now) != container_.template end<Tag>();
     }
 
     template <typename Tag, typename Key>
@@ -117,19 +131,55 @@ class ExpirableContainer {
     using CacheContainer = Container<CacheItem, IndexSpecifierList, Allocator>;
 
     template <typename Tag, typename Key>
-    auto find(std::lock_guard<userver::engine::SharedMutex>&, const Key& key) {
+    auto find(std::lock_guard<userver::engine::SharedMutex>&, 
+                   const Key& key, 
+                   std::chrono::steady_clock::time_point now) {
         auto it = container_.template find<Tag, Key>(key);
 
-        if (it != container_.template end<Tag>()) {
-            if (std::chrono::steady_clock::now() > it->last_accessed + ttl_) {
+        if (it != end<Tag>()) {
+            if (now > it->last_accessed + ttl_) {
                 container_.template get_index<Tag>().erase(it);
-                return impl::TimestampedIteratorWrapper{container_.template end<Tag>()};
+                return end<Tag>();
+            } else {
+                it->last_accessed = now;
             }
-
-            it->last_accessed = std::chrono::steady_clock::now();
         }
+        
+        return it;
+    }
 
-        return impl::TimestampedIteratorWrapper{it};
+    template <typename Tag, typename Key>
+    auto find_range(std::lock_guard<userver::engine::SharedMutex>&,
+                    const Key& key,
+                    std::chrono::steady_clock::time_point now) {
+        auto& index = container_.template get_index<Tag>();
+        auto [begin, end] = index.equal_range(key);
+        
+        auto it = begin;
+        std::vector<decltype(it)> to_erase;
+        std::vector<decltype(it)> to_move;
+        
+        while (it != end) {
+            if (now > it->last_accessed + ttl_) {
+                to_erase.push_back(it);
+                ++it;
+            } else {
+                it->last_accessed = now;
+                to_move.push_back(it);
+                ++it;
+            }
+        }
+        
+        for (auto erase_it : to_erase) {
+            index.erase(erase_it);
+        }
+        
+        auto& seq_index = container_.get_sequensed();
+        for (auto move_it : to_move) {
+            seq_index.relocate(seq_index.begin(), container_.project_to_sequenced(move_it));
+        }
+        
+        return index.equal_range(key);
     }
 
     void cleanup() {
@@ -174,7 +224,6 @@ class ExpirableContainer {
     userver::engine::Task cleanup_task_; 
 };
 
-
 }  // namespace multi_index_lru
 
 USERVER_NAMESPACE_END

libraries/multi-index-lru/include/userver/multi-index-lru/impl/mpl_helpers.hpp

@@ -93,6 +93,20 @@ class TimestampedIteratorWrapper : public Iterator {
         return *(this->Iterator::operator->());
     }
 };
+
+template<typename T>
+struct is_unique_index {
+private:
+    template<typename U>
+    static auto test(int) -> decltype(std::declval<U>().find(std::declval<typename U::key_type>()), 
+                                      std::true_type{});
+    
+    template<typename>
+    static std::false_type test(...);
+    
+public:
+    static constexpr bool value = decltype(test<T>(0))::value;
+};
 } // namespace impl
 } // namespace multi_index_lru
 

libraries/multi-index-lru/src/expirable_container_test.cpp

@@ -59,18 +59,18 @@ UTEST_F(ExpirableUsersTest, BasicOperations) {
 
     // Test get by id
     auto by_id = cache.get<IdTag>(1);
-    EXPECT_TRUE(by_id.has_value());
-    EXPECT_EQ(by_id->name, "Alice");
+    EXPECT_FALSE(by_id.empty());
+    EXPECT_EQ(by_id.begin()->name, "Alice");
 
     // Test get by email
     auto by_email = cache.get<EmailTag>("bob@test.com");
-    EXPECT_TRUE(by_email.has_value());
-    EXPECT_EQ(by_email->id, 2);
+    EXPECT_FALSE(by_email.empty());
+    EXPECT_EQ(by_email.begin()->id, 2);
 
     // Test get by name
     auto by_name = cache.get<NameTag>("Charlie");
-    EXPECT_TRUE(by_name.has_value());
-    EXPECT_EQ(by_name->email, "charlie@test.com");
+    EXPECT_FALSE(by_name.empty());
+    EXPECT_EQ(by_name.begin()->email, "charlie@test.com");
 }
 
 UTEST_F(ExpirableUsersTest, LRUEviction) {