PLog.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "convertToString.h"
#include "phoenix_system.h"
#include "PLog.h"
 
 
PString phoenix_logLevelToStr(PLog::Level logLevel){
        switch(logLevel){
                case PLog::INFO:
                        return "INFO";
                case PLog::WARNING:
                        return "WARNING";
                case PLog::ERROR:
                        return "ERROR";
                case PLog::CRITICAL:
                        return "CRITICAL";
                case PLog::ALWAYS:
                        return "ALWAYS";
                default:
                        return "DEBUG";
        }
}
 
 
PLog::Level phoenix_strToLogLevel(const PString & str){
        if(str == "DEBUG"){return PLog::DEBUG;}
        else if(str == "WARNING"){return PLog::WARNING;}
        else if(str == "ERROR"){return PLog::ERROR;}
        else if(str == "CRITICAL"){return PLog::CRITICAL;}
        else if(str == "ALWAYS"){return PLog::ALWAYS;}
        else{return PLog::INFO;}
}
 
PLog::PLog(){
        initialisationPLog();
}
 
PLog::~PLog(){
        close();
        clear();
        delete p_nullStream;
}
 
 
void PLog::setFileName(const PPath & fileName){
        p_fileName = fileName;
}
 
 
void PLog::setMode(PLog::Mode mode){
        p_mode = mode;
}
 
 
void PLog::setLogLevel(PLog::Level logLevel){
        p_logLevel = logLevel;
}
 
 
void PLog::setThreadIndex(size_t threadIndex){
        p_threadIndex = threadIndex;
}
 
 
void PLog::resize(size_t nbThread){
        clear();
        p_vecLog.resize(nbThread);
        PString baseFileName(p_fileName.eraseExtension());
        PString extention(p_fileName.getExtension());
        for(size_t i(0lu); i < nbThread; ++i){
                p_vecLog[i] = new PLog;
                p_vecLog[i]->setFileName(PString(baseFileName + "_" + PString(valueToString(i)) + "." + extention));
                p_vecLog[i]->setMode(p_mode);
                p_vecLog[i]->setLogLevel(p_logLevel);
        }
}
 
 
bool PLog::open(){
        bool b(true);
        b &= streamOpen();
        p_isOpen = b;
        if(b){
                getLogAlways() << "[UTC][Date][ThreadIndex][LogLevel] : log message" << std::endl;
                getLogAlways() << "Start logging at " << phoenix_getDate() << std::endl;
                getLogAlways() << "Current logging level '"<<phoenix_logLevelToStr(getLogLevel())<<"'" << std::endl;
        }
        for(std::vector<PLog*>::iterator it(p_vecLog.begin()); it != p_vecLog.end(); ++it){
                PLog* log = *it;
                if(log != NULL){
                        b &= log->open();
                }
        }
        return b;
}
 
void PLog::close(){
        if(p_stream != NULL && p_isOpen){
                getLogAlways() << "Close Log File at " << phoenix_getDate() << std::endl;
        }
        if(p_logFile.is_open()){
                p_logFile.close();
        }
//      if(p_mode == PLog::STRING_ONLY){
//              p_logString.close();
//      }
        if(p_oldStdCerrBuffer != NULL){
                std::cerr.rdbuf(p_oldStdCerrBuffer);    //Let's get back to previous std::cerr buffer
        }
        if(p_oldStdCoutBuffer != NULL){
                std::cout.rdbuf(p_oldStdCoutBuffer);    //Let's get back to previous std::cout buffer
        }
        if(p_stream != NULL){
                delete p_stream;
                p_stream = NULL;
        }
        p_isOpen = false;
        for(std::vector<PLog*>::iterator it(p_vecLog.begin()); it != p_vecLog.end(); ++it){
                PLog* log = *it;
                if(log != NULL){
                        log->close();
                }
        }
}
 
void PLog::clear(){
        if(p_vecLog.size() != 0lu){
                for(std::vector<PLog*>::iterator it(p_vecLog.begin()); it != p_vecLog.end(); ++it){
                        PLog* log = *it;
                        if(log != NULL){
                                delete log;
                        }
                }
                p_vecLog.clear();
        }
}
 
 
void PLog::appendLog(std::stringstream & str){
        getLog(PLog::ALWAYS) << "Append log" << std::endl << str.str();
}
 
 
PLog & PLog::getLog(size_t threadIndex){
        return *(p_vecLog[threadIndex]);
}
 
 
std::ofstream & PLog::getLogFile(){
        return p_logFile;
}
 
 
std::stringstream & PLog::getLogString(){
        return p_logString;
}
 
 
std::ostream & PLog::getLog(PLog::Level logLevel){
        if(logLevel >= p_logLevel){
                *p_stream << "[" << phoenix_getTime() << "][" << phoenix_getDateCompact() << "][" << p_threadIndex << "]["<<phoenix_logLevelToStr(logLevel)<<"] : ";
                return *p_stream;
        }else{
                return *p_nullStream;
        }
}
 
 
std::ostream & PLog::getLogDebug(){
        return getLog(PLog::DEBUG);
}
 
 
std::ostream & PLog::getLogInfo(){
        return getLog(PLog::INFO);
}
 
 
std::ostream & PLog::getLogWarning(){
        return getLog(PLog::WARNING);
}
 
 
std::ostream & PLog::getLogError(){
        return getLog(PLog::ERROR);
}
 
 
std::ostream & PLog::getLogCritical(){
        return getLog(PLog::CRITICAL);
}
 
 
std::ostream & PLog::getLogAlways(){
        return getLog(PLog::ALWAYS);
}
 
 
 
const PPath & PLog::getFileName() const{
        return p_fileName;
}
 
 
PLog::Mode PLog::getMode() const{
        return p_mode;
}
 
 
PLog::Level PLog::getLogLevel() const{
        return p_logLevel;
}
 
 
size_t PLog::getThreadIndex() const{
        return p_threadIndex;
}
 
 
bool PLog::isOpen() const{
        return p_isOpen;
}
 
void PLog::initialisationPLog(){
        p_mode = PLog::FILE_ONLY;
        p_logLevel = PLog::INFO;
        p_oldStdCerrBuffer = NULL;
        p_oldStdCoutBuffer = NULL;
        p_isOpen = false;
        p_stream = NULL;
        p_nullStream = new std::ostream(NULL);
        p_threadIndex = 0lu;
}
 
 
void PLog::allocateStream(std::streambuf* buffer){
        if(p_stream != NULL){
                delete p_stream;
        }
        p_stream = new std::ostream(buffer);
}
 
 
bool PLog::streamOpen(){
        bool b(true);
        if(p_mode == PLog::FILE_ONLY){
                p_logFile.open(p_fileName);
                b &= p_logFile.is_open();
                if(b){
                        allocateStream(p_logFile.rdbuf());
                }
        }else if(p_mode == PLog::STRING_ONLY){
                std::cerr << "PLog::streamOpen : p_logString.rdbuf() = " << p_logString.rdbuf() << std::endl;
                allocateStream(p_logString.rdbuf());
        }else if(p_mode == PLog::FILE_CAPTURE_STDOUT_STDERR){
                p_logFile.open(p_fileName);
                b &= p_logFile.is_open();
                if(b){
                        p_oldStdCerrBuffer = std::cerr.rdbuf(p_logFile.rdbuf());
                        p_oldStdCoutBuffer = std::cout.rdbuf(p_logFile.rdbuf());
                        allocateStream(p_logFile.rdbuf());
                }
        }else if(p_mode == PLog::STDOUT_ONLY){
                allocateStream(std::cout.rdbuf());
        }else if(p_mode == PLog::DISABLE){
                allocateStream(NULL);
        }
        return b;
}