logger.h

Go to the documentation of this file.

// Author(s): Jeroen Keiren
// Copyright: see the accompanying file COPYING or copy at
// https://github.com/mCRL2org/mCRL2/blob/master/COPYING
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
 
#ifndef MCRL2_UTILITIES_LOGGER_H
#define MCRL2_UTILITIES_LOGGER_H
 
#include <cassert>
#include <atomic>
#include <cstdio>
#include <ctime>
#include <map>
#include <memory>
#include <set>
#include <stdexcept>
 
#include "mcrl2/utilities/noncopyable.h"
#include "mcrl2/utilities/text_utility.h"
 
namespace mcrl2::log {
 
enum log_level_t
{
  quiet, // No log message should ever be printed to this log level!
  error,
  warning,
  info,
  status, // This is overwritten in the output when printed consecutively, and the highest level that is shown by default.
  verbose,
  debug,
  trace,
};
 
inline
std::string log_level_to_string(const log_level_t level)
{
  static const char* const buffer[] = {"quiet", "error", "warning", "info", "status", "verbose", "debug", "trace"};
  if ((unsigned) level >= sizeof(buffer) / sizeof(buffer[0]))  return "unknown level";
  return buffer[level];
}
 
inline
log_level_t log_level_from_string(const std::string& s)
{
  if (s == "quiet")
  {
    return quiet;
  }
  else if (s == "error")
  {
    return error;
  }
  else if (s == "warning")
  {
    return warning;
  }
  else if (s == "info")
  {
    return info;
  }
  else if (s == "status")
  {
    return status;
  }
  else if (s == "verbose")
  {
    return verbose;
  }
  else if (s == "debug")
  {
    return debug;
  }
  else if (s == "trace")
  {
    return trace;
  }
  else
  {
    throw std::runtime_error("Unknown log-level " + s + " provided.");
  }
}
 
std::string format_time(const time_t* t);
 
class output_policy
{
  public:
    output_policy()
    {}
 
    virtual ~output_policy()
    {}
 
    virtual void output(const log_level_t level, const time_t timestamp, const std::string& msg, const bool print_time_information) = 0;
};
 
std::set<output_policy*> initialise_output_policies();
 
class logger: private utilities::noncopyable
{
  protected:
    std::ostringstream m_os;
 
    log_level_t m_level;
 
    time_t m_timestamp;
 
   static std::atomic<log_level_t>& log_level()
    {
      static std::atomic<log_level_t> g_log_level(log_level_t::info);
      return g_log_level;
    }
 
    static bool& m_print_time_information()
    {
      thread_local bool print_timing_info=false;
      return print_timing_info;
    }
 
    static
    std::set<output_policy*>& output_policies()
    {
      static std::set<output_policy*> m_output_policies = initialise_output_policies();
      return m_output_policies;
    }
 
  public:
    logger(const log_level_t l)
    {
      assert(quiet != l);
      m_level = l;
      std::time(&m_timestamp);
    }
 
    ~logger()
    {
      for(output_policy* policy: output_policies())
      {
        policy->output(m_level, m_timestamp, m_os.str(), m_print_time_information());
      }
    }
 
    static
    void register_output_policy(output_policy& policy)
    {
      output_policies().insert(&policy);
    }
 
    static
    void unregister_output_policy(output_policy& policy)
    {
      std::set<output_policy*>::iterator i = output_policies().find(&policy);
      if(i != output_policies().end())
      {
        output_policies().erase(i);
      }
    }
 
    static
    void clear_output_policies()
    {
      output_policies().clear();
    }
 
    static
    void set_reporting_level(const log_level_t level)
    {
      log_level() = level;
    }
 
    static
    log_level_t get_reporting_level()
    {
      return log_level();
    }
 
    static void set_report_time_info()
    {
      m_print_time_information() = true;
    }
 
    static void clear_report_time_info()
    {
      m_print_time_information() = false;
    }
 
    static bool get_report_time_info() 
    {
      return m_print_time_information();
    }
 
    std::ostringstream& get()
    {
      return m_os;
    }
};
 
class formatter_interface
{
public:
  static std::string format(const log_level_t level, const time_t timestamp, const std::string& msg, const bool print_time_information)
  {
    (void)level; (void)timestamp; (void)print_time_information;
 
    assert(quiet != level);
    return msg;
  }
}; 
 
class formatter: public formatter_interface
{
protected:
  static
  std::atomic<bool>& last_message_ended_with_newline()
  {
    static std::atomic<bool> m_last_message_ended_with_newline = true;
    return m_last_message_ended_with_newline;
  }
 
  static
  std::atomic<bool>& last_message_was_status()
  {
    static std::atomic<bool> m_last_message_was_status = false;
    return m_last_message_was_status;
  }
 
  static
  std::atomic<std::size_t>& caret_pos()
  {
    static std::atomic<std::size_t> m_caret_pos = 0;
    return m_caret_pos;
  }
 
  static
  std::atomic<std::size_t>& last_caret_pos()
  {
    static std::atomic<std::size_t> m_last_caret_pos = 0;
    return m_last_caret_pos;
  }
 
public:
  static std::string format(const log_level_t level, const time_t timestamp, const std::string& msg, const bool print_time_information);
};
 
class file_output: public output_policy
{
  protected:
    static std::atomic<FILE*>& get_stream()
    {
      static std::atomic<FILE*> g_stream(stderr);
      return g_stream;
    }
 
  public:
    file_output()
    {}
 
    virtual ~file_output()
    {}
 
    static
    void set_stream(FILE* stream)
    {
      get_stream() = stream;
    }
 
    virtual void output(const log_level_t level, const time_t timestamp, const std::string& msg, const bool print_time_information) override
    {
      assert(quiet != level);
      FILE* p_stream = get_stream();
      if (!p_stream)
      {
        return;
      }
 
      fprintf(p_stream, "%s", formatter::format(level, timestamp, msg, print_time_information).c_str());
      fflush(p_stream);
    }
};
 
inline
output_policy& default_output_policy()
{
  static file_output m_default = file_output();
  return m_default;
}
 
inline
std::set<output_policy*> initialise_output_policies()
{
  std::set<output_policy*> result;
  result.insert(&default_output_policy());
  return result;
}
 
inline bool mCRL2logEnabled(const log_level_t level)
{
  return level <= mcrl2::log::logger::get_reporting_level();
}
 
} // namespace mcrl2::log
 
#define mCRL2log(LEVEL) if (mcrl2::log::mCRL2logEnabled(LEVEL)) mcrl2::log::logger(LEVEL).get()
 
#endif // MCRL2_UTILITIES_LOGGER_H