⚡️ 将queue切换为set

memdb/include/memdb.hpp

@@ -1,14 +1,15 @@
 #pragma once
-#include <memory>
 #include <list>
 #include <unordered_map>
 #include <chrono>
-#include <queue>
 #include <set>
 #include <optional>
+#include <cmath>
 
 
 
+namespace shufeng2012 {
+
 template <typename T, typename U>
 
 class Memdb {
@@ -18,7 +19,6 @@ struct memdb_column {
     T key;
     U value;
     std::chrono::system_clock::time_point timestamp;
-    bool be_del = false;
 };
 
 struct index_keys {
@@ -36,15 +36,10 @@ struct index_timestamp {
 private:
     std::list <memdb_column> db;
     std::unordered_map <T, index_keys> keys;
-    std::priority_queue <index_timestamp> time_touch;
+    std::multiset <index_timestamp> time_touch;
-    std::multiset <index_timestamp> time_touch_;
     size_t __size = 0;
     int MAX_TIME = 60 * 10;       // 10分钟
     void flush();
-    void update_queue();
-
-    // 内测版
-    void flush_();
 
 
 public:
@@ -61,17 +56,11 @@ public:
     size_t size() const;
     const std::unordered_map <T, index_keys>& get_keys() const;
     const std::list <memdb_column>& get_db() const;
-    const std::priority_queue <index_timestamp>& get_time_touch() const;
+    const std::multiset <typename Memdb <T, U>::index_timestamp>& get_time_touch() const;
 
     bool insert(key_t to_be_ins_k, value_t ins_v);
     bool remove(key_t to_be_del_k);
     bool update(key_t to_be_udt_k, value_t udt_v, bool need_to_udt_timetouch=false);
     std::optional<U> search(key_t to_be_sch_k);
-
+};
-    // 内测版
+}
-    const std::multiset <index_timestamp>& get_time_touch_() const;
-    bool insert_(key_t to_be_ins_k, value_t ins_v);
-    bool remove_(key_t to_be_del_k);
-    bool update_(key_t to_be_udt_k, value_t udt_v, bool need_to_udt_timetouch=false);
-    std::optional<U> search_(key_t to_be_sch_k);
-};

memdb/src/main/memdb.cpp

@@ -2,46 +2,11 @@
 
 
 
+namespace shufeng2012 {
 template <typename T, typename U>
 
 bool Memdb <T, U>::index_timestamp::operator<(const index_timestamp& a) const {
-    return this -> item -> timestamp > a.item -> timestamp;
+    return this -> item -> timestamp < a.item -> timestamp;
-}
-
-
-template <typename T, typename U>
-
-void Memdb <T, U>::flush() {
-    if (this -> time_touch.empty() == true) {
-        return;
-    }
-    std::chrono::system_clock::time_point now_time = std::chrono::system_clock::now();
-    typename std::list <memdb_column>::iterator it = this -> time_touch.top().item;
-
-    while (now_time > it -> timestamp || it -> be_del == true) {
-        if (it -> be_del != true) this -> __size--;
-        this -> keys.erase(it -> key);
-		this -> time_touch.pop();
-        this -> db.erase(it);
-
-        if (this -> time_touch.empty() == true) {
-            return;
-        }
-        it = this -> time_touch.top().item;
-        now_time = std::chrono::system_clock::now();
-    }
-}
-
-
-template <typename T, typename U>
-
-void Memdb <T, U>::update_queue() {
-    std::priority_queue <index_timestamp> new_time_touch;
-    while (this -> time_touch.empty() == false) {
-        new_time_touch.push(this -> time_touch.top());
-        this -> time_touch.pop();
-    }
-    this -> time_touch = new_time_touch;
 }
 
 
@@ -52,7 +17,7 @@ Memdb <T, U>::Memdb() = default;
 
 template <typename T, typename U>
 
-Memdb <T, U>::Memdb(int max_time) : MAX_TIME(max_time) {}
+Memdb <T, U>::Memdb(int max_time) : MAX_TIME(std::max(0, max_time)) {}
 
 
 template <typename T, typename U>
@@ -86,13 +51,42 @@ const std::list <typename Memdb <T, U>::memdb_column>& Memdb <T, U>::get_db() co
 }
 
 
+/*
+内测版
+*/
+
+
 template <typename T, typename U>
 
-const std::priority_queue <typename Memdb <T, U>::index_timestamp>& Memdb <T, U>::get_time_touch() const {
+void Memdb <T, U>::flush() {
-    return this -> time_touch;
+    if (this -> time_touch.empty() == true) {
+        return;
+    }
+    std::chrono::system_clock::time_point now_time = std::chrono::system_clock::now();
+    typename std::list <memdb_column>::iterator it = this -> time_touch.begin() -> item;
+
+    while (now_time >= it -> timestamp) {
+        this -> __size--;
+        key_t to_be_del_k = it -> key;
+        this -> db.erase(it);
+        this -> keys.erase(to_be_del_k);
+		this -> time_touch.erase(this -> time_touch.begin());
+
+        if (this -> time_touch.empty() == true) {
+            return;
+        }
+        it = this -> time_touch.begin() -> item;
+        now_time = std::chrono::system_clock::now();
+    }
 }
 
 
+template <typename T, typename U>
+
+const std::multiset <typename Memdb <T, U>::index_timestamp>& Memdb <T, U>::get_time_touch() const {
+    return this -> time_touch;
+}
+
 
 template <typename T, typename U>
 
@@ -117,7 +111,7 @@ bool Memdb <T, U>::insert(key_t to_be_ins_k, value_t ins_v) {
 
     Memdb::index_timestamp new_time_touch;
     new_time_touch.item = std::prev(this -> db.end());
-    this -> time_touch.push(new_time_touch);
+    this -> time_touch.insert(new_time_touch);
 
     this -> __size++;
 
@@ -128,14 +122,17 @@ bool Memdb <T, U>::insert(key_t to_be_ins_k, value_t ins_v) {
 template <typename T, typename U>
 
 bool Memdb <T, U>::remove(key_t to_be_del_k) {
+    //! 直接删除，不要lazy
     this -> flush();
     if (this -> keys.find(to_be_del_k) == this -> keys.end()) {
         return this -> fail;
     }
 
     typename std::list <memdb_column>::iterator it = this -> keys[to_be_del_k].item;
-    it -> be_del = true;
+    // it -> be_del = true;
     this -> keys.erase(it -> key);
+    this -> time_touch.erase({it});
+    this -> db.erase(it);
     this -> __size--;
 
     return this -> succ;
@@ -145,6 +142,7 @@ bool Memdb <T, U>::remove(key_t to_be_del_k) {
 template <typename T, typename U>
 
 bool Memdb <T, U>::update(key_t to_be_udt_k, value_t udt_v, bool need_to_udt_timetouch) {
+    //! 先删再加
     this -> flush();
     if (this -> keys.find(to_be_udt_k) == this -> keys.end()) {
         return this -> fail;
@@ -154,8 +152,10 @@ bool Memdb <T, U>::update(key_t to_be_udt_k, value_t udt_v, bool need_to_udt_tim
     it -> value = udt_v;
     if (need_to_udt_timetouch == true) {
         std::chrono::system_clock::time_point now_time = std::chrono::system_clock::now();
-        it -> timestamp = now_time + std::chrono::seconds(MAX_TIME);
+        T copy_k = it -> key;
-        this -> update_queue();
+        U copy_v = it -> value;
+        this -> remove(copy_k);
+        this -> insert(copy_k, copy_v);
     }
 
     return this -> succ;
@@ -174,119 +174,4 @@ std::optional<U> Memdb <T, U>::search(key_t to_be_sch_k){
     return it -> value;
 }
 
-
-/*
-内测版
-*/
-
-
-template <typename T, typename U>
-
-void Memdb <T, U>::flush_() {
-    if (this -> time_touch_.empty() == true) {
-        return;
-    }
-    std::chrono::system_clock::time_point now_time = std::chrono::system_clock::now();
-    typename std::list <memdb_column>::iterator it = this -> time_touch_.begin() -> item;
-
-    while (now_time > it -> timestamp || it -> be_del == true) {
-        if (it -> be_del != true) this -> __size--;
-        key_t to_be_del_k = it -> key;
-        this -> db.erase(it);
-        this -> keys.erase(to_be_del_k);
-		this -> time_touch_.erase(this -> time_touch_.begin());
-
-        if (this -> time_touch_.empty() == true) {
-            return;
-        }
-        it = this -> time_touch_.begin() -> item;
-        now_time = std::chrono::system_clock::now();
-    }
-}
-
-
-template <typename T, typename U>
-
-const std::multiset <typename Memdb <T, U>::index_timestamp>& Memdb <T, U>::get_time_touch_() const {
-    return this -> time_touch_;
-}
-
-
-template <typename T, typename U>
-
-bool Memdb <T, U>::insert_(key_t to_be_ins_k, value_t ins_v) {
-    this -> flush_();
-    if (this -> keys.find(to_be_ins_k) != this -> keys.end()) {
-        return this -> fail;
-    }
-
-    std::chrono::system_clock::time_point now_time = std::chrono::system_clock::now();
-
-    Memdb::memdb_column new_column;
-    new_column.key = to_be_ins_k;
-    new_column.value = ins_v;
-    new_column.timestamp = now_time + std::chrono::seconds(MAX_TIME);
-    this -> db.push_back(new_column);
-
-    Memdb::index_keys new_key;
-    new_key.key = to_be_ins_k;
-    new_key.item = std::prev(this -> db.end());
-    this -> keys[to_be_ins_k] = new_key;
-
-    Memdb::index_timestamp new_time_touch;
-    new_time_touch.item = std::prev(this -> db.end());
-    this -> time_touch_.insert(new_time_touch);
-
-    this -> __size++;
-
-    return this -> succ;
-}
-
-
-template <typename T, typename U>
-
-bool Memdb <T, U>::remove_(key_t to_be_del_k) {
-    this -> flush_();
-    if (this -> keys.find(to_be_del_k) == this -> keys.end()) {
-        return this -> fail;
-    }
-
-    typename std::list <memdb_column>::iterator it = this -> keys[to_be_del_k].item;
-    it -> be_del = true;
-    this -> keys.erase(it -> key);
-    this -> __size--;
-
-    return this -> succ;
-}
-
-
-template <typename T, typename U>
-
-bool Memdb <T, U>::update_(key_t to_be_udt_k, value_t udt_v, bool need_to_udt_timetouch) {
-    this -> flush_();
-    if (this -> keys.find(to_be_udt_k) == this -> keys.end()) {
-        return this -> fail;
-    }
-
-    typename std::list <memdb_column>::iterator it = this -> keys[to_be_udt_k].item;
-    it -> value = udt_v;
-    if (need_to_udt_timetouch == true) {
-        std::chrono::system_clock::time_point now_time = std::chrono::system_clock::now();
-        it -> timestamp = now_time + std::chrono::seconds(MAX_TIME);
-    }
-
-    return this -> succ;
-}
-
-
-template <typename T, typename U>
-
-std::optional<U> Memdb <T, U>::search_(key_t to_be_sch_k){
-    this -> flush_();
-    if (this -> keys.find(to_be_sch_k) == this -> keys.end()) {
-        return std::nullopt;
-    }
-
-    typename std::list <memdb_column>::iterator it = this -> keys[to_be_sch_k].item;
-    return it -> value;
 }