SystemLogger.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_SYSTEMLOGGER_H
#define RTC_SYSTEMLOGGER_H

#include <rtm/config_rtc.h>

// COIL
#include <coil/Time.h>
#include <coil/ClockManager.h>
#include <coil/Logger.h>
#include <coil/Mutex.h>
#include <coil/Guard.h>
#include <coil/stringutil.h>

namespace RTC
{
  typedef ::coil::LogStreamBuffer LogStreamBuf;
  typedef ::coil::LogStream 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)
      };
 
    Logger(const char* name = "");
    Logger(LogStreamBuf* streambuf);
    virtual ~Logger(void);

    bool setLevel(const char* level);

    void setDateFormat(const char* format);

    void setClockType(std::string clocktype);

    void setName(const char* name);
    void enableEscapeSequence();
    void disableEscapeSequence();

  protected:
    virtual void header(int level);

    std::string getDate(void);

    int strToLevel(const char* level);

  private:
    std::string m_name;
    std::string m_dateFormat;
    coil::IClock* m_clock;
    static const char* m_levelString[];
    int m_msEnable;
    int m_usEnable;
    bool m_esEnable;
  };    


#ifndef NO_LOGGING

#define RTC_LOG(LV, fmt)                        \
  if (rtclog.isValid(LV))                                   \
    {                                                       \
      std::string str = ::coil::sprintf fmt;                \
      rtclog.lock();                                        \
      rtclog.level(LV) << str << std::endl; \
      rtclog.unlock();                                      \
    }

#define RTC_LOG_STR(LV, str)                        \
  if (rtclog.isValid(LV))                                   \
    {                                                       \
      rtclog.lock();                                        \
      rtclog.level(LV) << str << std::endl;  \
      rtclog.unlock();                                      \
    }

#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)
#endif
  
}; // namespace RTC

#endif  // RTC_SYSTEMLOGGER_H