logging.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2023
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_LOGGING_H_
#define SRC_INCLUDE_SMASH_LOGGING_H_
 
#include <stdexcept>
#include <tuple>
 
#include "einhard.hpp"
#include "yaml-cpp/yaml.h"
 
#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, Pythia);
DECLARE_LOGAREA(24, GrandcanThermalizer);
DECLARE_LOGAREA(25, CrossSections);
DECLARE_LOGAREA(26, Output);
DECLARE_LOGAREA(27, HyperSurfaceCrossing);
DECLARE_LOGAREA(28, InitialConditions);
DECLARE_LOGAREA(29, ScatterActionMulti);
DECLARE_LOGAREA(30, Configuration);
DECLARE_LOGAREA(31, Potentials);
DECLARE_LOGAREA(32, RootSolver);
 
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, Pythia,
               GrandcanThermalizer, CrossSections, Output, HyperSurfaceCrossing,
               InitialConditions, ScatterActionMulti, Configuration, Potentials,
               RootSolver>;
}  // namespace LogArea
 
void create_all_loggers(Configuration config);
 
#define SMASH_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};
}
 
extern std::array<einhard::Logger<>, std::tuple_size<LogArea::AreaTuple>::value>
    logg;
}  // 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_SMASH_LOGGING_H_