hikyuu 2.2.4__py3-none-macosx_11_1_arm64.whl

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([=] {
+            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