renamed

2025-09-30 10:29:02 +08:00 · 2019-03-23 17:25:50 +02:00
parent 6b0bf33f8e
commit 9858f2e499
5 changed files with 4 additions and 4 deletions
--- a/lite/spdlite.h
+++ b/lite/spdlite.h
@@ -0,0 +1,241 @@
+//
+// Copyright(c) 2015-present Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include "spdlog/fmt/fmt.h"
+
+//
+// enable/disable log calls at compile time according to global level.
+//
+// define SPDLITE_ACTIVE_LEVEL to one of those (before including lite.h):
+
+#define SPDLITE_LEVEL_TRACE 0
+#define SPDLITE_LEVEL_DEBUG 1
+#define SPDLITE_LEVEL_INFO 2
+#define SPDLITE_LEVEL_WARN 3
+#define SPDLITE_LEVEL_ERROR 4
+#define SPDLITE_LEVEL_CRITICAL 5
+#define SPDLITE_LEVEL_OFF 6
+
+#define SPDLITE_LOGGER_CALL(logger, level, ...)                                                                                            \
+    if (logger.should_log(level))                                                                                                          \
+    logger.log(level, __VA_ARGS__)
+
+#if SPDLITE_ACTIVE_LEVEL <= SPDLITE_LEVEL_TRACE
+#define SPDLITE_LOGGER_TRACE(logger, ...) SPDLITE_LOGGER_CALL(logger, spdlog::lite::level::trace, __VA_ARGS__)
+#define SPDLITE_TRACE(...) SPDLITE_LOGGER_TRACE(spdlog::lite::default_logger(), __VA_ARGS__)
+#else
+#define SPDLITE_LOGGER_TRACE(logger, ...) (void)0
+#define SPDLITE_TRACE(...) (void)0
+#endif
+
+#if SPDLITE_ACTIVE_LEVEL <= SPDLITE_LEVEL_DEBUG
+#define SPDLITE_LOGGER_DEBUG(logger, ...) SPDLITE_LOGGER_CALL(logger, spdlog::lite::level::debug, __VA_ARGS__)
+#define SPDLITE_DEBUG(...) SPDLITE_LOGGER_DEBUG(spdlog::lite::default_logger(), __VA_ARGS__)
+#else
+#define SPDLITE_LOGGER_DEBUG(logger, ...) (void)0
+#define SPDLITE_DEBUG(...) (void)0
+#endif
+
+#if SPDLITE_ACTIVE_LEVEL <= SPDLITE_LEVEL_INFO
+#define SPDLITE_LOGGER_INFO(logger, ...) SPDLITE_LOGGER_CALL(logger, spdlog::lite::level::info, __VA_ARGS__)
+#define SPDLITE_INFO(...) SPDLITE_LOGGER_INFO(spdlog::lite::default_logger(), __VA_ARGS__)
+#else
+#define SPDLITE_LOGGER_INFO(logger, ...) (void)0
+#define SPDLITE_INFO(...) (void)0
+#endif
+
+#if SPDLITE_ACTIVE_LEVEL <= SPDLITE_LEVEL_WARN
+#define SPDLITE_LOGGER_WARN(logger, ...) SPDLITE_LOGGER_CALL(logger, spdlog::lite::level::warn, __VA_ARGS__)
+#define SPDLITE_WARN(...) SPDLITE_LOGGER_WARN(spdlog::lite::default_logger(), __VA_ARGS__)
+#else
+#define SPDLITE_LOGGER_WARN(logger, ...) (void)0
+#define SPDLITE_WARN(...) (void)0
+#endif
+
+#if SPDLITE_ACTIVE_LEVEL <= SPDLITE_LEVEL_ERROR
+#define SPDLITE_LOGGER_ERROR(logger, ...) SPDLITE_LOGGER_CALL(logger, spdlog::lite::level::err, __VA_ARGS__)
+#define SPDLITE_ERROR(...) SPDLITE_LOGGER_ERROR(spdlog::lite::default_logger(), __VA_ARGS__)
+#else
+#define SPDLITE_LOGGER_ERROR(logger, ...) (void)0
+#define SPDLITE_ERROR(...) (void)0
+#endif
+
+#if SPDLITE_ACTIVE_LEVEL <= SPDLITE_LEVEL_CRITICAL
+#define SPDLITE_LOGGER_CRITICAL(logger, ...) SPDLITE_LOGGER_CALL(logger, spdlog::lite::level::critical, __VA_ARGS__)
+#define SPDLITE_CRITICAL(...) SPDLITE_LOGGER_CRITICAL(spdlog::lite::default_logger(), __VA_ARGS__)
+#else
+#define SPDLITE_LOGGER_CRITICAL(logger, ...) (void)0
+#define SPDLITE_CRITICAL(...) (void)0
+#endif
+
+namespace spdlog {
+class logger;
+
+namespace lite {
+enum class level
+{
+    trace = SPDLITE_LEVEL_TRACE,
+    debug = SPDLITE_LEVEL_DEBUG,
+    info = SPDLITE_LEVEL_INFO,
+    warn = SPDLITE_LEVEL_WARN,
+    err = SPDLITE_LEVEL_ERROR,
+    critical = SPDLITE_LEVEL_CRITICAL,
+    off = SPDLITE_LEVEL_OFF
+};
+
+struct src_loc
+{
+    const char *filename;
+    int line;
+    const char *funcname;
+};
+
+class logger
+{
+public:
+    logger() = default;
+
+    logger(std::shared_ptr<spdlog::logger> impl);
+    logger(const logger &) = default;
+    logger(logger &&) = default;
+    logger &operator=(const logger &) = default;
+
+    ~logger() = default;
+
+    bool should_log(spdlog::lite::level lvl) const noexcept;
+
+    template<typename... Args>
+    void log(spdlog::lite::level lvl, const char *fmt, const Args &... args)
+    {
+        if (!should_log(lvl))
+        {
+            return;
+        }
+        fmt::memory_buffer formatted_buf;
+        fmt::format_to(formatted_buf, fmt, args...);
+        log_formatted_(lvl, formatted_buf);
+    }
+
+    template<typename... Args>
+    void log(const spdlog::lite::src_loc &src, spdlog::lite::level lvl, const char *fmt, const Args &... args)
+    {
+        if (!should_log(lvl))
+        {
+            return;
+        }
+        fmt::memory_buffer formatted_buf;
+        fmt::format_to(formatted_buf, fmt, args...);
+        log_formatted_src(src, lvl, formatted_buf);
+    }
+
+    template<typename... Args>
+    void trace(const char *fmt, const Args &... args)
+    {
+        log(spdlog::lite::level::trace, fmt, args...);
+    }
+
+    template<typename... Args>
+    void trace(const char *source_file, int source_line, const char *source_func, const char *fmt, const Args &... args)
+    {
+        spdlog::lite::src_loc src{source_file, source_line, source_func};
+        log(src, spdlog::lite::level::trace, fmt, args...);
+    }
+
+    template<typename... Args>
+    void debug(const char *fmt, const Args &... args)
+    {
+        log(spdlog::lite::level::debug, fmt, args...);
+    }
+
+    template<typename... Args>
+    void info(const char *fmt, const Args &... args)
+    {
+        log(spdlog::lite::level::info, fmt, args...);
+    }
+
+    template<typename... Args>
+    void warn(const char *fmt, const Args &... args)
+    {
+        log(spdlog::lite::level::warn, fmt, args...);
+    }
+
+    template<typename... Args>
+    void error(const char *fmt, const Args &... args)
+    {
+        log(spdlog::lite::level::err, fmt, args...);
+    }
+
+    template<typename... Args>
+    void critical(const char *fmt, const Args &... args)
+    {
+        log(spdlog::lite::level::critical, fmt, args...);
+    }
+
+    std::string name() const;
+
+    // level
+    void set_level(lite::level level);
+    lite::level get_level() const;
+
+    // flush
+    void flush();
+    void flush_on(spdlog::lite::level log_level);
+    spdlog::lite::level flush_level() const;
+
+    // pattern
+    void set_pattern(std::string pattern);
+
+protected:
+    std::shared_ptr<spdlog::logger> impl_;
+    void log_formatted_(spdlog::lite::level lvl, const fmt::memory_buffer &formatted);
+    void log_formatted_src(const spdlog::lite::src_loc &src, spdlog::lite::level lvl, const fmt::memory_buffer &formatted);
+};
+spdlog::lite::logger &default_logger();
+
+template<typename... Args>
+void trace(const char *fmt, const Args &... args)
+{
+    default_logger().trace(fmt, args...);
+}
+template<typename... Args>
+void debug(const char *fmt, const Args &... args)
+{
+    default_logger().debug(fmt, args...);
+}
+
+template<typename... Args>
+void info(const char *fmt, const Args &... args)
+{
+    default_logger().info(fmt, args...);
+}
+
+template<typename... Args>
+void warn(const char *fmt, const Args &... args)
+{
+    default_logger().warn(fmt, args...);
+}
+
+template<typename... Args>
+void error(const char *fmt, const Args &... args)
+{
+    default_logger().error(fmt, args...);
+}
+
+template<typename... Args>
+void critical(const char *fmt, const Args &... args)
+{
+    default_logger().critical(fmt, args...);
+}
+
+} // namespace lite
+
+// factory to create lite logger
+// implement it in a dedicated compilation unit for fast compiles
+spdlog::lite::logger create_lite(void *ctx = nullptr);
+
+} // namespace spdlog