feat: callback manager

Author: MiemieMethod

src/callback/CallbackManager.hpp

@@ -0,0 +1,117 @@
+#include <algorithm>
+#include <any>
+#include <functional>
+#include <iostream>
+#include <map>
+#include <mutex>
+#include <shared_mutex>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <vector>
+
+namespace primordial_core {
+
+template <typename T>
+struct function_traits;
+
+template <typename R, typename... Args>
+struct function_traits<R (*)(Args...)> {
+    using args_type = std::tuple<Args...>;
+};
+
+template <typename R, typename... Args>
+struct function_traits<std::function<R(Args...)>> {
+    using args_type = std::tuple<Args...>;
+};
+
+template <typename C, typename R, typename... Args>
+struct function_traits<R (C::*)(Args...) const> {
+    using args_type = std::tuple<Args...>;
+};
+
+template <typename T>
+struct function_traits : public function_traits<decltype(&T::operator())> {};
+
+class CallbackManager {
+    template <typename... Args>
+    struct CallbackList {
+        struct Entry {
+            int                          priority;
+            std::function<void(Args...)> func;
+            uint64_t                     id;
+
+            static bool compare(const Entry& a, const Entry& b) {
+                return a.priority > b.priority;
+            }
+        };
+        std::vector<Entry> list;
+
+        void add(int p, std::function<void(Args...)> f, uint64_t id) {
+            list.push_back({p, std::move(f), id});
+            std::stable_sort(list.begin(), list.end(), Entry::compare);
+        }
+
+        void invoke(Args... args) const {
+            for (const auto& e : list) {
+                e.func(args...);
+            }
+        }
+    };
+
+    std::map<std::string, std::any> events;
+    mutable std::shared_mutex       mutex;
+    uint64_t                        next_id = 0;
+
+    template <typename... Args>
+    void register_impl(const std::string& name, std::function<void(Args...)> f, int p) {
+        std::unique_lock lock(mutex);
+        using ListT = CallbackList<Args...>;
+
+        if (events.find(name) == events.end()) {
+            events[name] = ListT{};
+        }
+
+        try {
+            auto& container = std::any_cast<ListT&>(events[name]);
+            container.add(p, std::move(f), ++next_id);
+        } catch (const std::bad_any_cast&) {
+            throw std::runtime_error("Signature mismatch for event: " + name);
+        }
+    }
+
+    template <typename Callable, typename... Args>
+    void deduce_and_register(const std::string& name, Callable&& c, int p, std::tuple<Args...>) {
+        std::function<void(Args...)> f = std::forward<Callable>(c);
+        register_impl<Args...>(name, std::move(f), p);
+    }
+
+public:
+    template <typename Callable>
+    void addCallback(const std::string& name, Callable&& cb, int priority = 0) {
+        using traits = function_traits<std::decay_t<Callable>>;
+        using ArgsT  = typename traits::args_type;
+        deduce_and_register(name, std::forward<Callable>(cb), priority, ArgsT{});
+    }
+
+    template <typename... Args>
+    void invokeCallback(const std::string& name, Args&&... args) {
+        std::shared_lock lock(mutex);
+        auto             it = events.find(name);
+        if (it == events.end()) {
+            std::cerr << "Warning: Event '" << name << "' not found\n";
+            return;
+        }
+
+        using ListT = CallbackList<std::decay_t<Args>...>;
+
+        try {
+            const auto& container = std::any_cast<const ListT&>(it->second);
+            container.invoke(std::forward<Args>(args)...);
+        } catch (const std::bad_any_cast&) {
+            std::cerr << "Error: Invoke arguments do not match stored signature for '" << name << "'\n";
+        }
+    }
+};
+
+} // namespace primordial_core

src/mod/PrimordialCore.cpp

@@ -1,4 +1,5 @@
 #include "mod/PrimordialCore.h"
+#include "callback/CallbackManager.hpp"
 
 #include "ll/api/mod/RegisterHelper.h"
 
@@ -12,6 +13,33 @@ PrimordialCore& PrimordialCore::getInstance() {
 bool PrimordialCore::load() {
     getSelf().getLogger().debug("Loading...");
     // Code for loading the mod goes here.
+
+    CallbackManager mgr;
+
+    // 添加不同签名的事件
+    mgr.addCallback(
+        "OnLogin",
+        [](std::string user, int age) { std::cout << "[User] " << user << " logged in. Age: " << age << "\n"; },
+        10
+    );
+
+    mgr.addCallback("OnSystem", [](int code) { std::cout << "Code: " << code << "\n"; });
+
+    // 高优先级测试
+    mgr.addCallback(
+        "OnLogin",
+        [](std::string user, int) { std::cout << "[Admin] Priority check for " << user << "\n"; },
+        100
+    );
+
+    // 调用
+    std::cout << "--- Triggering Login ---\n";
+    // 注意：必须显式构造std::string，否则推导为const char*导致类型不匹配
+    mgr.invokeCallback("OnLogin", std::string("Alice"), 25);
+
+    std::cout << "\n--- Triggering System ---\n";
+    mgr.invokeCallback("OnSystem", 404);
+
     return true;
 }
 
@@ -27,6 +55,12 @@ bool PrimordialCore::disable() {
     return true;
 }
 
+bool PrimordialCore::unload() {
+    getSelf().getLogger().debug("Unloading...");
+    // Code for unloading the mod goes here.
+    return true;
+}
+
 } // namespace primordial_core
 
 LL_REGISTER_MOD(primordial_core::PrimordialCore, primordial_core::PrimordialCore::getInstance());

src/mod/PrimordialCore.h

@@ -22,9 +22,8 @@ class PrimordialCore {
     /// @return True if the mod is disabled successfully.
     bool disable();
 
-    // TODO: Implement this method if you need to unload the mod.
-    // /// @return True if the mod is unloaded successfully.
-    // bool unload();
+    // @return True if the mod is unloaded successfully.
+    bool unload();
 
 private:
     ll::mod::NativeMod& mSelf;