hikyuu 2.5.6__py3-none-macosx_11_0_arm64.whl

hikyuu/include/hikyuu/python/pickle_support.h

@@ -0,0 +1,90 @@
+/*
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2020-5-24
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef PICKLE_SUPPORT_H_
+#define PICKLE_SUPPORT_H_
+
+#include <hikyuu/config.h>
+
+#if HKU_SUPPORT_BINARY_ARCHIVE || HKU_SUPPORT_XML_ARCHIVE || HKU_SUPPORT_TEXT_ARCHIVE
+#define HKU_PYTHON_SUPPORT_PICKLE 1
+#endif
+
+#if HKU_PYTHON_SUPPORT_PICKLE
+#if HKU_SUPPORT_BINARY_ARCHIVE
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/archive/binary_iarchive.hpp>
+#define OUTPUT_ARCHIVE boost::archive::binary_oarchive
+#define INPUT_ARCHIVE boost::archive::binary_iarchive
+
+#else
+#if HKU_SUPPORT_XML_ARCHIVE
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+#define OUTPUT_ARCHIVE boost::archive::xml_oarchive
+#define INPUT_ARCHIVE boost::archive::xml_iarchive
+
+#else
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#define OUTPUT_ARCHIVE boost::archive::text_oarchive
+#define INPUT_ARCHIVE boost::archive::text_iarchive
+#endif /* HKU_SUPPORT_XML_ARCHIVE */
+
+#endif /* HKU_SUPPORT_BINARY_ARCHIVE */
+#endif /* HKU_PYTHON_SUPPORT_PICKLE */
+
+#if HKU_PYTHON_SUPPORT_PICKLE
+#include <string>
+#include <sstream>
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+#define DEF_PICKLE(classname)                                                                      \
+    .def(py::pickle(                                                                               \
+      [](const classname& p) {                                                                     \
+          std::ostringstream os;                                                                   \
+          OUTPUT_ARCHIVE oa(os);                                                                   \
+          oa << p;                                                                                 \
+          std::string tmp(os.str());                                                               \
+          return py::make_tuple(py::handle(PyBytes_FromStringAndSize(tmp.data(), tmp.size())));    \
+      },                                                                                           \
+      [](py::tuple t) {                                                                            \
+          classname result;                                                                        \
+          if (len(t) != 1) {                                                                       \
+              PyErr_SetObject(                                                                     \
+                PyExc_ValueError,                                                                  \
+                py::str("expected 1-item tuple in call to __setstate__; got {}").format(t).ptr()); \
+              throw py::error_already_set();                                                       \
+          }                                                                                        \
+          py::object obj = t[0];                                                                   \
+          if (py::isinstance<py::str>(obj)) {                                                      \
+              std::string st = obj.cast<py::str>();                                                \
+              std::istringstream is(st);                                                           \
+              INPUT_ARCHIVE ia(is);                                                                \
+              ia >> result;                                                                        \
+          } else if (PyBytes_Check(py::object(t[0]).ptr())) {                                      \
+              py::object obj = t[0];                                                               \
+              char* data = PyBytes_AsString(obj.ptr());                                            \
+              auto num = PyBytes_Size(obj.ptr());                                                  \
+              std::istringstream sin(std::string(data, num));                                      \
+              INPUT_ARCHIVE ia(sin);                                                               \
+              ia >> result;                                                                        \
+              return result;                                                                       \
+          } else {                                                                                 \
+              throw std::runtime_error("Unable to unpickle, error in input file.");                \
+          }                                                                                        \
+          return result;                                                                           \
+      }))
+
+#else
+#define DEF_PICKLE(classname)
+#endif /* HKU_PYTHON_SUPPORT_PICKLE */
+
+#endif /* PICKLE_SUPPORT_H_ */

hikyuu/include/hikyuu/python/pybind_utils.h

@@ -0,0 +1,103 @@
+/*
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2020-5-25
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HIKYUU_PYTHON_BIND_UTILS_H
+#define HIKYUU_PYTHON_BIND_UTILS_H
+
+#include <pybind11/pybind11.h>
+
+#include <pybind11/operators.h>
+#include <pybind11/stl.h>
+#include <pybind11/numpy.h>
+#include <vector>
+#include <string>
+#include "convert_any.h"
+#include "pickle_support.h"
+#include "ioredirect.h"
+
+namespace py = pybind11;
+
+namespace hku {
+
+template <typename T>
+py::bytes vector_to_python_bytes(const std::vector<T>& vect) {
+    return py::bytes((char*)vect.data(), vect.size() * sizeof(T));
+}
+
+template <typename T>
+std::vector<T> python_bytes_to_vector(const py::bytes& obj) {
+    auto bytes_len = len(obj);
+    if (bytes_len % sizeof(T) != 0) {
+        throw std::runtime_error("The length bytes not match!");
+    }
+    auto vect_len = bytes_len / sizeof(T);
+    std::vector<T> result(vect_len);
+
+    char* buffer = nullptr;
+    Py_ssize_t length = 0;
+    if (PyBytes_AsStringAndSize(obj.ptr(), &buffer, &length) != 0) {
+        throw std::runtime_error("trans bytes to vector failed!");
+    }
+
+    if (length != static_cast<Py_ssize_t>(vect_len * sizeof(T))) {
+        throw std::runtime_error("The length bytes not match!");
+    }
+
+    memcpy(result.data(), buffer, length);
+    return result;
+}
+
+template <typename T>
+std::vector<T> python_list_to_vector(const py::sequence& obj) {
+    auto total = len(obj);
+    std::vector<T> vect(total);
+    for (auto i = 0; i < total; ++i) {
+        vect[i] = obj[i].cast<T>();
+    }
+    return vect;
+}
+
+template <typename T>
+py::list vector_to_python_list(const std::vector<T>& vect) {
+    py::list obj;
+    for (unsigned long i = 0; i < vect.size(); ++i)
+        obj.append(vect[i]);
+    return obj;
+}
+
+template <typename T>
+void extend_vector_with_python_list(std::vector<T>& v, const py::sequence& l) {
+    for (const auto& item : l)
+        v.push_back(item.cast<T>());
+}
+
+template <typename T>
+std::string to_py_str(const T& item) {
+    std::stringstream out;
+    out << item;
+    return out.str();
+}
+
+// 直接使用 pybind11 重载 _clone，在 C++ 中会丢失 python 中的类型
+// 参考：https://github.com/pybind/pybind11/issues/1049 进行修改
+// PYBIND11_OVERLOAD(IndicatorImpPtr, IndicatorImp, _clone, );
+#define PY_CLONE(pyclassname, classname)                                     \
+public:                                                                      \
+    std::shared_ptr<classname> _clone() override {                           \
+        auto self = py::cast(this);                                          \
+        auto cloned = self.attr("_clone")();                                 \
+                                                                             \
+        auto keep_python_state_alive = std::make_shared<py::object>(cloned); \
+        auto ptr = cloned.cast<pyclassname*>();                              \
+                                                                             \
+        return std::shared_ptr<classname>(keep_python_state_alive, ptr);     \
+    }
+
+}  // namespace hku
+
+#endif  // HIKYUU_PYTHON_BIND_UTILS_H

hikyuu/include/hikyuu/serialization/Block_serialization.h

@@ -0,0 +1,55 @@
+/*
+ * Block_serialization.h
+ *
+ *  Created on: 2015年2月9日
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef BLOCK_SERIALIZATION_H_
+#define BLOCK_SERIALIZATION_H_
+
+#include "../config.h"
+#include "../Block.h"
+
+#if HKU_SUPPORT_SERIALIZATION
+#include "Stock_serialization.h"
+
+namespace boost {
+namespace serialization {
+template <class Archive>
+void save(Archive& ar, const hku::Block& blk, unsigned int version) {
+    hku::string category = blk.category();
+    hku::string name = blk.name();
+    ar& boost::serialization::make_nvp("category", category);
+    ar& boost::serialization::make_nvp("name", name);
+    hku::StockList stock_list;
+    stock_list.reserve(blk.size());
+    for (auto iter = blk.begin(); iter != blk.end(); ++iter) {
+        stock_list.push_back(*iter);
+    }
+    ar& boost::serialization::make_nvp("stock_list", stock_list);
+}
+
+template <class Archive>
+void load(Archive& ar, hku::Block& blk, unsigned int version) {
+    hku::string category, name;
+    ar& boost::serialization::make_nvp("category", category);
+    ar& boost::serialization::make_nvp("name", name);
+    hku::StockList stock_list;
+    ar& boost::serialization::make_nvp("stock_list", stock_list);
+    HKU_IF_RETURN(category.empty() && name.empty(), void());
+    blk.category(category);
+    blk.name(name);
+    for (auto iter = stock_list.begin(); iter != stock_list.end(); ++iter) {
+        blk.add(*iter);
+    }
+}
+}  // namespace serialization
+}  // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(hku::Block)
+
+#endif /* HKU_SUPPORT_SERIALIZATION */
+
+#endif /* BLOCK_SERIALIZATION_H_ */

hikyuu/include/hikyuu/serialization/Datetime_serialization.h

@@ -0,0 +1,40 @@
+/*
+ * Datetime_Serialization.h
+ *
+ *  Created on: 2013-4-29
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef DATETIME_SERIALIZATION_H_
+#define DATETIME_SERIALIZATION_H_
+
+#include "hikyuu/utilities/datetime/Datetime.h"
+#include "../config.h"
+
+#if HKU_SUPPORT_SERIALIZATION
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost {
+namespace serialization {
+template <class Archive>
+void save(Archive& ar, const hku::Datetime& date, unsigned int version) {
+    std::string datetime = date.str();
+    ar& BOOST_SERIALIZATION_NVP(datetime);
+}
+
+template <class Archive>
+void load(Archive& ar, hku::Datetime& date, unsigned int version) {
+    std::string datetime;
+    ar& BOOST_SERIALIZATION_NVP(datetime);
+    date = hku::Datetime(datetime);
+}
+}  // namespace serialization
+}  // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(hku::Datetime)
+
+#endif /* HKU_SUPPORT_SERIALIZATION */
+
+#endif /* DATETIME_SERIALIZATION_H_ */

hikyuu/include/hikyuu/serialization/KData_serialization.h

@@ -0,0 +1,45 @@
+/*
+ * KData.h
+ *
+ *  Created on: 2013-5-1
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef KDATA_SERIALIZATION_H_
+#define KDATA_SERIALIZATION_H_
+
+#include "../config.h"
+#include "../KData.h"
+
+#if HKU_SUPPORT_SERIALIZATION
+#include "Stock_serialization.h"
+#include "KQuery_serialization.h"
+
+namespace boost {
+namespace serialization {
+template <class Archive>
+void save(Archive& ar, const hku::KData& kdata, unsigned int version) {
+    hku::Stock stock = kdata.getStock();
+    hku::KQuery query = kdata.getQuery();
+    ar& BOOST_SERIALIZATION_NVP(stock);
+    ar& BOOST_SERIALIZATION_NVP(query);
+}
+
+template <class Archive>
+void load(Archive& ar, hku::KData& kdata, unsigned int version) {
+    hku::Stock stock;
+    hku::KQuery query;
+    ar& BOOST_SERIALIZATION_NVP(stock);
+    ar& BOOST_SERIALIZATION_NVP(query);
+    kdata = stock.isNull() ? hku::KData() : hku::KData(stock, query);
+}
+
+}  // namespace serialization
+}  // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(hku::KData)
+
+#endif /* HKU_SUPPORT_SERIALIZATION */
+
+#endif /* KDATA_SERIALIZATION_H_ */

hikyuu/include/hikyuu/serialization/KQuery_serialization.h

@@ -0,0 +1,79 @@
+/*
+ * KQuery.h
+ *
+ *  Created on: 2013-5-1
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef SERIALIZATION_KQUERY_H_
+#define SERIALIZATION_KQUERY_H_
+
+#include "../KQuery.h"
+#include "../config.h"
+
+#if HKU_SUPPORT_SERIALIZATION
+
+namespace boost {
+namespace serialization {
+
+template <class Archive>
+void save(Archive& ar, const hku::KQuery& query, unsigned int version) {
+    hku::string queryType, kType, recoverType;
+    queryType = hku::KQuery::getQueryTypeName(query.queryType());
+    kType = hku::KQuery::getKTypeName(query.kType());
+    recoverType = hku::KQuery::getRecoverTypeName(query.recoverType());
+    ar& BOOST_SERIALIZATION_NVP(queryType);
+    ar& BOOST_SERIALIZATION_NVP(kType);
+    ar& BOOST_SERIALIZATION_NVP(recoverType);
+
+    if (query.queryType() == hku::KQuery::INDEX) {
+        hku::int64_t start = query.start();
+        hku::int64_t end = query.end();
+        ar& BOOST_SERIALIZATION_NVP(start);
+        ar& BOOST_SERIALIZATION_NVP(end);
+    } else if (query.queryType() == hku::KQuery::DATE) {
+        hku::uint64_t start = query.startDatetime().number();
+        hku::uint64_t end = query.endDatetime().number();
+        ar& BOOST_SERIALIZATION_NVP(start);
+        ar& BOOST_SERIALIZATION_NVP(end);
+    } else {
+        // 非法忽略
+    }
+}
+
+template <class Archive>
+void load(Archive& ar, hku::KQuery& query, unsigned int version) {
+    hku::string queryType, kType, recoverType;
+    ar& BOOST_SERIALIZATION_NVP(queryType);
+    ar& BOOST_SERIALIZATION_NVP(kType);
+    ar& BOOST_SERIALIZATION_NVP(recoverType);
+
+    hku::KQuery::QueryType enum_query = hku::KQuery::getQueryTypeEnum(queryType);
+    hku::KQuery::KType enmu_ktype = hku::KQuery::getKTypeEnum(kType);
+    hku::KQuery::RecoverType enum_recover = hku::KQuery::getRecoverTypeEnum(recoverType);
+
+    if (enum_query == hku::KQuery::INDEX) {
+        hku::int64_t start, end;
+        ar& BOOST_SERIALIZATION_NVP(start);
+        ar& BOOST_SERIALIZATION_NVP(end);
+        query = hku::KQuery(start, end, enmu_ktype, enum_recover);
+    } else if (enum_query == hku::KQuery::DATE) {
+        hku::uint64_t start, end;
+        ar& BOOST_SERIALIZATION_NVP(start);
+        ar& BOOST_SERIALIZATION_NVP(end);
+        query =
+          hku::KQueryByDate(hku::Datetime(start), hku::Datetime(end), enmu_ktype, enum_recover);
+    } else {
+        // 非法忽略
+    }
+}
+
+}  // namespace serialization
+}  // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(hku::KQuery)
+
+#endif /* HKU_SUPPORT_SERIALIZATION */
+
+#endif /* SERIALIZATION_KQUERY_H_ */

hikyuu/include/hikyuu/serialization/KRecord_serialization.h

@@ -0,0 +1,50 @@
+/*
+ * KRecord.h
+ *
+ *  Created on: 2013-5-1
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef KRECORD_SERIALIZATION_H_
+#define KRECORD_SERIALIZATION_H_
+
+#include "../config.h"
+#include "../KRecord.h"
+
+#if HKU_SUPPORT_SERIALIZATION
+
+namespace boost {
+namespace serialization {
+template <class Archive>
+void save(Archive& ar, const hku::KRecord& record, unsigned int version) {
+    hku::uint64_t datetime = record.datetime.number();
+    ar& BOOST_SERIALIZATION_NVP(datetime);
+    ar& make_nvp("openPrice", record.openPrice);
+    ar& make_nvp("highPrice", record.highPrice);
+    ar& make_nvp("lowPrice", record.lowPrice);
+    ar& make_nvp("closePrice", record.closePrice);
+    ar& make_nvp("transAmount", record.transAmount);
+    ar& make_nvp("transCount", record.transCount);
+}
+
+template <class Archive>
+void load(Archive& ar, hku::KRecord& record, unsigned int version) {
+    hku::uint64_t datetime;
+    ar& BOOST_SERIALIZATION_NVP(datetime);
+    record.datetime = hku::Datetime(datetime);
+    ar& make_nvp("openPrice", record.openPrice);
+    ar& make_nvp("highPrice", record.highPrice);
+    ar& make_nvp("lowPrice", record.lowPrice);
+    ar& make_nvp("closePrice", record.closePrice);
+    ar& make_nvp("transAmount", record.transAmount);
+    ar& make_nvp("transCount", record.transCount);
+}
+}  // namespace serialization
+}  // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(hku::KRecord)
+
+#endif /* HKU_SUPPORT_SERIALIZATION */
+
+#endif /* KRECORD_SERIALIZATION_H_ */

hikyuu/include/hikyuu/serialization/MarketInfo_serialization.h

@@ -0,0 +1,68 @@
+/*
+ * MarketInfo.h
+ *
+ *  Created on: 2013-5-1
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef MARKETINFO_SERIALIZATION_H_
+#define MARKETINFO_SERIALIZATION_H_
+
+#include "../config.h"
+#include "../MarketInfo.h"
+
+#if HKU_SUPPORT_SERIALIZATION
+#include "TimeDelta_serialization.h"
+
+namespace boost {
+namespace serialization {
+
+template <class Archive>
+void save(Archive& ar, const hku::MarketInfo& record, unsigned int version) {
+    hku::string market = record.market();
+    hku::string name = record.name();
+    hku::string description = record.description();
+    hku::string code = record.code();
+    hku::uint64_t lastDate = record.lastDate().number();
+    hku::TimeDelta openTime1 = record.openTime1();
+    hku::TimeDelta openTime2 = record.openTime2();
+    hku::TimeDelta closeTime1 = record.closeTime1();
+    hku::TimeDelta closeTime2 = record.closeTime2();
+    ar& BOOST_SERIALIZATION_NVP(market);
+    ar& BOOST_SERIALIZATION_NVP(name);
+    ar& BOOST_SERIALIZATION_NVP(description);
+    ar& BOOST_SERIALIZATION_NVP(code);
+    ar& BOOST_SERIALIZATION_NVP(lastDate);
+    ar& BOOST_SERIALIZATION_NVP(openTime1);
+    ar& BOOST_SERIALIZATION_NVP(closeTime1);
+    ar& BOOST_SERIALIZATION_NVP(openTime2);
+    ar& BOOST_SERIALIZATION_NVP(closeTime2);
+}
+
+template <class Archive>
+void load(Archive& ar, hku::MarketInfo& record, unsigned int version) {
+    hku::string market, name, description, code;
+    hku::uint64_t lastDate;
+    hku::TimeDelta openTime1, openTime2, closeTime1, closeTime2;
+    ar& BOOST_SERIALIZATION_NVP(market);
+    ar& BOOST_SERIALIZATION_NVP(name);
+    ar& BOOST_SERIALIZATION_NVP(description);
+    ar& BOOST_SERIALIZATION_NVP(code);
+    ar& BOOST_SERIALIZATION_NVP(lastDate);
+    ar& BOOST_SERIALIZATION_NVP(openTime1);
+    ar& BOOST_SERIALIZATION_NVP(closeTime1);
+    ar& BOOST_SERIALIZATION_NVP(openTime2);
+    ar& BOOST_SERIALIZATION_NVP(closeTime2);
+    record = hku::MarketInfo(market, name, description, code, hku::Datetime(lastDate), openTime1,
+                             closeTime1, openTime2, closeTime2);
+}
+
+}  // namespace serialization
+}  // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(hku::MarketInfo)
+
+#endif /* HKU_SUPPORT_SERIALIZATION */
+
+#endif /* MARKETINFO_SERIALIZATION_H_ */

hikyuu/include/hikyuu/serialization/PriceList_serialization.h

@@ -0,0 +1,66 @@
+/*
+ * PriceList_serialization.h
+ *
+ *  Created on: 2019-5-26
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef PRICELIST_SERIALIZATION_H_
+#define PRICELIST_SERIALIZATION_H_
+
+#include "../config.h"
+#include "../DataType.h"
+
+#if HKU_SUPPORT_SERIALIZATION
+#if HKU_SUPPORT_XML_ARCHIVE
+
+namespace boost {
+namespace serialization {
+template <class Archive>
+void save(Archive& ar, hku::PriceList& values, unsigned int version) {
+    size_t count = values.size();
+    unsigned int item_version = 0;
+    ar& BOOST_SERIALIZATION_NVP(count);
+    ar& BOOST_SERIALIZATION_NVP(item_version);
+    for (size_t i = 0; i < count; i++) {
+        if (std::isnan(values[i])) {
+            ar& boost::serialization::make_nvp("item", "nan");
+        } else if (std::isinf(values[i])) {
+            ar& boost::serialization::make_nvp("item", values[i] > 0 ? "+inf" : "-inf");
+        } else {
+            ar& boost::serialization::make_nvp("item", values[i]);
+        }
+    }
+}
+
+template <class Archive>
+void load(Archive& ar, hku::PriceList& values, unsigned int version) {
+    size_t count = 0;
+    unsigned int item_version = 0;
+    ar& BOOST_SERIALIZATION_NVP(count);
+    ar& BOOST_SERIALIZATION_NVP(item_version);
+    values.resize(count);
+    for (size_t i = 0; i < count; i++) {
+        std::string vstr;
+        ar >> boost::serialization::make_nvp("item", vstr);
+        if (vstr == "nan") {
+            values[i] = std::numeric_limits<double>::quiet_NaN();
+        } else if (vstr == "+inf") {
+            values[i] = std::numeric_limits<double>::infinity();
+        } else if (vstr == "-inf") {
+            values[i] = 0.0 - std::numeric_limits<double>::infinity();
+        } else {
+            values[i] = std::atof(vstr.c_str());
+        }
+    }
+}
+}  // namespace serialization
+}  // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(hku::PriceList)
+
+#endif /* HKU_SUPPORT_XML_ARCHIVE */
+#endif /* HKU_SUPPORT_SERIALIZATION */
+
+#endif /* PRICELIST_SERIALIZATION_H_ */

hikyuu/include/hikyuu/serialization/StockTypeInfo_serialization.h

@@ -0,0 +1,62 @@
+/*
+ * StockTypeInfo.h
+ *
+ *  Created on: 2013-5-1
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef STOCKTYPEINFO_SERIALIZATION_H_
+#define STOCKTYPEINFO_SERIALIZATION_H_
+
+#include "../config.h"
+#include "../StockTypeInfo.h"
+
+#if HKU_SUPPORT_SERIALIZATION
+
+namespace boost {
+namespace serialization {
+
+template <class Archive>
+void save(Archive& ar, const hku::StockTypeInfo& record, unsigned int version) {
+    hku::uint32_t type = record.type();
+    hku::string description = record.description();
+    hku::price_t tick = record.tick();
+    hku::price_t tickValue = record.tickValue();
+    int precision = record.precision();
+    double minTradeNumber = record.minTradeNumber();
+    double maxTradeNumber = record.maxTradeNumber();
+    ar& BOOST_SERIALIZATION_NVP(type);
+    ar& BOOST_SERIALIZATION_NVP(description);
+    ar& BOOST_SERIALIZATION_NVP(tick);
+    ar& BOOST_SERIALIZATION_NVP(tickValue);
+    ar& BOOST_SERIALIZATION_NVP(precision);
+    ar& BOOST_SERIALIZATION_NVP(minTradeNumber);
+    ar& BOOST_SERIALIZATION_NVP(maxTradeNumber);
+}
+
+template <class Archive>
+void load(Archive& ar, hku::StockTypeInfo& record, unsigned int version) {
+    hku::uint32_t type;
+    hku::string description;
+    hku::price_t tick, tickValue;
+    int precision;
+    double minTradeNumber, maxTradeNumber;
+    ar& BOOST_SERIALIZATION_NVP(type);
+    ar& BOOST_SERIALIZATION_NVP(description);
+    ar& BOOST_SERIALIZATION_NVP(tick);
+    ar& BOOST_SERIALIZATION_NVP(tickValue);
+    ar& BOOST_SERIALIZATION_NVP(precision);
+    ar& BOOST_SERIALIZATION_NVP(minTradeNumber);
+    ar& BOOST_SERIALIZATION_NVP(maxTradeNumber);
+    record = hku::StockTypeInfo(type, description, tick, tickValue, precision, minTradeNumber,
+                                maxTradeNumber);
+}
+}  // namespace serialization
+}  // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(hku::StockTypeInfo)
+
+#endif /* HKU_SUPPORT_SERIALIZATION */
+
+#endif /* STOCKTYPEINFO_SERIALIZATION_H_ */