🎨 更改为libmemdb

libmemdb/.gitignore

@@ -0,0 +1,69 @@
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Linker files
+*.ilk
+
+# Debugger Files
+*.pdb
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+*.so.*
+
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+# Build directories
+build/
+Build/
+build-*/
+
+# CMake generated files
+CMakeFiles/
+CMakeCache.txt
+cmake_install.cmake
+#Makefile
+install_manifest.txt
+compile_commands.json
+
+# Temporary files
+*.tmp
+*.log
+*.bak
+*.swp
+
+# vcpkg
+vcpkg_installed/
+
+# debug information files
+*.dwo
+
+# test output & cache
+Testing/
+.cache/

libmemdb/Makefile

@@ -0,0 +1,25 @@
+VERSION := 1.0.0
+FRAMEWORK_NAME := us
+LIB_NAME := libus_memdb
+INSTL_TDIR := /lib
+INCLU_TDIR := /usr/include
+INCLU_SDIR := inc
+CPP := g++
+INCS := -I inc
+CPPFLAGS := --std=c++20 -O3 -pipe -Wall -Werror
+LIBS :=
+BUILD_TDIR := build
+$(shell mkdir -p $(BUILD_TDIR))
+
+
+
+install:
+	@echo "install UniServe_libmemdb..."
+	@mkdir -vp $(INCLU_TDIR)/${FRAMEWORK_NAME}
+	@cp -vf $(INCLU_SDIR)/$(FRAMEWORK_NAME)/memdb.hpp $(INCLU_TDIR)/$(FRAMEWORK_NAME)/
+	@echo "done."
+
+uninstall:
+	@echo "uninstall UniServe_libmemdb..."
+	@rm -vf $(INCLU_TDIR)/$(FRAMEWORK_NAME)/memdb.hpp
+	@echo "done."

libmemdb/README.md

@@ -0,0 +1,5 @@
+# UniServe_libmemdb
+UniServe Framework memdb Library
+
+# Dependancy
+libmemdb-dev

libmemdb/_set.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+cd "$(dirname "$0")" || exit
+make install

libmemdb/inc/us/memdb.hpp

@@ -0,0 +1,156 @@
+#pragma once
+#include <list>
+#include <unordered_map>
+#include <chrono>
+#include <set>
+#include <optional>
+#include <cmath>
+
+
+
+namespace shufeng2012 {
+
+
+
+template <typename T, typename U>
+
+class Memdb {
+
+
+struct memdb_column {
+    T key;
+    U value;
+    std::chrono::system_clock::time_point timestamp;
+};
+
+struct index_keys {
+    T key;
+    std::list <memdb_column>::iterator item;
+};
+
+struct index_timestamp {
+    std::list <memdb_column>::iterator item;
+
+    bool operator<(const index_timestamp& a) const {
+        return this -> item -> timestamp < a.item -> timestamp;
+    }
+};
+
+
+private:
+    std::list <memdb_column> db;
+    std::unordered_map <T, index_keys> keys;
+    std::multiset <index_timestamp> time_touch;
+    size_t __size = 0;
+    int MAX_TIME = 60 * 10;       // 10分钟
+    void flush();
+
+
+
+public:
+    using key_t = T;
+    using value_t = U;
+    static constexpr bool fail = false;
+    static constexpr bool succ = true;
+
+
+
+    Memdb() = default;
+    Memdb(int max_time) : MAX_TIME(std::max(0, max_time)) {}
+    Memdb& operator=(const Memdb& to_be_cp_memdb) = default;
+    ~Memdb() = default;
+
+
+    size_t size() const {
+        return this -> __size;
+    }
+
+    const std::unordered_map <T, index_keys>& get_keys() const {
+        return this -> keys;
+    }
+
+    const std::list <memdb_column>& get_db() const {
+        return this -> db;
+    }
+
+    const std::multiset <typename Memdb <T, U>::index_timestamp>& get_time_touch() const {
+        return this -> time_touch;
+    }
+
+
+    bool 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;
+    }
+
+    bool 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;
+        this -> keys.erase(it -> key);
+        this -> time_touch.erase({it});
+        this -> db.erase(it);
+        this -> __size--;
+
+        return this -> succ;
+    }
+
+    bool update(key_t to_be_udt_k, value_t udt_v, bool need_to_udt_timetouch=false) {
+        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();
+            T copy_k = it -> key;
+            U copy_v = it -> value;
+            this -> remove(copy_k);
+            this -> insert(copy_k, copy_v);
+        }
+
+        return this -> succ;
+    }
+
+    std::optional<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;
+    }
+};
+
+
+
+}