hikyuu 2.0.9__cp310-none-win_amd64.whl → 2.1.1__cp310-none-win_amd64.whl

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

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

@@ -16,13 +16,19 @@
 #include "config.h"
 #include "exception.h"
 
+#ifndef HKU_LOG_ACTIVE_LEVEL
+#define HKU_LOG_ACTIVE_LEVEL 0
+#endif
+
 // clang-format off
-#if USE_SPDLOG_LOGGER
-    #include <spdlog/spdlog.h>
-    #include <spdlog/fmt/ostr.h>
-    #if HKU_USE_SPDLOG_ASYNC_LOGGER
-        #include "spdlog/async.h"
-    #endif
+#ifndef SPDLOG_ACTIVE_LEVEL
+#define SPDLOG_ACTIVE_LEVEL HKU_LOG_ACTIVE_LEVEL
+#endif
+
+#include <spdlog/spdlog.h>
+#include <spdlog/fmt/ostr.h>
+#if HKU_USE_SPDLOG_ASYNC_LOGGER
+    #include "spdlog/async.h"
 #endif
 // clang-format on
 
@@ -30,30 +36,24 @@
 #include <fmt/format.h>
 #include <fmt/chrono.h>
 
-#ifdef HKU_ENABLE_STACK_TRACE
+#ifndef HKU_ENABLE_STACK_TRACE
+#define HKU_ENABLE_STACK_TRACE 0
+#endif
+
+#if HKU_ENABLE_STACK_TRACE
 #include <boost/stacktrace.hpp>
 #endif
 
-#ifndef HKU_API
-#define HKU_API
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
 #endif
 
 namespace hku {
 
-/**
- * @ingroup Utilities
- * @addtogroup logging Logging tools 日志工具
- * @details 打印等级：
- * TRACE < DEBUG < INFO < WARN < ERROR < FATAL
- * @{
- */
-
-bool HKU_API isLogInMainThread();
-
 /**********************************************
  * Use SPDLOG for logging
  *********************************************/
-#if USE_SPDLOG_LOGGER
+
 /** 日志级别 */
 enum LOG_LEVEL {
     LOG_TRACE = SPDLOG_LEVEL_TRACE,     ///< 跟踪
@@ -65,19 +65,27 @@ enum LOG_LEVEL {
     LOG_OFF = SPDLOG_LEVEL_OFF,         ///< 关闭日志打印
 };
 
+/**
+ * 初始化 logger
+ * @param not_use_color 不使用彩色输出
+ * @param filename 日志文件名，为空时默认为当前目录下 "./hikyuu.log"，需自行保存存放目录存在且可写入
+ */
+void HKU_UTILS_API initLogger(bool not_use_color = false,
+                              const std::string& filename = std::string());
+
 /**
  * 获取当前日志级别
  * @return
  */
-LOG_LEVEL HKU_API get_log_level();
+LOG_LEVEL HKU_UTILS_API get_log_level();
 
 /**
  * 设置日志级别
  * @param level 指定的日志级别
  */
-void HKU_API set_log_level(LOG_LEVEL level);
+void HKU_UTILS_API set_log_level(LOG_LEVEL level);
 
-std::shared_ptr<spdlog::logger> HKU_API getHikyuuLogger();
+std::shared_ptr<spdlog::logger> HKU_UTILS_API getHikyuuLogger();
 
 #define HKU_TRACE(...) SPDLOG_LOGGER_TRACE(hku::getHikyuuLogger(), __VA_ARGS__)
 #define HKU_DEBUG(...) SPDLOG_LOGGER_DEBUG(hku::getHikyuuLogger(), __VA_ARGS__)
@@ -86,76 +94,6 @@ std::shared_ptr<spdlog::logger> HKU_API getHikyuuLogger();
 #define HKU_ERROR(...) SPDLOG_LOGGER_ERROR(hku::getHikyuuLogger(), __VA_ARGS__)
 #define HKU_FATAL(...) SPDLOG_LOGGER_CRITICAL(hku::getHikyuuLogger(), __VA_ARGS__)
 
-void initLogger(bool inJupyter = false);
-
-#else
-enum LOG_LEVEL {
-    LOG_TRACE = 0,
-    LOG_DEBUG = 1,
-    LOG_INFO = 2,
-    LOG_WARN = 3,
-    LOG_ERROR = 4,
-    LOG_FATAL = 5,
-    LOG_OFF = 6,
-};
-
-LOG_LEVEL HKU_API get_log_level();
-void HKU_API set_log_level(LOG_LEVEL level);
-void initLogger(bool inJupyter = false);
-
-/** 获取系统当前时间，精确到毫秒，如：2001-01-02 13:01:02.001 */
-std::string HKU_API getLocalTime();
-
-#if LOG_ACTIVE_LEVEL <= 0
-#define HKU_TRACE(...)                                                                            \
-    fmt::print("[{}] [HKU-T] - {} ({}:{})\n", getLocalTime(), fmt::format(__VA_ARGS__), __FILE__, \
-               __LINE__);
-#else
-#define HKU_TRACE(...)
-#endif
-
-#if LOG_ACTIVE_LEVEL <= 1
-#define HKU_DEBUG(...)                                                                            \
-    fmt::print("[{}] [HKU-D] - {} ({}:{})\n", getLocalTime(), fmt::format(__VA_ARGS__), __FILE__, \
-               __LINE__);
-#else
-#define HKU_DEBUG(...)
-#endif
-
-#if LOG_ACTIVE_LEVEL <= 2
-#define HKU_INFO(...)                                                                             \
-    fmt::print("[{}] [HKU-I] - {} ({}:{})\n", getLocalTime(), fmt::format(__VA_ARGS__), __FILE__, \
-               __LINE__);
-#else
-#define HKU_INFO(...)
-#endif
-
-#if LOG_ACTIVE_LEVEL <= 3
-#define HKU_WARN(...)                                                                             \
-    fmt::print("[{}] [HKU-W] - {} ({}:{})\n", getLocalTime(), fmt::format(__VA_ARGS__), __FILE__, \
-               __LINE__);
-#else
-#define HKU_WARN(...)
-#endif
-
-#if LOG_ACTIVE_LEVEL <= 4
-#define HKU_ERROR(...)                                                                            \
-    fmt::print("[{}] [HKU-E] - {} ({}:{})\n", getLocalTime(), fmt::format(__VA_ARGS__), __FILE__, \
-               __LINE__);
-#else
-#define HKU_ERROR(...)
-#endif
-
-#if LOG_ACTIVE_LEVEL <= 5
-#define HKU_FATAL(...)                                                                            \
-    fmt::print("[{}] [HKU-F] - {} ({}:{})\n", getLocalTime(), fmt::format(__VA_ARGS__), __FILE__, \
-               __LINE__);
-#else
-#define HKU_FATAL(...)
-#endif
-
-#endif /* USE_SPDLOG_LOGGER */
-
 ///////////////////////////////////////////////////////////////////////////////
 //
 // clang/gcc 下使用 __PRETTY_FUNCTION__ 会包含函数参数，可以在编译时指定
@@ -166,7 +104,7 @@ std::string HKU_API getLocalTime();
 #define HKU_FUNCTION __FUNCTION__
 #endif
 
-#ifndef HKU_ENABLE_STACK_TRACE
+#if !HKU_ENABLE_STACK_TRACE
 /**
  * 若表达式为 false，将抛出 hku::exception 异常, 并附带传入信息
  * @note 用于外部入参及结果检查
@@ -212,23 +150,9 @@ std::string HKU_API getLocalTime();
                                      __FILE__, __LINE__));                                         \
         }                                                                                          \
     } while (0)
-#endif  // #ifndef HKU_ENABLE_STACK_TRACE
+#endif  // #if !HKU_ENABLE_STACK_TRACE
 
-#if HKU_DEBUG_MODE
-#define HKU_ASSERT_DEBUG(expr)
-#else
-/** 仅在 debug 模式下生效 */
-#define HKU_ASSERT_DEBUG(expr)                                                            \
-    do {                                                                                  \
-        if (!(expr)) {                                                                    \
-            std::string err_msg(fmt::format("HKU_ASSERT({})", #expr));                    \
-            throw hku::exception(                                                         \
-              fmt::format("{} [{}] ({}:{})", err_msg, HKU_FUNCTION, __FILE__, __LINE__)); \
-        }                                                                                 \
-    } while (0)
-
-#endif /* #if HKU_DEBUG_MODE */
-#ifdef HKU_ENABLE_STACK_TRACE
+#if HKU_ENABLE_STACK_TRACE
 /**
  * 若表达式为 false，将抛出 hku::exception 异常
  * @note 仅用于内部入参检查，编译时可通过 HKU_DISABLE_ASSERT 宏关闭
@@ -253,9 +177,9 @@ std::string HKU_API getLocalTime();
         }                                                                                 \
     } while (0)
 
-#endif  // #ifndef HKU_ENABLE_STACK_TRACE
+#endif  // #if HKU_ENABLE_STACK_TRACE
 
-#ifndef HKU_ENABLE_STACK_TRACE
+#if !HKU_ENABLE_STACK_TRACE
 /** 抛出 hku::exception 及传入信息 */
 #define HKU_THROW(...)                                                                           \
     do {                                                                                         \
@@ -286,7 +210,7 @@ std::string HKU_API getLocalTime();
         throw except(                                                                           \
           fmt::format("EXCEPTION: {} [{}] ({}:{})", errmsg, HKU_FUNCTION, __FILE__, __LINE__)); \
     } while (0)
-#endif  // #ifndef HKU_ENABLE_STACK_TRACE
+#endif  // #if !HKU_ENABLE_STACK_TRACE
 
 /**
  * 满足指定条件时，打印 TRACE 信息
@@ -420,12 +344,66 @@ std::string HKU_API getLocalTime();
 
 /** 用于 catch (...) 中打印，减少编译后代码大小 */
 extern std::string g_unknown_error_msg;
+#define HKU_THROW_UNKNOWN HKU_THROW(g_unknown_error_msg);
 #define HKU_TRACE_UNKNOWN HKU_TRACE(g_unknown_error_msg)
 #define HKU_DEBUG_UNKNOWN HKU_DEBUG(g_unknown_error_msg)
 #define HKU_INFO_UNKNOWN HKU_INFO(g_unknown_error_msg)
 #define HKU_ERROR_UNKNOWN HKU_ERROR(g_unknown_error_msg)
 #define HKU_FATAL_UNKNOWN HKU_FATAL(g_unknown_error_msg)
 
+#if CPP_STANDARD >= CPP_STANDARD_17
+#define CLASS_LOGGER_IMP(cls) \
+protected:                    \
+    inline static const char* ms_logger = #cls;
+#else
+#define CLASS_LOGGER_IMP(cls) \
+protected:                    \
+    const char* ms_logger = #cls;
+#endif
+
+#define CLS_TRACE(...) HKU_TRACE(fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_DEBUG(...) HKU_DEBUG(fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_INFO(...) HKU_INFO(fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_WARN(...) HKU_WARN(fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_ERROR(...) HKU_ERROR(fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_FATAL(...) HKU_FATAL(fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+
+#define CLS_TRACE_IF(expr, ...) \
+    HKU_TRACE_IF(expr, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_DEBUG_IF(expr, ...) \
+    HKU_DEBUG_IF(expr, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_INFO_IF(expr, ...) \
+    HKU_INFO_IF(expr, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_WARN_IF(expr, ...) \
+    HKU_WARN_IF(expr, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_ERROR_IF(expr, ...) \
+    HKU_ERROR_IF(expr, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_FATAL_IF(expr, ...) \
+    HKU_FATAL_IF(expr, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+
+#define CLS_IF_RETURN(expr, ret) HKU_IF_RETURN(expr, ret)
+#define CLS_TRACE_IF_RETURN(expr, ret, ...) \
+    HKU_TRACE_IF_RETURN(expr, ret, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_DEBUG_IF_RETURN(expr, ret, ...) \
+    HKU_DEBUG_IF_RETURN(expr, ret, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_INFO_IF_RETURN(expr, ret, ...) \
+    HKU_INFO_IF_RETURN(expr, ret, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_WARN_IF_RETURN(expr, ret, ...) \
+    HKU_WARN_IF_RETURN(expr, ret, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_ERROR_IF_RETURN(expr, ret, ...) \
+    HKU_ERROR_IF_RETURN(expr, ret, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_FATAL_IF_RETURN(expr, ret, ...) \
+    HKU_FATAL_IF_RETURN(expr, ret, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+
+#define CLS_ASSERT HKU_ASSERT
+#define CLS_CHECK(expr, ...) \
+    HKU_CHECK(expr, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_CHECK_THROW(expr, except, ...) \
+    HKU_CHECK_THROW(expr, except, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_THROW(...) HKU_THROW(fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+#define CLS_THROW_EXCEPTION(except, ...) \
+    HKU_THROW_EXCEPTION(except, fmt::format("[{}] {}", ms_logger, fmt::format(__VA_ARGS__)))
+
 /** @} */
 
 } /* namespace hku */

hikyuu/include/hikyuu/utilities/Null.h

@@ -10,6 +10,7 @@
 #define NULL_H_
 
 #include <cstddef>
+#include <cstdint>
 #include <limits>
 #include <type_traits>
 #include "osdef.h"

hikyuu/include/hikyuu/utilities/Parameter.h

@@ -17,7 +17,8 @@
 #include <map>
 #include <boost/any.hpp>
 
-#include "../config.h"
+#include "hikyuu/config.h"
+#include "hikyuu/utilities/config.h"
 
 #if HKU_SUPPORT_SERIALIZATION
 #include <boost/lexical_cast.hpp>