Log.h

Go to the documentation of this file.

/*
 *    Logging facility described by Petru Marginean at:
 *    http://www.drdobbs.com/cpp/logging-in-c/201804215
 *
 *    Code adapted from
 *    ftp://ftp.drdobbs.com/sourcecode/ddj/2007/0710.zip
 */

/*
 * $Id: Log.h 1139 2016-07-20 14:57:28Z landolfa $
 */

#ifndef SCXML4CPP_LOG_H
#define SCXML4CPP_LOG_H

#include <log4cplus/logger.h>
#include <log4cplus/loggingmacros.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 LogInitialize();
void LogSetLevel(const std::string& levelName);
log4cplus::Logger& GetLogger();

}  // 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