hikyuu 2.6.8__py3-none-manylinux2014_aarch64.whl

hikyuu/include/hikyuu/utilities/DllLoader.h

@@ -0,0 +1,226 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-03-18
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HKU_UTILS_DLL_LOADER_H_
+#define HKU_UTILS_DLL_LOADER_H_
+
+#include <string>
+#include <vector>
+#include <cstdlib>
+#include "hikyuu/utilities/config.h"
+#include "hikyuu/utilities/osdef.h"
+#include "hikyuu/utilities/os.h"
+#include "hikyuu/utilities/Log.h"
+#include "hikyuu/utilities/arithmetic.h"
+
+#if HKU_OS_WINDOWS
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+namespace hku {
+
+class DllLoader {
+public:
+    DllLoader() {
+        initDefaultSearchPath();
+    }
+
+    explicit DllLoader(const std::vector<std::string>& path) {
+        if (!path.empty()) {
+            m_search_paths.resize(path.size());
+            std::copy(path.begin(), path.end(), m_search_paths.begin());
+        } else {
+            HKU_WARN("DllLoader: empty search path! Use default search path!");
+            initDefaultSearchPath();
+        }
+    }
+
+    DllLoader(const DllLoader&) = delete;
+    DllLoader& operator=(const DllLoader&) = delete;
+
+    DllLoader(DllLoader&& rhs)
+    : m_handle(rhs.m_handle), m_search_paths(std::move(rhs.m_search_paths)) {
+        rhs.m_handle = nullptr;
+    }
+
+    DllLoader& operator=(DllLoader&& rhs) {
+        if (this == &rhs) {
+            m_handle = rhs.m_handle;
+            m_search_paths = std::move(rhs.m_search_paths);
+            rhs.m_handle = nullptr;
+        }
+        return *this;
+    }
+
+    virtual ~DllLoader() {
+        unload();
+    }
+
+    bool load(const std::string& dllname) noexcept {
+        std::string filename = search(dllname);
+        HKU_WARN_IF_RETURN(filename.empty(), false, "Not found dll: {}!", dllname);
+
+#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 dll({}) failed!", filename);
+        return true;
+    }
+
+    void unload() noexcept {
+        if (m_handle) {
+#if HKU_OS_WINDOWS
+            FreeLibrary(m_handle);
+#else
+            dlclose(m_handle);
+#endif
+        }
+    }
+
+    std::string search(const std::string& dllname) const noexcept {
+#if HKU_OS_WINDOWS
+        std::string dll = fmt::format("{}.dll", dllname);
+#elif HKU_OS_OSX
+        std::string dll = fmt::format("lib{}.dylib", dllname);
+#else
+        std::string dll = fmt::format("lib{}.so", dllname);
+#endif
+        for (const auto& path : m_search_paths) {
+            auto filename = fmt::format("{}/{}", path, dll);
+            if (existFile(filename)) {
+                return filename;
+            }
+        }
+
+        return std::string();
+    }
+
+    void* getSymbol(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:
+    void initDefaultSearchPath() noexcept {
+        m_search_paths.emplace_back(".");
+
+        std::string userdir = getUserDir();
+        if (!userdir.empty()) {
+            m_search_paths.emplace_back(userdir + "/lib");
+        }
+
+#if HKU_OS_WINDOWS
+        m_search_paths.emplace_back("C:/Windows/System32");
+        m_search_paths.emplace_back("C:/Windows/SysWOW64");
+        m_search_paths.emplace_back("C:/Windows");
+        const char* path = getenv("PATH");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+
+#elif HKU_OS_OSX
+        const char* path = getenv("DYLD_IMAGE_SUFFIX");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+        path = getenv("DYLD_FRAMEWORK_PATH");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+        path = getenv("DYLD_LIBRARY_PATH");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+        m_search_paths.emplace_back("/Library/Frameworks");
+        m_search_paths.emplace_back("/Network/Library/Frameworks");
+        m_search_paths.emplace_back("/System/Library/Frameworks");
+        m_search_paths.emplace_back("/usr/local/lib");
+        m_search_paths.emplace_back("/usr/lib");
+        m_search_paths.emplace_back("/lib");
+
+#else
+        const char* path = getenv("LD_LIBRARY_PATH");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+        m_search_paths.emplace_back("/usr/local/lib");
+        m_search_paths.emplace_back("/usr/lib");
+        m_search_paths.emplace_back("/lib");
+        if (HKU_ARCH_X64) {
+            m_search_paths.emplace_back("/usr/lib/x86_64-linux-gnu");
+        } else if (HKU_ARCH_ARM64) {
+            m_search_paths.emplace_back("/usr/lib/aarch64-linux-gnu");
+        } else if (HKU_ARCH_X86) {
+            m_search_paths.emplace_back("/usr/lib/i386-linux-gnu");
+        } else if (HKU_ARCH_ARM) {
+            m_search_paths.emplace_back("/usr/lib/arm-linux-gnueabihf");
+        }
+#endif
+    }
+
+private:
+#if HKU_OS_WINDOWS
+    HMODULE m_handle{nullptr};
+#else
+    void* m_handle{nullptr};
+#endif
+
+    std::vector<std::string> m_search_paths;
+};
+
+}  // namespace hku
+
+#endif /* HKU_UTILS_DLL_LOADER_H_ */

hikyuu/include/hikyuu/utilities/FilterNode.h

@@ -0,0 +1,267 @@
+/*
+ *  Copyright (c) 2023 hikyuu.org
+ *
+ *  Created on: 2023-01-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include <memory>
+#include <functional>
+#include <forward_list>
+#include <unordered_map>
+#include "thread/ThreadPool.h"
+#include "any_to_string.h"
+#include "Log.h"
+
+namespace hku {
+
+/**
+ * @brief 过滤节点
+ */
+class FilterNode {
+public:
+    FilterNode() = default;
+    FilterNode(const FilterNode&) = default;
+    virtual ~FilterNode() = default;
+
+    /**
+     * @brief 构造函数
+     * @param exclusive 是否排他。为 true 时，只执行第一个遇到的满足过滤条件的子节点
+     */
+    explicit FilterNode(bool exclusive) : m_exclusive(exclusive) {}
+
+    FilterNode(FilterNode&& rv)
+    : m_value(std::move(rv.m_value)),
+      m_children(std::move(rv.m_children)),
+      m_exclusive(rv.m_exclusive) {}
+
+    FilterNode& operator=(const FilterNode& rv) {
+        if (this == &rv)
+            return *this;
+        m_value = rv.m_value;
+        m_children = rv.m_children;
+        m_exclusive = rv.m_exclusive;
+        return *this;
+    }
+
+    FilterNode& operator=(FilterNode&& rv) {
+        if (this == &rv)
+            return *this;
+        m_value = std::move(rv.m_value);
+        m_children = std::move(rv.m_children);
+        m_exclusive = rv.m_exclusive;
+        return *this;
+    }
+
+    using ptr_t = std::shared_ptr<FilterNode>;
+
+    ptr_t addChild(const ptr_t& child) {
+        HKU_CHECK(child, "Invalid input child! child is null!");
+        m_children.push_front(child);
+        return child;
+    }
+
+    bool exclusive() const {
+        return m_exclusive;
+    }
+
+    void exclusive(bool exclusive) {
+        m_exclusive = exclusive;
+    }
+
+    using const_iterator = std::forward_list<ptr_t>::const_iterator;
+    using iterator = std::forward_list<ptr_t>::iterator;
+    const_iterator cbegin() const {
+        return m_children.cbegin();
+    }
+
+    const_iterator cend() const {
+        return m_children.cend();
+    }
+
+    iterator begin() {
+        return m_children.begin();
+    }
+
+    iterator end() {
+        return m_children.end();
+    }
+
+    bool run(const any_t& data) noexcept {
+        if (_filter(data)) {
+            _process(data);
+            for (auto& node : m_children) {
+                if (node->run(data) && m_exclusive) {
+                    return true;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    virtual bool filter(const any_t& data) {
+        return true;
+    }
+
+    virtual void process(const any_t& data) {}
+
+    template <typename ValueT>
+    ValueT value() const {
+        return any_cast<ValueT>(m_value);
+    }
+
+    template <typename ValueT>
+    void value(const ValueT& value) {
+        m_value = value;
+    }
+
+    bool has_value() const {
+#if !HKU_OS_IOS && CPP_STANDARD >= CPP_STANDARD_17
+        return m_value.has_value();
+#else
+        return !m_value.empty();
+#endif
+    }
+
+private:
+    bool _filter(const any_t& data) noexcept {
+        try {
+            return filter(data);
+        } catch (const std::exception& e) {
+            HKU_WARN("Node filter exist error! {}", e.what());
+        } catch (...) {
+            HKU_WARN("Node filter exist unknown error!");
+        }
+        return false;
+    }
+
+    void _process(const any_t& data) noexcept {
+        try {
+            process(data);
+        } catch (const std::exception& e) {
+            HKU_WARN("Node process exist error! {}", e.what());
+        } catch (...) {
+            HKU_WARN("Node process exist unknown error!");
+        }
+    }
+
+protected:
+    any_t m_value;
+
+private:
+    std::forward_list<ptr_t> m_children;
+    bool m_exclusive = false;
+};
+
+template <>
+inline const any_t& FilterNode::value() const {
+    return m_value;
+}
+
+typedef std::shared_ptr<FilterNode> FilterNodePtr;
+
+/**
+ * @brief 绑定过滤节点，通过 std::function 绑定自定义的 filter 和 process 处理函数
+ */
+class BindFilterNode : public FilterNode {
+public:
+    BindFilterNode() = default;
+    virtual ~BindFilterNode() = default;
+
+    using filter_func = std::function<bool(FilterNode*, const any_t&)>;
+    using process_func = std::function<void(FilterNode*, const any_t&)>;
+
+    explicit BindFilterNode(const process_func& process) : FilterNode(false), m_process(process) {}
+    explicit BindFilterNode(process_func&& process)
+    : FilterNode(false), m_process(std::move(process)) {}
+
+    BindFilterNode(const filter_func& filter, const process_func& process, bool exclusive = false)
+    : FilterNode(exclusive), m_filter(filter), m_process(process) {}
+
+    BindFilterNode(filter_func&& filter, process_func&& process, bool exclusive = false)
+    : FilterNode(exclusive), m_filter(std::move(filter)), m_process(std::move(process)) {}
+
+    virtual bool filter(const any_t& data) {
+        return m_filter ? m_filter(this, data) : true;
+    }
+
+    virtual void process(const any_t& data) {
+        if (m_process) {
+            m_process(this, data);
+        }
+    }
+
+private:
+    filter_func m_filter;
+    process_func m_process;
+};
+
+/**
+ * @brief 异步串行事件处理器
+ * @tparam EventT
+ */
+template <class EventT>
+class AsyncSerialEventProcessor {
+public:
+    /**
+     * @brief 构造函数
+     * @param quit_wait 退出时等待所有任务完成
+     */
+    explicit AsyncSerialEventProcessor(bool quit_wait = true) : m_quit_wait(quit_wait) {
+        m_tg = std::unique_ptr<ThreadPool>(new ThreadPool(1));
+    }
+
+    /** 析构函数 */
+    virtual ~AsyncSerialEventProcessor() {
+        if (m_quit_wait) {
+            m_tg->join();
+        } else {
+            m_tg->stop();
+        }
+    }
+
+    /**
+     * @brief 添加事件处理节点
+     *
+     * @param event 事件
+     * @param action 对应的处理节点
+     * @return 返回加入的节点
+     */
+    FilterNodePtr addAction(const EventT& event, const FilterNodePtr& action) {
+        HKU_CHECK(action, "Input action is null!");
+        std::lock_guard<std::mutex> lock(m_mutex);
+        auto iter = m_trees.find(event);
+        if (iter != m_trees.end()) {
+            iter->second->addChild(action);
+        } else {
+            m_trees[event] = action;
+        }
+        return action;
+    }
+
+    /**
+     * @brief 分派事件消息
+     *
+     * @param event 事件
+     * @param data 事件附加信息
+     */
+    void dispatch(const EventT& event, const any_t& data) {
+        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);
+            iter->second->run(data);
+        });
+    }
+
+private:
+    mutable std::mutex m_mutex;
+    std::unordered_map<EventT, FilterNodePtr> m_trees;
+    std::unique_ptr<ThreadPool> m_tg;
+    bool m_quit_wait = true;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/utilities/LRUCache11.h

@@ -0,0 +1,230 @@
+/*
+ * LRUCache11 - a templated C++11 based LRU cache class that allows
+ * specification of
+ * key, value and optionally the map container type (defaults to
+ * std::unordered_map)
+ * By using the std::unordered_map and a linked list of keys it allows O(1) insert, delete
+ * and
+ * refresh operations.
+ *
+ * This is a header-only library and all you need is the LRUCache11.hpp file
+ *
+ * Github: https://github.com/mohaps/lrucache11
+ *
+ * This is a follow-up to the LRUCache project -
+ * https://github.com/mohaps/lrucache
+ *
+ * Copyright (c) 2012-22 SAURAV MOHAPATRA <mohaps@gmail.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#pragma once
+#include <algorithm>
+#include <cstdint>
+#include <list>
+#include <mutex>
+#include <stdexcept>
+#include <thread>
+#include <unordered_map>
+
+namespace lru11 {
+/*
+ * a noop lockable concept that can be used in place of std::mutex
+ */
+class NullLock {
+public:
+    void lock() {}
+    void unlock() {}
+    bool try_lock() {
+        return true;
+    }
+};
+
+/**
+ * error raised when a key not in cache is passed to get()
+ */
+class KeyNotFound : public std::invalid_argument {
+public:
+    KeyNotFound() : std::invalid_argument("key_not_found") {}
+};
+
+template <typename K, typename V>
+struct KeyValuePair {
+public:
+    K key;
+    V value;
+
+    KeyValuePair(K k, V v) : key(std::move(k)), value(std::move(v)) {}
+};
+
+/**
+ *	The LRU Cache class templated by
+ *		Key - key type
+ *		Value - value type
+ *		MapType - an associative container like std::unordered_map
+ *		LockType - a lock type derived from the Lock class (default:
+ *NullLock = no synchronization)
+ *
+ *	The default NullLock based template is not thread-safe, however passing
+ *Lock=std::mutex will make it
+ *	thread-safe
+ */
+template <class Key, class Value, class Lock = NullLock,
+          class Map =
+            std::unordered_map<Key, typename std::list<KeyValuePair<Key, Value>>::iterator>>
+class Cache {
+public:
+    typedef KeyValuePair<Key, Value> node_type;
+    typedef std::list<KeyValuePair<Key, Value>> list_type;
+    typedef Map map_type;
+    typedef Lock lock_type;
+    using Guard = std::lock_guard<lock_type>;
+    /**
+     * the maxSize is the soft limit of keys and (maxSize + elasticity) is the
+     * hard limit
+     * the cache is allowed to grow till (maxSize + elasticity) and is pruned back
+     * to maxSize keys
+     * set maxSize = 0 for an unbounded cache (but in that case, you're better off
+     * using a std::unordered_map
+     * directly anyway! :)
+     */
+    explicit Cache(size_t maxSize = 64, size_t elasticity = 10)
+    : maxSize_(maxSize), elasticity_(elasticity) {}
+    virtual ~Cache() = default;
+    size_t size() const {
+        Guard g(lock_);
+        return cache_.size();
+    }
+    bool empty() const {
+        Guard g(lock_);
+        return cache_.empty();
+    }
+    void clear() {
+        Guard g(lock_);
+        cache_.clear();
+        keys_.clear();
+    }
+    void insert(const Key& k, const Value& v) {
+        Guard g(lock_);
+        const auto iter = cache_.find(k);
+        if (iter != cache_.end()) {
+            iter->second->value = v;
+            keys_.splice(keys_.begin(), keys_, iter->second);
+            return;
+        }
+
+        keys_.emplace_front(k, v);
+        cache_[k] = keys_.begin();
+        prune();
+    }
+    void insert(const Key& k, Value&& v) {
+        Guard g(lock_);
+        const auto iter = cache_.find(k);
+        if (iter != cache_.end()) {
+            iter->second->value = std::move(v);
+            keys_.splice(keys_.begin(), keys_, iter->second);
+            return;
+        }
+
+        keys_.emplace_front(k, std::move(v));
+        cache_[k] = keys_.begin();
+        prune();
+    }
+    bool tryGet(const Key& kIn, Value& vOut) {
+        Guard g(lock_);
+        const auto iter = cache_.find(kIn);
+        if (iter == cache_.end()) {
+            return false;
+        }
+        keys_.splice(keys_.begin(), keys_, iter->second);
+        vOut = iter->second->value;
+        return true;
+    }
+    /**
+     *	The const reference returned here is only
+     *    guaranteed to be valid till the next insert/delete
+     *  修改为非常量引用，以便修改。但请注意这是危险操作！
+     */
+    Value& get(const Key& k) {
+        Guard g(lock_);
+        const auto iter = cache_.find(k);
+        if (iter == cache_.end()) {
+            throw KeyNotFound();
+        }
+        keys_.splice(keys_.begin(), keys_, iter->second);
+        return iter->second->value;
+    }
+    /**
+     * returns a copy of the stored object (if found)
+     */
+    Value getCopy(const Key& k) {
+        return get(k);
+    }
+    bool remove(const Key& k) {
+        Guard g(lock_);
+        auto iter = cache_.find(k);
+        if (iter == cache_.end()) {
+            return false;
+        }
+        keys_.erase(iter->second);
+        cache_.erase(iter);
+        return true;
+    }
+    bool contains(const Key& k) const {
+        Guard g(lock_);
+        return cache_.find(k) != cache_.end();
+    }
+
+    size_t getMaxSize() const {
+        return maxSize_;
+    }
+    size_t getElasticity() const {
+        return elasticity_;
+    }
+    size_t getMaxAllowedSize() const {
+        return maxSize_ + elasticity_;
+    }
+    template <typename F>
+    void cwalk(F& f) const {
+        Guard g(lock_);
+        std::for_each(keys_.begin(), keys_.end(), f);
+    }
+
+protected:
+    size_t prune() {
+        size_t maxAllowed = maxSize_ + elasticity_;
+        if (maxSize_ == 0 || cache_.size() < maxAllowed) {
+            return 0;
+        }
+        size_t count = 0;
+        while (cache_.size() > maxSize_) {
+            cache_.erase(keys_.back().key);
+            keys_.pop_back();
+            ++count;
+        }
+        return count;
+    }
+
+private:
+    // Disallow copying.
+    Cache(const Cache&) = delete;
+    Cache& operator=(const Cache&) = delete;
+
+    mutable Lock lock_;
+    Map cache_;
+    list_type keys_;
+    size_t maxSize_;
+    size_t elasticity_;
+};
+
+}  // namespace lru11