configuration.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2025
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_CONFIGURATION_H_
#define SRC_INCLUDE_SMASH_CONFIGURATION_H_
 
#include <algorithm>
#include <array>
#include <exception>
#include <filesystem>
#include <iostream>
#include <map>
#include <optional>
#include <set>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
#include "yaml-cpp/yaml.h"
 
#include "cxx17compat.h"
#include "forwarddeclarations.h"
#include "key.h"
#include "stringify.h"
 
namespace YAML {
 
template <typename T>
struct convert {
  static Node encode(const T &x) {
    if constexpr (std::is_convertible_v<T, std::string>) {
      return Node{static_cast<std::string>(x)};
    } else {
      static_assert(smash::has_to_string_v<T>,
                    "Encoding type T to YAML::Node requires an overload of "
                    "smash::to_string(T) to convert T to an std::string.");
      return Node{smash::to_string(x)};
    }
  }
 
  static bool decode(const Node &node, T &x) {
    if (!node.IsScalar()) {
      return false;
    } else {
      x = static_cast<T>(node.Scalar());
      return true;
    }
  }
};
}  // namespace YAML
 
namespace smash {
 
class Configuration {
 public:
  struct IncorrectTypeInAssignment : public std::runtime_error {
    using std::runtime_error::runtime_error;
  };
  struct ParseError : public std::runtime_error {
    using std::runtime_error::runtime_error;
  };
  struct FileDoesNotExist : public std::runtime_error {
    using std::runtime_error::runtime_error;
  };
  struct TakeSameKeyTwice : public std::logic_error {
    using std::logic_error::logic_error;
  };
 
  static const char InitializeFromYAMLString = 'S';
 
  enum class GetEmpty { Yes, No };
 
  enum class Is { Invalid, Deprecated, Valid };
 
  explicit Configuration(const std::filesystem::path &path);
 
  explicit Configuration(const std::filesystem::path &path,
                         const std::filesystem::path &filename);
 
  explicit Configuration(const char *yaml, const char sflag) {
    if (sflag == InitializeFromYAMLString) {
      merge_yaml(yaml);
    } else {
      throw std::runtime_error(
          "Unknown control flag in Configuration constructor"
          " with a YAML formatted string. Please, use"
          " Configuration::InitializeFromYAMLString.");
    }
  }
 
#ifdef BUILD_TESTS
  explicit Configuration(const char *yaml) : root_node_(YAML::Load(yaml)) {
    if (root_node_.IsNull())
      root_node_ = YAML::Node{YAML::NodeType::Map};
  }
#endif
 
  Configuration(const Configuration &) = delete;
  Configuration &operator=(const Configuration &) = delete;
 
  Configuration(Configuration &&);
 
  Configuration &operator=(Configuration &&);
 
  ~Configuration() noexcept(false);
 
  void merge_yaml(const std::string &yaml);
 
  std::vector<std::string> list_upmost_nodes();
 
  template <typename T>
  T take(const Key<T> &key) {
    if (has_value(key)) {
      // The following return statement converts a Value into T
      return unconditionally_take_and_validate(key);
    } else if (has_section(key.labels())) {
      // In this case, if the Key type is a map, we take it, otherwise fails
      if constexpr (isMap<typename Key<T>::type>::value) {
        return unconditionally_take_and_validate(key);
      } else {
        throw std::logic_error(
            "Key " + std::string{key} +  // NOLINT(whitespace/braces)
            " was taken, but its value is not a map, although there is a "
            "section in the configuration with its labels.");
      }
    } else if (did_key_exist_and_was_it_already_taken(key.labels())) {
      throw TakeSameKeyTwice("Attempt to take key " +
                             std::string{key} +  // NOLINT(whitespace/braces)
                             " twice.");
    } else {
      try {
        /* Note that a key with invalid default value cannot be constructed,
           hence we do not validate its default value here. */
        return key.default_value();
      } catch (std::bad_optional_access &) {
        throw std::invalid_argument(
            "Key " + std::string{key} +  // NOLINT(whitespace/braces)
            " without default value taken, but missing in configuration.");
      }
    }
  }
 
  template <typename T>
  T take(const Key<T> &key, T default_value) {
    if (!key.has_dependent_default()) {
      throw std::logic_error(
          "An input Key without dependent default cannot be taken specifying a "
          "default value! Either define the key as having a dependent default "
          "or take it without a default value (which is a Key property).");
    }
    if (!key.validate(default_value)) {
      throw std::logic_error("Invalid default value passed when taking " +
                             static_cast<std::string>(key) + " key.");
    }
    if (has_value(key)) {
      return take(key);
    }
    return default_value;
  }
 
  template <typename T>
  T read(const Key<T> &key) const {
    if (has_value(key)) {
      // The following return statement converts a Value into T
      return unconditionally_read_and_validate(key);
    } else if (has_section(key.labels())) {
      // In this case, if the Key type is a map, we take it, otherwise fails
      if constexpr (isMap<typename Key<T>::type>::value) {
        return unconditionally_read_and_validate(key);
      } else {
        throw std::logic_error(
            "Key " + std::string{key} +  // NOLINT(whitespace/braces)
            " was read, but its value is not a map, although there is a "
            "section in the configuration with its labels.");
      }
    } else {
      try {
        /* Note that a key with invalid default value cannot be constructed,
           hence we do not validate its default value here. */
        return key.default_value();
      } catch (std::bad_optional_access &) {
        throw std::invalid_argument(
            "Key " + std::string{key} +  // NOLINT(whitespace/braces)
            " without default value read, but missing in configuration.");
      }
    }
  }
 
  template <typename T>
  T read(const Key<T> &key, T default_value) const {
    if (!key.has_dependent_default()) {
      throw std::logic_error(
          "An input Key without dependent default cannot be read specifying a "
          "default value! Either define the key as having a dependent default "
          "or read it without a default value (which is a Key property).");
    }
    if (!key.validate(default_value)) {
      throw std::logic_error("Invalid default value passed when reading " +
                             static_cast<std::string>(key) + " key.");
    }
    if (has_value(key)) {
      return read(key);
    }
    return default_value;
  }
 
  template <typename T, typename U = remove_cvref_t<T>,
            typename std::enable_if_t<std::is_convertible_v<T, U>, bool> = true>
  void set_value(Key<U> key, T &&value) {
    auto node = find_node_creating_it_if_not_existing(
        {key.labels().begin(), key.labels().end()});
    node = std::forward<T>(value);
  }
 
  void remove_all_entries_in_section_but_one(const std::string &key,
                                             KeyLabels section = {});
 
  Configuration extract_sub_configuration(
      KeyLabels section, Configuration::GetEmpty empty_if_not_existing =
                             Configuration::GetEmpty::No);
 
  Configuration extract_complete_sub_configuration(
      KeyLabels section, Configuration::GetEmpty empty_if_not_existing =
                             Configuration::GetEmpty::No);
 
  void enclose_into_section(KeyLabels section);
 
  template <typename T>
  bool has_key(const Key<T> &key) const {
    const auto found_node =
        find_existing_node({key.labels().begin(), key.labels().end()});
    return found_node.has_value() && !(found_node.value().IsMap());
  }
 
  template <typename T>
  bool has_value(const Key<T> &key) const {
    const auto found_node =
        find_existing_node({key.labels().begin(), key.labels().end()});
    return found_node.has_value() && !(found_node.value().IsNull()) &&
           !(found_node.value().IsMap());
  }
 
  bool has_section(const KeyLabels &labels) const {
    const auto found_node = find_existing_node({labels.begin(), labels.end()});
    return found_node.has_value() && found_node.value().IsMap();
  }
 
  bool is_empty() const { return root_node_.size() == 0; }
 
  std::string to_string() const;
 
  void clear() { root_node_.reset(); }
 
  Is validate(bool full_validation = true) const;
 
 private:
  class Value {
    friend class Configuration;
 
    const YAML::Node node_;
    const char *const key_;
 
    Value(const YAML::Node &n, const char *key) : node_(n), key_(key) {
      if (!(n.IsScalar() || n.IsSequence() || n.IsMap())) {
        std::stringstream err;
        err << "Configuration value for \"" << key
            << "\" is missing or invalid";
        throw std::runtime_error(err.str());
      }
    }
 
   public:
    Value(const Value &) = delete;
    Value &operator=(const Value &) = delete;
 
    template <typename T>
    operator T() const {
      try {
        return node_.as<T>();
      } catch (YAML::TypedBadConversion<T> &e) {
        throw IncorrectTypeInAssignment(
            "The value for key \"" + std::string(key_) +
            "\" cannot be converted to the requested type.");
      }
    }
 
    template <typename T>
    operator std::vector<T>() const {
      try {
        return node_.as<std::vector<T>>();
      } catch (YAML::TypedBadConversion<T> &e) {
        throw IncorrectTypeInAssignment(
            "One of the values in the sequence for key \"" + std::string(key_) +
            "\" failed to convert to the requested type. E.g. [1 2] is a "
            "sequence of one string \"1 2\" and [1, 2] is a sequence of two "
            "integers. Often there is just a comma missing in the config "
            "file.");
      } catch (YAML::TypedBadConversion<std::vector<T>> &e) {
        throw IncorrectTypeInAssignment(
            "The value for key \"" + std::string(key_) +
            "\" cannot be converted to the requested type. A sequence was "
            "expected but apparently not found.");
      }
    }
 
    template <typename T, size_t N>
    operator std::array<T, N>() const {
      const std::vector<T> vec = operator std::vector<T>();
      const size_t n_read = vec.size();
      // Alert if size does not match
      if (n_read != N) {
        throw IncorrectTypeInAssignment("Wrong number of values in array \"" +
                                        std::string(key_) + "\". Expected " +
                                        std::to_string(N) +
                                        " values,"
                                        " found " +
                                        std::to_string(n_read) + ".");
      }
      std::array<T, N> arr;
      std::copy_n(vec.begin(), N, arr.begin());
      return arr;
    }
 
    operator ReactionsBitSet() const {
      const std::vector<std::string> v = operator std::vector<std::string>();
      ReactionsBitSet s;
      for (const auto &x : v) {
        if (x == "All") {
          s.set();
          break;
        } else if (x == "Elastic") {
          s.set(IncludedReactions::Elastic);
        } else if (x == "NN_to_NR") {
          s.set(IncludedReactions::NN_to_NR);
        } else if (x == "NN_to_DR") {
          s.set(IncludedReactions::NN_to_DR);
        } else if (x == "KN_to_KN") {
          s.set(IncludedReactions::KN_to_KN);
        } else if (x == "KN_to_KDelta") {
          s.set(IncludedReactions::KN_to_KDelta);
        } else if (x == "Strangeness_exchange") {
          s.set(IncludedReactions::Strangeness_exchange);
        } else if (x == "NNbar") {
          s.set(IncludedReactions::NNbar);
        } else if (x == "PiDeuteron_to_NN") {
          s.set(IncludedReactions::PiDeuteron_to_NN);
        } else if (x == "PiDeuteron_to_pidprime") {
          s.set(IncludedReactions::PiDeuteron_to_pidprime);
        } else if (x == "NDeuteron_to_Ndprime") {
          s.set(IncludedReactions::NDeuteron_to_Ndprime);
        } else {
          throw IncorrectTypeInAssignment(
              "The value for key \"" + std::string(key_) +
              "\" should be \"All\", \"Elastic\", \"NN_to_NR\", \"NN_to_DR\","
              "\"KN_to_KN\", \"KN_to_KDelta\", \"PiDeuteron_to_NN\", "
              "\"PiDeuteron_to_pidprime\", \"NDeuteron_to_Ndprime\", "
              "\"Strangeness_exchange\" or "
              "\"NNbar\", or any combination of these.");
        }
      }
      return s;
    }
 
    operator MultiParticleReactionsBitSet() const {
      const std::vector<std::string> v = operator std::vector<std::string>();
      MultiParticleReactionsBitSet s;
      for (const auto &x : v) {
        if (x == "All") {
          s.set();
          break;
        } else if (x == "Meson_3to1") {
          s.set(IncludedMultiParticleReactions::Meson_3to1);
        } else if (x == "Deuteron_3to2") {
          s.set(IncludedMultiParticleReactions::Deuteron_3to2);
        } else if (x == "NNbar_5to2") {
          s.set(IncludedMultiParticleReactions::NNbar_5to2);
        } else if (x == "A3_Nuclei_4to2") {
          s.set(IncludedMultiParticleReactions::A3_Nuclei_4to2);
        } else {
          throw IncorrectTypeInAssignment(
              "The value for key \"" + std::string(key_) +
              "\" should be \"All\", \"Meson_3to1\", "
              "\"Deuteron_3to2\" or \"NNbar_5to2\", "
              "\"A3_Nuclei_4to2\", or any combination of "
              "these.");
        }
      }
      return s;
    }
 
    operator std::set<ThermodynamicQuantity>() const {
      const std::vector<std::string> v = operator std::vector<std::string>();
      std::set<ThermodynamicQuantity> s;
      for (const auto &x : v) {
        if (x == "rho_eckart") {
          s.insert(ThermodynamicQuantity::EckartDensity);
        } else if (x == "tmn") {
          s.insert(ThermodynamicQuantity::Tmn);
        } else if (x == "tmn_landau") {
          s.insert(ThermodynamicQuantity::TmnLandau);
        } else if (x == "landau_velocity") {
          s.insert(ThermodynamicQuantity::LandauVelocity);
        } else if (x == "j_QBS") {
          s.insert(ThermodynamicQuantity::j_QBS);
        } else {
          throw IncorrectTypeInAssignment(
              "The value for key \"" + std::string(key_) +
              "\" should be \"rho_eckart\", \"tmn\""
              ", \"tmn_landau\", \"landau_velocity\" or \"j_QBS\".");
        }
      }
      return s;
    }
 
    operator CalculationFrame() const {
      const std::string s = operator std::string();
      if (s == "center of velocity") {
        return CalculationFrame::CenterOfVelocity;
      }
      if (s == "center of mass") {
        return CalculationFrame::CenterOfMass;
      }
      if (s == "fixed target") {
        return CalculationFrame::FixedTarget;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"center of velocity\" or \"center of mass\" "
          "or \"fixed target\".");
    }
 
    operator FermiMotion() const {
      const std::string s = operator std::string();
      if (s == "off") {
        return FermiMotion::Off;
      }
      if (s == "on") {
        return FermiMotion::On;
      }
      if (s == "frozen") {
        return FermiMotion::Frozen;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"off\" or \"on\" or \"frozen\".");
    }
 
    operator DensityType() const {
      const std::string s = operator std::string();
      if (s == "hadron") {
        return DensityType::Hadron;
      }
      if (s == "baryon") {
        return DensityType::Baryon;
      }
      if (s == "baryonic isospin") {
        return DensityType::BaryonicIsospin;
      }
      if (s == "pion") {
        return DensityType::Pion;
      }
      if (s == "total isospin") {
        return DensityType::Isospin3_tot;
      }
      if (s == "none") {
        return DensityType::None;
      }
      throw IncorrectTypeInAssignment("The value for key \"" +
                                      std::string(key_) +
                                      "\" should be \"hadron\" or \"baryon\" "
                                      "or \"baryonic isospin\" or \"pion\" "
                                      "or \"none\".");
    }
 
    operator ExpansionMode() const {
      const std::string s = operator std::string();
      if (s == "NoExpansion") {
        return ExpansionMode::NoExpansion;
      }
      if (s == "MasslessFRW") {
        return ExpansionMode::MasslessFRW;
      }
      if (s == "MassiveFRW") {
        return ExpansionMode::MassiveFRW;
      }
      if (s == "Exponential") {
        return ExpansionMode::Exponential;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"NoExpansion\", \"MasslessFRW\"," +
          "\"MassiveFRW\" or \"Exponential\".");
    }
 
    operator DerivativesMode() const {
      const std::string s = operator std::string();
      if (s == "Covariant Gaussian") {
        return DerivativesMode::CovariantGaussian;
      }
      if (s == "Finite difference") {
        return DerivativesMode::FiniteDifference;
      }
      if (s == "Off") {
        return DerivativesMode::Off;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"Covariant Gaussian\", \"Finite difference\"," +
          " or \"Off\".");
    }
 
    operator FieldDerivativesMode() const {
      const std::string s = operator std::string();
      if (s == "Chain Rule") {
        return FieldDerivativesMode::ChainRule;
      }
      if (s == "Direct") {
        return FieldDerivativesMode::Direct;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"Chain Rule\" or \"Direct\".");
    }
 
    operator SmearingMode() const {
      const std::string s = operator std::string();
      if (s == "Covariant Gaussian") {
        return SmearingMode::CovariantGaussian;
      }
      if (s == "Discrete") {
        return SmearingMode::Discrete;
      }
      if (s == "Triangular") {
        return SmearingMode::Triangular;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"Covariant Gaussian\", \"Discrete\"," +
          " or \"Triangular\".");
    }
 
    operator TimeStepMode() const {
      const std::string s = operator std::string();
      if (s == "None") {
        return TimeStepMode::None;
      }
      if (s == "Fixed") {
        return TimeStepMode::Fixed;
      }
      throw IncorrectTypeInAssignment("The value for key \"" +
                                      std::string(key_) +
                                      "\" should be \"None\" or \"Fixed\".");
    }
 
    operator BoxInitialCondition() const {
      const std::string s = operator std::string();
      if (s == "thermal momenta") {
        return BoxInitialCondition::ThermalMomentaBoltzmann;
      }
      if (s == "thermal momenta quantum") {
        return BoxInitialCondition::ThermalMomentaQuantum;
      }
      if (s == "peaked momenta") {
        return BoxInitialCondition::PeakedMomenta;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"thermal momenta\", \"thermal momenta quantum\", " +
          "or \"peaked momenta\".");
    }
 
    operator SphereInitialCondition() const {
      const std::string s = operator std::string();
      if (s == "thermal momenta") {
        return SphereInitialCondition::ThermalMomentaBoltzmann;
      }
      if (s == "thermal momenta quantum") {
        return SphereInitialCondition::ThermalMomentaQuantum;
      }
      if (s == "IC_ES") {
        return SphereInitialCondition::IC_ES;
      }
      if (s == "IC_1M") {
        return SphereInitialCondition::IC_1M;
      }
      if (s == "IC_2M") {
        return SphereInitialCondition::IC_2M;
      }
      if (s == "IC_Massive") {
        return SphereInitialCondition::IC_Massive;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"thermal momenta\", \"thermal momenta quantum\", " +
          "\"IC_ES\", \"IC_1M\", \"IC_2M\" or" + "\"IC_Massive\".");
    }
 
    operator NNbarTreatment() const {
      const std::string s = operator std::string();
      if (s == "no annihilation") {
        return NNbarTreatment::NoAnnihilation;
      }
      if (s == "resonances") {
        return NNbarTreatment::Resonances;
      }
      if (s == "two to five") {
        return NNbarTreatment::TwoToFive;
      }
      if (s == "strings") {
        return NNbarTreatment::Strings;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) + "\" should be " +
          "\"no annihilation\", \"resonances\", \"two to five\" or " +
          " \"strings\".");
    }
 
    operator Sampling() const {
      const std::string s = operator std::string();
      if (s == "quadratic") {
        return Sampling::Quadratic;
      }
      if (s == "custom") {
        return Sampling::Custom;
      }
      if (s == "uniform") {
        return Sampling::Uniform;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"quadratic\", \"uniform\" or \"custom\".");
    }
 
    operator ThermalizationAlgorithm() const {
      const std::string s = operator std::string();
      if (s == "mode sampling") {
        return ThermalizationAlgorithm::ModeSampling;
      }
      if (s == "biased BF") {
        return ThermalizationAlgorithm::BiasedBF;
      }
      if (s == "unbiased BF") {
        return ThermalizationAlgorithm::UnbiasedBF;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"mode sampling\", \"biased BF\" or \"unbiased BF\".");
    }
 
    operator CollisionCriterion() const {
      const std::string s = operator std::string();
      if (s == "Geometric") {
        return CollisionCriterion::Geometric;
      }
      if (s == "Stochastic") {
        return CollisionCriterion::Stochastic;
      }
      if (s == "Covariant") {
        return CollisionCriterion::Covariant;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) + "\" should be " +
          "\"Geometric\", \"Stochastic\" " + "or \"Covariant\".");
    }
 
    operator SpinInteractionType() const {
      const std::string s = operator std::string();
      if (s == "On")
        return SpinInteractionType::On;
      if (s == "Off")
        return SpinInteractionType::Off;
      throw IncorrectTypeInAssignment("The value for key \"" +
                                      std::string(key_) + "\" should be " +
                                      "\"On\", \"Off\" " + "or \"Elastic\".");
    }
 
    operator TotalCrossSectionStrategy() const {
      const std::string s = operator std::string();
      if (s == "BottomUp") {
        return TotalCrossSectionStrategy::BottomUp;
      }
      if (s == "TopDown") {
        return TotalCrossSectionStrategy::TopDown;
      }
      if (s == "TopDownMeasured") {
        return TotalCrossSectionStrategy::TopDownMeasured;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) + "\" should be " +
          "\"BottomUp\", \"TopDown\" " + "or \"TopDownMeasured\".");
    }
 
    operator PseudoResonance() const {
      const std::string s = operator std::string();
      if (s == "None") {
        return PseudoResonance::None;
      }
      if (s == "Largest") {
        return PseudoResonance::Largest;
      }
      if (s == "Closest") {
        return PseudoResonance::Closest;
      }
      if (s == "LargestFromUnstable") {
        return PseudoResonance::LargestFromUnstable;
      }
      if (s == "ClosestFromUnstable") {
        return PseudoResonance::ClosestFromUnstable;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) + "\" should be " +
          "\"None\",  \"Largest\",  \"Closest\", \"LargestFromUnstable\", or "
          "\"ClosestFromUnstable\".");
    }
 
    operator FluidizationType() const {
      const std::string s = operator std::string();
      if (s == "Constant_Tau") {
        return FluidizationType::ConstantTau;
      } else if (s == "Dynamic") {
        return FluidizationType::Dynamic;
      }
      throw IncorrectTypeInAssignment("The value for key \"" +
                                      std::string(key_) + "\" should be " +
                                      "\"Constant_Tau\" or \"Dynamic\".");
    }
 
    operator OutputOnlyFinal() const {
      const std::string s = operator std::string();
      if (s == "Yes") {
        return OutputOnlyFinal::Yes;
      }
      if (s == "No") {
        return OutputOnlyFinal::No;
      }
      if (s == "IfNotEmpty") {
        return OutputOnlyFinal::IfNotEmpty;
      }
      throw IncorrectTypeInAssignment("The value for key \"" +
                                      std::string(key_) + "\" should be " +
                                      "\"Yes\", \"No\" or \"IfNotEmpty\".");
    }
 
    operator FluidizableProcessesBitSet() const {
      const std::vector<std::string> v = operator std::vector<std::string>();
      FluidizableProcessesBitSet s;
      for (const auto &x : v) {
        if (x == "All") {
          s.set();
          break;
        } else if (x == "Elastic") {
          s.set(IncludedFluidizableProcesses::From_Elastic);
        } else if (x == "Decay") {
          s.set(IncludedFluidizableProcesses::From_Decay);
        } else if (x == "Inelastic") {
          s.set(IncludedFluidizableProcesses::From_Inelastic);
        } else if (x == "SoftString") {
          s.set(IncludedFluidizableProcesses::From_SoftString);
        } else if (x == "HardString") {
          s.set(IncludedFluidizableProcesses::From_HardString);
        } else {
          throw IncorrectTypeInAssignment(
              "The value for key \"" + std::string(key_) +
              "\" should be \"All\", \"Elastic\", \"Decay\", "
              "\"Inelastic\", \"SoftString\", \"HardString\", "
              "or any combination of these.");
        }
      }
      return s;
    }
  };
 
  Configuration(const YAML::Node &node)  // NOLINT(runtime/explicit) : see above
      : root_node_(YAML::Clone(node)) {}
 
  YAML::Node find_node_creating_it_if_not_existing(
      std::vector<std::string_view> keys) const;
 
  std::optional<YAML::Node> find_existing_node(
      std::vector<std::string_view> keys) const;
 
  template <class T>
  struct isMap : std::false_type {};
  template <class Key, class Value>
  struct isMap<std::map<Key, Value>> : std::true_type {};
 
  template <typename T>
  T get_validated_key_value(const Key<T> &key, const T &value) const {
    if (key.validate(value)) {
      return value;
    } else {
      throw std::invalid_argument(
          "Invalid value detected in configuration file:\n " +
          key.as_yaml(value));
    }
  }
 
  template <typename T>
  T unconditionally_take_and_validate(const Key<T> &key) {
    // The following assignment converts a Configuration::Value into T
    T value = take({key.labels().begin(), key.labels().end()});
    return get_validated_key_value(key, value);
  }
 
  template <typename T>
  T unconditionally_read_and_validate(const Key<T> &key) const {
    // The following assignment converts a Configuration::Value into T
    T value = read({key.labels().begin(), key.labels().end()});
    return get_validated_key_value(key, value);
  }
 
  Value take(std::vector<std::string_view> labels);
 
  Value read(std::vector<std::string_view> labels) const;
 
  bool did_key_exist_and_was_it_already_taken(const KeyLabels &labels) const {
    return std::find(existing_keys_already_taken_.begin(),
                     existing_keys_already_taken_.end(),
                     labels) != existing_keys_already_taken_.end();
  }
 
  YAML::Node root_node_{YAML::NodeType::Map};
 
  int uncaught_exceptions_{std::uncaught_exceptions()};
 
  std::vector<KeyLabels> existing_keys_already_taken_{};
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_CONFIGURATION_H_