Log.h

Go to the documentation of this file.

 
#ifndef SCXML4CPP_LOG_H
#define SCXML4CPP_LOG_H
 
#include <log4cplus/logger.h>
#include <log4cplus/loggingmacros.h>
#include <log4cplus/configurator.h>
#include <log4cplus/initializer.h>
#include <string>
 
#ifdef NDEBUG
#define SCXML4CPP_LOG_TRACE()
#else
#define SCXML4CPP_LOG_TRACE()      LOG4CPLUS_TRACE(scxml4cpp::GetLogger(), __FILE__ << " " << __FUNCTION__ << " " << __LINE__)
#endif
 
#define SCXML4CPP_LOG_INFO(msg)    LOG4CPLUS_INFO(scxml4cpp::GetLogger(), msg)
#define SCXML4CPP_LOG_DEBUG(msg)   LOG4CPLUS_DEBUG(scxml4cpp::GetLogger(), msg)
#define SCXML4CPP_LOG_WARNING(msg) LOG4CPLUS_WARN(scxml4cpp::GetLogger(), msg)
#define SCXML4CPP_LOG_ERROR(msg)   LOG4CPLUS_ERROR(scxml4cpp::GetLogger(), msg)
#define SCXML4CPP_LOG_FATAL(msg)   LOG4CPLUS_FATAL(scxml4cpp::GetLogger(), msg)
 
 
namespace scxml4cpp {
 
const std::string LOGGER_NAME = "scxml4cpp";  
 
void LogSetLevel(const std::string& levelName);
 
log4cplus::Logger& GetLogger();
 
class LogInitializer {
public:
    inline LogInitializer() {
        log4cplus::BasicConfigurator().configure();
        GetLogger().setLogLevel(log4cplus::INFO_LOG_LEVEL);
    }
 
    inline ~LogInitializer() = default;
 
    LogInitializer(const LogInitializer&) = delete;
    LogInitializer& operator=(const LogInitializer&) = delete;
 
private:
    log4cplus::Initializer mInitializer;
};
 
}  // namespace scxml4cpp
 
 
/*
 * Obsolete logging.
 */
#if 0
#include <sstream>
#include <string>
#include <stdio.h>
#include <sys/time.h>
 
namespace scxml4cpp {
/*
 * Supported Log Levels.
 */
const int LOG_LEVEL_ERROR   = 0;
const int LOG_LEVEL_WARNING = 1;
const int LOG_LEVEL_INFO    = 2;
const int LOG_LEVEL_DEBUG   = 3;
const int LOG_LEVEL_DEBUG1  = 4;
const int LOG_LEVEL_DEBUG2  = 5;
const int LOG_LEVEL_DEBUG3  = 6;
const int LOG_LEVEL_DEBUG4  = 7;
const int LOG_LEVEL_TRACE   = 8;
const int LOG_MAX_LEVEL     = LOG_LEVEL_TRACE;
 
inline std::string LogNowTime();
 
/*
 * Log class.
 * typename T is the output policy: stderr, stdout, Output2File, etc.
 */
template <typename T> class Log
{
 public:
    Log() {}
 
    virtual ~Log() {
        os << std::endl;
        T::Output(os.str());
    }
 
    inline std::ostringstream& Get(const int level = LOG_LEVEL_INFO) {
        os << LogNowTime();
        os << " " << ToString(level) << " ";
        return os;
    }
 
    inline static int& ReportingLevel() {
        static int reportingLevel = LOG_LEVEL_INFO;
        return reportingLevel;
    }
 
    inline static std::string ToString(const int level) {
        static const char* const buffer[] = {
                        "ERROR",
                        "WARNING",
                        "INFO",
                        "DEBUG",
                        "DEBUG1",
                        "DEBUG2",
                        "DEBUG3",
                        "DEBUG4",
                        "TRACE"
        };
        return (level >= LOG_LEVEL_ERROR && level <= LOG_MAX_LEVEL) ? buffer[level] : "INFO";
    }
 
    inline static int FromString(const std::string& level) {
        if (level == "TRACE")
            return LOG_LEVEL_TRACE;
        if (level == "DEBUG4")
            return LOG_LEVEL_DEBUG4;
        if (level == "DEBUG3")
            return LOG_LEVEL_DEBUG3;
        if (level == "DEBUG2")
            return LOG_LEVEL_DEBUG2;
        if (level == "DEBUG1")
            return LOG_LEVEL_DEBUG1;
        if (level == "DEBUG")
            return LOG_LEVEL_DEBUG;
        if (level == "INFO")
            return LOG_LEVEL_INFO;
        if (level == "WARNING")
            return LOG_LEVEL_WARNING;
        if (level == "ERROR")
            return LOG_LEVEL_ERROR;
        Log<T>().Get(LOG_LEVEL_WARNING) << "Unknown logging level '" << level << "'. Using INFO level as default.";
        return LOG_LEVEL_INFO;
    }
 
 protected:
    std::ostringstream  os;
 
 private:
    Log(const Log&);
    Log& operator =(const Log&);
};
 
class Output2FILE
{
 public:
    inline static FILE*& Stream() {
        static FILE* pStream = stderr;
        return pStream;
    }
 
    static void Output(const std::string& msg) {
        FILE* pStream = Stream();
        if (!pStream) return;
 
        fprintf(pStream, "%s", msg.c_str());
        fflush(pStream);
    }
};
 
inline void LogSetLevel(const std::string& levelName) {
    Log<scxml4cpp::Output2FILE>::ReportingLevel() = Log<scxml4cpp::Output2FILE>::FromString(levelName);
}
 
inline std::string LogNowTime()
{
    char buffer[64];
    time_t t;
    time(&t);
    tm r = {0};
    strftime(buffer, sizeof(buffer), "%Y-%m-%d  %H:%M:%S", localtime_r(&t, &r));
    struct timeval tv;
    gettimeofday(&tv, 0);
    char result[100] = {0};
    sprintf(result, "%s.%06ld", buffer, (long)tv.tv_usec / 1000);
    return result;
}
 
}  // namespace scxml4cpp
 
#define SCXML4CPP_LOG(level)                            \
                if (level > scxml4cpp::LOG_MAX_LEVEL) ;                 \
                else if (level > scxml4cpp::Log<scxml4cpp::Output2FILE>::ReportingLevel() || !scxml4cpp::Output2FILE::Stream()) ; \
                else scxml4cpp::Log<scxml4cpp::Output2FILE>().Get(level) << "scxml4cpp " << __FILE__ << " " << __FUNCTION__ << " " << __LINE__ << " "
 
#define SCXML4CPP_LOG_TRACE()   SCXML4CPP_LOG(scxml4cpp::LOG_LEVEL_TRACE)
#define SCXML4CPP_LOG_DEBUG()   SCXML4CPP_LOG(scxml4cpp::LOG_LEVEL_DEBUG)
#define SCXML4CPP_LOG_DEBUG1()  SCXML4CPP_LOG(scxml4cpp::LOG_LEVEL_DEBUG1)
#define SCXML4CPP_LOG_DEBUG2()  SCXML4CPP_LOG(scxml4cpp::LOG_LEVEL_DEBUG2)
#define SCXML4CPP_LOG_DEBUG3()  SCXML4CPP_LOG(scxml4cpp::LOG_LEVEL_DEBUG3)
#define SCXML4CPP_LOG_DEBUG4()  SCXML4CPP_LOG(scxml4cpp::LOG_LEVEL_DEBUG4)
#define SCXML4CPP_LOG_INFO()    SCXML4CPP_LOG(scxml4cpp::LOG_LEVEL_INFO)
#define SCXML4CPP_LOG_WARNING() SCXML4CPP_LOG(scxml4cpp::LOG_LEVEL_WARNING)
#define SCXML4CPP_LOG_ERROR()   SCXML4CPP_LOG(scxml4cpp::LOG_LEVEL_ERROR)
#endif
 
#endif  //SCXML4CPP_LOG_H