FairLogger.h

Go to the documentation of this file.

/********************************************************************************
 *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *              GNU Lesser General Public Licence (LGPL) version 3,             *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/
/*
 * FairLogger.h
 *
 *  Created on: Mar 03, 2011
 *      Author: f.uhlig
 */
 
#ifndef BASE_FAIRLOGGER_H_
#define BASE_FAIRLOGGER_H_
 
#include <Rtypes.h>   // for bool, FairLogger::Class, etc
#include <fairlogger/Logger.h>
#include <stdarg.h>   // for va_list
#include <string>     // for operator<<
#include <vector>     // for vector
 
#define MESSAGE_ORIGIN __FILE__, CONVERTTOSTRING(__LINE__), __FUNCTION__
 
// backwards-compatibility with older FairLogger calls, TODO: delete me as soon as possible
enum FairLogLevel
{
    FATAL,
    ERROR,
    WARNING,
    INFO,
    DEBUG,
    DEBUG1,
    DEBUG2,
    DEBUG3,
    DEBUG4
};
 
// backwards-compatibility with older FairLogger calls, TODO: delete me as soon as possible
static const char* const LogLevelString[] =
    {"FATAL", "ERROR", "WARNING", "INFO", "DEBUG", "DEBUG1", "DEBUG2", "DEBUG3", "DEBUG4"};
 
class FairLogger
{
  public:
    static FairLogger* GetLogger();
 
    void SetLogToScreen(bool enabled)
    {
        if (enabled) {
            fair::Logger::SetConsoleSeverity(fConsoleSeverity);
        } else {
            fair::Logger::SetConsoleSeverity(fair::Severity::fatal);
        }
    }
 
    void SetLogScreenLevel(const char* severity)
    {
        fConsoleSeverity = severity;
        fair::Logger::SetConsoleSeverity(fConsoleSeverity);
    }
 
    void SetLogToFile(bool enabled)
    {
        if (enabled) {
            fair::Logger::SetFileSeverity(fLogFileSeverity);
        } else {
            fair::Logger::SetFileSeverity(fair::Severity::fatal);
        }
    }
 
    void SetLogFileLevel(const char* severity)
    {
        fLogFileSeverity = severity;
        fair::Logger::SetFileSeverity(fLogFileSeverity);
    }
 
    void SetLogFileName(const std::string& name)
    {
        fLogFileName = name;
        OpenLogFile();
    }
 
    void SetColoredLog(bool enabled) { fair::Logger::SetConsoleColor(enabled); }
 
    void SetLogVerbosityLevel(const char* verbosity) { fair::Logger::SetVerbosity(verbosity); }
 
    bool IsLogNeeded(fair::Severity severity);
    bool IsLogNeeded(FairLogLevel level) __attribute__((
        deprecated("Use 'IsLogNeeded(fair::Severity severity)' or 'fair::Logger::Logging(const fair::Severity "
                   "severity)' or 'fair::Logger::Logging(const std::string& severityStr)'")));
 
    void Fatal(const char* file, const char* line, const char* func, const char* format, ...)
        __attribute__((deprecated("Use 'LOG(fatal) << content;' macro interface instead.")));
    void Error(const char* file, const char* line, const char* func, const char* format, ...)
        __attribute__((deprecated("Use 'LOG(error) << content;' macro interface instead.")));
    void Warning(const char* file, const char* line, const char* func, const char* format, ...)
        __attribute__((deprecated("Use 'LOG(warn) << content;' macro interface instead.")));
    void Info(const char* file, const char* line, const char* func, const char* format, ...)
        __attribute__((deprecated("Use 'LOG(info) << content;' macro interface instead.")));
    void Debug(const char* file, const char* line, const char* func, const char* format, ...)
        __attribute__((deprecated("Use 'LOG(debug) << content;' macro interface instead.")));
    void Debug1(const char* file, const char* line, const char* func, const char* format, ...)
        __attribute__((deprecated("Use 'LOG(debug1) << content;' macro interface instead.")));
    void Debug2(const char* file, const char* line, const char* func, const char* format, ...)
        __attribute__((deprecated("Use 'LOG(debug2) << content;' macro interface instead.")));
    void Debug3(const char* file, const char* line, const char* func, const char* format, ...)
        __attribute__((deprecated("Use 'LOG(debug3) << content;' macro interface instead.")));
    void Debug4(const char* file, const char* line, const char* func, const char* format, ...)
        __attribute__((deprecated("Use 'LOG(debug4) << content;' macro interface instead.")));
 
    static char const endl __attribute__((
        deprecated("Line break is now added automatically by the LOG macro, this variable only adds empty space.")));
    static char const flush __attribute__((
        deprecated("Data is now flushed automatically by the LOG macro, this variable only adds empty space.")));
 
    void SetScreenStreamToCerr(bool /* useCerr */) {}
 
  private:
    static FairLogger* instance;
 
    FairLogger();
    FairLogger(const FairLogger&);
    FairLogger operator=(const FairLogger&);
 
    ~FairLogger() {}
 
    void Log(fair::Severity level,
             const char* file,
             const char* line,
             const char*,
             const char* format,
             va_list arglist);
 
    const char* ConvertLogLevelToString(FairLogLevel level) const { return LogLevelString[level]; }
 
    static void LogFatalMessage();
 
    void OpenLogFile() { fair::Logger::InitFileSink(fLogFileSeverity, fLogFileName, false); }
 
    void CloseLogFile() { fair::Logger::RemoveFileSink(); }
 
    std::string fLogFileName;
    std::string fLogFileSeverity;
    std::string fConsoleSeverity;
 
    int fBufferSize;
    int fBufferSizeNeeded;
    std::vector<char> fDynamicBuffer;
    char* fBufferPointer;
 
    ClassDef(FairLogger, 4);
};
 
#define gLogger (FairLogger::GetLogger())
 
#endif   // BASE_FAIRLOGGER_H_