hikyuu 2.2.4__py3-none-macosx_11_1_arm64.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/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

hikyuu/include/hikyuu/utilities/thread/FuncWrapper.h

@@ -0,0 +1,85 @@
+/*
+ * FuncWrapper.h
+ *
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2019-9-16
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HIKYUU_UTILITIES_THREAD_FUNCWRAPPER_H
+#define HIKYUU_UTILITIES_THREAD_FUNCWRAPPER_H
+
+#include <memory>
+#include <functional>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4521)
+#endif
+
+namespace hku {
+
+/**
+ * 函数及函数对象等包装器实现移动语义，以便线程池支持不同类型的任务
+ */
+class FuncWrapper {
+public:
+    FuncWrapper() = default;
+    FuncWrapper(const FuncWrapper&) = delete;
+    FuncWrapper(FuncWrapper&) = delete;
+    FuncWrapper& operator=(const FuncWrapper&) = delete;
+
+    /** 移动构造函数，实现对函数及函数对象等任务包装 */
+    template <typename F>
+    // cppcheck-suppress noExplicitConstructor ; 此处不能添加 explicit 修饰，需要使用转换复制
+    FuncWrapper(F&& f) : impl(new impl_type<F>(std::move(f))) {}
+
+    /** 执行被包装的任务 */
+    void operator()() {
+        if (impl) {
+            impl->call();
+        }
+    }
+
+    /** 移动构造函数 */
+    FuncWrapper(FuncWrapper&& other) : impl(std::move(other.impl)) {}
+
+    /** 移动复制函数 */
+    FuncWrapper& operator=(FuncWrapper&& other) {
+        impl = std::move(other.impl);
+        return *this;
+    }
+
+    /** 是否是空任务，用于线程池判断是否在所有任务完成后终止运行 */
+    bool isNullTask() const {
+        return impl ? false : true;
+    }
+
+private:
+    struct impl_base {
+        virtual void call() = 0;
+        virtual ~impl_base() {}
+    };
+
+    std::unique_ptr<impl_base> impl;
+
+    template <typename F>
+    struct impl_type : impl_base {
+        F f;
+        // cppcheck-suppress noExplicitConstructor ; 此处不能添加 explicit 修饰，需要使用转换复制
+        impl_type(F&& f_) : f(std::move(f_)) {}
+        void call() override {
+            f();
+        }
+    };
+};
+
+} /* namespace hku */
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif /* HIKYUU_UTILITIES_THREAD_FUNCWRAPPER_H */

hikyuu/include/hikyuu/utilities/thread/InterruptFlag.h

@@ -0,0 +1,30 @@
+/**
+ *  Copyright (c) 2021 hikyuu.org
+ *
+ *  Created on: 2021/07/13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include <atomic>
+
+namespace hku {
+
+class InterruptFlag {
+public:
+    InterruptFlag() : m_flag(false) {}
+
+    void set() {
+        m_flag = true;
+    }
+
+    bool isSet() const {
+        return m_flag;
+    }
+
+private:
+    std::atomic_bool m_flag;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/utilities/thread/MQStealQueue.h

@@ -0,0 +1,112 @@
+/*
+ * MQStealQueue.h
+ *
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2019-11-17
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include <queue>
+#include <thread>
+#include <condition_variable>
+
+namespace hku {
+
+template <typename T>
+class MQStealQueue {
+public:
+    MQStealQueue() {}
+
+    void push(T&& item) {
+        std::lock_guard<std::mutex> lk(m_mutex);
+        m_queue.push_back(std::move(item));
+        m_cond.notify_one();
+    }
+
+    /** 将数据插入队列头部 */
+    void push_front(T&& data) {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_queue.push_front(std::move(data));
+        m_cond.notify_one();
+    }
+
+    void wait_and_pop(T& value) {
+        std::unique_lock<std::mutex> lk(m_mutex);
+        m_cond.wait(lk, [this] { return !m_queue.empty(); });
+        value = std::move(m_queue.front());
+        m_queue.pop_front();
+    }
+
+    std::shared_ptr<T> wait_and_pop() {
+        std::unique_lock<std::mutex> lk(m_mutex);
+        m_cond.wait(lk, [this] { return !m_queue.empty(); });
+        std::shared_ptr<T> res(std::make_shared<T>(std::move(m_queue.front())));
+        m_queue.pop_front();
+        return res;
+    }
+
+    bool try_pop(T& value) {
+        std::lock_guard<std::mutex> lk(m_mutex);
+        if (m_queue.empty()) {
+            return false;
+        }
+        value = std::move(m_queue.front());
+        m_queue.pop_front();
+        return true;
+    }
+
+    std::shared_ptr<T> try_pop() {
+        std::lock_guard<std::mutex> lk(m_mutex);
+        if (m_queue.empty()) {
+            return std::shared_ptr<T>();
+        }
+        std::shared_ptr<T> res(std::make_shared<T>(std::move(m_queue.front())));
+        m_queue.pop();
+        return res;
+    }
+
+    /**
+     * 尝试从队列尾部偷取一条数据
+     * @param res 存储偷取的数据
+     * @return 如果原本队列为空返回 false，否则为 true
+     */
+    bool try_steal(T& res) {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        if (m_queue.empty()) {
+            return false;
+        }
+
+        if (m_queue.back().isNullTask()) {
+            return false;
+        }
+        res = std::move(m_queue.back());
+        m_queue.pop_back();
+        return true;
+    }
+
+    bool empty() const {
+        std::lock_guard<std::mutex> lk(m_mutex);
+        return m_queue.empty();
+    }
+
+    // 队列大小，无锁
+    size_t size() const {
+        return m_queue.size();
+    }
+
+    void clear() {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        auto tmp = std::deque<T>();
+        m_queue.swap(tmp);
+    }
+
+private:
+    mutable std::mutex m_mutex;
+    std::deque<T> m_queue;
+    std::condition_variable m_cond;
+};
+
+} /* namespace hku */