hikyuu 2.5.6__py3-none-win_amd64.whl → 2.6.1__py3-none-win_amd64.whl

hikyuu/include/hikyuu/strategy/Strategy.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <future>
+#include <forward_list>
 #include "hikyuu/DataType.h"
 #include "hikyuu/StrategyContext.h"
 #include "hikyuu/global/SpotRecord.h"
@@ -34,7 +35,8 @@ public:
     Strategy();
     explicit Strategy(const string& name, const string& config_file = "");
     Strategy(const vector<string>& codeList, const vector<KQuery::KType>& ktypeList,
-             const string& name = "Strategy", const string& config_file = "");
+             const unordered_map<string, int>& preloadNum = {}, const string& name = "Strategy",
+             const string& config_file = "");
     explicit Strategy(const StrategyContext& context, const string& name = "Strategy",
                       const string& config_file = "");
 
@@ -55,14 +57,16 @@ public:
         return m_context;
     }
 
+    bool running() const;
+
     /**
      * 每日开盘时间内，以 delta 为周期循环定时执行指定任务
      * @param func 待执行的任务
      * @param delta 间隔时间
-     * @param market 指定的市场
+     * @param market 指定的市场, 用于获取开/收盘时间
      * @param ignoreMarket 是否忽略市场时间限制，如为 true，则为定时循环不受开闭市时间限制
      */
-    void runDaily(std::function<void()>&& func, const TimeDelta& delta,
+    void runDaily(const std::function<void(Strategy*)>& func, const TimeDelta& delta,
                   const std::string& market = "SH", bool ignoreMarket = false);
 
     /**
@@ -71,7 +75,7 @@ public:
      * @param delta 指定时刻
      * @param ignoreHoliday 忽略节假日，即节假日不执行
      */
-    void runDailyAt(std::function<void()>&& func, const TimeDelta& delta,
+    void runDailyAt(const std::function<void(Strategy*)>& func, const TimeDelta& delta,
                     bool ignoreHoliday = true);
 
     /**
@@ -79,7 +83,8 @@ public:
      * @note 通常用于调试。且只要收到行情采集消息就会触发，不受开、闭市时间限制
      * @param changeFunc 回调函数
      */
-    void onChange(std::function<void(const Stock&, const SpotRecord& spot)>&& changeFunc);
+    void onChange(
+      const std::function<void(Strategy*, const Stock&, const SpotRecord& spot)>& changeFunc);
 
     /**
      * 一批行情数据接受完毕后通知
@@ -87,36 +92,108 @@ public:
      *       且只要收到行情采集消息就会触发，不受开、闭市时间限制。
      * @param recievedFucn 回调函数
      */
-    void onReceivedSpot(std::function<void(const Datetime&)>&& recievedFucn);
+    void onReceivedSpot(const std::function<void(Strategy*, const Datetime&)>& recievedFucn);
 
     /**
      * 启动策略执行，必须在已注册相关处理函数后执行
      */
     void start(bool autoRecieveSpot = true);
 
-private:
+    //==========================================================================
+    // 以下为策略运行时对外接口，建议使用这些接口代替同名其他功能函数，已保证回测和实盘一致
+    //==========================================================================
+
+    TradeManagerPtr getTM() const noexcept {
+        return m_tm;
+    }
+
+    void setTM(const TradeManagerPtr& tm) noexcept {
+        m_tm = tm;
+    }
+
+    /** 仅在回测状态下使用 */
+    SlippagePtr getSP() const noexcept {
+        return m_sp;
+    }
+
+    void setSP(const SlippagePtr& slippage) noexcept {
+        m_sp = slippage;
+    }
+
+    KData getLastKData(const Stock& stk, const Datetime& start_date, const KQuery::KType& ktype,
+                       KQuery::RecoverType recover_type = KQuery::NO_RECOVER) const {
+        return getKData(stk, start_date, Null<Datetime>(), ktype, recover_type);
+    }
+
+    KData getLastKData(const Stock& stk, size_t lastnum, const KQuery::KType& ktype,
+                       KQuery::RecoverType recover_type = KQuery::NO_RECOVER) const;
+
+    virtual KData getKData(const Stock& stk, const Datetime& start_date, const Datetime& end_date,
+                           const KQuery::KType& ktype,
+                           KQuery::RecoverType recover_type = KQuery::NO_RECOVER) const;
+    virtual Datetime today() const {
+        return Datetime::today();
+    }
+
+    virtual Datetime now() const {
+        return Datetime::now();
+    }
+
+    virtual Datetime nextDatetime() const {
+        return Null<Datetime>();
+    }
+
+    virtual TradeRecord buy(const Stock& stk, price_t price, double num, double stoploss = 0.0,
+                            double goal_price = 0.0,
+                            SystemPart part_from = SystemPart::PART_SIGNAL) {
+        HKU_ASSERT(m_tm);
+        return m_tm->buy(Datetime::now(), stk, price, num, stoploss, goal_price, price, part_from);
+    }
+
+    virtual TradeRecord sell(const Stock& stk, price_t price, double num, price_t stoploss = 0.0,
+                             price_t goal_price = 0.0,
+                             SystemPart part_from = SystemPart::PART_SIGNAL) {
+        HKU_ASSERT(m_tm);
+        return m_tm->sell(Datetime::now(), stk, price, num, stoploss, goal_price, price, part_from);
+    }
+
+    virtual bool isBacktesting() const {
+        return false;
+    }
+
+protected:
     string m_name;
     string m_config_file;
     StrategyContext m_context;
-    std::function<void(const Datetime&)> m_on_recieved_spot;
-    std::function<void(const Stock&, const SpotRecord& spot)> m_on_change;
+    TradeManagerPtr m_tm;
+    SlippagePtr m_sp;
+
+    std::function<void(Strategy*, const Datetime&)> m_on_recieved_spot;
+    std::function<void(Strategy*, const Stock&, const SpotRecord& spot)> m_on_change;
+
+    struct RunDailyAt {
+        std::function<void()> func;
+        TimeDelta delta;
+        string market;
+        bool ignoreMarket{false};
+    };
+    std::forward_list<RunDailyAt> m_run_daily_at_list;
+
+    std::unordered_map<TimeDelta, std::function<void()>> m_run_daily_at_funcs;
 
-    std::function<void()> m_run_daily_func;
-    TimeDelta m_run_daily_delta;
-    string m_run_daily_market;
-    bool m_ignoreMarket{false};
+protected:
+    static std::atomic_bool ms_keep_running;
 
-    std::map<TimeDelta, std::function<void()>> m_run_daily_at_funcs;
+protected:
+    void _init();
 
 private:
     void _initParam();
-    void _init();
     void _receivedSpot(const SpotRecord& spot);
     void _runDaily();
     void _runDailyAt();
 
 private:
-    static std::atomic_bool ms_keep_running;
     static void sig_handler(int sig);
 
     typedef FuncWrapper event_type;

hikyuu/include/hikyuu/trade_manage/TradeManagerBase.h

@@ -697,8 +697,10 @@ public:
     /**
      * 从订单代理实例同步当前账户资产信息（包含资金、持仓等）
      * @param broker 订单代理实例
+     * @param datetime 同步时，通常为当前时间（Null)，也可以强制为指定的时间点
      */
-    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker) {
+    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker,
+                                          const Datetime& datetime = Null<Datetime>()) {
         HKU_WARN("The subclass does not implement this method");
     }
 
@@ -706,7 +708,7 @@ protected:
     string m_name;            // 账户名称
     TradeCostPtr m_costfunc;  // 成本算法
 
-    Datetime m_broker_last_datetime;  // 订单代理最近一次执行操作的时刻,当前启动运行时间
+    Datetime m_broker_last_datetime;     // 订单代理最近一次执行操作的时刻,当前启动运行时间
     list<OrderBrokerPtr> m_broker_list;  // 订单代理列表
 
 //============================================

hikyuu/include/hikyuu/trade_sys/portfolio/Portfolio.h

@@ -116,7 +116,8 @@ private:
 
 protected:
     // 跟踪打印当前TM持仓情况
-    void traceMomentTM(const Datetime& date);
+    void traceMomentTMAfterRunAtOpen(const Datetime& date);
+    void traceMomentTMAfterRunAtClose(const Datetime& date);
 
 protected:
     string m_name;

hikyuu/include/hikyuu/trade_sys/selector/SelectorBase.h

@@ -87,6 +87,9 @@ public:
      */
     const SystemList& getRealSystemList() const;
 
+    /** 获取指定时刻收盘时选中的标的 */
+    SystemWeightList getSelected(Datetime date);
+
     /**
      * @brief 复位
      * @note 复位不会清除已有的原型系统
@@ -111,7 +114,7 @@ public:
     virtual void _calculate() = 0;
 
     /** 子类获取指定时刻收盘时选中的标的 */
-    virtual SystemWeightList getSelected(Datetime date) = 0;
+    virtual SystemWeightList _getSelected(Datetime date) = 0;
 
     virtual bool isMatchAF(const AFPtr& af) = 0;
 
@@ -141,7 +144,7 @@ protected:
     KQuery m_query;
     KQuery m_proto_query;
 
-    SystemList m_pro_sys_list;  // 原型系统列表
+    SystemList m_pro_sys_list;   // 原型系统列表
     SystemList m_real_sys_list;  // PF组合中实际运行的系统，有PF执行时设定，顺序与原型列表一一对应
 
 //============================================
@@ -197,13 +200,13 @@ private:                                                       \
 #define SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
 #endif
 
-#define SELECTOR_IMP(classname)                                   \
-public:                                                           \
-    virtual SelectorPtr _clone() override {                       \
-        return std::make_shared<classname>();                     \
-    }                                                             \
-    virtual SystemWeightList getSelected(Datetime date) override; \
-    virtual bool isMatchAF(const AFPtr& af) override;             \
+#define SELECTOR_IMP(classname)                                    \
+public:                                                            \
+    virtual SelectorPtr _clone() override {                        \
+        return std::make_shared<classname>();                      \
+    }                                                              \
+    virtual SystemWeightList _getSelected(Datetime date) override; \
+    virtual bool isMatchAF(const AFPtr& af) override;              \
     virtual void _calculate() override;
 
 /**

hikyuu/include/hikyuu/trade_sys/selector/imp/MultiFactorSelector.h

@@ -21,7 +21,7 @@ public:
     virtual void _checkParam(const string& name) const override;
     virtual void _reset() override;
     virtual SelectorPtr _clone() override;
-    virtual SystemWeightList getSelected(Datetime date) override;
+    virtual SystemWeightList _getSelected(Datetime date) override;
     virtual bool isMatchAF(const AFPtr& af) override;
     virtual void _calculate() override;
 

hikyuu/include/hikyuu/trade_sys/selector/imp/logic/OperatorSelector.h

@@ -22,7 +22,7 @@ public:
     virtual SelectorPtr _clone() override;
     virtual bool isMatchAF(const AFPtr& af) override;
     virtual void _calculate() override;
-    virtual SystemWeightList getSelected(Datetime date) override {
+    virtual SystemWeightList _getSelected(Datetime date) override {
         return SystemWeightList();
     }
 
@@ -80,17 +80,17 @@ private:
 #endif
 };
 
-#define OPERATOR_SELECTOR_IMP(classname, name)                    \
-public:                                                           \
-    classname() : OperatorSelector(name) {}                       \
-    classname(const SelectorPtr& se1, const SelectorPtr& se2)     \
-    : OperatorSelector(name, se1, se2) {}                         \
-    virtual ~classname() {}                                       \
-                                                                  \
-    virtual SystemWeightList getSelected(Datetime date) override; \
-                                                                  \
-    virtual SelectorPtr _clone() override {                       \
-        HKU_THROW("OperatorSelector Could't support clone!");     \
+#define OPERATOR_SELECTOR_IMP(classname, name)                     \
+public:                                                            \
+    classname() : OperatorSelector(name) {}                        \
+    classname(const SelectorPtr& se1, const SelectorPtr& se2)      \
+    : OperatorSelector(name, se1, se2) {}                          \
+    virtual ~classname() {}                                        \
+                                                                   \
+    virtual SystemWeightList _getSelected(Datetime date) override; \
+                                                                   \
+    virtual SelectorPtr _clone() override {                        \
+        HKU_THROW("OperatorSelector Could't support clone!");      \
     }
 
 #if HKU_SUPPORT_SERIALIZATION

hikyuu/include/hikyuu/trade_sys/selector/imp/logic/OperatorValueSelector.h

@@ -22,7 +22,7 @@ public:
     virtual SelectorPtr _clone() override;
     virtual bool isMatchAF(const AFPtr& af) override;
     virtual void _calculate() override;
-    virtual SystemWeightList getSelected(Datetime date) override {
+    virtual SystemWeightList _getSelected(Datetime date) override {
         return SystemWeightList();
     }
 
@@ -68,7 +68,7 @@ public:
     classname(const SelectorPtr& se, double value) : OperatorValueSelector(name, se, value) {} \
     virtual ~classname() {}                                                                    \
                                                                                                \
-    virtual SystemWeightList getSelected(Datetime date) override;                              \
+    virtual SystemWeightList _getSelected(Datetime date) override;                             \
                                                                                                \
     virtual SelectorPtr _clone() override {                                                    \
         auto p = std::make_shared<classname>();                                                \

hikyuu/include/hikyuu/trade_sys/selector/imp/optimal/PerformanceOptimalSelector.h

@@ -22,7 +22,7 @@ public:
     virtual void _checkParam(const string& name) const override;
     virtual void calculate(const SystemList& pf_realSysList, const KQuery& query) override;
 
-    virtual SystemWeightList getSelected(Datetime date) override;
+    virtual SystemWeightList _getSelected(Datetime date) override;
     virtual SelectorPtr _clone() override;
     virtual void _reset() override;
 

hikyuu/include/hikyuu/trade_sys/system/System.h

@@ -251,11 +251,20 @@ public:
     virtual void clearDelayBuyRequest();
 
     // 当前是否存在延迟的操作请求，供Portfolio
-    virtual bool haveDelaySellRequest() const;
+    bool haveDelaySellRequest() const {
+        return m_sellRequest.valid;
+    }
+
+    bool haveDelayBuyRequest() const {
+        return m_buyRequest.valid;
+    }
 
     // 处理延迟买入请求，仅供 PF 调用
     virtual TradeRecord pfProcessDelaySellRequest(const Datetime& date);
 
+    // 处理延迟买入请求，仅供 PF 调用
+    virtual TradeRecord pfProcessDelayBuyRequest(const Datetime& date);
+
 private:
     bool _environmentIsValid(const Datetime& datetime);
     bool _conditionIsValid(const Datetime& datetime);
@@ -329,8 +338,8 @@ protected:
     bool m_pre_ev_valid;
     bool m_pre_cn_valid;
 
-    int m_buy_days;         // 每一次买入清零，计算一次加1，即买入后的天数
-    int m_sell_short_days;  // 每一次卖空清零
+    int m_buy_days;                 // 每一次买入清零，计算一次加1，即买入后的天数
+    int m_sell_short_days;          // 每一次卖空清零
     TradeRecordList m_trade_list;   // 保存实际执行的交易记录
     price_t m_lastTakeProfit;       // 上一次多头止损价，用于保证止赢价单调递增
     price_t m_lastShortTakeProfit;  // 上一次空头止赢价

hikyuu/include/hikyuu/trade_sys/system/imp/DelegateSystem.h

@@ -28,7 +28,6 @@ public:
     virtual TradeRecord sellForceOnOpen(const Datetime& date, double num, Part from) override;
     virtual TradeRecord sellForceOnClose(const Datetime& date, double num, Part from) override;
     virtual void clearDelayBuyRequest() override;
-    virtual bool haveDelaySellRequest() const override;
     virtual TradeRecord pfProcessDelaySellRequest(const Datetime& date) override;
 
 private:

hikyuu/include/hikyuu/trade_sys/system/imp/WalkForwardSystem.h

@@ -36,7 +36,6 @@ public:
     virtual TradeRecord sellForceOnOpen(const Datetime& date, double num, Part from) override;
     virtual TradeRecord sellForceOnClose(const Datetime& date, double num, Part from) override;
     virtual void clearDelayBuyRequest() override;
-    virtual bool haveDelaySellRequest() const override;
     virtual TradeRecord pfProcessDelaySellRequest(const Datetime& date) override;
 
 private:

hikyuu/include/hikyuu/trade_sys/system/imp/WalkForwardTradeManager.h

@@ -437,8 +437,9 @@ public:
      * 从订单代理实例同步当前账户资产信息（包含资金、持仓等）
      * @param broker 订单代理实例
      */
-    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker) override {
-        m_tm->fetchAssetInfoFromBroker(broker);
+    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker,
+                                          const Datetime& datetime = Null<Datetime>()) override {
+        m_tm->fetchAssetInfoFromBroker(broker, datetime);
     }
 
 private:

hikyuu/include/hikyuu/utilities/arithmetic.h

@@ -85,29 +85,39 @@ std::string HKU_UTILS_API gb_to_utf8(const std::string &szinput);
 template <typename ValueT>
 ValueT roundEx(ValueT number, int ndigits = 0) {
     // 切换至：ROUND_HALF_EVEN 银行家舍入法
-    ValueT pow1, pow2, y, z;
-    ValueT x = number;
-    if (ndigits >= 0) {
-        pow1 = pow(ValueT(10.0), ValueT(ndigits));
-        pow2 = 1.0;
-        y = (x * pow1) * pow2;
-    } else {
-        pow1 = pow(ValueT(10.0), ValueT(-ndigits));
-        pow2 = 1.0;
-        y = x / pow1;
-    }
-
-    z = std::round(y);
-    if (std::fabs(y - z) == 0.5)
-        /* halfway between two integers; use round-half-even */
-        z = 2.0 * std::round(y / 2.0);
-
-    if (ndigits >= 0)
-        z = (z / pow2) / pow1;
+    // ValueT pow1, pow2, y, z;
+    // ValueT x = number;
+    // if (ndigits >= 0) {
+    //     pow1 = pow(ValueT(10.0), ValueT(ndigits));
+    //     pow2 = 1.0;
+    //     y = (x * pow1) * pow2;
+    // } else {
+    //     pow1 = pow(ValueT(10.0), ValueT(-ndigits));
+    //     pow2 = 1.0;
+    //     y = x / pow1;
+    // }
+
+    // z = std::round(y);
+    // if (std::fabs(y - z) == 0.5)
+    //     /* halfway between two integers; use round-half-even */
+    //     z = 2.0 * std::round(y / 2.0);
+
+    // if (ndigits >= 0)
+    //     z = (z / pow2) / pow1;
+    // else
+    //     z *= pow1;
+
+    // 国内一般使用传统四舍五入法
+    if (ndigits < 0)
+        return number;  // 无效位数直接返回原值
+
+    const double factor = std::pow(10.0, ndigits);
+    const double epsilon = 1e-10 * factor;  // 动态调整epsilon避免精度误差
+
+    if (number >= 0)
+        return static_cast<ValueT>(std::floor(number * factor + 0.5 + epsilon) / factor);
     else
-        z *= pow1;
-
-    return z;
+        return static_cast<ValueT>(std::ceil(number * factor - 0.5 - epsilon) / factor);
 }
 
 /**

hikyuu/include/hikyuu/utilities/datetime/Datetime.h

@@ -94,6 +94,7 @@ public:
      * <pre>
      *     1、YYYYMMDDhhmm，如 200101010000
      *     2、YYYYMMDD, 如 20010101
+     *     3、YYYYMMDDhhmmss，如 20010101000000
      * </pre>
      */
     explicit Datetime(unsigned long long);

hikyuu/include/hikyuu/utilities/plugin/PluginClient.h

@@ -17,7 +17,7 @@ public:
     PluginClient() = delete;
     PluginClient(const std::string &path, const std::string &filename) {
         m_loader = std::make_unique<PluginLoader>(path);
-        m_loader->load(filename);
+        HKU_CHECK(m_loader->load(filename), "load plugin failed! {}/{}", path, filename);
         m_impl = m_loader->instance<InterfaceT>();
     }
     virtual ~PluginClient() = default;
@@ -46,7 +46,7 @@ public:
     }
 
 protected:
-    InterfaceT *m_impl;
+    InterfaceT *m_impl{nullptr};
 
 protected:
     std::unique_ptr<PluginLoader> m_loader;

hikyuu/include/hikyuu/utilities/plugin/PluginLoader.h

@@ -14,29 +14,29 @@
 #include <memory>
 #include "hikyuu/utilities/config.h"
 #include "hikyuu/utilities/osdef.h"
+#include "hikyuu/utilities/os.h"
 #include "hikyuu/utilities/Log.h"
 #include "PluginBase.h"
 
 #if HKU_OS_WINDOWS
 #include <windows.h>
-#endif
-
-#ifndef HKU_UTILS_API
-#define HKU_UTILS_API
+#else
+#include <dlfcn.h>
 #endif
 
 namespace hku {
 
-class HKU_UTILS_API PluginLoader final {
+class PluginLoader final {
 public:
-    PluginLoader();
-    explicit PluginLoader(const std::string& path);
+    PluginLoader() : PluginLoader(".") {}
+    explicit PluginLoader(const std::string& path) : m_path(path) {}
+
     PluginLoader(const PluginLoader&) = delete;
     PluginLoader(PluginLoader&&) = delete;
 
-    ~PluginLoader();
-
-    bool load(const std::string& pluginname) noexcept;
+    ~PluginLoader() {
+        unload();
+    }
 
     template <typename T>
     T* instance() const noexcept {
@@ -44,10 +44,63 @@ public:
         return dynamic_cast<T*>(m_plugin.get());
     }
 
+    bool load(const std::string& pluginname) noexcept {
+        std::string filename = getFileName(pluginname);
+        HKU_WARN_IF_RETURN(!existFile(filename), false, "file({}) not exist!", filename);
+
+#if HKU_OS_WINDOWS
+        m_handle = LoadLibrary(HKU_PATH(filename).c_str());
+#else
+        m_handle = dlopen(filename.c_str(), RTLD_LAZY);
+#endif
+        HKU_WARN_IF_RETURN(!m_handle, false, "load plugin({}) failed!", filename);
+
+        typedef PluginBase* (*CreateFunction)();
+        CreateFunction createFunction =
+          reinterpret_cast<CreateFunction>(getFunciton("createPlugin"));
+        HKU_WARN_IF_RETURN(!createFunction, false, "Failed to get plugin({}) handle!", filename);
+
+        m_plugin.reset(createFunction());
+        if (!m_plugin) {
+            HKU_ERROR("Failed to create plugin ({})!", filename);
+            unload();
+            m_plugin.reset();
+            return false;
+        }
+
+        return true;
+    }
+
 private:
-    void unload() noexcept;
-    void* getFunciton(const char* symbol) noexcept;
-    std::string getFileName(const std::string& pluginname) const noexcept;
+    void unload() noexcept {
+        m_plugin.reset();
+        if (m_handle) {
+#if HKU_OS_WINDOWS
+            FreeLibrary(m_handle);
+#else
+            dlclose(m_handle);
+#endif
+        }
+    }
+
+    void* getFunciton(const char* symbol) noexcept {
+#if HKU_OS_WINDOWS
+        void* func = GetProcAddress(m_handle, symbol);
+#else
+        void* func = dlsym(m_handle, symbol);
+#endif
+        return func;
+    }
+
+    std::string getFileName(const std::string& pluginname) const noexcept {
+#if HKU_OS_WINDOWS
+        return fmt::format("{}/{}.dll", m_path, pluginname);
+#elif HKU_OS_LINUX
+        return fmt::format("{}/lib{}.so", m_path, pluginname);
+#elif HKU_OS_OSX
+        return fmt::format("{}/lib{}.dylib", m_path, pluginname);
+#endif
+    }
 
 private:
 #if HKU_OS_WINDOWS

hikyuu/include/hikyuu/utilities/plugin/PluginManager.h

@@ -0,0 +1,72 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-04-10
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include <string>
+#include <memory>
+#include <unordered_map>
+#include <mutex>
+#include "hikyuu/utilities/Log.h"
+#include "hikyuu/utilities/plugin/PluginLoader.h"
+
+namespace hku {
+
+class PluginManager final {
+public:
+    PluginManager() : m_plugin_path(".") {};
+    explicit PluginManager(const std::string& plugin_path) : m_plugin_path(plugin_path) {}
+
+    ~PluginManager() = default;
+    PluginManager(const PluginManager&) = delete;
+    PluginManager(PluginManager&&) = delete;
+    PluginManager& operator=(const PluginManager&) = delete;
+    PluginManager& operator=(PluginManager&&) = delete;
+
+    const std::string& pluginPath() const noexcept {
+        return m_plugin_path;
+    }
+
+    void pluginPath(const std::string& plugin_path) noexcept {
+        HKU_TRACE_IF_RETURN(!m_plugins.empty(), void(),
+                            "Existing loaded plugins, Ignore set plugin path: {}, ", plugin_path);
+        m_plugin_path = plugin_path;
+    }
+
+    template <typename PluginInterfaceT>
+    PluginInterfaceT* getPlugin(const std::string& pluginname) noexcept;
+
+private:
+    std::unordered_map<std::string, std::unique_ptr<PluginLoader>>::iterator load(
+      const std::string& pluginname) noexcept {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        std::unique_ptr<PluginLoader> loader = std::make_unique<PluginLoader>(m_plugin_path);
+        if (loader->load(pluginname)) {
+            auto [it, success] = m_plugins.insert(std::make_pair(pluginname, std::move(loader)));
+            if (success) {
+                return it;
+            }
+        }
+        return m_plugins.end();
+    }
+
+private:
+    std::string m_plugin_path;
+    std::unordered_map<std::string, std::unique_ptr<PluginLoader>> m_plugins;
+    std::mutex m_mutex;
+};
+
+template <typename PluginInterfaceT>
+PluginInterfaceT* PluginManager::getPlugin(const std::string& pluginname) noexcept {
+    auto it = m_plugins.find(pluginname);
+    if (it == m_plugins.end()) {
+        it = load(pluginname);
+    }
+    return it != m_plugins.end() ? it->second->instance<PluginInterfaceT>() : nullptr;
+}
+
+}  // namespace hku