Logger.h

浏览该文件的文档.

/****************************************************************************
** 本库是为了更方便地使用 spdlog 日志系统，参考了 QDebug 的日志打印代码实现。
**
** 通过 lDebug 宏，你可以像用 qDebug 一样使用流式输入，与 qDebug 不同的是，
** lDebug 除了会在控制台输出你要打印的内容外，也会在日志文件中记录相同的信息。
**
** lDebug 本质上只是调用了 Debug().output 方法，记录的是 Log_Debug 等级的信息，
** 你可以根据你的需要创建其他宏来更方便地调用其他日志创建方法。
**
** 如果你想要禁用 lDebug 输出，可以在配置文件中添加 LOGGER_NO_DEBUG_OUTPUT 定义，
** 例如 CONFIG (release, debug | release) {DEFINES += LOGGER_NO_DEBUG_OUTPUT}。
**
** -------------------------------------------------------------------------
** This library is designed to facilitate the usage of the spdlog logging system,
** taking inspiration from the logging implementation of QDebug.
**
** With the lDebug macro, you can use it similarly to qDebug for streaming input.
** The difference is that lDebug not only outputs the desired content to the console
** but also records the same information in the log file.
**
** In essence, lDebug simply calls the Debug().output method, logging information
** at the Log_Debug level. You can create other macros based on your needs to
** conveniently invoke other logging methods.
**
** If you want to disable lDebug output, you can add the LOGGER_NO_DEBUG_OUTPUT
** definition in the configuration file.
** e.g. CONFIG (release, debug | release) {DEFINES += LOGGER_NO_DEBUG_OUTPUT}.
**
****************************************************************************/
 
#ifndef LOGGER_H
#define LOGGER_H
 
#if defined(LOGGER_LIBRARY)
#  define LOGGER_EXPORT __declspec(dllexport)
#else
#  define LOGGER_EXPORT __declspec(dllimport)
#endif
 
#include <QDebug>
#include <QString>
#include <QSettings>
#include <QTextStream>
#include <QDateTime>
 
#include <iostream>
#include <memory>
#include <atomic>
#include <mutex>
#include <functional>
 
#ifdef __DOXYGEN__
#define LOGGER_SINGLE_THREAD
 
#define LOGGER_NO_DEBUG_OUTPUT
#endif
 
namespace spdlog {
class logger;
}
 
namespace EZLog {
class LOGGER_EXPORT Lib {
    Lib() = default;
    ~Lib() = default;
 
    static Lib& instance();
    std::shared_ptr<spdlog::logger> logger_;
    QString errmsg_;
 
public:
    static bool Initialize(const QString& project = "Project",
                           const QString& prefix  = "log",
                           const QString& dir     = "Logs/",
                           bool multi_thread      = true);
 
    static QString errmsg();
 
    static void Debug(const QString& msg);
    static void Info(const QString& msg);
    static void Warn(const QString& msg);
    static void Error(const QString& msg);
    static void Critical(const QString& msg);
};
 
struct null_mutex {
    void lock() const {}
    void unlock() const {}
    bool try_lock() const { return true; }
};
 
template <typename T>
struct null_atomic {
    T value;
 
    null_atomic() : value() {}
    explicit null_atomic(T new_value) : value(new_value) {}
 
    T load(std::memory_order = std::memory_order_relaxed) const
    { return value; }
    void store(T new_value, std::memory_order = std::memory_order_relaxed)
    { value = new_value; }
};
 
extern LOGGER_EXPORT std::mutex real_mutex;
extern LOGGER_EXPORT null_mutex fake_mutex;
 
#if !defined(LOGGER_SINGLE_THREAD)
template <typename T> using Atomic = std::atomic<T>;
using Mutex = std::mutex;
static Mutex& mutex(real_mutex);
#else
template <typename T> using Atomic = null_atomic<T>;
using Mutex = null_mutex;
static Mutex& mutex(fake_mutex);
#endif
 
#define LOG_INIT(name) Logger::Initialize(#name)
 
#define TAKE_OVER_QDEBUG Logger::InstallMessageHandler()
 
#define lDebug Logger::Debug().output
 
#define LogDebug Logger::Debug()
 
#define LogInfo Logger::Info()
 
#define LogWarn Logger::Warn()
 
#define LogError Logger::Error()
 
#define LogCritical Logger::Critical()
 
class Logger final {
public:
    using Callback = std::function<void(const QString&)>;
 
    enum Level {
        Log_Debug,
        Log_Info,
        Log_Warn,
        Log_Error,
        Log_Critical,
        Log_Off
               };
 
    static bool Initialize(const QString& projectName = "Project",
                           const QString& logPrefix   = "log",
                           const QString& logDir      = "Logs/");
 
    static QString errMsg();
 
    static void InstallMessageHandler();
    static void UninstallMessageHandler();
 
    static void SetLogLevel(int level);
    static Level logLevel();
 
    static void ReadConfig(const QString& filePath);
 
    static void SetShowTimeStamp(bool set);
    static void SetTimeStampFormat(const QString& format);
 
    static void SetShowLevelTag(bool set);
    static void SetDebugTag(const QString& tag);
    static void SetInfoTag(const QString& tag);
    static void SetWarnTag(const QString& tag);
    static void SetErrorTag(const QString& tag);
    static void SetCriticalTag(const QString& tag);
 
    static void SetNeedOutput(bool set);
 
    static void SetUnifiedCallback(const Callback& callback);
    static void SetDebugCallback(const Callback& callback);
    static void SetInfoCallback(const Callback& callback);
    static void SetWarnCallback(const Callback& callback);
    static void SetErrorCallback(const Callback& callback);
    static void SetCriticalCallback(const Callback& callback);
 
    static Logger Debug();
    static Logger Info();
    static Logger Warn();
    static Logger Error();
    static Logger Critical();
 
    Logger& notimestamp();
    Logger& timestamp();
 
    Logger& noleveltag();
    Logger& leveltag();
 
    Logger& nooutput();
    Logger& output();
 
public: // Obsolete
    static Logger Debug(const QString& msg);
    static Logger Info(const QString& msg);
    static Logger Warn(const QString& msg);
    static Logger Error(const QString& msg);
    static Logger Critical(const QString& msg);
 
public: // Implementation
    ~Logger() {
        if (!--stream->ref) {
            if (stream->space && stream->buffer.endsWith(QLatin1Char(' ')))
                stream->buffer.chop(1);
            if (stream->level >= logLevel()) {
                const QString& msg = stream->buffer;
                switch (stream->level) {
                case Log_Debug:
                    WriteLog<Log_Debug>(msg);
#if !defined(LOGGER_NO_DEBUG_OUTPUT)
                    if (stream->output) HandleOutput<Log_Debug>(stream->timestamp, stream->level_tag, msg);
#endif
                    HandleCallback<Log_Debug>(stream->timestamp, stream->level_tag, msg);
                    break;
                case Log_Info:
                    WriteLog<Log_Info>(msg);
                    if (stream->output) HandleOutput<Log_Info>(stream->timestamp, stream->level_tag, msg);
                    HandleCallback<Log_Info>(stream->timestamp, stream->level_tag, msg);
                    break;
                case Log_Warn:
                    WriteLog<Log_Warn>(msg);
                    if (stream->output) HandleOutput<Log_Warn>(stream->timestamp, stream->level_tag, msg);
                    HandleCallback<Log_Warn>(stream->timestamp, stream->level_tag, msg);
                    break;
                case Log_Error:
                    WriteLog<Log_Error>(msg);
                    if (stream->output) HandleOutput<Log_Error>(stream->timestamp, stream->level_tag, msg);
                    HandleCallback<Log_Error>(stream->timestamp, stream->level_tag, msg);
                    break;
                case Log_Critical:
                    WriteLog<Log_Critical>(msg);
                    if (stream->output) HandleOutput<Log_Critical>(stream->timestamp, stream->level_tag, msg);
                    HandleCallback<Log_Critical>(stream->timestamp, stream->level_tag, msg);
                    break;
                default: break;
                }
            }
 
            delete stream;
        }
    }
 
    inline Logger& operator<<(QChar t) { putUcs4(t.unicode()); return maybeSpace(); }
    inline Logger& operator<<(bool t) { stream->ts << (t ? "true" : "false"); return maybeSpace(); }
    inline Logger& operator<<(char t) { stream->ts << t; return maybeSpace(); }
    inline Logger& operator<<(signed short t) { stream->ts << t; return maybeSpace(); }
    inline Logger& operator<<(unsigned short t) { stream->ts << t; return maybeSpace(); }
#ifdef Q_COMPILER_UNICODE_STRINGS
    inline Logger& operator<<(char16_t t) { return *this << QChar(ushort(t)); }
    inline Logger& operator<<(char32_t t) { putUcs4(t); return maybeSpace(); }
#endif
    inline Logger& operator<<(signed int t) { stream->ts << t; return maybeSpace(); }
    inline Logger& operator<<(unsigned int t) { stream->ts << t; return maybeSpace(); }
    inline Logger& operator<<(signed long t) { stream->ts << t; return maybeSpace(); }
    inline Logger& operator<<(unsigned long t) { stream->ts << t; return maybeSpace(); }
    inline Logger& operator<<(qint64 t) { stream->ts << t; return maybeSpace(); }
    inline Logger& operator<<(quint64 t) { stream->ts << t; return maybeSpace(); }
    inline Logger& operator<<(float t) { stream->ts << t; return maybeSpace(); }
    inline Logger& operator<<(double t) { stream->ts << t; return maybeSpace(); }
    inline Logger& operator<<(const char* t) { stream->ts << QString::fromUtf8(t); return maybeSpace(); }
#if QT_STRINGVIEW_LEVEL < 2
    inline Logger& operator<<(const QString & t) { stream->ts << t; return maybeSpace(); }
    inline Logger& operator<<(const QStringRef & t) { stream->ts << t; return maybeSpace(); }
#endif
#if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
    inline Logger& operator<<(QStringView s) { stream->ts << s; return maybeSpace(); }
#endif
    inline Logger& operator<<(QLatin1String t) { stream->ts << t; return maybeSpace(); }
    inline Logger& operator<<(const QByteArray & t) { stream->ts << t; return maybeSpace(); }
    inline Logger& operator<<(const void* t) { stream->ts << t; return maybeSpace(); }
#ifdef Q_COMPILER_NULLPTR
    inline Logger& operator<<(std::nullptr_t) { stream->ts << "(nullptr)"; return maybeSpace(); }
#endif
    inline Logger& operator<<(QTextStreamFunction f) { stream->ts << f; return *this; }
    inline Logger& operator<<(QTextStreamManipulator m) { stream->ts << m; return *this; }
 
    template <typename SequentialContainer>
    inline Logger& printSequentialContainer(Logger& logger, const char* which, const SequentialContainer& c)
    {
        const bool oldSetting = logger.autoInsertSpaces();
        logger.nospace() << which << '(';
        typename SequentialContainer::const_iterator it = c.begin(), end = c.end();
        if (it != end) {
            logger << *it;
            ++it;
        }
        while (it != end) {
            logger << ", " << *it;
            ++it;
        }
        logger << ')';
        logger.setAutoInsertSpaces(oldSetting);
        return logger.maybeSpace();
    }
 
    template <typename T>
    inline Logger& operator<<(const QList<T> &list) {
        return printSequentialContainer(*this, "", list);
    }
 
    template <typename T>
    inline Logger& operator<<(const QVector<T> &vec)
    {
        return printSequentialContainer(*this, "QVector", vec);
    }
 
    template <typename T, typename Alloc>
    inline Logger& operator<<(const std::vector<T, Alloc> &vec)
    {
        return printSequentialContainer(*this, "std::vector", vec);
    }
 
    template <typename T, typename Alloc>
    inline Logger& operator<<(const std::list<T, Alloc> &list)
    {
        return printSequentialContainer(*this, "std::list", list);
    }
 
    template <typename Key, typename T, typename Compare, typename Alloc>
    inline Logger& operator<<(const std::map<Key, T, Compare, Alloc> &map)
    {
        return printSequentialContainer(*this, "std::map", map);
    }
 
    template <typename Key, typename T, typename Compare, typename Alloc>
    inline Logger& operator<<(const std::multimap<Key, T, Compare, Alloc> &map)
    {
        return printSequentialContainer(*this, "std::multimap", map);
    }
 
    template <class Key, class T>
    inline Logger& operator<<(const QMap<Key, T> &map)
    {
        const bool oldSetting = this->autoInsertSpaces();
        this->nospace() << "QMap(";
        for (typename QMap<Key, T>::const_iterator it = map.constBegin();
             it != map.constEnd(); ++it) {
            (*this) << '(' << it.key() << ", " << it.value() << ')';
        }
        (*this) << ')';
        this->setAutoInsertSpaces(oldSetting);
        return this->maybeSpace();
    }
 
    template <class Key, class T>
    inline Logger& operator<<(const QHash<Key, T> &hash)
    {
        const bool oldSetting = this->autoInsertSpaces();
        this->nospace() << "QHash(";
        for (typename QHash<Key, T>::const_iterator it = hash.constBegin();
                it != hash.constEnd(); ++it)
            (*this) << '(' << it.key() << ", " << it.value() << ')';
        (*this) << ')';
        this->setAutoInsertSpaces(oldSetting);
        return this->maybeSpace();
    }
 
    template <class T1, class T2>
    inline Logger& operator<<(const QPair<T1, T2> &pair)
    {
        const bool oldSetting = this->autoInsertSpaces();
        this->nospace() << "QPair(" << pair.first << ',' << pair.second << ')';
        this->setAutoInsertSpaces(oldSetting);
        return this->maybeSpace();
    }
 
    template <class T1, class T2>
    inline Logger& operator<<(const std::pair<T1, T2> &pair)
    {
        const bool oldSetting = this->autoInsertSpaces();
        this->nospace() << "std::pair(" << pair.first << ',' << pair.second << ')';
        this->setAutoInsertSpaces(oldSetting);
        return this->maybeSpace();
    }
 
    template <typename T>
    inline Logger& operator<<(const QSet<T> &set)
    {
        return printSequentialContainer((*this), "QSet", set);
    }
 
    template <typename T>
    inline Logger& operator<<(const QContiguousCache<T> &cache)
    {
        const bool oldSetting = this->autoInsertSpaces();
        this->nospace() << "QContiguousCache(";
        for (int i = cache.firstIndex(); i <= cache.lastIndex(); ++i) {
            (*this) << cache[i];
            if (i != cache.lastIndex())
                (*this) << ", ";
        }
        (*this) << ')';
        this->setAutoInsertSpaces(oldSetting);
        return this->maybeSpace();
    }
 
    inline explicit Logger(Level level) : stream(new LogStream(level)) {}
    inline Logger(const Logger& other) : stream(other.stream) { ++stream->ref; }
    inline Logger& operator=(const Logger& other) {
        if (this != &other) {
            Logger copy(other);
            std::swap(stream, copy.stream);
        }
        return *this;
    }
 
    inline Logger& space() { stream->space = true; stream->ts << ' '; return *this; }
 
    inline Logger& nospace() { stream->space = false; return *this; }
 
    inline Logger& maybeSpace() { if (stream->space) stream->ts << ' '; return *this; }
 
    bool autoInsertSpaces() const { return stream->space; }
 
    void setAutoInsertSpaces(bool set) { stream->space = set; }
 
private:
    struct LogStream {
        explicit LogStream(Level l)
            : ts(&buffer, QIODevice::WriteOnly), ref(1), level(l), space(true),
              timestamp(stamp().show_time.load(std::memory_order_relaxed)),
              level_tag(stamp().show_tag.load(std::memory_order_relaxed)),
              output(need_output().load(std::memory_order_relaxed)) {}
 
        QTextStream ts;
        QString buffer;
        int ref;
        Level level;
        bool space;
        bool timestamp;
        bool level_tag;
        bool output;
    } *stream;
 
    static Atomic<Level>& log_level() {
        static Atomic<Level> _log_level(Log_Debug);
        return _log_level;
    };
 
    static Atomic<bool>& need_output() {
        static Atomic<bool> _need_output(false);
        return _need_output;
    }
 
    static Atomic<bool>& qDebug_is_handled() {
        static Atomic<bool> _qDebug_is_handled(false);
        return _qDebug_is_handled;
    }
 
    struct Stamp {
        Stamp()
            : show_time(false)
            , show_tag(true)
            , time_format("[HH:mm:ss]")
            , debug_tag("[debug]")
            , info_tag("[info]")
            , warn_tag("[warning]")
            , err_tag("[error]")
            , crit_tag("[critical]")
        {}
 
        Atomic<bool> show_time;
        Atomic<bool> show_tag;
        QString time_format;
        QString debug_tag;
        QString info_tag;
        QString warn_tag;
        QString err_tag;
        QString crit_tag;
    };
 
    static Stamp& stamp() {
        static Stamp _stamp;
        return _stamp;
    }
 
    struct Callbacks {
        Callbacks()
            : debug_callback(nullptr)
            , info_callback(nullptr)
            , warn_callback(nullptr)
            , err_callback(nullptr)
            , crit_callback(nullptr)
        {}
 
        Callback debug_callback;
        Callback info_callback;
        Callback warn_callback;
        Callback err_callback;
        Callback crit_callback;
    };
 
    static Callbacks& callbacks() {
        static Callbacks _callbacks;
        return _callbacks;
    }
 
    void putUcs4(uint ucs4) {
        if (ucs4 < 0x20) {
            stream->ts << "\\x" << hex << ucs4 << reset;
        } else if (ucs4 < 0x80) {
            stream->ts << char(ucs4);
        } else {
            if (ucs4 < 0x10000)
                stream->ts << "\\u" << qSetFieldWidth(4);
            else
                stream->ts << "\\U" << qSetFieldWidth(8);
            stream->ts << hex << qSetPadChar(QLatin1Char('0')) << ucs4 << reset;
        }
    }
 
    template<Level> QString tag();
    template<Level> void log(const QString&);
    template<Level> void callback(const QString&);
    template<Level> bool callback();
 
    template<Level level>
    inline void WriteLog(const QString& msg) {
        log<level>(msg);
    }
 
    template<Level level>
    inline void HandleOutput(bool showTime, bool showTag, const QString& msg) {
        std::lock_guard<Mutex> lock(mutex);
        if (qDebug_is_handled().load(std::memory_order_acquire)) {
            auto& out = std::cout;
            if (showTime && !stamp().time_format.isNull())
                out << QDateTime::currentDateTime().toString(stamp().time_format).toLocal8Bit().constData() << ' ';
            if (showTag && !tag<level>().isNull())
                out << tag<level>().toLocal8Bit().constData() << ' ';
            out << msg.toLocal8Bit().constData() << std::endl;
        } else {
#if !defined(QT_NO_DEBUG_OUTPUT)
            auto out = qDebug().noquote();
            if (showTime && !stamp().time_format.isNull())
                out << QDateTime::currentDateTime().toString(stamp().time_format);
            if (showTag && !tag<level>().isNull())
                out << tag<level>();
            out << msg;
#endif
        }
    }
 
    template<Level level>
    inline void HandleCallback(bool showTime, bool showTag, const QString& msg) {
        std::lock_guard<Mutex> lock(mutex);
        if (callback<level>()) {
            QString str;
            QTextStream out(&str);
            if (showTime && !stamp().time_format.isNull())
                out << QDateTime::currentDateTime().toString(stamp().time_format) << ' ';
            if (showTag && !tag<level>().isNull())
                out << tag<level>() << ' ';
            out << msg;
            callback<level>(str);
        }
    }
};
 
template<> inline QString Logger::tag<Logger::Log_Debug>()    { return stamp().debug_tag; };
template<> inline QString Logger::tag<Logger::Log_Info>()     { return stamp().info_tag;  };
template<> inline QString Logger::tag<Logger::Log_Warn>()     { return stamp().warn_tag;  };
template<> inline QString Logger::tag<Logger::Log_Error>()    { return stamp().err_tag;   };
template<> inline QString Logger::tag<Logger::Log_Critical>() { return stamp().crit_tag;  };
 
template<> inline void Logger::log<Logger::Log_Debug>(const QString& msg)    { Lib::Debug(msg);    };
template<> inline void Logger::log<Logger::Log_Info>(const QString& msg)     { Lib::Info(msg);     };
template<> inline void Logger::log<Logger::Log_Warn>(const QString& msg)     { Lib::Warn(msg);     };
template<> inline void Logger::log<Logger::Log_Error>(const QString& msg)    { Lib::Error(msg);    };
template<> inline void Logger::log<Logger::Log_Critical>(const QString& msg) { Lib::Critical(msg); };
 
template<> inline void Logger::callback<Logger::Log_Debug>(const QString& msg)    { callbacks().debug_callback(msg); };
template<> inline void Logger::callback<Logger::Log_Info>(const QString& msg)     { callbacks().info_callback(msg);  };
template<> inline void Logger::callback<Logger::Log_Warn>(const QString& msg)     { callbacks().warn_callback(msg);  };
template<> inline void Logger::callback<Logger::Log_Error>(const QString& msg)    { callbacks().err_callback(msg);   };
template<> inline void Logger::callback<Logger::Log_Critical>(const QString& msg) { callbacks().crit_callback(msg);  };
 
template<> inline bool Logger::callback<Logger::Log_Debug>()    { return callbacks().debug_callback.operator bool(); };
template<> inline bool Logger::callback<Logger::Log_Info>()     { return callbacks().info_callback.operator bool();  };
template<> inline bool Logger::callback<Logger::Log_Warn>()     { return callbacks().warn_callback.operator bool();  };
template<> inline bool Logger::callback<Logger::Log_Error>()    { return callbacks().err_callback.operator bool();   };
template<> inline bool Logger::callback<Logger::Log_Critical>() { return callbacks().crit_callback.operator bool();  };
 
inline bool Logger::Initialize(const QString &projectName, const QString &logPrefix, const QString &logDir)
{
    std::lock_guard<Mutex> lock(mutex);
#if !defined(LOGGER_SINGLE_THREAD)
    return Lib::Initialize(projectName, logPrefix, logDir, true);
#else
    return Lib::Initialize(projectName, logPrefix, logDir, false);
#endif
}
 
inline QString Logger::errMsg()
{
    return Lib::errmsg();
}
 
inline void Logger::InstallMessageHandler()
{
    qInstallMessageHandler([](QtMsgType t, const QMessageLogContext&, const QString& str) {
        switch (t) {
        case QtDebugMsg:    Debug().output()    << str; break;
        case QtWarningMsg:  Warn().output()     << str; break;
        case QtCriticalMsg: Critical().output() << str; break;
        case QtFatalMsg:    Critical().output() << str; break;
        case QtInfoMsg:     Info().output()     << str; break;
        default: break;
        }
    });
    qDebug_is_handled().store(true, std::memory_order_release);
}
 
inline void Logger::UninstallMessageHandler()
{
    qInstallMessageHandler(0);
    qDebug_is_handled().store(false, std::memory_order_release);
}
 
inline void Logger::SetLogLevel(int level) { if (level >= Log_Debug && level <= Log_Off) { log_level().store((Level)level); }}
 
inline Logger::Level Logger::logLevel() { return log_level().load(std::memory_order_relaxed); }
 
inline void Logger::ReadConfig(const QString &filePath)
{
    QSettings config(filePath, QSettings::IniFormat);
    auto logLevelVar = config.value("logLevel");
    if (logLevelVar.isValid()) {
        SetLogLevel(logLevelVar.toInt());
    } else {
        SetLogLevel(Log_Debug);
    }
}
 
inline void Logger::SetShowTimeStamp(bool set)
{
    stamp().show_time.store(set);
}
 
inline void Logger::SetTimeStampFormat(const QString &format)
{
    std::lock_guard<Mutex> lock(mutex);
    stamp().time_format = format;
}
 
inline void Logger::SetShowLevelTag(bool set)
{
    stamp().show_tag.store(set);
}
 
inline void Logger::SetDebugTag(const QString &tag)
{
    std::lock_guard<Mutex> lock(mutex);
    stamp().debug_tag = tag;
}
 
inline void Logger::SetInfoTag(const QString &tag)
{
    std::lock_guard<Mutex> lock(mutex);
    stamp().info_tag = tag;
}
 
inline void Logger::SetWarnTag(const QString &tag)
{
    std::lock_guard<Mutex> lock(mutex);
    stamp().warn_tag = tag;
}
 
inline void Logger::SetErrorTag(const QString &tag)
{
    std::lock_guard<Mutex> lock(mutex);
    stamp().err_tag = tag;
}
 
inline void Logger::SetCriticalTag(const QString &tag)
{
    std::lock_guard<Mutex> lock(mutex);
    stamp().crit_tag = tag;
}
 
inline void Logger::SetNeedOutput(bool set)
{
    need_output().store(set);
}
 
inline void Logger::SetUnifiedCallback(const Callback &callback)
{
    std::lock_guard<Mutex> lock(mutex);
    callbacks().debug_callback = callback;
    callbacks().info_callback  = callback;
    callbacks().warn_callback  = callback;
    callbacks().err_callback   = callback;
    callbacks().crit_callback  = callback;
}
 
inline void Logger::SetDebugCallback(const Callback &callback)
{
    std::lock_guard<Mutex> lock(mutex);
    callbacks().debug_callback = callback;
}
 
inline void Logger::SetInfoCallback(const Callback &callback)
{
    std::lock_guard<Mutex> lock(mutex);
    callbacks().info_callback = callback;
}
 
inline void Logger::SetWarnCallback(const Callback &callback)
{
    std::lock_guard<Mutex> lock(mutex);
    callbacks().warn_callback = callback;
}
 
inline void Logger::SetErrorCallback(const Callback &callback)
{
    std::lock_guard<Mutex> lock(mutex);
    callbacks().err_callback = callback;
}
 
inline void Logger::SetCriticalCallback(const Callback &callback)
{
    std::lock_guard<Mutex> lock(mutex);
    callbacks().crit_callback = callback;
}
 
inline Logger Logger::Debug() { return Logger(Log_Debug); }
 
inline Logger Logger::Info() { return Logger(Log_Info);}
 
inline Logger Logger::Warn() { return Logger(Log_Warn); }
 
inline Logger Logger::Error() { return Logger(Log_Error); }
 
inline Logger Logger::Critical() { return Logger(Log_Critical); }
 
inline Logger &Logger::notimestamp() { stream->timestamp = false; return *this; }
 
inline Logger &Logger::timestamp() { stream->timestamp = true; return *this; }
 
inline Logger &Logger::noleveltag() { stream->level_tag = false; return *this; }
 
inline Logger &Logger::leveltag() { stream->level_tag = true; return *this; }
 
inline Logger &Logger::nooutput() { stream->output = false; return *this; }
 
inline Logger &Logger::output() { stream->output = true; return *this; }
 
inline Logger Logger::Debug(const QString &msg) { return Logger(Log_Debug) << msg; }
 
inline Logger Logger::Info(const QString &msg) { return Logger(Log_Info) << msg; }
 
inline Logger Logger::Warn(const QString &msg) { return Logger(Log_Warn) << msg; }
 
inline Logger Logger::Error(const QString &msg) { return Logger(Log_Error) << msg; }
 
inline Logger Logger::Critical(const QString &msg) { return Logger(Log_Critical) << msg; }
}
 
using namespace EZLog;
 
#endif // LOGGER_H