DebugFunctions.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 5 -*- */
 
#ifndef _DEBUG_FUNCTIONS_
#define _DEBUG_FUNCTIONS_

#include <iosfwd>
#include <sstream>

class Log {
public:
     //Logger manipulation function pointer, such as write
     typedef Log& (*manip_t)(Log&);
     typedef std::ostream& (*std_manip_t)(std::ostream&);

     //Valid log levels
     enum Level {
       //Don't change this order without chaning writeLog
       //and enabled
       OFF = 0,
       DEBUG, 
       INFO,
       WARN,
       ERROR,
       FATAL
     };

     Log(); 

     Log(const char* logger); 

     //Release the logger object
     ~Log();

     //Set the level of this logger
     void setLevel(Level l) { m_level = l; }

     void writeLog();

     Log& operator()(Level l) { setLevel(l); return *this; }

     template<typename T> Log& operator<<(const T &rhs)
     {
       if(enabled())
            m_oss << rhs;
       
       return *this;  
     }
     
     //Overloaded function for manipulators
     Log& operator<<(manip_t manip) { return manip(*this); }
     //This takes care of the std:: manipulators such as std::endl or
     //std::hex. All std manipulators are simply passed to the
     //ostream, except for std::endl which is equivalent to calling 
     //writeLog()
     Log& operator<<(std_manip_t manip) 
     { 
          std_manip_t endlPtr = std::endl<std::ostream::char_type, 
               std::ostream::traits_type>;
          
          if(manip == endlPtr) {
               writeLog();
          }

          return *this;
     }

     static Log& write(Log& l) { l.writeLog(); return l; }

private:
     bool enabled();

     void* m_logger;
     Level m_level;
     std::ostringstream m_oss;
};

#ifdef NDEBUG
struct DummyLog { 
     typedef std::ostream& (*std_manip_t)(std::ostream&); 
     typedef Log& (*manip_t)(Log&);

     template<typename T> DummyLog& operator<<(const T &rhs)
     { return *this; }
     
     DummyLog& operator<<(std_manip_t manip) 
     { return *this; }

     DummyLog& operator<<(manip_t manip) 
     { return *this; }
};
#define LOG_DEBUG(l) if(false) DummyLog()
#else
#define LOG_DEBUG(l) l(Log::DEBUG)
#endif

#define LOG_INFO(l) l(Log::INFO)
#define LOG_WARN(l) l(Log::WARN)
#define LOG_ERROR(l) l(Log::ERROR)
#define LOG_FATAL(l) l(Log::FATAL)
#define LOG_WRITE Log::write
#define UNIT_LOGGER g_untlgr
#define SET_UNIT_LOGGER(lnam) namespace { Log UNIT_LOGGER(#lnam); }

#define LOG LOG_INFO(UNIT_LOGGER)
#define DEBUG(l) LOG_DEBUG(UNIT_LOGGER)

void InitLogging(const char* configfile=0);

#endif // _DEBUG_FUNCTIONS_

---