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

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

@@ -22,20 +22,20 @@
 
 namespace hku {
 
-class HKU_API MySQLConnect : public DBConnectBase {
+class HKU_UTILS_API MySQLConnect : public DBConnectBase {
 public:
-    explicit MySQLConnect(const Parameter& param);
+    explicit MySQLConnect(const Parameter &param);
     virtual ~MySQLConnect();
 
-    MySQLConnect(const MySQLConnect&) = delete;
-    MySQLConnect& operator=(const MySQLConnect&) = delete;
+    MySQLConnect(const MySQLConnect &) = delete;
+    MySQLConnect &operator=(const MySQLConnect &) = delete;
 
     virtual bool ping() override;
 
-    virtual int64_t exec(const std::string& sql_string) override;
-    virtual SQLStatementPtr getStatement(const std::string& sql_statement) override;
-    virtual bool tableExist(const std::string& tablename) override;
-    virtual void resetAutoIncrement(const std::string& tablename) override;
+    virtual int64_t exec(const std::string &sql_string) override;
+    virtual SQLStatementPtr getStatement(const std::string &sql_statement) override;
+    virtual bool tableExist(const std::string &tablename) override;
+    virtual void resetAutoIncrement(const std::string &tablename) override;
 
     virtual void transaction() noexcept override;
     virtual void commit() noexcept override;
@@ -48,7 +48,7 @@ private:
 
 private:
     friend class MySQLStatement;
-    MYSQL* m_mysql;
+    MYSQL *m_mysql;
 };
 
 }  // namespace hku

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

@@ -26,16 +26,16 @@
 typedef bool my_bool;
 #endif
 
-#ifndef HKU_API
-#define HKU_API
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
 #endif
 
 namespace hku {
 
-class HKU_API MySQLStatement : public SQLStatementBase {
+class HKU_UTILS_API MySQLStatement : public SQLStatementBase {
 public:
     MySQLStatement() = delete;
-    MySQLStatement(DBConnectBase* driver, const std::string& sql_statement);
+    MySQLStatement(DBConnectBase *driver, const std::string &sql_statement);
     virtual ~MySQLStatement();
 
     virtual void sub_exec() override;
@@ -45,28 +45,28 @@ public:
     virtual void sub_bindNull(int idx) override;
     virtual void sub_bindInt(int idx, int64_t value) override;
     virtual void sub_bindDouble(int idx, double item) override;
-    virtual void sub_bindDatetime(int idx, const Datetime& item) override;
-    virtual void sub_bindText(int idx, const std::string& item) override;
-    virtual void sub_bindText(int idx, const char* item, size_t len) override;
-    virtual void sub_bindBlob(int idx, const std::string& item) override;
-    virtual void sub_bindBlob(int idx, const std::vector<char>& item) override;
+    virtual void sub_bindDatetime(int idx, const Datetime &item) override;
+    virtual void sub_bindText(int idx, const std::string &item) override;
+    virtual void sub_bindText(int idx, const char *item, size_t len) override;
+    virtual void sub_bindBlob(int idx, const std::string &item) override;
+    virtual void sub_bindBlob(int idx, const std::vector<char> &item) override;
 
     virtual int sub_getNumColumns() const override;
-    virtual void sub_getColumnAsInt64(int idx, int64_t& item) override;
-    virtual void sub_getColumnAsDouble(int idx, double& item) override;
-    virtual void sub_getColumnAsDatetime(int idx, Datetime& item) override;
-    virtual void sub_getColumnAsText(int idx, std::string& item) override;
-    virtual void sub_getColumnAsBlob(int idx, std::string& item) override;
-    virtual void sub_getColumnAsBlob(int idx, std::vector<char>& item) override;
+    virtual void sub_getColumnAsInt64(int idx, int64_t &item) override;
+    virtual void sub_getColumnAsDouble(int idx, double &item) override;
+    virtual void sub_getColumnAsDatetime(int idx, Datetime &item) override;
+    virtual void sub_getColumnAsText(int idx, std::string &item) override;
+    virtual void sub_getColumnAsBlob(int idx, std::string &item) override;
+    virtual void sub_getColumnAsBlob(int idx, std::vector<char> &item) override;
 
 private:
     void _reset();
     void _bindResult();
 
 private:
-    MYSQL* m_db;
-    MYSQL_STMT* m_stmt;
-    MYSQL_RES* m_meta_result;
+    MYSQL *m_db;
+    MYSQL_STMT *m_stmt;
+    MYSQL_RES *m_meta_result;
     bool m_needs_reset;
     bool m_has_bind_result;
     std::vector<MYSQL_BIND> m_param_bind;

hikyuu/include/hikyuu/utilities/db_connect/sqlite/SQLiteConnect.h

@@ -25,7 +25,7 @@ namespace hku {
  * SQLite连接
  * @ingroup SQLite
  */
-class HKU_API SQLiteConnect : public DBConnectBase {
+class HKU_UTILS_API SQLiteConnect : public DBConnectBase {
 public:
     /**
      * 构造函数
@@ -78,11 +78,11 @@ private:
 
 private:
     friend class SQLiteStatement;
-    string m_dbname;
+    std::string m_dbname;
     sqlite3 *m_db;
 };
 
-typedef shared_ptr<SQLiteConnect> SQLiteConnectPtr;
+typedef std::shared_ptr<SQLiteConnect> SQLiteConnectPtr;
 
 }  // namespace hku
 

hikyuu/include/hikyuu/utilities/db_connect/sqlite/SQLiteStatement.h

@@ -19,7 +19,7 @@ namespace hku {
  * SQLite Statemen
  * @ingroup DBConnect
  */
-class HKU_API SQLiteStatement : public SQLStatementBase {
+class HKU_UTILS_API SQLiteStatement : public SQLStatementBase {
 public:
     SQLiteStatement() = delete;
 
@@ -28,7 +28,7 @@ public:
      * @param driver 数据库连接
      * @param sql_statement SQL语句
      */
-    SQLiteStatement(DBConnectBase *driver, const string &sql_statement);
+    SQLiteStatement(DBConnectBase *driver, const std::string &sql_statement);
 
     /** 析构函数 */
     virtual ~SQLiteStatement();

hikyuu/include/hikyuu/utilities/db_connect/sqlite/SQLiteUtil.h

@@ -15,7 +15,7 @@ namespace hku {
  * @brief SQLite 其他相关操作方法集合
  * @ingroup DBConnect
  */
-class HKU_API SQLiteUtil {
+class HKU_UTILS_API SQLiteUtil {
 public:
     SQLiteUtil() = default;
     ~SQLiteUtil() = default;
@@ -43,8 +43,8 @@ public:
      * @param n_page 分批备份时每次循环备份的 page 数，小于等于0时，一次性备份，不进行分批备份
      * @param step_sleep 分批备份时每次循环后，休眠间隔时长（毫秒），以便让出cpu
      */
-    static BackupResult onlineBackup(const std::shared_ptr<SQLiteConnect>& conn,
-                                     const std::string& dst, int n_page = -1,
+    static BackupResult onlineBackup(const std::shared_ptr<SQLiteConnect> &conn,
+                                     const std::string &dst, int n_page = -1,
                                      int step_sleep = 250) noexcept;
     /**
      * @brief 在线备份数据库，不影响其他数据库连接进行操作
@@ -53,7 +53,7 @@ public:
      * @param n_page 分批备份时每次循环备份的 page 数，小于等于0时，一次性备份，不进行分批备份
      * @param step_sleep 分批备份时每次循环后，休眠间隔时长（毫秒），以便让出cpu
      */
-    static BackupResult onlineBackup(const std::string& src, const std::string& dst,
+    static BackupResult onlineBackup(const std::string &src, const std::string &dst,
                                      int n_page = -1, int step_sleep = 250) noexcept;
 
     /**
@@ -65,7 +65,7 @@ public:
      * @param save_bad 是否保存损坏的数据，将 dst 及 dst-journal 加上后缀 .bad 另存
      * @return RecoverResult
      */
-    static RecoverResult recoverFromBackup(const std::string& backup, const std::string& dst,
+    static RecoverResult recoverFromBackup(const std::string &backup, const std::string &dst,
                                            bool save_bad = false) noexcept;
 
     /**
@@ -74,7 +74,7 @@ public:
      * @return true 指定的数据库文件及其日志文件都被成功删除或都不存在时，返回成功
      * @return false 指定的数据文件及其日志文件，其中一个删除失败都会返回删除失败
      */
-    static bool removeDBFile(const std::string& dbfilename);
+    static bool removeDBFile(const std::string &dbfilename);
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/{exception.h → utilities/exception.h}

@@ -29,6 +29,7 @@ public:
     exception(const std::string& msg)  // cppcheck-suppress noExplicitConstructor
     : std::exception(msg.c_str()) {}
     exception(const char* msg) : std::exception(msg) {}  // cppcheck-suppress noExplicitConstructor
+    virtual ~exception() noexcept {};
 };
 
 #else

hikyuu/include/hikyuu/utilities/http_client/HttpClient.h

@@ -0,0 +1,229 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-07-26
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HKU_UTILS_HTTP_CLIENT_H
+#define HKU_UTILS_HTTP_CLIENT_H
+
+#include "hikyuu/utilities/config.h"
+#if !HKU_ENABLE_HTTP_CLIENT
+#error "Don't enable http client, please config with --http_client=y"
+#endif
+
+#include <string>
+#include <nlohmann/json.hpp>
+#include "nng_wrap.h"
+
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
+#endif
+
+namespace hku {
+
+using json = nlohmann::json;
+
+class HKU_UTILS_API HttpClient;
+
+class HKU_UTILS_API HttpResponse final {
+    friend class HKU_UTILS_API HttpClient;
+
+public:
+    HttpResponse();
+    ~HttpResponse();
+
+    HttpResponse(const HttpResponse&) = delete;
+    HttpResponse& operator=(const HttpResponse&) = delete;
+
+    HttpResponse(HttpResponse&& rhs);
+    HttpResponse& operator=(HttpResponse&& rhs);
+
+    const std::string& body() const noexcept {
+        return m_body;
+    }
+
+    hku::json json() const {
+        return json::parse(m_body);
+    }
+
+    int status() const noexcept {
+        return nng_http_res_get_status(m_res);
+    }
+
+    std::string reason() noexcept {
+        return nng_http_res_get_reason(m_res);
+    }
+
+    std::string getHeader(const std::string& key) noexcept {
+        const char* hdr = nng_http_res_get_header(m_res, key.c_str());
+        return hdr ? std::string(hdr) : std::string();
+    }
+
+    size_t getContentLength() noexcept {
+        std::string slen = getHeader("Content-Length");
+        return slen.empty() ? 0 : std::stoi(slen);
+    }
+
+private:
+    void _resizeBody(size_t len) {
+        m_body.resize(len);
+    }
+
+    nng_http_res* get() const noexcept {
+        return m_res;
+    }
+
+    void reset();
+
+private:
+    nng_http_res* m_res{nullptr};
+    std::string m_body;
+};
+
+class HKU_UTILS_API HttpClient {
+public:
+    HttpClient() = default;
+    explicit HttpClient(const std::string& url, int32_t timeout_ms = NNG_DURATION_DEFAULT)
+    : m_url(nng::url(url)), m_timeout_ms(timeout_ms) {};
+    virtual ~HttpClient();
+
+    HttpClient(const HttpClient&) = delete;
+    HttpClient& operator=(const HttpClient&) = delete;
+
+    HttpClient(HttpClient&& rhs)
+    : m_default_headers(std::move(rhs.m_default_headers)),
+      m_url(std::move(rhs.m_url)),
+      m_client(std::move(rhs.m_client)),
+      m_aio(std::move(rhs.m_aio)),
+      m_conn(std::move(rhs.m_conn)),
+#if HKU_ENABLE_HTTP_CLIENT_SSL
+      m_tls_cfg(std::move(rhs.m_tls_cfg)),
+      m_ca_file(std::move(rhs.m_ca_file)),
+#endif
+      m_timeout_ms(rhs.m_timeout_ms) {
+    }
+
+    HttpClient& operator=(HttpClient&& rhs) {
+        if (this != &rhs) {
+            m_default_headers = std::move(rhs.m_default_headers);
+            m_url = std::move(rhs.m_url);
+            m_client = (std::move(rhs.m_client));
+            m_aio = std::move(rhs.m_aio);
+            m_conn = std::move(rhs.m_conn);
+#if HKU_ENABLE_HTTP_CLIENT_SSL
+            m_tls_cfg = std::move(rhs.m_tls_cfg);
+            m_ca_file = std::move(rhs.m_ca_file);
+#endif
+            m_timeout_ms = rhs.m_timeout_ms;
+            rhs.m_timeout_ms = NNG_DURATION_DEFAULT;
+        }
+        return *this;
+    }
+
+    bool valid() const noexcept {
+        return m_url.valid();
+    }
+
+    const std::string& url() const noexcept {
+        return m_url.raw_url();
+    }
+
+    void setUrl(const std::string& url) noexcept {
+        m_url = std::move(nng::url(url));
+        reset();
+    }
+
+    // #define NNG_DURATION_INFINITE (-1)
+    // #define NNG_DURATION_DEFAULT (-2)
+    // #define NNG_DURATION_ZERO (0)
+    void setTimeout(int32_t ms) {
+        if (m_timeout_ms != ms) {
+            m_timeout_ms = ms;
+            reset();
+        }
+    }
+
+    void setDefaultHeaders(const HttpHeaders& headers) {
+        m_default_headers = headers;
+    }
+
+    void setDefaultHeaders(HttpHeaders&& headers) {
+        m_default_headers = std::move(headers);
+    }
+
+    void setCaFile(const std::string& filename);
+
+    void reset();
+
+    HttpResponse request(const std::string& method, const std::string& path,
+                         const HttpParams& params, const HttpHeaders& headers, const char* body,
+                         size_t body_len, const std::string& content_type);
+
+    HttpResponse get(const std::string& path, const HttpHeaders& headers = HttpHeaders()) {
+        return request("GET", path, HttpParams(), headers, nullptr, 0, "");
+    }
+
+    HttpResponse get(const std::string& path, const HttpParams& params,
+                     const HttpHeaders& headers) {
+        return request("GET", path, params, headers, nullptr, 0, "");
+    }
+
+    HttpResponse post(const std::string& path, const HttpParams& params, const HttpHeaders& headers,
+                      const char* body, size_t len, const std::string& content_type) {
+        return request("POST", path, params, headers, body, len, content_type);
+    }
+
+    HttpResponse post(const std::string& path, const HttpHeaders& headers, const char* body,
+                      size_t len, const std::string& content_type) {
+        return request("POST", path, HttpParams(), headers, body, len, content_type);
+    }
+
+    HttpResponse post(const std::string& path, const HttpParams& params, const HttpHeaders& headers,
+                      const std::string& content, const std::string& content_type = "text/plaint") {
+        return post(path, params, headers, content.data(), content.size(), content_type);
+    }
+
+    HttpResponse post(const std::string& path, const HttpHeaders& headers,
+                      const std::string& content, const std::string& content_type = "text/plaint") {
+        return post(path, HttpParams(), headers, content, content_type);
+    }
+
+    HttpResponse post(const std::string& path, const HttpParams& params, const HttpHeaders& headers,
+                      const json& body) {
+        return post(path, params, headers, body.dump(), "application/json");
+    }
+
+    HttpResponse post(const std::string& path, const HttpHeaders& headers, const json& body) {
+        return post(path, HttpParams(), headers, body);
+    }
+
+    HttpResponse post(const std::string& path, const json& body) {
+        return post(path, HttpHeaders(), body);
+    }
+
+private:
+    void _connect();
+    HttpResponse _readResChunk(const std::string& method, const std::string& uri,
+                               const HttpHeaders& headers, const char* body, size_t body_len,
+                               const std::string& content_type);
+
+private:
+    HttpHeaders m_default_headers;
+    nng::url m_url;
+    nng::http_client m_client;
+    nng::aio m_aio;
+    nng::http_conn m_conn;
+#if HKU_ENABLE_HTTP_CLIENT_SSL
+    nng::tls_config m_tls_cfg;
+    std::string m_ca_file;
+#endif
+
+    int32_t m_timeout_ms{NNG_DURATION_DEFAULT};
+};
+
+}  // namespace hku
+
+#endif