Logger.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include <iostream>     // for std::cout
#include <sstream>      // for std::ostringstream
#include <stdarg.h>     // for va_list
 
 
AST_NAMESPACE_BEGIN
 
enum ELogLevel
{
    eDebug,     
    eInfo,      
    eWarning,   
    eError,     
    eCritical,  
    eFatal      
};
 
 
 
 
class MessageLogContext
{
public:
    MessageLogContext()
        : line(0)
        , file(nullptr)
        , function(nullptr)
        , category(nullptr)
    {}
    MessageLogContext(const char* fileName, int lineNumber, const char* functionName, const char* categoryName = nullptr)
        : line(lineNumber)
        , file(fileName)
        , function(functionName)
        , category(categoryName)
    {}
 
    int   line;             
    const char* file;       
    const char* function;   
    const char* category;   
};
 
 
AST_UTIL_CAPI void aLogMessageV(ELogLevel level, const MessageLogContext& context, const char* format, va_list ap);
AST_UTIL_CAPI void aLogMessage(ELogLevel level, const MessageLogContext& context, const char* format, ...);
 
 
class LoggerStream
{
public:
    LoggerStream(ELogLevel level, const MessageLogContext& context)
        : m_context{ context }
        , m_level{ level }
    {}
    LoggerStream(ELogLevel level, const char* fileName, int lineNumber, const char* functionName, const char* categoryName = nullptr)
        :m_context{ fileName, lineNumber, functionName, categoryName }
        , m_level{ level }
    {}
    LoggerStream(const LoggerStream& other)
        :m_context{ other.m_context }
        , m_level{ other.m_level }
    {}
    ~LoggerStream()
    {
        aLogMessage(m_level, m_context, m_stream.str().c_str());
    }
    inline LoggerStream& space()
    {
        stream() << ' '; return *this;
    }
    inline LoggerStream& operator<<(bool t)
    {
        stream() << (t ? "true" : "false"); return space();
    }
    inline LoggerStream& operator<<(char t)
    {
        stream() << t; return space();
    }
    inline LoggerStream& operator<<(signed short t)
    {
        stream() << t; return space();
    }
    inline LoggerStream& operator<<(unsigned short t)
    {
        stream() << t; return space();
    }
    inline LoggerStream& operator<<(signed int t)
    {
        stream() << t; return space();
    }
    inline LoggerStream& operator<<(unsigned int t)
    {
        stream() << t; return space();
    }
    inline LoggerStream& operator<<(signed long t)
    {
        stream() << t; return space();
    }
    inline LoggerStream& operator<<(unsigned long t)
    {
        stream() << t; return space();
    }
    inline LoggerStream& operator<<(float t)
    {
        stream() << t; return space();
    }
    inline LoggerStream& operator<<(double t)
    {
        stream() << t; return space();
    }
    inline LoggerStream& operator<<(const char* t)
    {
        stream() << (t); return space();
    }
    inline LoggerStream& operator<<(const void* t)
    {
        stream() << t; return space();
    }
    inline std::ostringstream& stream()
    {
        return m_stream;
    }
protected:
    MessageLogContext   m_context;    
    ELogLevel           m_level;      
    std::ostringstream  m_stream;     
};
 
class NoopStream
{
public:
    inline NoopStream& space()
    {
        return *this;
    }
    template<typename T>
    inline NoopStream& operator<<(const T&)
    {
        return *this;
    }
};
 
 
class MessageLogger
{
public:
    MessageLogger()
        :m_context{}
    {}
    MessageLogger(const char* file, int line, const char* function)
        : m_context{file, line, function}
    {}
    template<typename ...Args>
    inline void debug(const char* msg, Args&& ...args) const
    {
        aLogMessage(eDebug, m_context, msg, std::forward<Args>(args)...);
    };
    template<typename ...Args>
    inline void noDebug(const char*, Args&& ...args) const{}
    template<typename ...Args>
    void info(const char* msg, Args&& ...args) const
    {
        aLogMessage(eInfo, m_context, msg, std::forward<Args>(args)...);
    }
    template<typename ...Args>
    inline void warning(const char* msg, Args&& ...args) const
    {
        aLogMessage(eWarning, m_context, msg, std::forward<Args>(args)...);
    }
    template<typename ...Args>
    inline void error(const char* msg, Args&& ...args) const
    {
        aLogMessage(eError, m_context, msg, std::forward<Args>(args)...);
    }
    template<typename ...Args>
    inline void critical(const char* msg, Args&& ...args) const
    {
        aLogMessage(eCritical, m_context, msg, std::forward<Args>(args)...);
    }
    template<typename ...Args>
    inline void fatal(const char* msg, Args&& ...args) const
    {
        aLogMessage(eFatal, m_context, msg, std::forward<Args>(args)...);
    }
    inline LoggerStream debug() const{return LoggerStream(eDebug, m_context); }
    inline NoopStream   noDebug() const{ return NoopStream(); }
    inline LoggerStream info() const{return LoggerStream(eInfo, m_context); }
    inline LoggerStream warning() const{return LoggerStream(eWarning, m_context);}
    inline LoggerStream error() const{return LoggerStream(eError, m_context);}
    inline LoggerStream critical() const{return LoggerStream(eCritical, m_context); };
    inline LoggerStream fatal() const{return LoggerStream(eFatal, m_context); };
private:
    MessageLogContext m_context;
};
 
AST_NAMESPACE_END
 
 
// 日志宏定义
 
#ifdef NDEBUG
#define aDebug(...)    while(false) AST_PREPEND_NAMESPACE(MessageLogger)().noDebug(__VA_ARGS__)
#else
#define aDebug(...)    AST_PREPEND_NAMESPACE(MessageLogger)(__FILE__, __LINE__, __FUNCTION__).debug(__VA_ARGS__)
#endif
#define aInfo(...)     AST_PREPEND_NAMESPACE(MessageLogger)(__FILE__, __LINE__, __FUNCTION__).info(__VA_ARGS__)
#define aWarning(...)  AST_PREPEND_NAMESPACE(MessageLogger)(__FILE__, __LINE__, __FUNCTION__).warning(__VA_ARGS__)
#define aError(...)    AST_PREPEND_NAMESPACE(MessageLogger)(__FILE__, __LINE__, __FUNCTION__).error(__VA_ARGS__)
#define aCritical(...) AST_PREPEND_NAMESPACE(MessageLogger)(__FILE__, __LINE__, __FUNCTION__).critical(__VA_ARGS__)
#define aFatal(...)    AST_PREPEND_NAMESPACE(MessageLogger)(__FILE__, __LINE__, __FUNCTION__).fatal(__VA_ARGS__)
 
 
#define AST_CHECK_NULLPTR(variable) if(variable == nullptr){aError(#variable " is notset(nullptr)"); return eErrorNullPtr;}
#define AST_CHECK_ERRCODE(rc, msg) if(rc){aError(msg); return rc;}
#define AST_CHECK_INVALID(condition) if(condition){aError("invalid parameter, with " #condition); return eErrorInvalidParam;}