Logger.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_core_tracing_Logger_hpp
#define anna_core_tracing_Logger_hpp

#include <syslog.h>

#ifdef _MT
#include <pthread.h>
#endif

#include <anna/core/mt/NRMutex.hpp>
#include <anna/core/mt/Guard.hpp>

namespace anna {

class DataBlock;

class Logger {
public:
  enum Level {
    Emergency = LOG_EMERG,
    Alert = LOG_ALERT, Critical = LOG_CRIT, Error = LOG_ERR, Warning = LOG_WARNING,
    Notice = LOG_NOTICE, Information = LOG_INFO, Debug = LOG_DEBUG,
    Local0 = LOG_LOCAL0, Local1 = LOG_LOCAL1, Local2 = LOG_LOCAL2, Local3 = LOG_LOCAL3,
    Local4 = LOG_LOCAL4, Local5 = LOG_LOCAL5, Local6 = LOG_LOCAL6, Local7 = LOG_LOCAL7
  };

  class Writer {
  public:
    virtual ~Writer();

    virtual void initialize(const char* id)  = 0;

    virtual void do_write(int level, const char* text, ...)  = 0;

  protected:
    Writer(const int bufferSize);

    Writer();

    DataBlock& getDataBlock() { return *a_dataBlock; }

  private:
    DataBlock* a_dataBlock;
  };

  static void initialize(const char* ident) ;

  static void initialize(const char* ident, Writer* writer) ;

  static Level getLevel() { return st_level; }

  static void setLevel(const Level level)
  noexcept(false) {
    Guard guard(st_mutex, "Logger::setLevel");
    st_level = (level <= Error) ? Error : level;
  }

  static bool isActive(const Level level) {
    return (st_writer != NULL && level <= Error) ? true : (st_enabled && level <= st_level && st_writer != NULL);
  }

  static void disable() noexcept(false);

  static void enable() noexcept(false);

  static void showPID(const bool show) ;

  static void write(const Level level, const char* text, const char* fromFile, const int fromLine) ;

  static void write(const Level level, const std::string& text, const char* fromFile, const int fromLine) {
    write(level, text.c_str(), fromFile, fromLine);
  }

  static void write(const Level level, const char* text, const char* value, const char* fromFile, const int fromLine) ;

  static void write(const Level level, const char* text, const std::string& value, const char* fromFile, const int fromLine)
  {
    write(level, text, value.c_str(), fromFile, fromLine);
  }

  static void write(const Level level, const std::string& text, const std::string& value, const char* fromFile, const int fromLine)
  {
    write(level, text.c_str(), value.c_str(), fromFile, fromLine);
  }

  static void write(const Level level, const char* text, const int value, const char* fromFile, const int fromLine)
  ;

  static void write(const Level level, const char* text, const DataBlock& value, const char* fromFile, const int fromLine)
  ;

  static void debug(const std::string& text, const char* fromFile, const int fromLine)
  {
    write(Logger::Debug, text, fromFile, fromLine);
  }

  static void information(const std::string& text, const char* fromFile, const int fromLine)
  {
    write(Logger::Information, text, fromFile, fromLine);
  }

  static void notice(const std::string& text, const char* fromFile, const int fromLine)
  {
    write(Logger::Notice, text, fromFile, fromLine);
  }

  static void warning(const std::string& text, const char* fromFile, const int fromLine)
  {
    write(Logger::Warning, text, fromFile, fromLine);
  }

  static void error(const std::string& text, const char* fromFile, const int fromLine)
  {
    write(Logger::Error, text, fromFile, fromLine);
  }

  static void critical(const std::string& text, const char* fromFile, const int fromLine)
  {
    write(Logger::Critical, text, fromFile, fromLine);
  }

  static void alert(const std::string& text, const char* fromFile, const int fromLine)
  {
    write(Logger::Alert, text, fromFile, fromLine);
  }

  static void emergency(const std::string& text, const char* fromFile, const int fromLine)
  {
    write(Logger::Emergency, text, fromFile, fromLine);
  }

  static const char* asString(const Level level) ;

  static Level asLevel(const char* level) noexcept(false);

private:
  static NRMutex st_mutex;
  static Level st_level;
  static bool st_enabled;
  static Writer* st_writer;

#ifndef _MT
  static pid_t st_pid;
#endif

  Logger();

  friend class Logger::Writer;
};

} //namespace anna

#endif