SystemLogger.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_SYSTEMLOGGER_H
#define RTC_SYSTEMLOGGER_H
 
#include <rtm/config_rtc.h>
 
#include <coil/ClockManager.h>
#include <coil/Logger.h>
#include <mutex>
#include <coil/stringutil.h>
#include <coil/Properties.h>
 
#include <string>
 
namespace RTC
{
  using LogStreamBuf = ::coil::LogStreamBuffer;
  using LogStream = ::coil::LogStream;
 
  class Logger
    : public coil::LogStream
  {
  public:
    enum
      {               // No: Write out messages include the following.
        RTL_SILENT,   // 0: ()
        RTL_FATAL,    // 1: (FATAL)
        RTL_ERROR,    // 2: (FATAL, ERROR)
        RTL_WARN,     // 3: (FATAL, ERROR, WARN)
        RTL_INFO,     // 4: (FATAL, ERROR, WARN, INFO)
        RTL_DEBUG,    // 5: (FATAL, ERROR, WARN, INFO, DEBUG)
        RTL_TRACE,    // 6: (FATAL, ERROR, WARN, INFO, DEBUG, TRACE)
        RTL_VERBOSE,  // 7: (FATAL, ERROR, WARN, INFO, DEBUG, TRACE, VERBOSE)
        RTL_PARANOID  // 8: (FATAL, ERROR, WARN, INFO,
                      //     DEBUG, TRACE, VERBOSE, PARA)
      };
 
    explicit Logger(const char* name = "");
    explicit Logger(LogStreamBuf* streambuf);
    ~Logger() override;
 
    bool setLevel(const char* level);
 
    void setDateFormat(const char* format);
 
    void setClockType(const std::string& clocktype);
 
    void setName(const char* name);
 
 
    void write(int level, const std::string &mes) override;
 
    void write(int level, const coil::Properties &prop);
 
    static std::string getLevelString(int level)
    {
        return m_levelString[level];
    }
 
    static std::string getLevelOutputString(int level)
    {
        return m_levelOutputString[level];
    }
 
 
    static std::string getLevelColor(int level)
    {
        return m_levelColor[level];
    }
    
 
  protected:
 
 
    std::string getDate();
 
    static int strToLevel(const char* level);
 
 
 
  private:
    std::string m_name = "unknown";
    std::string m_dateFormat = "%b %d %H:%M:%S.%Q";
    coil::IClock* m_clock{&coil::ClockManager::instance().getClock("system")};
 
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
#ifdef LIBRARY_EXPORTS
    static __declspec(dllexport) const char* const m_levelString[];
    static __declspec(dllexport) const char* const m_levelOutputString[];
    static __declspec(dllexport) const char* const m_levelColor[];
#else
    static __declspec(dllimport) const char* const m_levelString[];
    static __declspec(dllimport) const char* const m_levelOutputString[];
    static __declspec(dllimport) const char* const m_levelColor[];
#endif
#else
    static const char* const m_levelString[];
    static const char* const m_levelOutputString[];
    static const char* const m_levelColor[];
#endif
    bool m_msEnable{false};
    bool m_usEnable{false};
  };
 
 
#ifndef NO_LOGGING
#define RTC_LOG(LV, fmt)                                    \
  do{                                                       \
    if (rtclog.isValid(LV))                                 \
      {                                                     \
        std::string str = ::coil::sprintf fmt;              \
        rtclog.lock();                                      \
        rtclog.write(LV, str);                              \
        rtclog.unlock();                                    \
      }                                                     \
  } while(0)
 
#define RTC_LOG_STR(LV, str)                                \
  do {                                                      \
    if (rtclog.isValid(LV))                                 \
      {                                                     \
        rtclog.lock();                                      \
        rtclog.write(LV, str);                              \
        rtclog.unlock();                                    \
      }                                                     \
   } while(0)
 
#define RTC_FATAL(fmt) RTC_LOG(::RTC::Logger::RTL_FATAL, fmt)
#define RTC_FATAL_STR(str) RTC_LOG_STR(::RTC::Logger::RTL_FATAL, str)
 
#define RTC_ERROR(fmt) RTC_LOG(::RTC::Logger::RTL_ERROR, fmt)
#define RTC_ERROR_STR(str) RTC_LOG_STR(::RTC::Logger::RTL_ERROR, str)
 
#define RTC_WARN(fmt) RTC_LOG(::RTC::Logger::RTL_WARN, fmt)
#define RTC_WARN_STR(str) RTC_LOG_STR(::RTC::Logger::RTL_WARN, str)
 
#define RTC_INFO(fmt) RTC_LOG(::RTC::Logger::RTL_INFO, fmt)
#define RTC_INFO_STR(str) RTC_LOG_STR(::RTC::Logger::RTL_INFO, str)
 
#define RTC_DEBUG(fmt) RTC_LOG(::RTC::Logger::RTL_DEBUG, fmt)
#define RTC_DEBUG_STR(str) RTC_LOG_STR(::RTC::Logger::RTL_DEBUG, str)
 
#define RTC_TRACE(fmt) RTC_LOG(::RTC::Logger::RTL_TRACE, fmt)
#define RTC_TRACE_STR(str) RTC_LOG_STR(::RTC::Logger::RTL_TRACE, str)
 
 
#define RTC_VERBOSE(fmt) RTC_LOG(::RTC::Logger::RTL_VERBOSE, fmt)
#define RTC_VERBOSE_STR(str) RTC_LOG_STR(::RTC::Logger::RTL_VERBOSE, str)
 
#define RTC_PARANOID(fmt) RTC_LOG(::RTC::Logger::RTL_PARANOID, fmt)
#define RTC_PARANOID_STR(str) RTC_LOG_STR(::RTC::Logger::RTL_PARANOID, str)
 
#else
#define RTC_FATAL(fmt)
#define RTC_FATAL_STR(str)
#define RTC_ERROR(fmt)
#define RTC_ERROR_STR(str)
#define RTC_WARN(fmt)
#define RTC_WARN_STR(str)
#define RTC_INFO(fmt)
#define RTC_INFO_STR(str)
#define RTC_DEBUG(fmt)
#define RTC_DEBUG_STR(str)
#define RTC_TRACE(fmt)
#define RTC_TRACE_STR(str)
#define RTC_VERBOSE(fmt)
#define RTC_VERBOSE_STR(str)
#define RTC_PARANOID(fmt)
#define RTC_PARANOID_STR(str)
#define RTC_FATAL(fmt)
#define RTC_FATAL_STR(str)
#endif
 
} // namespace RTC
 
#endif  // RTC_SYSTEMLOGGER_H