[C++/单例模式] QT-Logger的分级管理机制

有没有羡慕过python自带的logging的易用性？这里简单地完成了一个较为高效的模板化分级logger.
先理一下思路：
1.希望有一个根据字符串索引的单例集合
2.希望有一个可以分级的日志管理
3.不要写得太长

先来设计一下分级管理的标签

/* Logger级别 */
namespace LoggerFlag {
   
    struct logger_flag                                       {
   };
    struct critical_logger_flag : public logger_flag         {
   };
    struct error_logger_flag    : public critical_logger_flag{
   };
    struct debug_logger_flag    : public error_logger_flag   {
   };
    struct warning_logger_flag  : public debug_logger_flag   {
   };
    struct info_logger_flag     : public warning_logger_flag {
   };
}

这个分级机制允许分级匹配，不过我们可以用type_traits，这样效率更高。

namespace LoggerFlag {
   
    template<typename m_flag> struct type_traitor;
    template<typename m_flag>
    struct type_traitor {
   
        typedef std::true_type enable_info;
        typedef std::true_type enable_warning;
        typedef std::true_type enable_debug;
        typedef std::true_type enable_error;
        typedef std::true_type enable_critical;
    };

    template<>
    struct type_traitor<critical_logger_flag> {
   
        typedef logger_flag _ww;
        typedef std::false_type enable_info;
        typedef std::false_type enable_warning;
        typedef std::false_type enable_debug;
        typedef std::false_type enable_error;
        typedef std::true_type enable_critical;
    };

	...
}

接下来是Logger的单例

/* Logger单例 */
class Logger
{
   
    static Logger m_logger_instance;
protected:
    typedef QDebug OutStream;
public:

    static Logger *get_logger(const std::string &logger_name);

    static OutStream criticals();
    static OutStream errors();
    static OutStream debugs();
    static OutStream warnings();
    static OutStream infos();

    OutStream critical();
    OutStream error();
    OutStream debug();
    OutStream warning();
    OutStream info();

public:
protected:
    Logger();
    virtual ~Logger();
private:
    template<typename out_flag=LoggerFlag::logger_flag>
    Logger(out_flag);
};

如果我们直接在如critical()里返回一个qDebug，或者qNoDebug，用m_logger_instance作为单例载体，那么单例模式算是设计完了。
但是如何去设计static Logger *get_logger(const std::string &logger_name);呢？
结合我们之前的分级方法，我们可能要先设计一个真正工作的Logger指针。

/* Logger指针 */
template <typename output_flag>
class LoggerHelper: public LoggerManagable
{
   
protected:
    typedef QDebug OutStream;
public:
    LoggerHelper();
    ~LoggerHelper();

    OutStream _critical();
    OutStream _error();
    OutStream _debug();
    OutStream _warning();
    OutStream _info();
};

然后拿map<>(或unordered_map)保存每一个std::string对应的单例。
但是这里LoggerHandler并不能写在map<>的声明上，所以我们还要加一个非泛型的基类。

/* Logger指针 */
class LoggerManagable
{
   
protected:
    typedef QDebug OutStream; // <-把OutStream提升到这里
public:
    LoggerManagable();
    virtual ~LoggerManagable() = 0;

    virtual OutStream _critical() = 0;
    virtual OutStream _error() = 0;
    virtual OutStream _debug() = 0;
    virtual OutStream _warning() = 0;
    virtual OutStream _info() = 0;
};

然后用一个内存管理器的单例做一个tricky的编程

/* Logger单例管理器 */
class LoggerManager{
   
    friend class Logger;
    static std::map<std::string, Logger*> m_logger_instances;
    static LoggerManager logger_destructor;
public:
    LoggerManager();
    ~LoggerManager();
};

为什么上面是Logger*?，我在Logger里保存了LoggerManagable的指针，这样也是合情合理的。Logger里新添加的内容在下面：

/* Logger单例 */
class Logger
{
   
    friend class LoggerManager;
private:
    LoggerManagable *handler;
};

来看一下第一组实例代码，单例的内存管理器是怎么实现的？回顾以前的某一个blog，我们用那个思想做了一个威力加强版。

LoggerManager::LoggerManager()
{
   
    m_logger_instances.clear();
}

LoggerManager::~LoggerManager()
{
   
    for (auto &logger_instance: m_logger_instances) {
   
        if (logger_instance.second != nullptr) {
   
#ifdef DEBUG
            qDebug() << "logger" << QString::fromStdString(logger_instance.first) << "is destructed";
#endif
            delete logger_instance.second;
            logger_instance.second = nullptr;
        }
    }
}

用户是没有权限delete单例的，因此这里map中的每一个指针都对应一个单例，放心释放吧。

接下来是设计真正的handler.以critical为例：

/* 申请假的stream(Not True Type) */
template<typename request_bool_type>
inline LoggerManagable::OutStream LoggerManagable::request_stream() {
   
    static QString idle_buffer;
    static QDebug idle_dbg(&idle_buffer);
    idle_buffer.clear();
    return idle_dbg;
}

/* 申请真的stream(偏特化True Type) */
template<>
inline LoggerManagable::OutStream LoggerManagable::request_stream<std::true_type>() {
   
    return qDebug();
}

/* 根据type_traits里记录的值选择对应的stream */
template<typename out_flag>
LoggerManagable::OutStream LoggerHelper<out_flag>::_critical()
{
   
    return request_stream<typename LoggerFlag::type_traitor<out_flag>::enable_critical::type>();
}
Logger::OutStream Logger::criticals()
{
   
    return Logger::m_logger_instance.handler->_critical();
}

Logger::OutStream Logger::critical()
{
   
    return this->handler->_critical();
}

这里criticals是单例的静态方法。
其他的复制粘贴替换即可。

我们还差什么？
好像还差分级。
一开始我的设计是这样的。

/* Logger单例 */
class Logger
{
   
public:
	template<typename out_flag>
    bool set_mode();
	template<typename out_flag>
    static bool set_modes();

};

但是头文件和实现的cpp文件分离了，会报未实例化偏函数的warning，忍不了。干脆还是回归平常吧。
好在这里 logger_flag都是一字节的，也没有哪个程序会疯狂更改mode，好像也不会浪费到哪里去。
修改一下

/* Logger单例 */
class Logger
{
   
public:

    bool set_mode(LoggerFlag::logger_flag);
    bool set_mode(LoggerFlag::critical_logger_flag