Message.h

Go to the documentation of this file.

/*
 *  CepGen: a central exclusive processes event generator
 *  Copyright (C) 2013-2022  Laurent Forthomme
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef CepGen_Utils_Message_h
#define CepGen_Utils_Message_h
 
#include <set>
#include <sstream>
#include <unordered_map>
 
#include "CepGen/Utils/Logger.h"
 
namespace cepgen {
  struct Message {
    explicit inline Message() = default;
    virtual ~Message() = default;
    virtual void dump(std::ostream* os = nullptr) const = 0;
    static std::string now();  
  };
 
  class LoggedMessage : public Message {
  public:
    enum class MessageType {
      undefined = -1,  
      debug,           
      verbatim,        
      info,            
      warning,         
    };
    explicit LoggedMessage(const char* mod,
                           const char* from = "",
                           MessageType type = MessageType::undefined,
                           const char* file = "",
                           short lineno = 0) noexcept;
    LoggedMessage(const LoggedMessage&) noexcept;
    virtual ~LoggedMessage() noexcept override;
 
    friend std::ostream& operator<<(std::ostream&, const MessageType&);
 
    //----- Overloaded stream operators
 
    template <typename T>
    inline friend const LoggedMessage& operator<<(const LoggedMessage& exc, const T& var) noexcept {
      auto& nc_except = const_cast<LoggedMessage&>(exc);
      nc_except.message_ << var;
      return exc;
    }
    friend const LoggedMessage& operator<<(const LoggedMessage&, const bool&) noexcept;
    friend const LoggedMessage& operator<<(const LoggedMessage&, const std::wstring&) noexcept;
    template <typename T, typename U>
    inline friend const LoggedMessage& operator<<(const LoggedMessage& exc, const std::pair<T, U>& pair_var) noexcept {
      return exc << "(" << pair_var.first << ", " << pair_var.second << ")";
    }
    template <typename T>
    inline friend const LoggedMessage& operator<<(const LoggedMessage& exc, const std::set<T>& set_var) noexcept {
      exc << "[";
      std::string sep;
      if (!set_var.empty())
        for (const auto& var : set_var)
          exc << sep << var, sep = ", ";
      return exc << "]";
    }
    template <typename T>
    inline friend const LoggedMessage& operator<<(const LoggedMessage& exc, const std::vector<T>& vec_var) noexcept {
      exc << "{";
      std::string sep;
      if (!vec_var.empty())
        for (const auto& var : vec_var)
          exc << sep << var, sep = ", ";
      return exc << "}";
    }
    template <typename T, std::size_t N>
    inline friend const LoggedMessage& operator<<(const LoggedMessage& exc, const std::array<T, N>& vec_var) noexcept {
      exc << "{";
      std::string sep;
      if (!vec_var.empty())
        for (const auto& var : vec_var)
          exc << sep << var, sep = ", ";
      return exc << "}";
    }
    template <typename T, typename U>
    inline friend const LoggedMessage& operator<<(const LoggedMessage& exc, const std::map<T, U>& map_var) noexcept {
      exc << "{";
      std::string sep;
      if (!map_var.empty())
        for (const auto& var : map_var)
          exc << sep << "{" << var.first << " -> " << var.second << "}", sep = ", ";
      return exc << "}";
    }
    template <typename T, typename U>
    inline friend const LoggedMessage& operator<<(const LoggedMessage& exc,
                                                  const std::unordered_map<T, U>& map_var) noexcept {
      exc << "{";
      std::string sep;
      if (!map_var.empty())
        for (const auto& var : map_var)
          exc << sep << "{" << var.first << " -> " << var.second << "}", sep = ", ";
      return exc << "}";
    }
    inline friend const LoggedMessage& operator<<(const LoggedMessage& exc,
                                                  std::ios_base& (*f)(std::ios_base&)) noexcept {
      LoggedMessage& nc_except = const_cast<LoggedMessage&>(exc);
      f(nc_except.message_);
      return exc;
    }
 
    template <typename T>
    inline const LoggedMessage& log(T&& lam) noexcept {
      lam(*this);
      return *this;
    }
 
    std::string message() const { return message_.str(); }
 
    const std::string& from() const { return from_; }
    const std::string& file() const { return file_; }
    short lineNumber() const { return line_num_; }
    const MessageType& type() const { return type_; }
    void dump(std::ostream* os = nullptr) const noexcept override;
    std::ostream& stream() { return message_; }
 
  protected:
    std::ostringstream message_;  
    std::string from_;            
    std::string file_;            
    short line_num_;              
 
  private:
    MessageType type_;    
    std::string module_;  
  };
 
  struct NullStream : Message {
    using Message::Message;
    inline NullStream() = default;
    inline NullStream(const LoggedMessage&) {}
    void dump(std::ostream* os = nullptr) const override { (void)(os); }
    template <class T>
    NullStream& operator<<(const T&) {
      return *this;
    }
    template <typename T>
    NullStream& log(T&&) {
      return *this;
    }
  };
}  // namespace cepgen
 
#ifdef _WIN32
#define __FUNC__ __FUNCSIG__
#else
#define __FUNC__ __PRETTY_FUNCTION__
#endif
 
#define CG_LOG                                                                    \
  (cepgen::utils::Logger::get().level() <= cepgen::utils::Logger::Level::nothing) \
      ? cepgen::NullStream()                                                      \
      : cepgen::LoggedMessage("Logging", __FUNC__, cepgen::LoggedMessage::MessageType::verbatim, __FILE__, __LINE__)
#define CG_INFO(mod)                \
  (!CG_LOG_MATCH(mod, information)) \
      ? cepgen::NullStream()        \
      : cepgen::LoggedMessage(mod, __FUNC__, cepgen::LoggedMessage::MessageType::info, __FILE__, __LINE__)
#define CG_DEBUG(mod)         \
  (!CG_LOG_MATCH(mod, debug)) \
      ? cepgen::NullStream()  \
      : cepgen::LoggedMessage(mod, __FUNC__, cepgen::LoggedMessage::MessageType::debug, __FILE__, __LINE__)
#define CG_DEBUG_LOOP(mod)              \
  (!CG_LOG_MATCH(mod, debugInsideLoop)) \
      ? cepgen::NullStream()            \
      : cepgen::LoggedMessage(mod, __FUNC__, cepgen::LoggedMessage::MessageType::debug, __FILE__, __LINE__)
#define CG_WARNING(mod)         \
  (!CG_LOG_MATCH(mod, warning)) \
      ? cepgen::NullStream()    \
      : cepgen::LoggedMessage(mod, __FUNC__, cepgen::LoggedMessage::MessageType::warning, __FILE__, __LINE__)
 
#endif