Logger.hh

//
// This file is part of MARLEY (Model of Argon Reaction Low Energy Yields)
//
// MARLEY is free software: you can redistribute it and/or modify it under the
// terms of version 3 of the GNU General Public License as published by the
// Free Software Foundation.
//
// For the full text of the license please see COPYING or
// visit http://opensource.org/licenses/GPL-3.0
//
// Please respect the MCnet academic usage guidelines. See GUIDELINES
// or visit https://www.montecarlonet.org/GUIDELINES for details.
 
#pragma once
#include <algorithm>
#include <fstream>
#include <memory>
#include <sstream>
#include <vector>
 
// Forward declare some MARLEY classes and their operator<< functions so that
// we can stream them to the Logger
namespace marley {
  class HauserFeshbachDecay;
  class Parity;
  class Target;
  class TargetAtom;
}
 
std::ostream& operator<<(std::ostream& out,
  const marley::HauserFeshbachDecay& hfd);
 
std::ostream& operator<<(std::ostream& out, const marley::Parity& p);
std::ostream& operator<<(std::ostream& out, const marley::Target& t);
std::ostream& operator<<(std::ostream& out, const marley::TargetAtom& ta);
 
namespace marley {
 
  class Logger {
 
    public:
 
      enum class LogLevel { DISABLED, ERROR, WARNING, INFO, DEBUG };
 
    private:
 
      const char* loglevel_to_str(LogLevel lev);
 
      class OutStream {
 
        friend class Logger;
        friend class OutStreamVector;
 
        public:
 
          OutStream(std::shared_ptr<std::ostream> os, LogLevel lev,
            bool enable = true);
 
          OutStream(std::ostream& os, LogLevel lev, bool enable = true);
 
        private:
 
          std::shared_ptr<std::ostream> stream_;
 
          LogLevel level_;
 
          bool enabled_;
      };
 
      class OutStreamVector : public std::vector<OutStream> {
        public:
 
          OutStreamVector() : std::vector<OutStream>() {}
 
          template<typename OutputType> OutStreamVector&
            operator<<(const OutputType& ot);
 
          OutStreamVector& operator<<(std::ostream& (*manip)(std::ostream&));
 
          OutStreamVector& operator<<(std::ios_base& (*manip)(std::ios_base&));
      };
 
      class Message {
        public:
          Message(OutStreamVector& vec) : osvec_( vec ) {}
 
          inline ~Message() {
            osvec_ << '\n';
          }
 
          template<typename OutputType> Message&&
            operator<<(const OutputType& ot)
          {
            osvec_ << ot;
            return std::move( *this );
          }
 
        protected:
          OutStreamVector& osvec_;
      };
 
      Logger(bool log_enabled = true);
 
    public:
 
      static Logger& Instance();
 
      void add_stream(std::shared_ptr<std::ostream> stream,
        LogLevel level = LogLevel::WARNING);
 
      void add_stream(std::ostream& stream,
        LogLevel level = LogLevel::WARNING);
 
      void clear_streams();
 
      void enable(bool log_enabled = true);
 
      inline void disable();
 
      void flush();
 
      void newline();
 
      bool has_stream(const std::ostream& stream) const;
 
      Message log(LogLevel lev = LogLevel::WARNING);
 
      // Make the singleton Logger uncopyable and unmovable
      Logger(const Logger&) = delete;
      Logger& operator=(const Logger&) = delete;
      Logger(Logger&&) = delete;
      Logger& operator=(Logger&&) = delete;
 
    private:
 
      OutStream* find_stream(const std::ostream* os, bool& stream_enabled,
        LogLevel level);
 
      // @brief Returns a pointer to the given stream's OutStream object if
      // it has been added to the Logger, or nullptr otherwise.
      const OutStream* get_stream(const std::ostream* os) const;
 
      // @brief Returns a pointer to the given stream's OutStream object if
      // it has been added to the Logger, or nullptr otherwise.
      OutStream* get_stream(const std::ostream* os);
 
      OutStreamVector streams_;
 
      bool enabled_;
 
      LogLevel old_level_;
  };
 
}
 
// Inline function definitions
inline void marley::Logger::disable() { enable(false); }
 
template<typename OutputType> marley::Logger::OutStreamVector&
  marley::Logger::OutStreamVector::operator<<(const OutputType& ot)
{
  for (auto s : *this) if (s.enabled_ && s.stream_) *(s.stream_) << ot;
  return *this;
}
 
// Convenient shortcut functions for recording log messages
inline auto MARLEY_LOG_ERROR() {
  return marley::Logger::Instance().log(marley::Logger::LogLevel::ERROR);
}
 
inline auto MARLEY_LOG_WARNING() {
  return marley::Logger::Instance().log(marley::Logger::LogLevel::WARNING);
}
 
inline auto MARLEY_LOG_INFO() {
  return marley::Logger::Instance().log(marley::Logger::LogLevel::INFO);
}
 
inline auto MARLEY_LOG_DEBUG() {
  return marley::Logger::Instance().log(marley::Logger::LogLevel::DEBUG);
}