clog.h

//==========================================================================
//   CLOG.H  -  header for
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================
 
/*--------------------------------------------------------------*
  Copyright (C) 1992-2017 Andras Varga
  Copyright (C) 2006-2017 OpenSim Ltd.
 
  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/
 
#ifndef __OMNETPP_CLOG_H
#define __OMNETPP_CLOG_H
 
#include <ctime>
#include <sstream>
#include "simkerneldefs.h"
 
namespace omnetpp {
 
class cObject;
class cComponent;
 
enum LogLevel
{
    LOGLEVEL_TRACE,
 
    LOGLEVEL_DEBUG,
 
    LOGLEVEL_DETAIL,
 
    LOGLEVEL_INFO,
 
    LOGLEVEL_WARN,
 
    LOGLEVEL_ERROR,
 
    LOGLEVEL_FATAL,
 
    LOGLEVEL_OFF,
 
    LOGLEVEL_NOTSET = -1
};
 
#ifndef COMPILETIME_LOGLEVEL
#ifdef NDEBUG
#define COMPILETIME_LOGLEVEL omnetpp::LOGLEVEL_DETAIL
#else
#define COMPILETIME_LOGLEVEL omnetpp::LOGLEVEL_TRACE
#endif
#endif
 
constexpr bool defaultCompiletimeLogPredicate(LogLevel logLevel, LogLevel compiletimeLogLevel)
{
    // The COMPILETIME_LOGLEVEL macro is not used directly here,
    // as that would prevent its redefinitions from taking effect.
    // Rather, it is taken as a parameter, so COMPILETIME_LOGLEVEL
    // is substituted at each call site with its current value.
    return logLevel >= compiletimeLogLevel;
}
 
#ifndef COMPILETIME_LOG_PREDICATE
#define COMPILETIME_LOG_PREDICATE(object, logLevel, category) \
    (::omnetpp::defaultCompiletimeLogPredicate(logLevel, COMPILETIME_LOGLEVEL))
#endif
 
class SIM_API cLog
{
  public:
    typedef bool (*NoncomponentLogPredicate)(const void *object, LogLevel logLevel, const char *category);
    typedef bool (*ComponentLogPredicate)(const cComponent *object, LogLevel logLevel, const char *category);
 
  public:
    static LogLevel logLevel;
 
    static NoncomponentLogPredicate noncomponentLogPredicate;
 
    static ComponentLogPredicate componentLogPredicate;
 
  public:
    static const char *getLogLevelName(LogLevel logLevel);
 
    static LogLevel resolveLogLevel(const char *name);
 
    static inline bool runtimeLogPredicate(const void *object, LogLevel logLevel, const char *category)
    { return noncomponentLogPredicate(object, logLevel, category); }
 
    static inline bool runtimeLogPredicate(const cComponent *object, LogLevel logLevel, const char *category)
    { return componentLogPredicate(object, logLevel, category); }
 
    static bool defaultNoncomponentLogPredicate(const void *object, LogLevel logLevel, const char *category);
    static bool defaultComponentLogPredicate(const cComponent *object, LogLevel logLevel, const char *category);
};
 
// Creates a log proxy object that captures the provided context.
// This macro is internal to the logging infrastructure.
//
// NOTE: the (void)0 trick prevents GCC producing statement has no effect warnings
// for compile time disabled log statements.
//
#define OPP_LOGPROXY(object, logLevel, category) \
    ((void)0, !(COMPILETIME_LOG_PREDICATE(object, logLevel, category) && \
    omnetpp::cLog::runtimeLogPredicate(object, logLevel, category))) ? \
    omnetpp::internal::cLogProxy::dummyStream : omnetpp::internal::cLogProxy(object, logLevel, category, __FILE__, __LINE__, __FUNCTION__)
 
// Returns nullptr. Helper function for the logging macros.
inline void *getThisPtr() {return nullptr;}
 
#define EV_STATICCONTEXT  void *(*getThisPtr)() = omnetpp::getThisPtr;
 
#define EV_LOG(logLevel, category) OPP_LOGPROXY(getThisPtr(), logLevel, category).getStream()
 
#define EV        EV_INFO
 
#define EV_FATAL  EV_LOG(omnetpp::LOGLEVEL_FATAL, nullptr)
 
#define EV_ERROR  EV_LOG(omnetpp::LOGLEVEL_ERROR, nullptr)
 
#define EV_WARN   EV_LOG(omnetpp::LOGLEVEL_WARN, nullptr)
 
#define EV_INFO   EV_LOG(omnetpp::LOGLEVEL_INFO, nullptr)
 
#define EV_DETAIL EV_LOG(omnetpp::LOGLEVEL_DETAIL, nullptr)
 
#define EV_DEBUG  EV_LOG(omnetpp::LOGLEVEL_DEBUG, nullptr)
 
#define EV_TRACE  EV_LOG(omnetpp::LOGLEVEL_TRACE, nullptr)
 
#define EV_C(category)        EV_INFO_C(category)
 
#define EV_FATAL_C(category)  EV_LOG(omnetpp::LOGLEVEL_FATAL, category)
 
#define EV_ERROR_C(category)  EV_LOG(omnetpp::LOGLEVEL_ERROR, category)
 
#define EV_WARN_C(category)   EV_LOG(omnetpp::LOGLEVEL_WARN, category)
 
#define EV_INFO_C(category)   EV_LOG(omnetpp::LOGLEVEL_INFO, category)
 
#define EV_DETAIL_C(category) EV_LOG(omnetpp::LOGLEVEL_DETAIL, category)
 
#define EV_DEBUG_C(category)  EV_LOG(omnetpp::LOGLEVEL_DEBUG, category)
 
#define EV_TRACE_C(category)  EV_LOG(omnetpp::LOGLEVEL_TRACE, category)
 
class SIM_API cLogEntry
{
  public:
    // log statement related
    LogLevel logLevel;
    const char *category;
 
    // C++ source related (where the log statement appears)
    const void *sourcePointer;
    const cObject *sourceObject;
    const cComponent *sourceComponent;
    const char *sourceFile;
    int sourceLine;
    const char *sourceFunction;
 
    // operating system related
    clock_t userTime;
 
    // the actual text of the log statement
    const char *text;
    int textLength;
};
 
 namespace internal {
 
//
// This class captures the context where the log statement appears.
// NOTE: This class is internal to the logging infrastructure.
//
class SIM_API cLogProxy
{
  private:
    // This class is used for buffering the text content to be able to send whole
    // lines one by one to the active environment.
    class LogBuffer : public std::basic_stringbuf<char> {
      public:
        LogBuffer() {}
        bool isEmpty() { return pptr() == pbase(); }
      protected:
        virtual int sync() override;  // invokes getEnvir()->log() for each log line
    };
 
    // act likes /dev/null
    class nullstream : public std::ostream {
      public:
        nullstream() : std::ostream(nullptr) {}  // results in rdbuf==0 and badbit==true
    };
 
  public:
    static nullstream dummyStream; // EV evaluates to this when in express mode (getEnvir()->disabled())
 
  private:
    static LogBuffer buffer;  // underlying buffer that contains the text that has been written so far
    static std::ostream stream;  // this singleton is used to avoid allocating a new stream each time a log statement executes
    static cLogEntry currentEntry; // context of the current (last) log statement that has been executed.
    static LogLevel previousLogLevel; // log level of the previous log statement
    static const char *previousCategory; // category of the previous log statement
 
  private:
    void fillEntry(LogLevel logLevel, const char *category, const char *sourceFile, int sourceLine, const char *sourceFunction);
 
  public:
    cLogProxy(const void *sourcePointer, LogLevel logLevel, const char *category, const char *sourceFile, int sourceLine, const char *sourceFunction);
    cLogProxy(const cObject *sourceObject, LogLevel logLevel, const char *category, const char *sourceFile, int sourceLine, const char *sourceFunction);
    cLogProxy(const cComponent *sourceComponent, LogLevel logLevel, const char *category, const char *sourceFile, int sourceLine, const char *sourceFunction);
    ~cLogProxy();
 
    std::ostream& getStream() { return stream; }
    static void flushLastLine();
};
 
}  // namespace internal
 
}  // namespace omnetpp
 
#endif