hikyuu 2.5.2__py3-none-win_amd64.whl → 2.5.5__py3-none-win_amd64.whl

hikyuu/include/hikyuu/indicator/crt/TR.h

@@ -0,0 +1,32 @@
+/*
+ * TRG.h
+ *
+ *  Created on: 2019年3月6日
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef INDICATOR_CRT_TR_H_
+#define INDICATOR_CRT_TR_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/**
+ * @brief 真实波动幅度（TR）
+ * @details
+ * <pre>
+ * 真实波动幅度（TR）是以下三个值中的最大值：
+ *  1. 当前周期最高价（H）与最低价（L）之差
+ *  2. 当前周期最高价与前一周期收盘价（PC）之差的绝对值
+ *  3. 当前周期最低价与前一周期收盘价之差的绝对值
+ * </pre>
+ * @ingroup Indicator
+ */
+Indicator HKU_API TR();
+Indicator HKU_API TR(const KData&);
+
+}  // namespace hku
+
+#endif /* INDICATOR_CRT_TR_H_ */

hikyuu/include/hikyuu/indicator/imp/IAtr.h

@@ -14,11 +14,13 @@
 namespace hku {
 
 class IAtr : public IndicatorImp {
-    INDICATOR_IMP_SUPPORT_DYNAMIC_STEP(IAtr)
+    INDICATOR_IMP(IAtr)
+    INDICATOR_NEED_CONTEXT
     INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
 
 public:
     IAtr();
+    explicit IAtr(const KData&, int n);
     virtual ~IAtr();
     virtual void _checkParam(const string& name) const override;
 };

hikyuu/include/hikyuu/indicator/imp/IBarsSince.h

@@ -15,6 +15,11 @@
 
 namespace hku {
 
+/*
+ * N周期内首个条件成立位置, N为0时，为整个序列
+ * 用法：BARSSINCEN(X,N):N周期内第一次X不为0到现在的周期数,N为常量BARSSINCEN(X,N):
+ * 例如：BARSSINCEN(HIGH>10,10)表示10个周期内股价超过10元时到当前的周期数
+ */
 class IBarsSince : public IndicatorImp {
     INDICATOR_IMP(IBarsSince)
     INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
@@ -22,6 +27,7 @@ class IBarsSince : public IndicatorImp {
 public:
     IBarsSince();
     virtual ~IBarsSince();
+    virtual void _checkParam(const string& name) const override;
 };
 
 } /* namespace hku */

hikyuu/include/hikyuu/indicator/imp/IKalman.h

@@ -0,0 +1,27 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-03-02
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef INDICATOR_IMP_IKALMAN_H_
+#define INDICATOR_IMP_IKALMAN_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/* kalman滤波 */
+class IKalman : public IndicatorImp {
+    INDICATOR_IMP(IKalman)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IKalman();
+    virtual ~IKalman();
+};
+
+} /* namespace hku */
+#endif /* INDICATOR_IMP_IKALMAN_H_ */

hikyuu/include/hikyuu/indicator/imp/ITr.h

@@ -0,0 +1,35 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-03-05
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef INDICATOR_IMP_ITR_H_
+#define INDICATOR_IMP_ITR_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/*
+ * 真实波动幅度（TR）是以下三个值中的最大值：
+ *  1. 当前周期最高价与最低价之差
+ *  2. 当前周期最高价与前一周期收盘价之差的绝对值
+ *  3. 当前周期最低价与前一周期收盘价之差的绝对值
+ */
+class ITr : public IndicatorImp {
+    INDICATOR_IMP(ITr)
+    INDICATOR_NEED_CONTEXT
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    ITr();
+    explicit ITr(const KData&);
+    virtual ~ITr();
+};
+
+} /* namespace hku */
+
+#endif /* INDICATOR_IMP_ITR_H_ */

hikyuu/include/hikyuu/python/convert_any.h

@@ -0,0 +1,299 @@
+/*
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2020-5-24
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HIKYUU_PYTHON_CONVERT_ANY_H
+#define HIKYUU_PYTHON_CONVERT_ANY_H
+
+#include <string>
+#include <pybind11/pybind11.h>
+#include <pybind11/eval.h>
+#include <hikyuu/hikyuu.h>
+#include <datetime.h>
+#include "bind_stl.h"
+
+using namespace hku;
+
+inline Datetime pydatetime_to_Datetime(const pybind11::object& source) {
+    Datetime value;
+    if (source.is_none()) {
+        return value;
+    }
+
+    if (pybind11::isinstance<Datetime>(source)) {
+        value = source.cast<Datetime>();
+        return value;
+    }
+
+    if (!PyDateTimeAPI) {
+        PyDateTime_IMPORT;
+    }
+
+    PyObject* src = source.ptr();
+
+    long year = 0, month = 0, day = 0, hour = 0, minute = 0, second = 0, microsecond = 0;
+    if (PyDateTime_Check(src)) {
+        second = PyDateTime_DATE_GET_SECOND(src);
+        minute = PyDateTime_DATE_GET_MINUTE(src);
+        hour = PyDateTime_DATE_GET_HOUR(src);
+        day = PyDateTime_GET_DAY(src);
+        month = PyDateTime_GET_MONTH(src);
+        year = PyDateTime_GET_YEAR(src);
+        microsecond = PyDateTime_DATE_GET_MICROSECOND(src);
+
+    } else if (PyDate_Check(src)) {
+        day = PyDateTime_GET_DAY(src);
+        month = PyDateTime_GET_MONTH(src);
+        year = PyDateTime_GET_YEAR(src);
+
+    } else if (PyTime_Check(src)) {
+        second = PyDateTime_TIME_GET_SECOND(src);
+        minute = PyDateTime_TIME_GET_MINUTE(src);
+        hour = PyDateTime_TIME_GET_HOUR(src);
+        day = 1;      // This date (day, month, year) = (1, 0, 70)
+        month = 1;    // represents 1-Jan-1940, which is the first
+        year = 1400;  // earliest available date for Datetime, not Python datetime
+        microsecond = PyDateTime_TIME_GET_MICROSECOND(src);
+
+    } else {
+        throw std::invalid_argument("Can't convert this python object to Datetime!");
+    }
+
+    // Datetime 最小只到 1400年 1 月 1日，最大只到 9999 年 12月 31 日 0点
+    if (year < 1400) {
+        value = Datetime::min();
+    } else if (Datetime(year, month, day) == Datetime::max()) {
+        value = Datetime::max();
+    } else {
+        long millisecond = microsecond / 1000;
+        microsecond = microsecond - millisecond * 1000;
+        value = Datetime(year, month, day, hour, minute, second, millisecond, microsecond);
+    }
+
+    return value;
+}
+
+namespace pybind11 {
+namespace detail {
+template <>
+struct type_caster<boost::any> {
+public:
+    PYBIND11_TYPE_CASTER(boost::any, _("any"));
+
+    /**
+     * Conversion part 1 (Python->C++)
+     */
+    bool load(handle source, bool) {
+        if (source.is_none()) {
+            return false;
+        }
+
+        /* Extract PyObject from handle */
+        PyObject* src = source.ptr();
+
+        object obj = reinterpret_borrow<object>(source);
+        if (PyBool_Check(src)) {
+            // value = bool(PyLong_AsLong(src));
+            bool tmp = obj.cast<bool>();
+            value = tmp;
+            return true;
+        }
+
+        if (PyLong_Check(src)) {
+            int overflow;
+            long tmp = PyLong_AsLongAndOverflow(src, &overflow);
+            if (overflow == 0) {
+                value = static_cast<int>(tmp);
+            } else {
+                value = PyLong_AsLongLong(src);
+            }
+            return true;
+        }
+
+        if (PyFloat_Check(src)) {
+            value = PyFloat_AsDouble(src);
+            return true;
+        }
+
+        if (PyUnicode_Check(src)) {
+            object temp = reinterpret_borrow<object>(PyUnicode_AsUTF8String(src));
+            if (!temp)
+                pybind11_fail("Unable to extract string contents! (encoding issue)");
+            char* buffer;
+            ssize_t length;
+            if (PYBIND11_BYTES_AS_STRING_AND_SIZE(temp.ptr(), &buffer, &length))
+                pybind11_fail("Unable to extract string contents! (invalid type)");
+            value = std::string(buffer, (size_t)length);
+            return true;
+        }
+
+        if (isinstance<Stock>(obj)) {
+            value = obj.cast<Stock>();
+            return true;
+
+        } else if (isinstance<Block>(obj)) {
+            value = obj.cast<Block>();
+            return true;
+
+        } else if (isinstance<KQuery>(obj)) {
+            value = obj.cast<KQuery>();
+            return true;
+
+        } else if (isinstance<KData>(obj)) {
+            value = obj.cast<KData>();
+            return true;
+
+        } else if (isinstance<sequence>(obj)) {
+            sequence pyseq = obj.cast<sequence>();
+            size_t total = pyseq.size();
+            HKU_CHECK(total > 0, "Can't support empty sequence!");
+            if (isinstance<Datetime>(pyseq[0])) {
+                std::vector<Datetime> vect(total);
+                for (size_t i = 0; i < total; i++) {
+                    vect[i] = pyseq[i].cast<Datetime>();
+                }
+                value = vect;
+
+            } else if (PyFloat_Check(pyseq[0].ptr()) || PyLong_Check(pyseq[0].ptr())) {
+                std::vector<price_t> vect(total);
+                for (size_t i = 0; i < total; i++) {
+                    vect[i] = pyseq[i].cast<price_t>();
+                }
+                value = vect;
+
+            } else {
+                // 尝试 python 原生 datetime 的转换
+                std::vector<Datetime> vect(total);
+                for (size_t i = 0; i < total; i++) {
+                    vect[i] = pydatetime_to_Datetime(pyseq[i]);
+                }
+                value = vect;
+            }
+            return true;
+        }
+
+        HKU_THROW_EXCEPTION(std::logic_error,
+                            "Faile convert this value to boost::any, it may be not supported!");
+        return false;
+    }
+
+    /**
+     * Conversion part 2 (C++ -> Python)
+     */
+    static handle cast(boost::any x, return_value_policy /* policy */, handle /* parent */) {
+        if (x.type() == typeid(bool)) {
+            bool tmp = boost::any_cast<bool>(x);
+            if (tmp) {
+                Py_RETURN_TRUE;
+            } else {
+                Py_RETURN_FALSE;
+            }
+        } else if (x.type() == typeid(int)) {
+            return Py_BuildValue("n", boost::any_cast<int>(x));
+        } else if (x.type() == typeid(double)) {
+            return Py_BuildValue("d", boost::any_cast<double>(x));
+        } else if (x.type() == typeid(std::string)) {
+            std::string s(boost::any_cast<std::string>(x));
+            return Py_BuildValue("s", s.c_str());
+
+        } else if (x.type() == typeid(KData)) {
+            const KData& k = boost::any_cast<KData>(x);
+            std::stringstream cmd;
+            if (k == Null<KData>()) {
+                cmd << "KData()";
+            } else {
+                auto stk = k.getStock();
+                auto query = k.getQuery();
+                std::stringstream q_cmd;
+                if (query.queryType() == KQuery::INDEX) {
+                    q_cmd << "Query(" << query.start() << "," << query.end() << ", Query."
+                          << KQuery::getKTypeName(query.kType()) << ", Query."
+                          << KQuery::getRecoverTypeName(query.recoverType()) << ")";
+                } else {
+                    q_cmd << "Query(Datetime('" << query.startDatetime() << "'), Datetime('"
+                          << query.endDatetime() << "'), " << "Query."
+                          << KQuery::getKTypeName(query.kType()) << ", Query."
+                          << KQuery::getRecoverTypeName(query.recoverType()) << ")";
+                }
+                cmd << "KData(get_stock('" << stk.market_code() << "'), " << q_cmd.str() << ")";
+            }
+            object o = eval(cmd.str());
+            o.inc_ref();
+            return o;
+
+        } else if (x.type() == typeid(Stock)) {
+            const Stock& stk = boost::any_cast<Stock>(x);
+            std::stringstream cmd;
+            if (stk.isNull()) {
+                cmd << "Stock()";
+            } else {
+                cmd << "get_stock('" << stk.market_code() << "')";
+            }
+            object o = eval(cmd.str());
+            o.inc_ref();
+            return o;
+
+        } else if (x.type() == typeid(Block)) {
+            const Block& blk = boost::any_cast<const Block&>(x);
+            std::stringstream cmd;
+            object o;
+            if (blk == Null<Block>()) {
+                cmd << "Block()";
+                o = eval(cmd.str());
+                o.inc_ref();
+            } else {
+                cmd << "Block('" << blk.category() << "','" << blk.name() << "')";
+                o = eval(cmd.str());
+                o.inc_ref();
+                Block out = o.cast<Block>();
+                out.add(blk.getStockList());
+            }
+            return o;
+
+        } else if (x.type() == typeid(KQuery)) {
+            const KQuery& query = boost::any_cast<KQuery>(x);
+            std::stringstream cmd;
+            if (query.queryType() == KQuery::INDEX) {
+                cmd << "Query(" << query.start() << "," << query.end() << ", Query."
+                    << KQuery::getKTypeName(query.kType()) << ", Query."
+                    << KQuery::getRecoverTypeName(query.recoverType()) << ")";
+            } else {
+                cmd << "Query(Datetime('" << query.startDatetime() << "'), Datetime('"
+                    << query.endDatetime() << "'), " << "Query."
+                    << KQuery::getKTypeName(query.kType()) << ", Query."
+                    << KQuery::getRecoverTypeName(query.recoverType()) << ")";
+            }
+            object o = eval(cmd.str());
+            o.inc_ref();
+            return o;
+
+        } else if (x.type() == typeid(PriceList)) {
+            PriceList price_list = boost::any_cast<PriceList>(x);
+            list o;
+            for (auto iter = price_list.begin(); iter != price_list.end(); ++iter) {
+                o.append(*iter);
+            }
+            o.inc_ref();
+            return o;
+
+        } else if (x.type() == typeid(DatetimeList)) {
+            const DatetimeList& date_list = boost::any_cast<DatetimeList>(x);
+            list o;
+            for (auto iter = date_list.begin(); iter != date_list.end(); ++iter) {
+                o.append(*iter);
+            }
+            o.inc_ref();
+            return o;
+        }
+
+        HKU_THROW_EXCEPTION(std::runtime_error, "convert failed! Unkown type!!");
+    }
+};
+}  // namespace detail
+}  // namespace pybind11
+
+#endif /* HIKYUU_PYTHON_CONVERT_ANY_H */

hikyuu/include/hikyuu/trade_manage/PositionRecord.h

@@ -28,10 +28,11 @@ public:
     /** 仅用于python的__str__ */
     string str() const;
 
-    /** 盈利 = 买入资金 - 累计交易总成本 - 卖出资金 */
-    price_t totalProfit() const {
-        return buyMoney - totalCost - sellMoney;
-    }
+    /**
+     * @brief 盈亏 = 买入资金 - 累计交易总成本 - 卖出资金
+     * @note 只对已清仓的记录有效，未清仓将返回0.0
+     */
+    price_t totalProfit() const;
 
     Stock stock;              ///< 交易对象
     Datetime takeDatetime;    ///< 初次建仓日期

hikyuu/include/hikyuu/trade_sys/allocatefunds/crt/AF_MultiFactor.h

@@ -12,7 +12,7 @@
 namespace hku {
 
 /**
- * 创建 MultiFactor 评分权重的资产分配算法实例
+ * 创建 MultiFactor 评分权重的资产分配算法实例，即直接以SE返回的评分作为权重。
  * @return AFPtr
  * @ingroup AllocateFunds
  */

hikyuu/include/hikyuu/trade_sys/allocatefunds/imp/MultiFactorAllocaterFunds.h

@@ -11,6 +11,9 @@
 
 namespace hku {
 
+/*
+ * 创建 MultiFactor 评分权重的资产分配算法实例, 即直接以SE返回的评分作为权重。
+ */
 class MultiFactorAllocaterFunds : public AllocateFundsBase {
     ALLOCATEFUNDS_IMP(MultiFactorAllocaterFunds)
     ALLOCATEFUNDS_NO_PRIVATE_MEMBER_SERIALIZATION

hikyuu/include/hikyuu/trade_sys/condition/ConditionBase.h

@@ -66,7 +66,10 @@ public:
     /** 获取系统有效的日期列表，注意：和交易对象不等长 */
     DatetimeList getDatetimeList() const;
 
-    /** 以指标的形式获取实际值，与交易对象等长，0表示无效，1表示系统有效 */
+    /**
+     * 以指标的形式获取实际值，与交易对象等长，<=0表示无效，>0表示系统有效
+     * @note 带日期的时间序列指标
+     */
     Indicator getValues() const;
 
     /**

hikyuu/include/hikyuu/trade_sys/condition/imp/{SubCondition.h → logic/SubCondition.h}

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include "../ConditionBase.h"
+#include "hikyuu/trade_sys/condition/ConditionBase.h"
 
 namespace hku {
 

hikyuu/include/hikyuu/trade_sys/environment/EnvironmentBase.h

@@ -13,6 +13,7 @@
 #include <shared_mutex>
 #include "../../KQuery.h"
 #include "../../utilities/Parameter.h"
+#include "hikyuu/indicator/Indicator.h"
 
 namespace hku {
 
@@ -64,15 +65,24 @@ public:
     /**
      * 加入有效时间，在_calculate中调用
      * @param datetime 系统有效日期
+     * @param value 默认为1.0，大于0表示有效，小于等于0表示无效
      */
-    void _addValid(const Datetime& datetime);
+    void _addValid(const Datetime& datetime, price_t value = 1.0);
 
     /**
      * 判断指定日期的外部环境是否有效
      * @param datetime 指定日期
      * @return true 有效 | false 无效
      */
-    bool isValid(const Datetime& datetime);
+    bool isValid(const Datetime& datetime) const;
+
+    price_t getValue(const Datetime& datetime) const;
+
+    /**
+     * 以指标的形式获取实际值，与交易对象等长，<=0表示无效，>0表示系统有效
+     * @note 带日期的时间序列指标
+     */
+    Indicator getValues() const;
 
     /** 子类计算接口 */
     virtual void _calculate() = 0;
@@ -86,8 +96,9 @@ public:
 protected:
     string m_name;
     KQuery m_query;
-    std::set<Datetime> m_valid;
-    std::shared_mutex m_mutex;
+    map<Datetime, size_t> m_date_index;
+    vector<price_t> m_values;
+    mutable std::shared_mutex m_mutex;
 
 //============================================
 // 序列化支持
@@ -101,14 +112,17 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_params);
         // ev可能多个系统共享，保留m_query可能用于查错
         ar& BOOST_SERIALIZATION_NVP(m_query);
-        ar& BOOST_SERIALIZATION_NVP(m_valid);
+        ar& BOOST_SERIALIZATION_NVP(m_date_index);
+        ar& BOOST_SERIALIZATION_NVP(m_values);
     }
 
     template <class Archive>
     void load(Archive& ar, const unsigned int version) {
         ar& BOOST_SERIALIZATION_NVP(m_name);
+        ar& BOOST_SERIALIZATION_NVP(m_params);
         ar& BOOST_SERIALIZATION_NVP(m_query);
-        ar& BOOST_SERIALIZATION_NVP(m_valid);
+        ar& BOOST_SERIALIZATION_NVP(m_date_index);
+        ar& BOOST_SERIALIZATION_NVP(m_values);
     }
 
     BOOST_SERIALIZATION_SPLIT_MEMBER()

hikyuu/include/hikyuu/trade_sys/environment/build_in.h

@@ -12,5 +12,6 @@
 #include "crt/EV_TwoLine.h"
 #include "crt/EV_Bool.h"
 #include "crt/EV_Manual.h"
+#include "crt/EV_Logic.h"
 
 #endif /* ENVIRONMENT_BUILD_IN_H */

hikyuu/include/hikyuu/trade_sys/environment/crt/EV_Logic.h

@@ -0,0 +1,35 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-03-06
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_sys/environment/EnvironmentBase.h"
+
+namespace hku {
+
+/**
+ * 两个市场环境判定相与，等效于两者的交集
+ * @param ev1 市场环境判定1
+ * @param ev2 市场环境判定2
+ * @return AndCondition 实例指针
+ */
+HKU_API EnvironmentPtr operator&(const EnvironmentPtr& ev1, const EnvironmentPtr& ev2);
+
+/**
+ * 两个市场环境判定相或，等效于两者的并集
+ * @param ev1 市场环境判定1
+ * @param ev2 市场环境判定2
+ * @return OrCondition 实例指针
+ */
+HKU_API EnvironmentPtr operator|(const EnvironmentPtr& ev1, const EnvironmentPtr& ev2);
+
+HKU_API EnvironmentPtr operator+(const EnvironmentPtr& ev1, const EnvironmentPtr& ev2);
+HKU_API EnvironmentPtr operator-(const EnvironmentPtr& ev1, const EnvironmentPtr& ev2);
+HKU_API EnvironmentPtr operator*(const EnvironmentPtr& ev1, const EnvironmentPtr& ev2);
+HKU_API EnvironmentPtr operator/(const EnvironmentPtr& ev1, const EnvironmentPtr& ev2);
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/environment/imp/logic/AddEnvironment.h

@@ -0,0 +1,42 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-03-06
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_sys/environment/EnvironmentBase.h"
+
+namespace hku {
+
+class HKU_API AddEnvironment : public EnvironmentBase {
+public:
+    AddEnvironment();
+    AddEnvironment(const EnvironmentPtr& ev1, const EnvironmentPtr& ev2);
+    virtual ~AddEnvironment();
+
+    virtual void _calculate() override;
+    virtual void _reset() override;
+    virtual EnvironmentPtr _clone() override;
+
+private:
+    EnvironmentPtr m_ev1;
+    EnvironmentPtr m_ev2;
+
+//============================================
+// 序列化支持
+//============================================
+#if HKU_SUPPORT_SERIALIZATION
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(EnvironmentBase);
+        ar& BOOST_SERIALIZATION_NVP(m_ev1);
+        ar& BOOST_SERIALIZATION_NVP(m_ev2);
+    }
+#endif
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/environment/imp/logic/AndEnvironment.h

@@ -0,0 +1,42 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-03-06
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_sys/environment/EnvironmentBase.h"
+
+namespace hku {
+
+class HKU_API AndEnvironment : public EnvironmentBase {
+public:
+    AndEnvironment();
+    AndEnvironment(const EnvironmentPtr& ev1, const EnvironmentPtr& ev2);
+    virtual ~AndEnvironment();
+
+    virtual void _calculate() override;
+    virtual void _reset() override;
+    virtual EnvironmentPtr _clone() override;
+
+private:
+    EnvironmentPtr m_ev1;
+    EnvironmentPtr m_ev2;
+
+//============================================
+// 序列化支持
+//============================================
+#if HKU_SUPPORT_SERIALIZATION
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(EnvironmentBase);
+        ar& BOOST_SERIALIZATION_NVP(m_ev1);
+        ar& BOOST_SERIALIZATION_NVP(m_ev2);
+    }
+#endif
+};
+
+}  // namespace hku