Logging.h

Go to the documentation of this file.

 
#ifndef ELEMENTSKERNEL_ELEMENTSKERNEL_LOGGING_H_
#define ELEMENTSKERNEL_ELEMENTSKERNEL_LOGGING_H_
 
#include <map>
#include <string>
#include <utility>  // for forward
 
#include <log4cpp/Category.hh>
 
#include "ElementsKernel/Export.h"  // ELEMENTS_API
#include "ElementsKernel/Path.h"    // for Item
 
namespace Elements {
 
class ELEMENTS_API Logging {
 
private:
  // We declare the LogMessageStream here because it is used from the public
  // functions. It is defined in the private section at the end.
  class LogMessageStream;
 
public:
  static Logging getLogger(const std::string& name = "");
 
  static void setLevel(std::string level);
 
  static void setLogFile(const Path::Item& fileName);
 
  void debug(const std::string& logMessage) {
    m_log4cppLogger.debug(logMessage);
  }
 
  template <typename... Args>
  void debug(const char* stringFormat, Args&&... args) {
    m_log4cppLogger.debug(stringFormat, std::forward<Args>(args)...);
  }
 
  LogMessageStream debug() {
    return LogMessageStream{m_log4cppLogger, &log4cpp::Category::debug};
  }
 
  void info(const std::string& logMessage) {
    m_log4cppLogger.info(logMessage);
  }
 
  template <typename... Args>
  void info(const char* stringFormat, Args&&... args) {
    m_log4cppLogger.info(stringFormat, std::forward<Args>(args)...);
  }
 
  LogMessageStream info() {
    return LogMessageStream{m_log4cppLogger, &log4cpp::Category::info};
  }
 
  void warn(const std::string& logMessage) {
    m_log4cppLogger.warn(logMessage);
  }
 
  template <typename... Args>
  void warn(const char* stringFormat, Args&&... args) {
    m_log4cppLogger.warn(stringFormat, std::forward<Args>(args)...);
  }
 
  LogMessageStream warn() {
    return LogMessageStream{m_log4cppLogger, &log4cpp::Category::warn};
  }
 
  void error(const std::string& logMessage) {
    m_log4cppLogger.error(logMessage);
  }
 
  template <typename... Args>
  void error(const char* stringFormat, Args&&... args) {
    m_log4cppLogger.error(stringFormat, std::forward<Args>(args)...);
  }
 
  LogMessageStream error() {
    return LogMessageStream{m_log4cppLogger, &log4cpp::Category::error};
  }
 
  void fatal(const std::string& logMessage) {
    m_log4cppLogger.fatal(logMessage);
  }
 
  template <typename... Args>
  void fatal(const char* stringFormat, Args&&... args) {
    m_log4cppLogger.fatal(stringFormat, std::forward<Args>(args)...);
  }
 
  LogMessageStream fatal() {
    return LogMessageStream{m_log4cppLogger, &log4cpp::Category::fatal};
  }
 
  void log(log4cpp::Priority::Value level, const std::string& logMessage) {
    m_log4cppLogger.log(level, logMessage);
  }
 
  template <typename... Args>
  void log(log4cpp::Priority::Value level, const char* stringFormat, Args&&... args) {
    m_log4cppLogger.log(level, stringFormat, std::forward<Args>(args)...);
  }
 
private:
  explicit Logging(log4cpp::Category& log4cppLogger);
 
  log4cpp::Category& m_log4cppLogger;
 
  class LogMessageStream {
    // The P_log_func is a pointer to member function. If you have no idea what
    // this is don't get scared! Just have a look in the following link:
    // http://www.codeproject.com/Articles/7150/Member-Function-Pointers-and-the-Fastest-Possible
    using P_log_func = void (log4cpp::Category::*)(const std::string&);
 
  public:
    LogMessageStream(log4cpp::Category& logger, P_log_func log_func);
    LogMessageStream(LogMessageStream&& other);
    LogMessageStream(const LogMessageStream& other);
    ~LogMessageStream();
    template <typename T>
    LogMessageStream& operator<<(const T& m) {
      m_message << m;
      return *this;
    }
 
  private:
    log4cpp::Category& m_logger;
    P_log_func         m_log_func;
    std::stringstream  m_message{};
  };
};
 
}  // namespace Elements
 
#endif  // ELEMENTSKERNEL_ELEMENTSKERNEL_LOGGING_H_