dl_log.h

浏览该文件的文档.

#pragma once
 
#include <string>
#include <iostream>
#include <stack>
#include <array>
#include <mutex>
 
#include "system/dl_platform.h"
 
#if DL_PLATFORM == DL_PLATFORM_WIN32
#include <stacktrace>
#include <source_location>
#define DL_SOURCE_LOCATION std::source_location location = std::source_location::current()
#define DL_SOURCE_LOCATION_IMP std::source_location location
#define DL_SOURCE_LOCATION_CALL std::source_location::current()
#define DL_SOURCE_LOCATION_FORWARD location
#else
#define DL_SOURCE_LOCATION        const char* file = __FILE__, int line = __LINE__
#define DL_SOURCE_LOCATION_IMP    const char* file, int line
#define DL_SOURCE_LOCATION_CALL   __FILE__, __LINE__
#define DL_SOURCE_LOCATION_FORWARD   file, line
#endif
 
namespace dl
{
    struct LogSourceLocation
    {
        const char* _file;
        const char* _func;
        int _line;
        int _column;
    };
}
 
#if DL_PLATFORM == DL_PLATFORM_WIN32
#define DL_MAKE_SOURCE_LOCATION(loc) \
    LogSourceLocation loc;\
    loc._file = location.file_name();\
    loc._func = location.function_name();\
    loc._line = location.line();\
    loc._column = location.column();
#else
#define DL_MAKE_SOURCE_LOCATION(loc) \
    LogSourceLocation loc;\
    loc._file = file;\
    loc._func = __func__;\
    loc._line = line;\
    loc._column = 0;
#endif
 
#include <fmt/format.h>
 
namespace dl
{
constexpr std::array<std::string_view, 9> DL_LOG_SYSTEM_LEVLE_NAME = {
    "damage", "err", "warn", "notice", "msg", "info", "test", "pause",
};

void Output(std::string_view str);
 

class LogSystem
{
    friend class LogLimit;
    friend class LogStackTrack;
    friend class LogLevelSet;
public:
    enum class Level
    {
        DAMAGE,
        ERR,
        WARN,
        NOTICE,
        MSG,
        INFO,
        TEST,
        PAUSE,
    };
    struct Setting
    {
        Level _level         = Level::INFO;
        bool _bSourceLocation   = true;
        bool _bTimeStamp     = true;
        bool _bStackTrace       = false;
    };
    LogSystem();

    const Setting& GetSetting()
    {
        _mutexSetting.lock();
        Setting& ret = _stackSetting.top();
        _mutexSetting.unlock();
        return ret;
    }

    void SetLogFile(std::string_view path, std::string_view name = {}, bool clear = true);
    std::string GetLogFile()
    {
        return _logFile;
    }
    
    bool IsLevelLimit(Level level)
    {
        _mutexLevel.lock();
        bool ret = level > _stackLevel.top();
        _mutexLevel.unlock();
        return ret;
    }

    bool IsLevelMsgBox(Level level)
    {
        return level <= _levelMsgBox;
    }

    void SetLevelMsgBox(Level level)
    {
        _levelMsgBox = level;
    }
 
    std::mutex& GetMutex() { return _mutexOutput; }

    static std::string_view Level2String(Level level)
    {
        size_t index = (size_t)level;
        if (index >= DL_LOG_SYSTEM_LEVLE_NAME.size())
            return "NONE";
        return DL_LOG_SYSTEM_LEVLE_NAME[index];
    }
private:
    std::stack<Setting> _stackSetting;
    std::stack<Level> _stackLevel;
    Level _levelMsgBox;// 弹窗等级
    static std::string _logFile;// 日志文件夹（为空时不生成）
    std::recursive_mutex _mutexSetting;// 当前设置锁
    std::recursive_mutex _mutexLevel; // level锁
    std::mutex _mutexOutput; // 输出锁
 
    // 容易错误使用，改为私有（请使用LogLimit）
    void Push(const Setting& setting)
    {
        _mutexSetting.lock();
        _stackSetting.push(setting);
    }
    void Pop()
    {
        _stackSetting.pop();
        _mutexSetting.unlock();
    }
    void PushLevel(Level level)
    {
        Setting setting = GetSetting();
        setting._level = level;
        Push(setting);
    }
    void PushLevelLimit(Level level)
    {
        _mutexLevel.lock();
        _stackLevel.push(level);
    }
    void PopLevelLimit()
    {
        _stackLevel.pop();
        _mutexLevel.unlock();
    }
};
extern LogSystem* g_log;
class LogLevelSet
{
public:
    LogLevelSet(LogSystem::Level level)
    {
        g_log->PushLevel(level);
    }
    ~LogLevelSet()
    {
        g_log->Pop();
    }
};

class LogLimit
{
public:
    LogLimit(LogSystem::Level level = LogSystem::Level::DAMAGE)
    {
        g_log->PushLevelLimit(level);
    }
    ~LogLimit()
    {
        g_log->PopLevelLimit();
    }
};

class LogStackTrack
{
public:
    LogStackTrack(bool open = true)
    {
        LogSystem::Setting s = g_log->GetSetting();
        s._bStackTrace = open;
        g_log->Push(s);
    }
    ~LogStackTrack()
    {
        g_log->Pop();
    }
};

inline void log_easy(std::string_view str)
{
    printf("%s", str.data()); // printf线程安全
    //std::cout << str << std::endl;
}
 
void log_pause0(std::string_view str, DL_SOURCE_LOCATION);
void log_test0(std::string_view str, DL_SOURCE_LOCATION);
void log_info0(std::string_view str, DL_SOURCE_LOCATION);
void log_msg0(std::string_view str, DL_SOURCE_LOCATION);
void log_notice0(std::string_view str, DL_SOURCE_LOCATION);
void log_warn0(std::string_view str, DL_SOURCE_LOCATION);
void log_err0(std::string_view str, DL_SOURCE_LOCATION);
void log_damage0(std::string_view str, DL_SOURCE_LOCATION);

void log(std::string_view str, DL_SOURCE_LOCATION);

void log_err0(const std::exception& e, DL_SOURCE_LOCATION);
void log_err0(const std::system_error& e, DL_SOURCE_LOCATION);
 
#define log_(...) log(fmt::format(__VA_ARGS__), DL_SOURCE_LOCATION_CALL)
#define log_pause(...) log_pause0(fmt::format(__VA_ARGS__), DL_SOURCE_LOCATION_CALL)
#define log_test(...) log_test0(fmt::format(__VA_ARGS__), DL_SOURCE_LOCATION_CALL)
#define log_info(...) log_info0(fmt::format(__VA_ARGS__), DL_SOURCE_LOCATION_CALL)
#define log_msg(...) log_msg0(fmt::format(__VA_ARGS__), DL_SOURCE_LOCATION_CALL)
#define log_notice(...) log_notice0(fmt::format(__VA_ARGS__), DL_SOURCE_LOCATION_CALL)
#define log_warn(...) log_warn0(fmt::format(__VA_ARGS__), DL_SOURCE_LOCATION_CALL)
#define log_err(...) log_err0(fmt::format(__VA_ARGS__), DL_SOURCE_LOCATION_CALL)
#define log_damage(...) log_damage0(fmt::format(__VA_ARGS__), DL_SOURCE_LOCATION_CALL)
 
 
 
 
}