hikyuu 2.6.8__py3-none-manylinux2014_aarch64.whl

hikyuu/include/hikyuu/utilities/osdef.h

@@ -0,0 +1,159 @@
+/**
+ *  Copyright (c) 2021 hikyuu.org
+ *
+ *  Created on: 2021/05/19
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#ifdef __APPLE__
+#include <TargetConditionals.h>
+#endif
+
+/*
+ * CPU 架构宏定义
+ */
+#if defined(__arm__) || defined(_M_ARM)
+#define HKU_ARCH_ARM 1
+#define HKU_ARCH_ARM64 0
+#define HKU_ARCH_X86 0
+#define HKU_ARCH_X64 0
+#elif defined(__aarch64__) || defined(_M_ARM64)
+#define HKU_ARCH_ARM 0
+#define HKU_ARCH_ARM64 1
+#define HKU_ARCH_X86 0
+#define HKU_ARCH_X64 0
+#elif defined(__x86_64__) || defined(_M_X64) || defined(_WIN64)
+#define HKU_ARCH_ARM 0
+#define HKU_ARCH_ARM64 0
+#define HKU_ARCH_X86 0
+#define HKU_ARCH_X64 1
+#elif defined(__i386__) || defined(_M_IX86) || defined(_WIN32)
+#define HKU_ARCH_ARM 0
+#define HKU_ARCH_ARM64 0
+#define HKU_ARCH_X86 1
+#define HKU_ARCH_X64 0
+#else
+#define HKU_ARCH_ARM 0
+#define HKU_ARCH_ARM64 0
+#define HKU_ARCH_X86 0
+#define HKU_ARCH_X64 0
+#endif
+
+/*
+ * 操作系统宏定义
+ */
+#if defined(_WIN32) || defined(_WIN64)
+#define HKU_OS_WINDOWS 1
+#define HKU_OS_LINUX 0
+#define HKU_OS_ANDROID 0
+#define HKU_OS_OSX 0
+#define HKU_OS_IOS 0
+#elif defined(__ANDROID__)
+#define HKU_OS_WINDOWS 0
+#define HKU_OS_LINUX 0
+#define HKU_OS_ANDROID 1
+#define HKU_OS_OSX 0
+#define HKU_OS_IOS 0
+#elif defined(__linux__)
+#define HKU_OS_WINDOWS 0
+#define HKU_OS_LINUX 1
+#define HKU_OS_ANDROID 0
+#define HKU_OS_OSX 0
+#define HKU_OS_IOS 0
+#elif TARGET_OS_OSX
+#define HKU_OS_WINDOWS 0
+#define HKU_OS_LINUX 0
+#define HKU_OS_ANDROID 0
+#define HKU_OS_OSX 1
+#define HKU_OS_IOS 0
+#elif TARGET_OS_IOS || TARGET_OS_IPHONE
+#define HKU_OS_WINDOWS 0
+#define HKU_OS_LINUX 0
+#define HKU_OS_ANDROID 0
+#define HKU_OS_OSX 0
+#define HKU_OS_IOS 1
+#else
+#define HKU_OS_WINDOWS 0
+#define HKU_OS_LINUX 0
+#define HKU_OS_ANDROID 0
+#define HKU_OS_OSX 0
+#define HKU_OS_IOS 0
+#endif
+
+// IOS 模拟器
+#if HKU_OS_IOS && TARGET_OS_SIMULATOR
+#define HKU_OS_IOS_SIMULATOR 1
+#else
+#define HKU_OS_IOS_SIMULATOR 0
+#endif
+
+//---------------------------------------------------------
+// SIMD 指令集配置
+//---------------------------------------------------------
+// clang-format off
+#ifndef HKU_DISABLE_SIMD
+    #ifndef HKU_ENABLE_SSE2
+        #if defined(_MSC_VER) 
+            #if defined(__AVX__) 
+                #ifndef HKU_ENABLE_SSE2
+                    #define HKU_ENABLE_SSE2
+                #endif
+                #ifndef HKU_ENABLE_SSE3
+                    #define HKU_ENABLE_SSE3
+                #endif
+                #ifndef HKU_ENABLE_SSE41
+                    #define HKU_ENABLE_SSE41
+                #endif
+                #ifndef HKU_ENABLE_AVX
+                    #define HKU_ENABLE_AVX
+                #endif
+                #ifndef HKU_ENABLE_AVX2
+                    #define HKU_ENABLE_AVX2
+                #endif
+            #endif
+            #if (defined( _M_X64) || defined(_M_IX86_FP) && _M_IX86_FP >= 2) && !defined(HKU_ENABLE_SSE2)
+                #define HKU_ENABLE_SSE2
+            #endif
+        #else
+            #if defined(HKU_ENABLE_SSE2) && !defined(__SSE2__)
+                #define HKU_ENABLE_SSE2
+            #endif
+            #if defined(HKU_ENABLE_SSE3) && !defined(__SSSE3__)
+                #define HKU_ENABLE_SSE3
+            #endif
+            #if defined(HKU_ENABLE_SSE41) && !defined(__SSE4_1__)
+                #define HKU_ENABLE_SSE41
+            #endif
+            #if defined(HKU_ENABLE_AVX) && !defined(__AVX__)
+                #define HKU_ENABLE_AVX
+            #endif            
+            #if defined(HKU_ENABLE_AVX2) && !defined(__AVX2__)
+                #define HKU_ENABLE_AVX2
+            #endif            
+        #endif
+    #endif
+
+    // ARM NEON 优化
+    #ifndef HKU_ENABLE_NEON
+        #if defined(ARM_NEON) || defined(__ARM_NEON) || defined(__ARM_NEON__) || defined(__arm_neon) || defined(__arm_neon__)
+            #define HKU_ENABLE_NEON
+        #endif
+    #endif
+#endif // #ifndef HKU_DISABLE_SIMD
+// clang-format on
+
+#ifdef HKU_ENABLE_SSE2
+#include <xmmintrin.h>
+#include <emmintrin.h>
+#include <mmintrin.h>
+#endif
+
+#ifdef HKU_ENABLE_AVX
+#include <immintrin.h>
+#endif
+
+#ifdef HKU_ENABLE_NEON
+#include <arm_neon.h>
+#endif

hikyuu/include/hikyuu/utilities/plugin/PluginBase.h

@@ -0,0 +1,47 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-03-18
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HKU_UTILS_PLUGIN_BASE_H_
+#define HKU_UTILS_PLUGIN_BASE_H_
+
+#include <string>
+#include "hikyuu/utilities/config.h"
+#include "hikyuu/utilities/osdef.h"
+
+namespace hku {
+
+class PluginBase {
+public:
+    PluginBase() = default;
+    virtual ~PluginBase() = default;
+
+    /**
+     * @brief 返回插件信息
+     * @details
+     * 插件信息为json格式，包含name(string)、version(int)、description(string)、author(string)字段
+     * 如：{"name":"unknown","version": 1.0,"description":"","author":"unknown"}
+     * @return std::string
+     */
+    virtual std::string info() const noexcept = 0;
+};
+
+}  // namespace hku
+
+#if HKU_OS_WINDOWS
+#define HKU_PLUGIN_DEFINE(plugin)                                      \
+    extern "C" __declspec(dllexport) hku::PluginBase* createPlugin() { \
+        return new plugin();                                           \
+    }
+#else
+#define HKU_PLUGIN_DEFINE(plugin)                \
+    extern "C" hku::PluginBase* createPlugin() { \
+        return new plugin();                     \
+    }
+#endif
+
+#endif /* HKU_UTILS_PLUGIN_BASE_H_ */

hikyuu/include/hikyuu/utilities/plugin/PluginClient.h

@@ -0,0 +1,55 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-04-06
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "PluginLoader.h"
+
+namespace hku {
+
+template <typename InterfaceT>
+class PluginClient : public InterfaceT {
+public:
+    PluginClient() = delete;
+    PluginClient(const std::string &path, const std::string &filename) {
+        m_loader = std::make_unique<PluginLoader>(path);
+        HKU_CHECK(m_loader->load(filename), "load plugin failed! {}/{}", path, filename);
+        m_impl = m_loader->instance<InterfaceT>();
+    }
+    virtual ~PluginClient() = default;
+
+    PluginClient(const PluginClient &) = delete;
+    PluginClient &operator=(const PluginClient &) = delete;
+
+    PluginClient(PluginClient &&rhs) : m_impl(rhs.m_impl), m_loader(std::move(rhs.m_loader)) {
+        rhs.m_impl = nullptr;
+    }
+
+    PluginClient &operator=(PluginClient &&rhs) {
+        if (this != &rhs) {
+            m_loader = std::move(rhs.m_loader);
+            m_impl = rhs.m_impl;
+            rhs.m_impl = nullptr;
+        }
+    }
+
+    std::string info() const noexcept override {
+        return m_impl->info();
+    }
+
+    InterfaceT *getPlugin() const {
+        return m_impl;
+    }
+
+protected:
+    InterfaceT *m_impl{nullptr};
+
+protected:
+    std::unique_ptr<PluginLoader> m_loader;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/utilities/plugin/PluginLoader.h

@@ -0,0 +1,118 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-03-18
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HKU_UTILS_PLUGIN_LOADER_H_
+#define HKU_UTILS_PLUGIN_LOADER_H_
+
+#include <mutex>
+#include <string>
+#include <memory>
+#include "hikyuu/utilities/config.h"
+#include "hikyuu/utilities/osdef.h"
+#include "hikyuu/utilities/os.h"
+#include "hikyuu/utilities/Log.h"
+#include "PluginBase.h"
+
+#if HKU_OS_WINDOWS
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+namespace hku {
+
+class PluginLoader final {
+public:
+    PluginLoader() : PluginLoader(".") {}
+    explicit PluginLoader(const std::string& path) : m_path(path) {}
+
+    PluginLoader(const PluginLoader&) = delete;
+    PluginLoader(PluginLoader&&) = delete;
+
+    ~PluginLoader() {
+        unload();
+    }
+
+    template <typename T>
+    T* instance() const noexcept {
+        HKU_IF_RETURN(!m_plugin, nullptr);
+        return dynamic_cast<T*>(m_plugin.get());
+    }
+
+    bool load(const std::string& pluginname) noexcept {
+        std::string filename = getFileName(pluginname);
+        // HKU_WARN_IF_RETURN(!existFile(filename), false, "file({}) not exist!", filename);
+        HKU_DEBUG_IF_RETURN(!existFile(filename), false, "file({}) not exist!", filename);
+
+#if HKU_OS_WINDOWS
+        m_handle = LoadLibrary(HKU_PATH(filename).c_str());
+#else
+        m_handle = dlopen(filename.c_str(), RTLD_LAZY);
+#endif
+        HKU_WARN_IF_RETURN(!m_handle, false, "load plugin({}) failed!", filename);
+
+        typedef PluginBase* (*CreateFunction)();
+        CreateFunction createFunction =
+          reinterpret_cast<CreateFunction>(getFunciton("createPlugin"));
+        HKU_WARN_IF_RETURN(!createFunction, false, "Failed to get plugin({}) handle!", filename);
+
+        m_plugin.reset(createFunction());
+        if (!m_plugin) {
+            HKU_ERROR("Failed to create plugin ({})!", filename);
+            unload();
+            m_plugin.reset();
+            return false;
+        }
+
+        return true;
+    }
+
+    std::string getFileName(const std::string& pluginname) const noexcept {
+#if HKU_OS_WINDOWS
+        return fmt::format("{}/{}.dll", m_path, pluginname);
+#elif HKU_OS_LINUX
+        return fmt::format("{}/lib{}.so", m_path, pluginname);
+#elif HKU_OS_OSX
+        return fmt::format("{}/lib{}.dylib", m_path, pluginname);
+#endif
+    }
+
+private:
+    void unload() noexcept {
+        m_plugin.reset();
+        if (m_handle) {
+#if HKU_OS_WINDOWS
+            FreeLibrary(m_handle);
+#else
+            dlclose(m_handle);
+#endif
+        }
+    }
+
+    void* getFunciton(const char* symbol) noexcept {
+#if HKU_OS_WINDOWS
+        void* func = GetProcAddress(m_handle, symbol);
+#else
+        void* func = dlsym(m_handle, symbol);
+#endif
+        return func;
+    }
+
+private:
+#if HKU_OS_WINDOWS
+    HMODULE m_handle{nullptr};
+#else
+    void* m_handle{nullptr};
+#endif
+    std::string m_path;
+    std::unique_ptr<PluginBase> m_plugin{nullptr};
+};
+
+}  // namespace hku
+
+#endif /* HKU_UTILS_PLUGIN_LOADER_H_ */

hikyuu/include/hikyuu/utilities/plugin/PluginManager.h

@@ -0,0 +1,72 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-04-10
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include <string>
+#include <memory>
+#include <unordered_map>
+#include <mutex>
+#include "hikyuu/utilities/Log.h"
+#include "hikyuu/utilities/plugin/PluginLoader.h"
+
+namespace hku {
+
+class PluginManager final {
+public:
+    PluginManager() : m_plugin_path(".") {};
+    explicit PluginManager(const std::string& plugin_path) : m_plugin_path(plugin_path) {}
+
+    ~PluginManager() = default;
+    PluginManager(const PluginManager&) = delete;
+    PluginManager(PluginManager&&) = delete;
+    PluginManager& operator=(const PluginManager&) = delete;
+    PluginManager& operator=(PluginManager&&) = delete;
+
+    const std::string& pluginPath() const noexcept {
+        return m_plugin_path;
+    }
+
+    void pluginPath(const std::string& plugin_path) noexcept {
+        HKU_TRACE_IF_RETURN(!m_plugins.empty(), void(),
+                            "Existing loaded plugins, Ignore set plugin path: {}, ", plugin_path);
+        m_plugin_path = plugin_path;
+    }
+
+    template <typename PluginInterfaceT>
+    PluginInterfaceT* getPlugin(const std::string& pluginname) noexcept;
+
+private:
+    std::unordered_map<std::string, std::unique_ptr<PluginLoader>>::iterator load(
+      const std::string& pluginname) noexcept {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        std::unique_ptr<PluginLoader> loader = std::make_unique<PluginLoader>(m_plugin_path);
+        if (loader->load(pluginname)) {
+            auto [it, success] = m_plugins.insert(std::make_pair(pluginname, std::move(loader)));
+            if (success) {
+                return it;
+            }
+        }
+        return m_plugins.end();
+    }
+
+private:
+    std::string m_plugin_path;
+    std::unordered_map<std::string, std::unique_ptr<PluginLoader>> m_plugins;
+    std::mutex m_mutex;
+};
+
+template <typename PluginInterfaceT>
+PluginInterfaceT* PluginManager::getPlugin(const std::string& pluginname) noexcept {
+    auto it = m_plugins.find(pluginname);
+    if (it == m_plugins.end()) {
+        it = load(pluginname);
+    }
+    return it != m_plugins.end() ? it->second->instance<PluginInterfaceT>() : nullptr;
+}
+
+}  // namespace hku

hikyuu/include/hikyuu/utilities/plugin/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/utilities/runtimeinfo.h

@@ -0,0 +1,35 @@
+/*
+ * runtimeinfo.h
+ *
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2019-10-1
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HIKYUU_UTILITIES_RUNTIMEINFO_H
+#define HIKYUU_UTILITIES_RUNTIMEINFO_H
+
+#include <iostream>
+#include <string>
+
+#ifdef _WIN32
+#include <windows.h>
+#pragma comment(lib, "Kernel32.lib")
+#endif
+
+namespace hku {
+
+bool supportChineseSimple();
+
+inline bool supportChineseSimple() {
+#ifdef _WIN32
+    return 0X0804 == GetUserDefaultUILanguage() ? true : false;
+#endif
+    return true;
+}
+
+} /* namespace hku */
+
+#endif /* HIKYUU_UTILITIES_RUNTIMEINFO_H */

hikyuu/include/hikyuu/utilities/snowflake.h

@@ -0,0 +1,110 @@
+/*
+ *  Copyright(C) 2021 hikyuu.org
+ *
+ *  The code comes from: https://github.com/sniper00/snowflake-cpp
+ *  Thanks sniper00
+ *
+ *  Create on: 2021-04-13
+ *     Author: fasiondog
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <chrono>
+#include <stdexcept>
+#include <mutex>
+
+namespace hku {
+
+class snowflake_nonlock {
+public:
+    void lock() {}
+    void unlock() {}
+};
+
+template <int64_t Twepoch, typename Lock = snowflake_nonlock>
+class snowflake {
+    using lock_type = Lock;
+    static constexpr int64_t TWEPOCH = Twepoch;
+    static constexpr int64_t WORKER_ID_BITS = 5L;
+    static constexpr int64_t DATACENTER_ID_BITS = 5L;
+    static constexpr int64_t MAX_WORKER_ID = (1 << WORKER_ID_BITS) - 1;
+    static constexpr int64_t MAX_DATACENTER_ID = (1 << DATACENTER_ID_BITS) - 1;
+    static constexpr int64_t SEQUENCE_BITS = 12L;
+    static constexpr int64_t WORKER_ID_SHIFT = SEQUENCE_BITS;
+    static constexpr int64_t DATACENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;
+    static constexpr int64_t TIMESTAMP_LEFT_SHIFT =
+      SEQUENCE_BITS + WORKER_ID_BITS + DATACENTER_ID_BITS;
+    static constexpr int64_t SEQUENCE_MASK = (1 << SEQUENCE_BITS) - 1;
+
+    using time_point = std::chrono::time_point<std::chrono::steady_clock>;
+
+    time_point start_time_point_ = std::chrono::steady_clock::now();
+    int64_t start_millsecond_ = std::chrono::duration_cast<std::chrono::milliseconds>(
+                                  std::chrono::system_clock::now().time_since_epoch())
+                                  .count();
+
+    int64_t last_timestamp_ = -1;
+    int64_t workerid_ = 0;
+    int64_t datacenterid_ = 0;
+    int64_t sequence_ = 0;
+    lock_type lock_;
+
+public:
+    snowflake() = default;
+
+    snowflake(const snowflake&) = delete;
+
+    snowflake& operator=(const snowflake&) = delete;
+
+    void init(int64_t workerid, int64_t datacenterid) {
+        std::lock_guard<lock_type> lock(lock_);
+        if (workerid > MAX_WORKER_ID || workerid < 0) {
+            throw std::runtime_error("worker Id can't be greater than 31 or less than 0");
+        }
+
+        if (datacenterid > MAX_DATACENTER_ID || datacenterid < 0) {
+            throw std::runtime_error("datacenter Id can't be greater than 31 or less than 0");
+        }
+
+        workerid_ = workerid;
+        datacenterid_ = datacenterid;
+    }
+
+    int64_t nextid() {
+        std::lock_guard<lock_type> lock(lock_);
+        // std::chrono::steady_clock  cannot decrease as physical time moves forward
+        auto timestamp = millsecond();
+        if (last_timestamp_ == timestamp) {
+            sequence_ = (sequence_ + 1) & SEQUENCE_MASK;
+            if (sequence_ == 0) {
+                timestamp = wait_next_millis(last_timestamp_);
+            }
+        } else {
+            sequence_ = 0;
+        }
+
+        last_timestamp_ = timestamp;
+
+        return ((timestamp - TWEPOCH) << TIMESTAMP_LEFT_SHIFT) |
+               (datacenterid_ << DATACENTER_ID_SHIFT) | (workerid_ << WORKER_ID_SHIFT) | sequence_;
+    }
+
+private:
+    int64_t millsecond() const {
+        auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(
+          std::chrono::steady_clock::now() - start_time_point_);
+        return start_millsecond_ + diff.count();
+    }
+
+    int64_t wait_next_millis(int64_t last) const {
+        auto timestamp = millsecond();
+        while (timestamp <= last) {
+            timestamp = millsecond();
+        }
+        return timestamp;
+    }
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/utilities/string_view.h

@@ -0,0 +1,70 @@
+/*
+ *  Copyright (c) 2019~2021, hikyuu
+ *
+ *  Created on: 2021/12/16
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "cppdef.h"
+
+#if CPP_STANDARD >= CPP_STANDARD_17
+#include <string>
+#include <string_view>
+namespace hku {
+
+using std::string_view;
+
+}
+
+#else
+
+#include <string>
+#include <cstring>
+#include "Log.h"
+
+namespace hku {
+
+class string_view {
+public:
+    constexpr string_view() noexcept = default;
+
+    string_view(const char *data, std::size_t size) : _data(data), _size(size) {
+        HKU_CHECK_THROW(data, std::invalid_argument, "Input null ptr!");
+    };
+
+    string_view(const char *data) : _data(data) {  // NOSONAR
+        HKU_CHECK_THROW(data, std::invalid_argument, "Input null ptr!");
+        _size = std::strlen(data);
+    }
+
+    string_view(const std::string &str) : _data(str.data()), _size(str.size()) {}  // NOSONAR
+
+    constexpr string_view(const string_view &) noexcept = default;
+
+    string_view &operator=(const string_view &) noexcept = default;
+
+    constexpr const char &operator[](std::size_t pos) const {
+        return _data[pos];
+    }
+
+    constexpr const char *data() const noexcept {
+        return _data;
+    }
+
+    constexpr std::size_t size() const noexcept {
+        return _size;
+    }
+
+private:
+    constexpr string_view(std::nullptr_t) = delete;
+
+private:
+    const char *_data = nullptr;
+    std::size_t _size = 0;
+};
+
+}  // namespace hku
+
+#endif