logging.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2019
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */

#ifndef SRC_INCLUDE_LOGGING_H_
#define SRC_INCLUDE_LOGGING_H_

#include <stdexcept>
#include <tuple>

#include <yaml-cpp/yaml.h>  // NOLINT(build/include_order)
#include <einhard.hpp>

#include "macros.h"

namespace smash {

class Configuration;

#define DECLARE_LOGAREA(id__, name__)                                     \
  struct name__ {                                                         \
    static constexpr int id = id__;                                       \
    static constexpr const char *textual() { return #name__; }            \
    static constexpr int textual_length() { return sizeof(#name__) - 1; } \
  }

namespace LogArea {
DECLARE_LOGAREA(0, Main);
DECLARE_LOGAREA(1, Experiment);
DECLARE_LOGAREA(2, Box);
DECLARE_LOGAREA(3, Collider);
DECLARE_LOGAREA(4, Sphere);
DECLARE_LOGAREA(5, Action);
DECLARE_LOGAREA(6, InputParser);
DECLARE_LOGAREA(7, ParticleType);
DECLARE_LOGAREA(8, FindScatter);
DECLARE_LOGAREA(9, Clock);
DECLARE_LOGAREA(10, DecayModes);
DECLARE_LOGAREA(11, Resonances);
DECLARE_LOGAREA(12, ScatterAction);
DECLARE_LOGAREA(13, Distributions);
DECLARE_LOGAREA(14, Propagation);
DECLARE_LOGAREA(15, Grid);
DECLARE_LOGAREA(16, List);  // ListModus
DECLARE_LOGAREA(17, Nucleus);
DECLARE_LOGAREA(18, Density);
DECLARE_LOGAREA(19, PauliBlocking);
DECLARE_LOGAREA(20, Tmn);
DECLARE_LOGAREA(21, Fpe);
DECLARE_LOGAREA(22, Lattice);
DECLARE_LOGAREA(23, Sampling);
DECLARE_LOGAREA(24, Pythia);
DECLARE_LOGAREA(25, GrandcanThermalizer);
DECLARE_LOGAREA(26, CrossSections);
DECLARE_LOGAREA(27, Output);
DECLARE_LOGAREA(28, HadronGasEos);
DECLARE_LOGAREA(29, HyperSurfaceCrossing);

using AreaTuple =
    std::tuple<Main, Experiment, Box, Collider, Sphere, Action, InputParser,
               ParticleType, FindScatter, Clock, DecayModes, Resonances,
               ScatterAction, Distributions, Propagation, Grid, List, Nucleus,
               Density, PauliBlocking, Tmn, Fpe, Lattice, Sampling, Pythia,
               GrandcanThermalizer, CrossSections, Output, HadronGasEos,
               HyperSurfaceCrossing>;
}  // namespace LogArea

void create_all_loggers(Configuration config);

einhard::Logger<> &retrieve_logger_impl(int id);

template <typename LogAreaTag>
inline einhard::Logger<> &logger() {
  static_assert(LogAreaTag::id < std::tuple_size<LogArea::AreaTuple>::value &&
                    LogAreaTag::id >= 0,
                "The LogArea::AreaTuple is out of sync with the declared log "
                "areas. Please fix! (see top of 'include/logging.h')");
  return retrieve_logger_impl(LogAreaTag::id);
}

#define source_location \
  __FILE__ ":" + std::to_string(__LINE__) + " (" + __func__ + ')'

einhard::LogLevel default_loglevel();

void set_default_loglevel(einhard::LogLevel level);

template <typename T>
struct FormattingHelper {
  const T &value;
  const int width;
  const int precision;
  const char *const unit;
  friend std::ostream &operator<<(std::ostream &out,
                                  const FormattingHelper &h) {
    if (h.width > 0) {
      out << std::setfill(' ') << std::setw(h.width);
    }
    if (h.precision >= 0) {
      out << std::setprecision(h.precision);
    }
    out << h.value;
    if (h.unit) {
      out << ' ' << h.unit;
    }
    return out;
  }
};

template <typename T>
FormattingHelper<T> format(const T &value, const char *unit, int width = -1,
                           int precision = -1) {
  return {value, width, precision, unit};
}
}  // namespace smash

namespace YAML {
template <>
struct convert<einhard::LogLevel> {
  static Node encode(const einhard::LogLevel &x) {
    return Node{einhard::getLogLevelString(x)};
  }

  static bool decode(const Node &node, einhard::LogLevel &x) {
    if (!node.IsScalar()) {
      return false;
    } else {
      x = einhard::getLogLevel(node.Scalar());
      return true;
    }
  }
};
}  // namespace YAML

// @}

#endif  // SRC_INCLUDE_LOGGING_H_