对log4cpp进一步封装

//Mylog.h如下：

#pragma once
//#include <iostream>
#include <log4cpp/Category.hh>
#include <log4cpp/Appender.hh>
#include "log4cpp/FileAppender.hh"
#include <log4cpp/OstreamAppender.hh>
#include "log4cpp/NTEventLogAppender.hh"
#include <log4cpp/StringQueueAppender.hh>
#include <log4cpp/RollingFileAppender.hh>
//#include "log4cpp/SyslogAppender.hh"
#include <log4cpp/Layout.hh>
#include <log4cpp/BasicLayout.hh>
#include <log4cpp/SimpleLayout.hh>
#include <log4cpp/PatternLayout.hh>
#include <log4cpp/BasicConfigurator.hh>
#include <log4cpp/PropertyConfigurator.hh>
#include <log4cpp/Priority.hh>
#include <log4cpp/NDC.hh>

#include <string>

#include "log4cppEnum.h "

using namespace std;

using namespace log4cpp;

#pragma comment(lib,".\\Result\\log4cpp.lib")

//
//enum PriorityLevel
//{    
//    EMERG,                        //EMERG  = 0,
//    FATAL,                        //FATAL  = 0,
//    ALERT,                        //ALERT  = 100,
//    CRIT,                        //CRIT   = 200,
//    ERROR,                        //ERROR  = 300,
//    WARN,                        //WARN   = 400,
//    NOTICE,                        //NOTICE = 500,
//    INFO,                        //INFO   = 600,
//    DEBUG,                        //DEBUG  = 700,
//    NOTSET,                        //NOTSET = 800,
//    PriorityLevel_Num            //PriorityLevel_Num = 10
//};
//
//enum AppenderStyle
//{
//    CONSOLE_APPENDER,            //无
//    OSTREAM_APPENDER,
//    FILE_APPENDER,
//    ROLLING_FILE_APPENDER,
//    STRING_QUEUE_APPENDER,
//    NTEVENTLOG_APPENDER,
//    SYSLOG_APPENDER,            //无            
//    LogStyle_Num
//};
//
//enum LayoutStyle
//{
//    BASIC_LAYOUT,
//    SIMPLE_LAYOUT,
//    PATTERN_LAYOUT,
//    layoutStyle_Num
//};

class MyLog
{
private:
    PriorityLevel m_prioritylevel;
    AppenderStyle m_appenderstyle;
    LayoutStyle m_layoutstyle;
    log4cpp::Appender* m_pAppender;
    log4cpp::Layout* m_pLayout;
    log4cpp::Category* m_pCategory;
public:
    MyLog(void);
    ~MyLog(void);
public:
    //void NotSet();
    void Debug(const char* msg);
    void Info(const char* msg);
    void Notice(const char* msg);
    void Warn(const char* msg);
    void Error(const char* msg);
    void Crit(const char* msg);
    void Alert(const char* msg);
    void Fatal(const char* msg);
    void Emerg(const char* msg);
    void SetPriority(PriorityLevel level);
    void SetAppender(AppenderStyle style, const char*  filename = nullptr);
    void SetLayout(LayoutStyle style);
    void SetPatternFormat(const char* format = nullptr);
    void ShowAllStringQueueMessages(const char* filename = nullptr);
    void Message(PriorityLevel level, std::string format, ...);
    void SetNDC(const char* ndc);
    void ClearNDC();
    void LoadConfigure(const char* filename = nullptr);

MyLog& operator<<(PriorityLevel level);
    MyLog& operator<<(const char* msg);
    MyLog& operator<<(std::string& msg);
    MyLog& operator>>(AppenderStyle appender);
    MyLog& operator>>(const char* szFileName);
    std::string bin2str( const unsigned char* buf, int nstrlen );
};

//MyLog.cpp如下：

#include "StdAfx.h"
#include "MyLog.h"

#include <queue>
#include <fstream>
#include <cstdio>                    // for vsprintf
#include <cstdarg>
//#include <vector>

MyLog::MyLog(void)
{
    log4cpp::NDC::clear();
    m_prioritylevel = NOTSET;
    m_appenderstyle = OSTREAM_APPENDER;
    m_layoutstyle = BASIC_LAYOUT;
    m_pAppender = new log4cpp::OstreamAppender("OstreamAppender", &std::cout);
    m_pLayout = new log4cpp::BasicLayout();
    m_pAppender->setLayout(m_pLayout);
    m_pCategory = &log4cpp::Category::getRoot();
    m_pCategory->setAppender(m_pAppender);
    m_pCategory->setPriority(log4cpp::Priority::DEBUG);
}

MyLog::~MyLog(void)
{
    log4cpp::NDC::clear();
    log4cpp::Category::shutdown();
}

//void MyLog::NotSet()
//{
//
//}

void MyLog::Debug(const char* msg)    
{
    m_pCategory->debug(msg);
}

void MyLog::Info(const char* msg)    
{
    m_pCategory->info(msg);
}

void MyLog::Notice(const char* msg)
{
    m_pCategory->notice(msg);
}

void MyLog::Warn(const char* msg)    
{
    m_pCategory->warn(msg);
}

void MyLog::Error(const char* msg)    
{
    m_pCategory->error(msg);
}

void MyLog::Crit(const char* msg)    
{
    m_pCategory->crit(msg);
}

void MyLog::Alert(const char* msg)    
{
    m_pCategory->alert(msg);
}

void MyLog::Fatal(const char* msg)    
{
    m_pCategory->fatal(msg);
}

void MyLog::Emerg(const char* msg)    
{
    m_pCategory->emerg(msg);
}

void MyLog::SetPriority(PriorityLevel level)
{
    m_prioritylevel = level;
    switch (m_prioritylevel)
    {
    case EMERG:
        m_pCategory->setPriority(log4cpp::Priority::EMERG);
        break;
    case FATAL:
        m_pCategory->setPriority(log4cpp::Priority::FATAL);
        break;
    case ALERT:
        m_pCategory->setPriority(log4cpp::Priority::ALERT);
        break;
    case CRIT:
        m_pCategory->setPriority(log4cpp::Priority::CRIT);
        break;
    case ERROR:
        m_pCategory->setPriority(log4cpp::Priority::ERROR);
        break;
    case WARN:
        m_pCategory->setPriority(log4cpp::Priority::WARN);
        break;
    case NOTICE:
        m_pCategory->setPriority(log4cpp::Priority::NOTICE);
        break;
    case INFO:
        m_pCategory->setPriority(log4cpp::Priority::INFO);
        break;
    case DEBUG:
        m_pCategory->setPriority(log4cpp::Priority::DEBUG);
        break;
    case NOTSET:        //default
        //break;
    default:
        //m_pCategory->setPriority(log4cpp::Priority::NOTSET);            //根节点不能设置为NOTSET
        m_pCategory->setPriority(log4cpp::Priority::DEBUG);
        break;
    }
}

void MyLog::SetAppender(AppenderStyle style, const char* filename)
{
    m_pCategory->removeAppender(m_pAppender);
    m_appenderstyle = style;
    switch (m_appenderstyle)
    {
    case FILE_APPENDER:
        if (nullptr == filename)
        {
            filename = "fileappender.log";
        }
        m_pAppender = new log4cpp::FileAppender("FileAppender", filename);
        break;
    case ROLLING_FILE_APPENDER:
        if (nullptr == filename)
        {
            filename = "RollingFileAppender.log";
        }
        m_pAppender = new log4cpp::RollingFileAppender( "RollingFileAppender",filename, 1*1024*1024, 10);
        break;
    case STRING_QUEUE_APPENDER:
        m_pAppender = new log4cpp::StringQueueAppender("StringQueueAppender");
        break;
    case NTEVENTLOG_APPENDER:
        if (nullptr == filename)
        {
            filename = "NTEventLogAppender.log";
        }
        m_pAppender = new log4cpp::NTEventLogAppender("NTEventLogAppender", filename);
        break;
    case SYSLOG_APPENDER:        //NULL                                                                    
        //break;                                            
    case CONSOLE_APPENDER:        //NULL    
        //break;
    case OSTREAM_APPENDER:        //default
        //break;        
    default:
        m_pAppender = new log4cpp::OstreamAppender("OstreamAppender", &std::cout);
        break;
    }
    m_pCategory->setAppender(m_pAppender);
}

void MyLog::SetLayout(LayoutStyle style)
{
    m_layoutstyle = style;
    switch (m_layoutstyle)
    {
    case SIMPLE_LAYOUT:
        m_pLayout = new log4cpp::SimpleLayout();
        break;
    case PATTERN_LAYOUT:
        m_pLayout = new log4cpp::PatternLayout();
        ((PatternLayout*)m_pLayout)->setConversionPattern("%t\t%p\t%x:%m\t\t%d{%Y-%m-%d %H:%M:%S.%l}%n");
        break;
    case BASIC_LAYOUT:
    default:
        m_pLayout = new log4cpp::BasicLayout();
        break;
    }
    m_pAppender->setLayout(m_pLayout);
}

void MyLog::ShowAllStringQueueMessages(const char* filename)
{
    if (m_appenderstyle == STRING_QUEUE_APPENDER)
    {
        queue<string>& myStrQ = ((StringQueueAppender*)m_pAppender)->getQueue();
        if (filename == nullptr)
        {
            filename = "stringqueue.log";
        }
        ofstream writetofile(filename);
        while(!myStrQ.empty())
        {
            std::string& stringqueue = myStrQ.front();
            cout<< stringqueue;
            //writetofile.write(stringqueue.c_str(),stringqueue.size());
            writetofile<<stringqueue<<endl;
            writetofile.flush();
            myStrQ.pop();
        }
        writetofile.close();
    }
}

void MyLog::SetPatternFormat(const char* format)
{
    if (m_layoutstyle == PATTERN_LAYOUT)
    {
        if (format != nullptr)
        {
            ((PatternLayout*)m_pLayout)->setConversionPattern(format);
        }
        else
        {
            ((PatternLayout*)m_pLayout)->setConversionPattern("%t\t%p\t%x:%m\t\t%d{%Y-%m-%d %H:%M:%S.%l}%n");
        }
    }
}

void MyLog::Message(PriorityLevel level, std::string format, ...)
{
    std::string message;                                        //vector<char>
    va_list args;
    va_start(args,format);
    message.reserve(_vscprintf(format.c_str(),args) + 1);        //_vscprintf只能在windows上使用
    vsprintf((char*)message.c_str(),format.c_str(),args);

switch (level)
    {
    case EMERG:
        Emerg(message.c_str());
        break;
    case FATAL:
        Fatal(message.c_str());
        break;
    case ALERT:
        Alert(message.c_str());
        break;
    case CRIT:
        Crit(message.c_str());
        break;
    case ERROR:
        Error(message.c_str());
        break;
    case WARN:                        //default
        Warn(message.c_str());
        break;
    case NOTICE:
        Notice(message.c_str());
        break;
    case INFO:
        Info(message.c_str());
        break;
    case DEBUG:
        Debug(message.c_str());
        break;
    case NOTSET:        
        //break;
    default:
        Warn(message.c_str());
        break;
    }
}

void MyLog::SetNDC(const char* ndc)
{
    log4cpp::NDC::push(ndc);
}

void MyLog::ClearNDC()
{
    log4cpp::NDC::clear();
}

void MyLog::LoadConfigure(const char* filename)
{
    if (filename == nullptr)
    {
        filename = ".\\include\\tests\\log4cpp.property";
    }
    log4cpp::PropertyConfigurator::configure(filename);
    m_pCategory = &log4cpp::Category::getRoot();
}

MyLog& MyLog::operator<<(PriorityLevel level)
{
    SetPriority(level);
    return *this;
}

MyLog& MyLog::operator<<(const char* msg)
{
    Message(m_prioritylevel, msg);
    return *this;
}

MyLog& MyLog::operator<<(std::string& msg)
{
    Message(m_prioritylevel, msg);
    return *this;
}

MyLog& MyLog::operator>>(AppenderStyle appender)
{
    SetAppender(appender);
    return *this;
}

MyLog& MyLog::operator>>(const char* filename)
{
    SetAppender(m_appenderstyle,filename);
    return *this;
}

std::string MyLog::bin2str( const unsigned char* buf, int nstrlen )
{
    stringstream ss;
    ss.setf(ios::hex | ios::uppercase );
    ss.width(2);
    ss.fill('0');
    for (int i = 0;i < nstrlen ; ++i)
    {
        ss << hex << (short)buf[i];
    }
    return ss.str();
}