hikyuu 2.3.0__py3-none-win_amd64.whl → 2.5.0__py3-none-win_amd64.whl

hikyuu/include/hikyuu/utilities/FilterNode.h

@@ -249,10 +249,10 @@ public:
      * @param data 事件附加信息
      */
     void dispatch(const EventT& event, const any_t& data) {
-        m_tg->submit([=] {
+        m_tg->submit([this, event, data] {
             auto iter = m_trees.find(event);
             HKU_WARN_IF_RETURN(iter == m_trees.end(), void(),
-                              "There is no matching handling method for the event({})!", event);
+                               "There is no matching handling method for the event({})!", event);
             iter->second->run(data);
         });
     }

hikyuu/include/hikyuu/utilities/Log.h

@@ -344,14 +344,18 @@ std::shared_ptr<spdlog::logger> HKU_UTILS_API getHikyuuLogger();
 
 /** 用于 catch (...) 中打印，减少编译后代码大小 */
 extern std::string g_unknown_error_msg;
-#define HKU_THROW_UNKNOWN HKU_THROW(g_unknown_error_msg);
-#define HKU_TRACE_UNKNOWN HKU_TRACE(g_unknown_error_msg)
-#define HKU_DEBUG_UNKNOWN HKU_DEBUG(g_unknown_error_msg)
-#define HKU_INFO_UNKNOWN HKU_INFO(g_unknown_error_msg)
-#define HKU_ERROR_UNKNOWN HKU_ERROR(g_unknown_error_msg)
-#define HKU_FATAL_UNKNOWN HKU_FATAL(g_unknown_error_msg)
-
-#if CPP_STANDARD >= CPP_STANDARD_17
+#define HKU_THROW_UNKNOWN HKU_THROW("{}", g_unknown_error_msg);
+#define HKU_TRACE_UNKNOWN HKU_TRACE("{}", g_unknown_error_msg)
+#define HKU_DEBUG_UNKNOWN HKU_DEBUG("{}", g_unknown_error_msg)
+#define HKU_INFO_UNKNOWN HKU_INFO("{}", g_unknown_error_msg)
+#define HKU_ERROR_UNKNOWN HKU_ERROR("{}", g_unknown_error_msg)
+#define HKU_FATAL_UNKNOWN HKU_FATAL("{}", g_unknown_error_msg)
+
+#if CPP_STANDARD >= CPP_STANDARD_20
+#define CLASS_LOGGER_IMP(cls) \
+protected:                    \
+    static constexpr const char* ms_logger = #cls;
+#elif CPP_STANDARD >= CPP_STANDARD_17
 #define CLASS_LOGGER_IMP(cls) \
 protected:                    \
     inline static const char* ms_logger = #cls;
@@ -396,13 +400,36 @@ protected:                    \
     HKU_FATAL_IF_RETURN(expr, ret, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
 
 #define CLS_ASSERT HKU_ASSERT
-#define CLS_CHECK(expr, ...) \
-    HKU_CHECK(expr, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
-#define CLS_CHECK_THROW(expr, except, ...) \
-    HKU_CHECK_THROW(expr, except, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
-#define CLS_THROW(...) HKU_THROW(fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
-#define CLS_THROW_EXCEPTION(except, ...) \
-    HKU_THROW_EXCEPTION(except, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+
+#define CLS_CHECK(expr, ...)                                                                  \
+    do {                                                                                      \
+        if (!(expr)) {                                                                        \
+            throw hku::exception(fmt::format("[{}] CLS_CHECK({}) {} [{}] ({}:{})", ms_logger, \
+                                             #expr, fmt::format(__VA_ARGS__), HKU_FUNCTION,   \
+                                             __FILE__, __LINE__));                            \
+        }                                                                                     \
+    } while (0)
+
+#define CLS_CHECK_THROW(expr, except, ...)                                                         \
+    do {                                                                                           \
+        if (!(expr)) {                                                                             \
+            throw except(fmt::format("[{}] CLS_CHECK({}) {} [{}] ({}:{})", ms_logger, #expr,       \
+                                     fmt::format(__VA_ARGS__), HKU_FUNCTION, __FILE__, __LINE__)); \
+        }                                                                                          \
+    } while (0)
+
+#define CLS_THROW(...)                                                                     \
+    do {                                                                                   \
+        throw hku::exception(fmt::format("[{}] EXCEPTION: {} [{}] ({}:{})", ms_logger,     \
+                                         fmt::format(__VA_ARGS__), HKU_FUNCTION, __FILE__, \
+                                         __LINE__));                                       \
+    } while (0)
+
+#define CLS_THROW_EXCEPTION(except, ...)                                                       \
+    do {                                                                                       \
+        throw except(fmt::format("[{}] EXCEPTION: {} [{}] ({}:{})", ms_logger,                 \
+                                 fmt::format(__VA_ARGS__), HKU_FUNCTION, __FILE__, __LINE__)); \
+    } while (0)
 
 /** @} */
 

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

@@ -424,7 +424,7 @@ inline string to_string(const hku::Datetime &date) {
 #if FMT_VERSION >= 90000
 template <>
 struct fmt::formatter<hku::Datetime> {
-    constexpr auto parse(format_parse_context &ctx) -> decltype(ctx.begin()) {
+    FMT_CONSTEXPR auto parse(format_parse_context &ctx) -> decltype(ctx.begin()) {
         return ctx.end();
     }
 

hikyuu/include/hikyuu/utilities/datetime/TimeDelta.h

@@ -59,7 +59,7 @@ public:
     explicit TimeDelta(bt::time_duration td);
 
     /** 从字符串构造，格式：-1 days, hh:mm:ss.000000) */
-    explicit TimeDelta(const std::string& delta);
+    explicit TimeDelta(const std::string &delta);
 
     /** 赋值构造函数 */
     TimeDelta(const TimeDelta &) = default;
@@ -329,7 +329,7 @@ inline string to_string(const hku::TimeDelta &delta) {
 #if FMT_VERSION >= 90000
 template <>
 struct fmt::formatter<hku::TimeDelta> {
-    constexpr auto parse(format_parse_context &ctx) -> decltype(ctx.begin()) {
+    FMT_CONSTEXPR auto parse(format_parse_context &ctx) -> decltype(ctx.begin()) {
         return ctx.end();
     }
 

hikyuu/include/hikyuu/utilities/db_connect/DBCondition.h

@@ -245,4 +245,8 @@ inline DBCondition operator==(const Field &field, const char *val) {
     return DBCondition(fmt::format(R"(({}="{}"))", field.name, val));
 }
 
+inline DBCondition operator!=(const Field &field, const char *val) {
+    return DBCondition(fmt::format(R"(({}<>"{}"))", field.name, val));
+}
+
 }  // namespace hku

hikyuu/include/hikyuu/utilities/db_connect/SQLResultSet.h

@@ -154,7 +154,7 @@ private:
         if (m_connect && page != m_current_page) {
             m_buffer.clear();
             m_connect->batchLoad(
-              m_buffer, fmt::format(m_sql_template, TableT::getTableName(), m_where,
+              m_buffer, fmt::format(fmt::runtime(m_sql_template), TableT::getTableName(), m_where,
                                     m_orderby_inner, page_size, page * page_size, m_orderby_outer));
             m_current_page = page;
         }
@@ -179,7 +179,7 @@ private:
 };
 
 template <class TableT, size_t page_size>
-class SQLResultSetIterator : public std::iterator<std::forward_iterator_tag, TableT> {
+class SQLResultSetIterator {
 public:
     using ResultSet = SQLResultSet<TableT, page_size>;
 

hikyuu/include/hikyuu/utilities/db_connect/mysql/MySQLConnect.h

@@ -41,13 +41,17 @@ public:
     virtual void commit() override;
     virtual void rollback() noexcept override;
 
+public:
+    MYSQL *getRawMYSQL() const noexcept {
+        return m_mysql;
+    }
+
 private:
     bool tryConnect() noexcept;
     void connect();
     void close();
 
 private:
-    friend class MySQLStatement;
     MYSQL *m_mysql;
 };
 

hikyuu/include/hikyuu/utilities/node/NodeServer.h

@@ -203,11 +203,11 @@ private:
             nng_ctx_send(work->ctx, work->aio);
 
         } catch (const NodeNngError& e) {
-            CLS_FATAL(e.what());
+            CLS_FATAL("{}", e.what());
             work->state = Work::FINISH;
 
         } catch (const NodeError& e) {
-            CLS_ERROR(e.what());
+            CLS_ERROR("{}", e.what());
             res["ret"] = e.errcode();
             res["msg"] = e.what();
             encodeMsg(msg, res);
@@ -216,7 +216,7 @@ private:
             nng_ctx_send(work->ctx, work->aio);
 
         } catch (const std::exception& e) {
-            CLS_ERROR(e.what());
+            CLS_ERROR("{}", e.what());
             res["ret"] = NodeErrorCode::UNKNOWN_ERROR;
             res["msg"] = e.what();
             encodeMsg(msg, res);
@@ -226,7 +226,7 @@ private:
 
         } catch (...) {
             std::string errmsg = "Unknown error!";
-            CLS_ERROR(errmsg);
+            CLS_ERROR("{}", errmsg);
             res["ret"] = NodeErrorCode::UNKNOWN_ERROR;
             res["msg"] = errmsg;
             nng_aio_set_msg(work->aio, msg);

hikyuu/include/hikyuu/utilities/thread/MQStealThreadPool.h

@@ -104,12 +104,12 @@ public:
 
     /** 向线程池提交任务 */
     template <typename FunctionType>
-    task_handle<typename std::result_of<FunctionType()>::type> submit(FunctionType f) {
+    auto submit(FunctionType f) {
         if (m_thread_need_stop.isSet() || m_done) {
             throw std::logic_error("You can't submit a task to the stopped MQStealThreadPool!");
         }
 
-        typedef typename std::result_of<FunctionType()>::type result_type;
+        typedef typename std::invoke_result<FunctionType>::type result_type;
         std::packaged_task<result_type()> task(f);
         task_handle<result_type> res(task.get_future());
 

hikyuu/include/hikyuu/utilities/thread/MQThreadPool.h

@@ -104,12 +104,12 @@ public:
 
     /** 向线程池提交任务 */
     template <typename FunctionType>
-    task_handle<typename std::result_of<FunctionType()>::type> submit(FunctionType f) {
+    auto submit(FunctionType f) {
         if (m_thread_need_stop.isSet() || m_done) {
             throw std::logic_error("You can't submit a task to the stopped MQThreadPool!");
         }
 
-        typedef typename std::result_of<FunctionType()>::type result_type;
+        typedef typename std::invoke_result<FunctionType>::type result_type;
         std::packaged_task<result_type()> task(f);
         task_handle<result_type> res(task.get_future());
 

hikyuu/include/hikyuu/utilities/thread/StealThreadPool.h

@@ -107,12 +107,12 @@ public:
 
     /** 向线程池提交任务 */
     template <typename FunctionType>
-    task_handle<typename std::result_of<FunctionType()>::type> submit(FunctionType f) {
+    auto submit(FunctionType f) {
         if (m_thread_need_stop.isSet() || m_done) {
             throw std::logic_error("You can't submit a task to the stopped StealThreadPool!!");
         }
 
-        typedef typename std::result_of<FunctionType()>::type result_type;
+        typedef typename std::invoke_result<FunctionType>::type result_type;
         std::packaged_task<result_type()> task(f);
         task_handle<result_type> res(task.get_future());
         if (m_local_work_queue) {
@@ -241,8 +241,8 @@ private:
     // 线程本地变量
 #if CPP_STANDARD >= CPP_STANDARD_17
     inline static thread_local WorkStealQueue* m_local_work_queue = nullptr;  // 本地任务队列
-    inline static thread_local int m_index = -1;                  // 在线程池中的序号
-    inline static thread_local InterruptFlag m_thread_need_stop;  // 线程停止运行指示
+    inline static thread_local int m_index = -1;                              // 在线程池中的序号
+    inline static thread_local InterruptFlag m_thread_need_stop;              // 线程停止运行指示
 #else
     static thread_local WorkStealQueue* m_local_work_queue;  // 本地任务队列
     static thread_local int m_index;                         // 在线程池中的序号
@@ -280,7 +280,7 @@ private:
             task();
         } else {
             std::unique_lock<std::mutex> lk(m_cv_mutex);
-            m_cv.wait(lk, [=] { return this->m_done || !this->m_master_work_queue.empty(); });
+            m_cv.wait(lk, [this] { return this->m_done || !this->m_master_work_queue.empty(); });
         }
     }
 

hikyuu/include/hikyuu/utilities/thread/ThreadPool.h

@@ -93,11 +93,11 @@ public:
 
     /** 向线程池提交任务 */
     template <typename FunctionType>
-    task_handle<typename std::result_of<FunctionType()>::type> submit(FunctionType f) {
+    auto submit(FunctionType f) {
         if (m_thread_need_stop.isSet() || m_done) {
             throw std::logic_error("You can't submit a task to the stopped task group!");
         }
-        typedef typename std::result_of<FunctionType()>::type result_type;
+        typedef typename std::invoke_result<FunctionType>::type result_type;
         std::packaged_task<result_type()> task(f);
         task_handle<result_type> res(task.get_future());
         m_master_work_queue.push(std::move(task));

hikyuu/include/hikyuu/utilities/thread/algorithm.h

@@ -26,19 +26,25 @@ inline std::vector<range_t> parallelIndexRange(size_t start, size_t end) {
     }
 
     size_t total = end - start;
+    if (total == 0) {
+        return ret;
+    }
+
     size_t cpu_num = std::thread::hardware_concurrency();
-    if (total <= cpu_num) {
+    if (cpu_num == 1) {
         ret.emplace_back(start, end);
         return ret;
     }
 
     size_t per_num = total / cpu_num;
-    for (size_t i = start; i < per_num; i++) {
-        size_t first = i * cpu_num;
-        ret.emplace_back(first, first + cpu_num);
+    if (per_num > 0) {
+        for (size_t i = 0; i < cpu_num; i++) {
+            size_t first = i * per_num + start;
+            ret.emplace_back(first, first + per_num);
+        }
     }
 
-    for (size_t i = per_num * cpu_num; i < total; i++) {
+    for (size_t i = per_num * cpu_num + start; i < end; i++) {
         ret.emplace_back(i, i + 1);
     }
 
@@ -64,11 +70,11 @@ template <typename FunctionType, class TaskGroup = MQStealThreadPool>
 auto parallel_for_index(size_t start, size_t end, FunctionType f) {
     auto ranges = parallelIndexRange(start, end);
     TaskGroup tg;
-    std::vector<std::future<std::vector<typename std::result_of<FunctionType(size_t)>::type>>>
+    std::vector<std::future<std::vector<typename std::invoke_result<FunctionType, size_t>::type>>>
       tasks;
     for (size_t i = 0, total = ranges.size(); i < total; i++) {
         tasks.emplace_back(tg.submit([func = f, range = ranges[i]]() {
-            std::vector<typename std::result_of<FunctionType(size_t)>::type> one_ret;
+            std::vector<typename std::invoke_result<FunctionType, size_t>::type> one_ret;
             for (size_t ix = range.first; ix < range.second; ix++) {
                 one_ret.emplace_back(func(ix));
             }
@@ -76,7 +82,7 @@ auto parallel_for_index(size_t start, size_t end, FunctionType f) {
         }));
     }
 
-    std::vector<typename std::result_of<FunctionType(size_t)>::type> ret;
+    std::vector<typename std::invoke_result<FunctionType, size_t>::type> ret;
     for (auto& task : tasks) {
         auto one = task.get();
         for (auto&& value : one) {
@@ -91,12 +97,12 @@ template <typename FunctionType, class TaskGroup = MQStealThreadPool>
 auto parallel_for_range(size_t start, size_t end, FunctionType f) {
     auto ranges = parallelIndexRange(start, end);
     TaskGroup tg;
-    std::vector<std::future<typename std::result_of<FunctionType(range_t)>::type>> tasks;
+    std::vector<std::future<typename std::invoke_result<FunctionType, range_t>::type>> tasks;
     for (size_t i = 0, total = ranges.size(); i < total; i++) {
         tasks.emplace_back(tg.submit([func = f, range = ranges[i]]() { return func(range); }));
     }
 
-    typename std::result_of<FunctionType(range_t)>::type ret;
+    typename std::invoke_result<FunctionType, range_t>::type ret;
     for (auto& task : tasks) {
         auto one = task.get();
         for (auto&& value : one) {

hikyuu/include/hikyuu/version.h

@@ -12,13 +12,13 @@
 #define HKU_VERSION_H
 
 // clang-format off
-#define HKU_VERSION "2.3.0"
+#define HKU_VERSION "2.5.0"
 #define HKU_VERSION_MAJOR 2
-#define HKU_VERSION_MINOR 3
+#define HKU_VERSION_MINOR 5
 #define HKU_VERSION_ALTER 0
-#define HKU_VERSION_BUILD 202501010140
+#define HKU_VERSION_BUILD 202502201617
 #define HKU_VERSION_MODE "RELEASE"
-#define HKU_VERSION_GIT "2.3.0 master.48495654 (RELEASE)"
+#define HKU_VERSION_GIT "2.5.0 release.77e90dd2 (RELEASE)"
 // clang-format on
 
 #endif /* HKU_VERSION_H */

hikyuu/indicator/indicator.py

@@ -155,3 +155,4 @@ VOL = C_VOL()
 # 同名指标
 VALUE = PRICELIST
 CAPITAL = LIUTONGPAN
+CONST = LASTVALUE