hikyuu 2.1.0__cp312-none-win_amd64.whl → 2.1.2__cp312-none-win_amd64.whl

hikyuu/include/hikyuu/utilities/TimerManager.h

@@ -11,7 +11,7 @@
 #include <unordered_map>
 #include <functional>
 #include "hikyuu/utilities/datetime/Datetime.h"
-#include "hikyuu/Log.h"
+#include "hikyuu/utilities/Log.h"
 #include "thread/ThreadPool.h"
 #include "cppdef.h"
 
@@ -35,7 +35,23 @@ public:
      * @param work_num 定时任务执行线程池线程数量
      */
     explicit TimerManager(size_t work_num = 1)
-    : m_stop(true), m_current_timer_id(-1), m_work_num(work_num) {
+    : m_stop(true),
+      m_current_timer_id(-1),
+      m_work_num(work_num),
+      m_tg(nullptr),
+      m_use_extend_tg(false) {
+        HKU_ASSERT(work_num >= 1);
+        start();
+    }
+
+    /**
+     * 指定线程池方式构造，以便共享其他线程池
+     * @note 请自行保证 tg 的生命周期在 TimerManager 存活期间始终有效
+     * @param tg 指定任务组线程池
+     */
+    explicit TimerManager(ThreadPool* tg)
+    : m_stop(true), m_current_timer_id(-1), m_work_num(1), m_tg(tg), m_use_extend_tg(true) {
+        HKU_ASSERT(m_tg);
         start();
     }
 
@@ -60,11 +76,7 @@ public:
         std::priority_queue<IntervalS> new_queue;
         m_queue.swap(new_queue);
         if (!m_tg) {
-#if CPP_STANDARD >= CPP_STANDARD_14
-            m_tg = std::make_unique<ThreadPool>(m_work_num);
-#else
-            m_tg = std::unique_ptr<ThreadPool>(new ThreadPool(m_work_num));
-#endif
+            m_tg = new ThreadPool(m_work_num);
         }
 
         /*
@@ -152,9 +164,10 @@ public:
             m_detect_thread.join();
         }
 
-        if (m_tg) {
+        if (!m_use_extend_tg && m_tg) {
             m_tg->stop();
-            m_tg.reset();
+            delete m_tg;
+            m_tg = nullptr;
         }
     }
 
@@ -399,7 +412,7 @@ private:
     // 分配 timer_id
     int getNewTimerId() {
         int max_int = std::numeric_limits<int>::max();
-        HKU_WARN_IF_RETURN(m_timers.size() >= max_int, -1, "Timer queue is full!");
+        HKU_WARN_IF_RETURN(m_timers.size() >= size_t(max_int), -1, "Timer queue is full!");
 
         if (m_current_timer_id >= max_int) {
             m_current_timer_id = 0;
@@ -532,7 +545,8 @@ private:
     std::unordered_map<int, Timer*> m_timers;
     int m_current_timer_id;
     size_t m_work_num;  // 任务执行线程池线程数量
-    std::unique_ptr<ThreadPool> m_tg;
+    ThreadPool* m_tg{nullptr};
+    bool m_use_extend_tg{false};
 };
 
 }  // namespace hku

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,18 +82,17 @@ 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 银行家舍入法
     ValueT pow1, pow2, y, z;
     ValueT x = number;
     if (ndigits >= 0) {
-        pow1 = std::pow<ValueT>(10.0, (ValueT)ndigits);
+        pow1 = pow(ValueT(10.0), ValueT(ndigits));
         pow2 = 1.0;
         y = (x * pow1) * pow2;
     } else {
-        pow1 = std::pow<ValueT>(10.0, (ValueT)-ndigits);
+        pow1 = pow(ValueT(10.0), ValueT(-ndigits));
         pow2 = 1.0;
         y = x / pow1;
     }
@@ -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_ */