hikyuu 2.0.9__cp39-none-win_amd64.whl → 2.1.0__cp39-none-win_amd64.whl

hikyuu/include/hikyuu/indicator/crt/INSUM.h

@@ -23,14 +23,11 @@ Indicator HKU_API INSUM(const Block& block, const KQuery& query, const Indicator
 
 /**
  * 返回板块各成分该指标相应输出按计算类型得到的计算值.计算类型:0-累加,1-平均数,2-最大值,3-最小值.
- * @param category 板块类别
- * @param category 板块名称
- * @param query 指定范围
+ * @param block 指定板块
  * @param ind 指定指标
  * @param mode 计算类型:0-累加,1-平均数,2-最大值,3-最小值.
  * @return Indicator
  */
-Indicator HKU_API INSUM(const string& category, const string& name, const KQuery& query,
-                        const Indicator& ind, int mode);
+Indicator HKU_API INSUM(const Block& block, const Indicator& ind, int mode);
 
 }  // namespace hku

hikyuu/include/hikyuu/trade_sys/allocatefunds/AllocateFundsBase.h

@@ -175,11 +175,11 @@ private:                                                            \
 #define ALLOCATEFUNDS_NO_PRIVATE_MEMBER_SERIALIZATION
 #endif
 
-#define ALLOCATEFUNDS_IMP(classname)   \
-public:                                \
-    virtual AFPtr _clone() override {  \
-        return AFPtr(new classname()); \
-    }                                  \
+#define ALLOCATEFUNDS_IMP(classname)          \
+public:                                       \
+    virtual AFPtr _clone() override {         \
+        return std::make_shared<classname>(); \
+    }                                         \
     virtual SystemWeightList _allocateWeight(const Datetime&, const SystemWeightList&) override;
 
 typedef shared_ptr<AllocateFundsBase> AllocateFundsPtr;

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

@@ -180,7 +180,7 @@ typedef shared_ptr<ConditionBase> CNPtr;
 #define CONDITION_IMP(classname)              \
 public:                                       \
     virtual ConditionPtr _clone() {           \
-        return ConditionPtr(new classname()); \
+        return std::make_shared<classname>(); \
     }                                         \
     virtual void _calculate();
 

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

@@ -151,11 +151,11 @@ private:                                                          \
 typedef shared_ptr<EnvironmentBase> EnvironmentPtr;
 typedef shared_ptr<EnvironmentBase> EVPtr;
 
-#define ENVIRONMENT_IMP(classname)              \
-public:                                         \
-    virtual EnvironmentPtr _clone() {           \
-        return EnvironmentPtr(new classname()); \
-    }                                           \
+#define ENVIRONMENT_IMP(classname)            \
+public:                                       \
+    virtual EnvironmentPtr _clone() {         \
+        return std::make_shared<classname>(); \
+    }                                         \
     virtual void _calculate();
 
 /**

hikyuu/include/hikyuu/trade_sys/moneymanager/MoneyManagerBase.h

@@ -209,7 +209,7 @@ typedef shared_ptr<MoneyManagerBase> MMPtr;
 #define MONEY_MANAGER_IMP(classname)                                                          \
 public:                                                                                       \
     virtual MoneyManagerPtr _clone() override {                                               \
-        return MoneyManagerPtr(new classname());                                              \
+        return std::make_shared<classname>();                                                 \
     }                                                                                         \
     virtual double _getBuyNumber(const Datetime& datetime, const Stock& stock, price_t price, \
                                  price_t risk, SystemPart from) override;

hikyuu/include/hikyuu/trade_sys/profitgoal/ProfitGoalBase.h

@@ -141,7 +141,7 @@ private:                                                         \
 #define PROFITGOAL_IMP(classname)                               \
 public:                                                         \
     virtual ProfitGoalPtr _clone() override {                   \
-        return ProfitGoalPtr(new classname());                  \
+        return std::make_shared<classname>();                   \
     }                                                           \
     virtual price_t getGoal(const Datetime&, price_t) override; \
     virtual void _calculate() override;

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

@@ -61,6 +61,20 @@ public:
      */
     void addStockList(const StockList& stkList, const SystemPtr& protoSys);
 
+    /**
+     * 直接加入已有系统策略示例
+     * @note 应该已经绑定 stock
+     * @param sys
+     */
+    void addSystem(const SYSPtr& sys);
+
+    /**
+     * 直接加入已有系统策略示例
+     * @note 应该已经绑定 stock
+     * @param sys
+     */
+    void addSystemList(const SystemList& sys);
+
     /**
      * @brief 获取原型系统列表
      * @return const SystemList&
@@ -101,9 +115,18 @@ public:
 
     virtual bool isMatchAF(const AFPtr& af) = 0;
 
+    /** 用于逻辑运算的子类中添加原型系统，一般不需要子类实现 */
+    virtual void _addSystem(const SYSPtr& sys) {}
+
+    /** 用于逻辑运算的子类中添加原型系统，一般不需要子类实现 */
+    virtual void _removeAll() {}
+
     /* 仅供PF调用，由PF通知其实际运行的系统列表，并启动计算 */
     void calculate(const SystemList& pf_realSysList, const KQuery& query);
 
+    /* 仅供PF调用，建立实际系统到原型系统映射 */
+    virtual void bindRealToProto(const SYSPtr& real, const SYSPtr& proto) {}
+
     void calculate_proto(const KQuery& query);
 
 private:
@@ -175,7 +198,7 @@ private:                                                       \
 #define SELECTOR_IMP(classname)                                   \
 public:                                                           \
     virtual SelectorPtr _clone() override {                       \
-        return SelectorPtr(new classname());                      \
+        return std::make_shared<classname>();                     \
     }                                                             \
     virtual SystemWeightList getSelected(Datetime date) override; \
     virtual bool isMatchAF(const AFPtr& af) override;             \

hikyuu/include/hikyuu/trade_sys/selector/build_in.h

@@ -11,6 +11,7 @@
 
 #include "crt/SE_Fixed.h"
 #include "crt/SE_MultiFactor.h"
+#include "crt/SE_Operator.h"
 #include "crt/SE_Signal.h"
 
 #endif /* TRADE_SYS_SELECTOR_BUILD_IN_H_ */

hikyuu/include/hikyuu/trade_sys/selector/crt/SE_Fixed.h

@@ -15,20 +15,23 @@ namespace hku {
 
 /**
  * @brief 固定选择器，每天都选择指定的交易系统
+ * @param weight 固定权重
  * @return SelectorPtr
  * @ingroup Selector
  */
-SelectorPtr HKU_API SE_Fixed();
+SelectorPtr HKU_API SE_Fixed(double weight = 1.0);
 
 /**
  * @brief 固定选择器，每天都选择指定的交易系统
  * @details 对指定的每个股票以原型系统创建相应的交易系统
  * @param stock_list 指定的股票列表
  * @param sys 原型系统
+ * @param weight 固定权重
  * @return SelectorPtr
  * @ingroup Selector
  */
-SelectorPtr HKU_API SE_Fixed(const StockList& stock_list, const SystemPtr& sys);
+SelectorPtr HKU_API SE_Fixed(const StockList& stock_list, const SystemPtr& sys,
+                             double weight = 1.0);
 
 } /* namespace hku */
 

hikyuu/include/hikyuu/trade_sys/selector/crt/SE_MultiFactor.h

@@ -24,9 +24,7 @@ SelectorPtr HKU_API SE_MultiFactor(const MFPtr& mf, int topn = 10);
 /**
  * 基于 MultiFactor 选股算法
  * @param src_inds 原始因子公式
- * @param stks 证券列表
- * @param query 查询条件
- * @param topn 只选取时间截面中前 topn 个系统
+ * @param topn 只选取时间截面中前 topn 个系统，小于等于0时代表不限制
  * @param ic_n ic 对应的 ic_n 日收益率
  * @param ic_rolling_n 计算滚动 IC （即 IC 的 n 日移动平均）周期
  * @param ref_stk 参照对比证券，未指定时，默认使用 sh000300 沪深300指数
@@ -34,8 +32,7 @@ SelectorPtr HKU_API SE_MultiFactor(const MFPtr& mf, int topn = 10);
  * @return SelectorPtr
  * @ingroup Selector
  */
-SelectorPtr HKU_API SE_MultiFactor(const IndicatorList& src_inds, const StockList& stks,
-                                   const KQuery& query, int topn = 10, int ic_n = 5,
+SelectorPtr HKU_API SE_MultiFactor(const IndicatorList& src_inds, int topn = 10, int ic_n = 5,
                                    int ic_rolling_n = 120, const Stock& ref_stk = Stock(),
                                    const string& mode = "MF_ICIRWeight");
 

hikyuu/include/hikyuu/trade_sys/selector/crt/SE_Operator.h

@@ -0,0 +1,43 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../SelectorBase.h"
+
+namespace hku {
+
+HKU_API SelectorPtr operator+(const SelectorPtr& se1, const SelectorPtr& se2);
+HKU_API SelectorPtr operator-(const SelectorPtr& se1, const SelectorPtr& se2);
+HKU_API SelectorPtr operator*(const SelectorPtr& se1, const SelectorPtr& se2);
+HKU_API SelectorPtr operator/(const SelectorPtr& se1, const SelectorPtr& se2);
+
+inline SelectorPtr operator&(const SelectorPtr& se1, const SelectorPtr& se2) {
+    return se1 * se2;
+}
+
+inline SelectorPtr operator|(const SelectorPtr& se1, const SelectorPtr& se2) {
+    return se1 + se2;
+}
+
+HKU_API SelectorPtr operator+(const SelectorPtr& se, double value);
+inline SelectorPtr operator+(double value, const SelectorPtr& se) {
+    return se + value;
+}
+
+HKU_API SelectorPtr operator-(const SelectorPtr& se, double value);
+HKU_API SelectorPtr operator-(double value, const SelectorPtr& se);
+
+HKU_API SelectorPtr operator*(const SelectorPtr& se, double value);
+inline SelectorPtr operator*(double value, const SelectorPtr& se) {
+    return se * value;
+}
+
+HKU_API SelectorPtr operator/(const SelectorPtr& se, double value);
+HKU_API SelectorPtr operator/(double value, const SelectorPtr& se);
+
+}  // namespace hku

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

@@ -19,6 +19,7 @@ class FixedSelector : public SelectorBase {
 
 public:
     FixedSelector();
+    FixedSelector(double weight);
     virtual ~FixedSelector();
 };
 

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

@@ -25,18 +25,25 @@ public:
     virtual bool isMatchAF(const AFPtr& af) override;
     virtual void _calculate() override;
 
+    void setIndicators(const IndicatorList& inds) {
+        HKU_ASSERT(!inds.empty());
+        m_inds = inds;
+    }
+
 private:
+    IndicatorList m_inds;
     MFPtr m_mf;
     unordered_map<Stock, SYSPtr> m_stk_sys_dict;
 
     //============================================
-// 序列化支持
-//============================================
+    // 序列化支持
+    //============================================
 #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(SelectorBase);
+        ar& BOOST_SERIALIZATION_NVP(m_inds);
         ar& BOOST_SERIALIZATION_NVP(m_mf);
     }
 #endif

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorAddSelector : public OperatorSelector {
+    OPERATOR_SELECTOR_IMP(OperatorAddSelector, "SE_Add")
+    OPERATOR_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorAddValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorAddValueSelector, "SE_AddValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorDivSelector : public OperatorSelector {
+    OPERATOR_SELECTOR_IMP(OperatorDivSelector, "SE_Div")
+    OPERATOR_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorDivValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorDivValueSelector, "SE_DivValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorInvertDivValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorInvertDivValueSelector, "SE_DivValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorInvertSubValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorInvertSubValueSelector, "SE_SubValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorMulSelector : public OperatorSelector {
+    OPERATOR_SELECTOR_IMP(OperatorMulSelector, "SE_Multi")
+    OPERATOR_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorMulValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorMulValueSelector, "SE_MultiValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,99 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../SelectorBase.h"
+
+namespace hku {
+
+class HKU_API OperatorSelector : public SelectorBase {
+public:
+    OperatorSelector();
+    OperatorSelector(const string& name);
+    OperatorSelector(const string& name, const SelectorPtr& se1, const SelectorPtr& se2);
+    virtual ~OperatorSelector();
+
+    virtual void _reset() override;
+    virtual SelectorPtr _clone() override;
+    virtual bool isMatchAF(const AFPtr& af) override;
+    virtual void _calculate() override;
+    virtual SystemWeightList getSelected(Datetime date) override {
+        return SystemWeightList();
+    }
+
+    virtual void _addSystem(const SYSPtr& sys) override;
+    virtual void _removeAll() override;
+
+protected:
+    virtual void bindRealToProto(const SYSPtr& real, const SYSPtr& proto) override {
+        m_real_to_proto[real] = proto;
+    }
+
+    SystemWeightList getUnionSelected(Datetime date,
+                                      const std::function<double(double, double)>&& func);
+
+    SystemWeightList getIntersectionSelected(Datetime date,
+                                             const std::function<double(double, double)>&& func);
+
+protected:
+    static void sortSystemWeightList(SystemWeightList& swlist);
+
+    void cloneRebuild(const SelectorPtr& se1, const SelectorPtr& se2);
+
+protected:
+    SelectorPtr m_se1;
+    SelectorPtr m_se2;
+    std::unordered_set<SYSPtr> m_se1_set;  // se1 的原型系统实例集合
+    std::unordered_set<SYSPtr> m_se2_set;  // se2 的原型系统实例集合
+    std::unordered_map<SYSPtr, SYSPtr> m_real_to_proto;
+
+private:
+    static std::unordered_set<System*> findIntersection(const SelectorPtr& se1,
+                                                        const SelectorPtr& se2);
+
+private:
+    //============================================
+    // 序列化支持
+    //============================================
+#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(SelectorBase);
+        ar& BOOST_SERIALIZATION_NVP(m_se1);
+        ar& BOOST_SERIALIZATION_NVP(m_se2);
+    }
+#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!");     \
+    }
+
+#if HKU_SUPPORT_SERIALIZATION
+#define OPERATOR_SELECTOR_SERIALIZATION                            \
+private:                                                           \
+    friend class boost::serialization::access;                     \
+    template <class Archive>                                       \
+    void serialize(Archive& ar, const unsigned int version) {      \
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(OperatorSelector); \
+    }
+#else
+#define OPERATOR_SELECTOR_SERIALIZATION
+#endif
+
+}  // namespace hku

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorSubSelector : public OperatorSelector {
+    OPERATOR_SELECTOR_IMP(OperatorSubSelector, "SE_Sub")
+    OPERATOR_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorSubValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorSubValueSelector, "SE_SubValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,77 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../SelectorBase.h"
+
+namespace hku {
+
+class HKU_API OperatorValueSelector : public SelectorBase {
+public:
+    OperatorValueSelector();
+    OperatorValueSelector(const string& name);
+    OperatorValueSelector(const string& name, const SelectorPtr& se, double value);
+    virtual ~OperatorValueSelector();
+
+    virtual void _reset() override;
+    virtual SelectorPtr _clone() override;
+    virtual bool isMatchAF(const AFPtr& af) override;
+    virtual void _calculate() override;
+    virtual SystemWeightList getSelected(Datetime date) override {
+        return SystemWeightList();
+    }
+
+protected:
+    SelectorPtr m_se;
+    double m_value{0.0};
+
+private:
+    //============================================
+    // 序列化支持
+    //============================================
+#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(SelectorBase);
+        ar& BOOST_SERIALIZATION_NVP(m_se);
+        ar& BOOST_SERIALIZATION_NVP(m_value);
+    }
+#endif
+};
+
+#define OPERATOR_VALUE_SELECTOR_IMP(classname, name)                                           \
+public:                                                                                        \
+    classname() : OperatorValueSelector(name) {}                                               \
+    classname(const SelectorPtr& se, double value) : OperatorValueSelector(name, se, value) {} \
+    virtual ~classname() {}                                                                    \
+                                                                                               \
+    virtual SystemWeightList getSelected(Datetime date) override;                              \
+                                                                                               \
+    virtual SelectorPtr _clone() override {                                                    \
+        auto p = std::make_shared<classname>();                                                \
+        if (m_se) {                                                                            \
+            p->m_se = m_se->clone();                                                           \
+        }                                                                                      \
+        p->m_value = m_value;                                                                  \
+        return p;                                                                              \
+    }
+
+#if HKU_SUPPORT_SERIALIZATION
+#define OPERATOR_VALUE_SELECTOR_SERIALIZATION                           \
+private:                                                                \
+    friend class boost::serialization::access;                          \
+    template <class Archive>                                            \
+    void serialize(Archive& ar, const unsigned int version) {           \
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(OperatorValueSelector); \
+    }
+#else
+#define OPERATOR_VALUE_SELECTOR_SERIALIZATION
+#endif
+
+}  // namespace hku