logger_types.hpp

浏览该文件的文档.

//
// Created by wanjiangzhi on 2026/3/30.
//
 
#ifndef ZCLIBLOG_LOGGER_TYPES_HPP
#define ZCLIBLOG_LOGGER_TYPES_HPP
 
#include <string>
#include <chrono>
#include <memory>
#include <utility>
#include <type_traits>
 
#include "logger_macros.h"
 
namespace ZCLibLog {
    using LogLevelBase = uint16_t;
 
    #define ZCLIBLOG_HELPER_LEVELS(Register) \
        Register(ALL,   0) \
        Register(TRACE, 1) \
        Register(DEBUG, 2) \
        Register(INFO,  3) \
        Register(WARN,  4) \
        Register(ERROR, 5) \
        Register(FATAL, 6) \
        Register(OFF, std::numeric_limits<LogLevelBase>::max())
 
    enum class LogLevel : LogLevelBase {
        #define ZCLIBLOG_HELPER_ENUM_CASE(name, value) name = value,
        ZCLIBLOG_HELPER_LEVELS(ZCLIBLOG_HELPER_ENUM_CASE)
        #undef ZCLIBLOG_HELPER_ENUM_CASE
    };
 
    inline const char* LogLevelToString(const LogLevel level) {
        switch (level) {
                #define ZCLIBLOG_HELPER_ENUM_CASE(name, value) case LogLevel::name: return #name;
            ZCLIBLOG_HELPER_LEVELS(ZCLIBLOG_HELPER_ENUM_CASE)
                #undef ZCLIBLOG_HELPER_ENUM_CASE
        }
        return "UNKNOWN";
    }
 
    #undef ZCLIBLOG_HELPER_LEVELS
 
    struct LogPack {
        const std::string* name = {};
        uint64_t time = {};
        LogLevel level = {};
    };
 
    struct LogLevelCfg {
        LogLevel min_level;
        LogLevel max_level;
 
        // ReSharper disable once CppNonExplicitConvertingConstructor
        LogLevelCfg(const LogLevel level = {}) : min_level(level),
                                                 max_level(LogLevel::OFF) {}
 
        LogLevelCfg(const LogLevel min_level, const LogLevel max_level) : min_level(min_level),
                                                                          max_level(max_level) {}
    };
 
    using ELogLevel = const LogLevel;
    using ELString = const std::string&;
 
    struct executor_api {
        virtual void do_execute(ELString, ELogLevel) = 0;
        virtual ~executor_api() = default;
 
    protected:
        using ELString = ELString;
        using ELogLevel = ELogLevel;
        using LogLevel = LogLevel;
    };
 
    template <typename Executor>
    using is_executor_api = std::is_base_of<executor_api, Executor>;
 
    class executor {
    public:
        using base_ptr_type = std::shared_ptr<executor_api>;
        using inside_type = base_ptr_type::element_type;
 
    private:
        base_ptr_type executor_ptr;
 
    public:
        executor() = default;
        // ReSharper disable once CppNonExplicitConvertingConstructor
        executor(inside_type* executor_ptr) : executor_ptr(executor_ptr) {}
 
        template <typename Executor, typename... Args>
        static executor make(Args&&... args) {
            static_assert(is_executor_api<Executor>::value, "Executor must be a real executor");
 
            executor made;
            made.executor_ptr = std::move(std::make_shared<Executor>(std::forward<Args>(args)...));
 
            return std::move(made);
        }
 
        ZCLibLog_NODISCARD inside_type* get() const noexcept {
            return executor_ptr.get();
        }
 
        ZCLibLog_NODISCARD bool unique() const noexcept {
            // return executor_ptr.unique();
            // unique成员函数在MSVC下不存在？不知为何通不过多平台构建测试
            return executor_ptr.use_count() == 1;
            // 这里使用等价逻辑代替
        }
 
        ZCLibLog_NODISCARD long use_count() const noexcept {
            return executor_ptr.use_count();
        }
 
        inside_type* operator->() const noexcept {
            return executor_ptr.operator->();
        }
 
        inside_type& operator*() const noexcept {
            return executor_ptr.operator*();
        }
 
        // ReSharper disable once CppNonExplicitConversionOperator
        operator bool() const noexcept {
            return executor_ptr.get() != nullptr;
        }
    };
 
    using FLogPack = const LogPack&;
    using FLString = std::string;
 
    struct format_api {
    protected:
        using FLogPack = FLogPack;
        using FLString = FLString;
        using LogLevel = LogLevel;
    };
 
    template <typename FormatAPI>
    struct is_format_api
    : std::integral_constant<
        bool,
        std::is_base_of<format_api, FormatAPI>::value &&
        !std::is_same<FormatAPI, format_api>::value
    > {};
 
    template <typename Formatter>
    struct is_formatter
    : std::integral_constant<
        bool,
        std::is_base_of<format_api, typename Formatter::Format_API>::value &&
        !std::is_same<typename Formatter::Format_API, format_api>::value &&
        std::is_base_of<typename Formatter::Format_API, Formatter>::value &&
        !std::is_same<typename Formatter::Format_API, Formatter>::value
    > {};
 
    template <typename Logger>
    class LogTagBase {
    protected:
        ZCLibLog_NODISCARD LogPack get_log_pack() const {
            const auto now = std::chrono::system_clock::now();
            const auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
                now.time_since_epoch()
            ).count();
 
            LogPack p;
            p.name = &m_logger->name();
            p.level = m_level;
            p.time = ms;
 
            return p;
        }
 
        ZCLibLog_NODISCARD bool check_executable() const {
            if (
                m_logger->has_executor() &&
                m_logger->be_executable(level())
            )
                return true;
            return {};
        }
 
        const Logger* const m_logger{};
        const LogLevel m_level{};
    public:
        ZCLibLog_NODISCARD const LogLevel& level() const noexcept {
            return m_level;
        }
 
        LogTagBase(const Logger* const logger, const LogLevel level) : m_logger(logger),
                                                                    m_level(level) {}
    };
 
    template <typename FormatterAPI, typename Logger>
    struct LogTag : LogTagBase<Logger> {
        using LogTagBase<Logger>::LogTagBase;
        static_assert(
            is_format_api<FormatterAPI>::value,
            "Formatter must be format_api"
        );
    };
}
 
#endif //ZCLIBLOG_LOGGER_TYPES_HPP