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

hikyuu/include/hikyuu/utilities/any_to_string.h

@@ -0,0 +1,142 @@
+/*
+ *  Copyright (c) 2023 hikyuu.org
+ *
+ *  Created on: 2023-01-15
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include <string>
+
+#include "osdef.h"
+#include "cppdef.h"
+#if !HKU_OS_IOS && CPP_STANDARD >= CPP_STANDARD_17
+#include <any>
+#else
+#include <boost/any.hpp>
+#endif
+
+#if defined(HKU_SUPPORT_DATETIME)
+#include "hikyuu/utilities/datetime/Datetime.h"
+#endif
+
+namespace hku {
+
+#if !HKU_OS_IOS && CPP_STANDARD >= CPP_STANDARD_17
+using any_t = std::any;
+using std::any_cast;
+#else
+using any_t = boost::any;
+using boost::any_cast;
+#endif
+
+//------------------------------------------------------------------------------
+//
+// 常见基本类型包装的 any_t 和 std::string 的互相转换函数
+// any_to_string 要用户自定义类型需包含从 std::string 进行构造的构造函数
+// string_to_any 需要用户自定义实现 std::to_string 特化方法
+//
+//------------------------------------------------------------------------------
+
+template <typename ValueT>
+inline std::string any_to_string(const any_t& data) {
+    return any_cast<ValueT>(data).str();
+}
+
+template <typename ValueT>
+inline any_t string_to_any(const std::string& data) {
+    return any_t(ValueT(data));
+}
+
+template <>
+inline std::string any_to_string<int>(const any_t& data) {
+    return std::to_string(any_cast<int>(data));
+}
+
+template <>
+inline std::string any_to_string<long>(const any_t& data) {
+    return std::to_string(any_cast<long>(data));
+}
+
+template <>
+inline std::string any_to_string<long long>(const any_t& data) {
+    return std::to_string(any_cast<long long>(data));
+}
+
+template <>
+inline std::string any_to_string<unsigned int>(const any_t& data) {
+    return std::to_string(any_cast<unsigned int>(data));
+}
+
+template <>
+inline std::string any_to_string<unsigned long>(const any_t& data) {
+    return std::to_string(any_cast<unsigned long>(data));
+}
+
+template <>
+inline std::string any_to_string<unsigned long long>(const any_t& data) {
+    return std::to_string(any_cast<unsigned long long>(data));
+}
+
+template <>
+inline std::string any_to_string<float>(const any_t& data) {
+    return std::to_string(any_cast<float>(data));
+}
+
+template <>
+inline std::string any_to_string<double>(const any_t& data) {
+    return std::to_string(any_cast<double>(data));
+}
+
+template <>
+inline std::string any_to_string<long double>(const any_t& data) {
+    return std::to_string(any_cast<long double>(data));
+}
+
+template <>
+inline any_t string_to_any<int>(const std::string& data) {
+    return any_t(std::stoi(data));
+}
+
+template <>
+inline any_t string_to_any<long>(const std::string& data) {
+    return any_t(std::stol(data));
+}
+
+template <>
+inline any_t string_to_any<long long>(const std::string& data) {
+    return any_t(std::stoll(data));
+}
+
+template <>
+inline any_t string_to_any<unsigned int>(const std::string& data) {
+    return any_t((unsigned int)(std::stoul(data)));
+}
+
+template <>
+inline any_t string_to_any<unsigned long>(const std::string& data) {
+    return any_t(std::stoul(data));
+}
+
+template <>
+inline any_t string_to_any<unsigned long long>(const std::string& data) {
+    return any_t(std::stoull(data));
+}
+
+template <>
+inline any_t string_to_any<float>(const std::string& data) {
+    return any_t(std::stof(data));
+}
+
+template <>
+inline any_t string_to_any<double>(const std::string& data) {
+    return any_t(std::stod(data));
+}
+
+template <>
+inline any_t string_to_any<long double>(const std::string& data) {
+    return any_t(std::stold(data));
+}
+
+}  // namespace hku

hikyuu/include/hikyuu/utilities/arithmetic.h

@@ -15,11 +15,12 @@
 #include <cctype>
 #include <vector>
 #include <string>
-#include <string_view>
 #include <algorithm>
 
-#ifndef HKU_API
-#define HKU_API
+#include "string_view.h"
+
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
 #endif
 
 namespace hku {
@@ -30,13 +31,13 @@ namespace hku {
  */
 
 #if defined(_MSC_VER)
-std::string HKU_API utf8_to_gb(const char* szinput);
-std::string HKU_API utf8_to_gb(const std::string& szinput);
-std::string HKU_API gb_to_utf8(const char* szinput);
-std::string HKU_API gb_to_utf8(const std::string& szinput);
+std::string HKU_UTILS_API utf8_to_gb(const char *szinput);
+std::string HKU_UTILS_API utf8_to_gb(const std::string &szinput);
+std::string HKU_UTILS_API gb_to_utf8(const char *szinput);
+std::string HKU_UTILS_API gb_to_utf8(const std::string &szinput);
 #else
-std::string HKU_API utf8_to_gb(const std::string& szinput);
-std::string HKU_API gb_to_utf8(const std::string& szinput);
+std::string HKU_UTILS_API utf8_to_gb(const std::string &szinput);
+std::string HKU_UTILS_API gb_to_utf8(const std::string &szinput);
 #endif
 
 #define UTF8ToGB hku::utf8_to_gb
@@ -81,7 +82,6 @@ std::string HKU_API gb_to_utf8(const std::string& szinput);
  * @param ndigits 保留小数位数
  * @return 处理过的数据
  */
-// double HKU_API roundEx(double number, int ndigits = 0);
 template <typename ValueT>
 ValueT roundEx(ValueT number, int ndigits = 0) {
     // 切换至：ROUND_HALF_EVEN 银行家舍入法
@@ -189,17 +189,17 @@ ValueT roundDown(ValueT number, int ndigits = 0) {
 #endif
 
 /** 转小写字符串 */
-inline void to_lower(std::string& s) {
+inline void to_lower(std::string &s) {
     std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); });
 }
 
 /** 转大写字符串 */
-inline void to_upper(std::string& s) {
+inline void to_upper(std::string &s) {
     std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::toupper(c); });
 }
 
 /** 删除字符串两端空格 */
-inline void trim(std::string& s) {
+inline void trim(std::string &s) {
     if (s.empty()) {
         return;
     }
@@ -210,12 +210,13 @@ inline void trim(std::string& s) {
     s.erase(s.find_last_not_of("\n") + 1);
 }
 
+#if CPP_STANDARD >= CPP_STANDARD_17
 /**
  * 分割字符串
  * @param str 待封的字符串
  * @param c 分割符
  */
-inline std::vector<std::string_view> split(const std::string& str, char c) {
+inline std::vector<std::string_view> split(const std::string &str, char c) {
     std::vector<std::string_view> result;
     std::string_view view(str);
     size_t prepos = 0;
@@ -226,9 +227,7 @@ inline std::vector<std::string_view> split(const std::string& str, char c) {
         pos = view.find_first_of(c, prepos);
     }
 
-    if (prepos < str.size() - 1) {
-        result.emplace_back(str.substr(prepos));
-    }
+    result.emplace_back(view.substr(prepos));
     return result;
 }
 
@@ -239,7 +238,7 @@ inline std::vector<std::string_view> split(const std::string& str, char c) {
  * @return string_view 组成的 vector
  * @note 注意返回结果的生命周期应小于输入的字符串相同！
  */
-inline std::vector<std::string_view> split(const std::string_view& view, char c) {
+inline std::vector<std::string_view> split(const std::string_view &view, char c) {
     std::vector<std::string_view> result;
     size_t prepos = 0;
     size_t pos = view.find_first_of(c);
@@ -249,14 +248,12 @@ inline std::vector<std::string_view> split(const std::string_view& view, char c)
         pos = view.find_first_of(c, prepos);
     }
 
-    if (prepos < view.size() - 1) {
-        result.emplace_back(view.substr(prepos));
-    }
+    result.emplace_back(view.substr(prepos));
     return result;
 }
 
-inline std::vector<std::string_view> split(const std::string_view& str,
-                                           const std::string& split_str) {
+inline std::vector<std::string_view> split(const std::string_view &str,
+                                           const std::string &split_str) {
     std::vector<std::string_view> result;
     size_t split_str_len = split_str.size();
     if (split_str_len == 0) {
@@ -272,25 +269,64 @@ inline std::vector<std::string_view> split(const std::string_view& str,
         pos = str.find(split_str, prepos);
     }
 
-    if (prepos < str.size() - 1) {
-        result.emplace_back(str.substr(prepos));
+    result.emplace_back(str.substr(prepos));
+    return result;
+}
+
+#else
+/**
+ * 分割字符串
+ * @param str 待封的字符串
+ * @param c 分割符
+ */
+inline std::vector<std::string> split(const std::string &str, char c) {
+    std::vector<std::string> result;
+    size_t prepos = 0;
+    size_t pos = str.find_first_of(c);
+    while (pos != std::string::npos) {
+        result.emplace_back(str.substr(prepos, pos - prepos));
+        prepos = pos + 1;
+        pos = str.find_first_of(c, prepos);
+    }
+
+    result.emplace_back(str.substr(prepos));
+    return result;
+}
+
+inline std::vector<std::string> split(const std::string &str, const std::string &split_str) {
+    std::vector<std::string> result;
+    size_t split_str_len = split_str.size();
+    if (split_str_len == 0) {
+        result.emplace_back(str);
+        return result;
     }
+
+    size_t prepos = 0;
+    size_t pos = str.find(split_str);
+    while (pos != std::string::npos) {
+        result.emplace_back(str.substr(prepos, pos - prepos));
+        prepos = pos + split_str_len;
+        pos = str.find(split_str, prepos);
+    }
+
+    result.emplace_back(str.substr(prepos));
     return result;
 }
+#endif /* #if CPP_STANDARD >= CPP_STANDARD_17 */
 
 /**
  * byte 转 16 进制字符串, 如 "abcd" 转换为 "61626364"
  * @param in_byte 输入的 byte 数组
  * @param in_len byte 数组长度
  */
-inline std::string byteToHexStr(const char* bytes, size_t in_len) {
+inline std::string byteToHexStr(const char *bytes, size_t in_len) {
     std::string hexstr;
-    const unsigned char* in_byte = (const unsigned char*)bytes;
+    const unsigned char *in_byte = (const unsigned char *)bytes;
     if (in_byte == nullptr) {
         return hexstr;
     }
 
-    char* buf = new char[2 * in_len + 1];
+    char *buf = new char[2 * in_len + 1];
     size_t buf_ix = 0;
 
     for (size_t i = 0; i < in_len; ++i) {
@@ -311,7 +347,7 @@ inline std::string byteToHexStr(const char* bytes, size_t in_len) {
  * byte 转 16 进制字符串, 如 "abcd" 转换为 "61626364"
  * @param in_byte std::string 格式的输入
  */
-inline std::string byteToHexStr(const std::string& bytes) {
+inline std::string byteToHexStr(const std::string &bytes) {
     return byteToHexStr(bytes.c_str(), bytes.size());
 }
 
@@ -320,14 +356,14 @@ inline std::string byteToHexStr(const std::string& bytes) {
  * @param in_byte 输入的 byte 数组
  * @param in_len byte 数组长度
  */
-inline std::string byteToHexStrForPrint(const char* bytes, size_t in_len) {
+inline std::string byteToHexStrForPrint(const char *bytes, size_t in_len) {
     std::string hexstr;
-    const unsigned char* in_byte = (const unsigned char*)bytes;
+    const unsigned char *in_byte = (const unsigned char *)bytes;
     if (in_byte == nullptr) {
         return hexstr;
     }
 
-    char* buf = new char[5 * in_len + 1];
+    char *buf = new char[5 * in_len + 1];
     size_t buf_ix = 0;
 
     for (size_t i = 0; i < in_len; ++i) {
@@ -355,7 +391,7 @@ inline std::string byteToHexStrForPrint(const char* bytes, size_t in_len) {
  * byte 转 16 进制字符串, 如 "abcd" 转换为 "61626364"
  * @param in_byte 输入的 byte 数组
  */
-inline std::string byteToHexStrForPrint(const std::string& bytes) {
+inline std::string byteToHexStrForPrint(const std::string &bytes) {
     return byteToHexStrForPrint(bytes.c_str(), bytes.size());
 }
 

hikyuu/include/hikyuu/utilities/base64.h

@@ -0,0 +1,59 @@
+/*
+ *  Copyright (c) hikyuu.org
+ *
+ *  Created on: 2020-6-2
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HKU_UTILS_BASE64_H
+#define HKU_UTILS_BASE64_H
+
+#include <memory>
+#include "string_view.h"
+
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
+#endif
+
+namespace hku {
+
+/**
+ * 将二进制 bytes 数组编码成 base64 字符串
+ * @param bytes_to_encode 内存起始地址
+ * @param in_len 待计算的字节长度
+ */
+std::string HKU_UTILS_API base64_encode(unsigned char const* bytes_to_encode, size_t in_len);
+
+/**
+ * 字符串编码为 base64
+ * @param bytes_to_encode 内存起始地址
+ * @param in_len 待计算的字节长度
+ * @note 通过 func(unsigned char *, unsigned int) 函数实现，而不是直接只提供 string_view
+ * 版本的原因是：c++17 string_view 处理 nullptr 时，程序会直接挂掉，无异常
+ */
+inline std::string base64_encode(string_view src) {
+    return base64_encode((unsigned char const*)src.data(), src.size());
+}
+
+/**
+ * 将 base64 字符串解码
+ * @param encoded_string base64 编码的字符串
+ * @param in_len 字符串长度
+ * @return string 实际解码后的二进制内容保存在返回的字符串对象中
+ * @note 如果传入的base64编码字符串中含有非法字符，不会告警，仅处理到能处理的字符
+ */
+std::string HKU_UTILS_API base64_decode(unsigned char const* encoded_string, size_t in_len);
+
+/**
+ * 将 base64 字符串解码
+ * @param encoded_string base64 编码的字符串
+ * @return string 实际解码后的二进制内容保存在返回的字符串对象中
+ */
+inline std::string base64_decode(string_view encoded_string) {
+    return base64_decode((unsigned char const*)encoded_string.data(), encoded_string.size());
+}
+
+}  // namespace hku
+
+#endif  // HKU_UTILS_BASE64_H

hikyuu/include/hikyuu/utilities/config.h

@@ -0,0 +1,41 @@
+#pragma once
+#ifndef HKU_UTILS_CONFIG_H_
+#define HKU_UTILS_CONFIG_H_
+
+#include "osdef.h"
+
+// clang-format off
+
+#define HKU_ENABLE_MYSQL 1
+#if HKU_ENABLE_MYSQL && HKU_OS_WINDOWS
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#endif
+
+#define HKU_ENABLE_SQLITE 1
+#define HKU_ENABLE_SQLCIPHER 0
+/* #define HKU_SQL_TRACE 0 */
+
+#define HKU_SUPPORT_DATETIME 1
+
+#define HKU_ENABLE_INI_PARSER 1
+
+#define HKU_ENABLE_STACK_TRACE 0
+
+#define HKU_CLOSE_SPEND_TIME 0
+
+#define HKU_USE_SPDLOG_ASYNC_LOGGER 0
+#define HKU_LOG_ACTIVE_LEVEL "2"
+
+#define HKU_ENABLE_MO 0
+
+#define HKU_ENABLE_HTTP_CLIENT 1
+#define HKU_ENABLE_HTTP_CLIENT_SSL 0
+#define HKU_ENABLE_HTTP_CLIENT_ZIP 0
+
+/* #undef HKU_ENABLE_NODE */
+
+// clang-format on
+
+#endif /* HKU_UTILS_CONFIG_H_ */

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

@@ -17,14 +17,19 @@
 #include <string>
 #include <vector>
 #include <fmt/ostream.h>
+
+#include "hikyuu/utilities/config.h"
+#if !HKU_SUPPORT_DATETIME
+#error "Don't support datetime, you can config with --datetime=y"
+#endif
 #include "TimeDelta.h"
 
 #if defined(_MSC_VER)
 #pragma warning(disable : 4251)
 #endif
 
-#ifndef HKU_API
-#define HKU_API
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
 #endif
 
 namespace hku {
@@ -37,7 +42,7 @@ namespace bd = boost::gregorian;
  * @details 构造失败将抛出异常 std::out_of_range
  * @ingroup DataType
  */
-class HKU_API Datetime {
+class HKU_UTILS_API Datetime {
 public:
     /** 返回所能表示的最小日期：1400-Jan-01 00:00:00 */
     static Datetime min();
@@ -61,7 +66,7 @@ public:
     /** 默认构造函数，Null<Datetime> */
     Datetime();
 
-    Datetime(const Datetime&);
+    Datetime(const Datetime &);
 
     /**
      * 构造函数
@@ -78,10 +83,10 @@ public:
              long millisec = 0, long microsec = 0);
 
     /** 从boost::gregorian::date构造日期类型 */
-    explicit Datetime(const bd::date&);
+    explicit Datetime(const bd::date &);
 
     /** 从boost::posix_time::ptime构造 */
-    explicit Datetime(const bt::ptime&);
+    explicit Datetime(const bt::ptime &);
 
     /**
      * 通过数字方式构造日期类型
@@ -103,9 +108,9 @@ public:
      *     4、"20010101T181159"
      * </pre>
      */
-    explicit Datetime(const std::string&);
+    explicit Datetime(const std::string &);
 
-    Datetime& operator=(const Datetime&);
+    Datetime &operator=(const Datetime &);
 
     /** 年份，如果是 Null 将抛出异常 */
     long year() const;
@@ -283,7 +288,7 @@ private:
     bt::ptime m_data;
 };
 
-HKU_API std::ostream& operator<<(std::ostream&, const Datetime&);
+HKU_UTILS_API std::ostream &operator<<(std::ostream &, const Datetime &);
 
 /**
  * 日期列表
@@ -297,41 +302,41 @@ typedef std::vector<Datetime> DatetimeList;
  * @param end 结束日期
  * @return [start, end)范围内的日历日期
  */
-DatetimeList HKU_API getDateRange(const Datetime& start, const Datetime& end);
+DatetimeList HKU_UTILS_API getDateRange(const Datetime &start, const Datetime &end);
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // 关系比较函数, 不直接在类中定义是为了支持 Null<>() == d，Null可以放在左边
 //
 ///////////////////////////////////////////////////////////////////////////////
-bool operator==(const Datetime&, const Datetime&);
-bool operator!=(const Datetime&, const Datetime&);
-bool operator>(const Datetime&, const Datetime&);
-bool operator<(const Datetime&, const Datetime&);
-bool operator>=(const Datetime&, const Datetime&);
-bool operator<=(const Datetime&, const Datetime&);
-
-inline bool operator==(const Datetime& d1, const Datetime& d2) {
+bool operator==(const Datetime &, const Datetime &);
+bool operator!=(const Datetime &, const Datetime &);
+bool operator>(const Datetime &, const Datetime &);
+bool operator<(const Datetime &, const Datetime &);
+bool operator>=(const Datetime &, const Datetime &);
+bool operator<=(const Datetime &, const Datetime &);
+
+inline bool operator==(const Datetime &d1, const Datetime &d2) {
     return d1.ptime() == d2.ptime();
 }
 
-inline bool operator!=(const Datetime& d1, const Datetime& d2) {
+inline bool operator!=(const Datetime &d1, const Datetime &d2) {
     return d1.ptime() != d2.ptime();
 }
 
-inline bool operator>(const Datetime& d1, const Datetime& d2) {
+inline bool operator>(const Datetime &d1, const Datetime &d2) {
     return d1.ptime() > d2.ptime();
 }
 
-inline bool operator<(const Datetime& d1, const Datetime& d2) {
+inline bool operator<(const Datetime &d1, const Datetime &d2) {
     return d1.ptime() < d2.ptime();
 }
 
-inline bool operator>=(const Datetime& d1, const Datetime& d2) {
+inline bool operator>=(const Datetime &d1, const Datetime &d2) {
     return d1.ptime() >= d2.ptime();
 }
 
-inline bool operator<=(const Datetime& d1, const Datetime& d2) {
+inline bool operator<=(const Datetime &d1, const Datetime &d2) {
     return d1.ptime() <= d2.ptime();
 }
 
@@ -340,11 +345,11 @@ inline bool operator<=(const Datetime& d1, const Datetime& d2) {
 // 加、减法运算补充
 //
 ///////////////////////////////////////////////////////////////////////////////
-inline Datetime operator+(const TimeDelta& delta, const Datetime& date) {
+inline Datetime operator+(const TimeDelta &delta, const Datetime &date) {
     return date + delta;
 }
 
-inline TimeDelta operator-(const Datetime& d1, const Datetime& d2) {
+inline TimeDelta operator-(const Datetime &d1, const Datetime &d2) {
     return TimeDelta(d1.ptime() - d2.ptime());
 }
 
@@ -359,11 +364,11 @@ inline Datetime::Datetime() {
     m_data = bt::ptime(d, bt::time_duration(0, 0, 0));
 }
 
-inline Datetime::Datetime(const Datetime& d) : m_data(d.m_data) {}
+inline Datetime::Datetime(const Datetime &d) : m_data(d.m_data) {}
 
-inline Datetime::Datetime(const bd::date& d) : m_data(bt::ptime(d, bt::time_duration(0, 0, 0))) {}
+inline Datetime::Datetime(const bd::date &d) : m_data(bt::ptime(d, bt::time_duration(0, 0, 0))) {}
 
-inline Datetime::Datetime(const bt::ptime& d) : m_data(d) {}
+inline Datetime::Datetime(const bt::ptime &d) : m_data(d) {}
 
 inline bt::ptime Datetime::ptime() const {
     return m_data;
@@ -404,21 +409,26 @@ namespace std {
 template <>
 class hash<hku::Datetime> {
 public:
-    size_t operator()(hku::Datetime const& d) const noexcept {
+    size_t operator()(hku::Datetime const &d) const noexcept {
         return d.ticks();  // or use boost::hash_combine
     }
 };
+
+inline string to_string(const hku::Datetime &date) {
+    return date.str();
+}
+
 }  // namespace std
 
 #if FMT_VERSION >= 90000
 template <>
 struct fmt::formatter<hku::Datetime> {
-    constexpr auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    constexpr auto parse(format_parse_context &ctx) -> decltype(ctx.begin()) {
         return ctx.end();
     }
 
     template <typename FormatContext>
-    auto format(const hku::Datetime& d, FormatContext& ctx) const -> decltype(ctx.out()) {
+    auto format(const hku::Datetime &d, FormatContext &ctx) const -> decltype(ctx.out()) {
         return fmt::format_to(ctx.out(), "{}", d.str());
     }
 };