smash::Configuration::Value Class Reference

#include <configuration.h>

Return type of Configuration::take that automatically determines the target type.

This class is an implementation detail of Configuration and can be ignored by users of Configuration.

Definition at line 345 of file configuration.h.

Collaboration diagram for smash::Configuration::Value:

Public Member Functions
	Value (const Value &)=delete
	If you want to copy this you're doing it wrong. More...
Value &	operator= (const Value &)=delete
	If you want to copy this you're doing it wrong. More...
template<typename T >
T	convert_for (const T &) const
	Convert the value to the type of the supplied argument. More...
template<typename T >
	operator T () const
	This function determines the type it is assigned to and calls YAML::Node::as<T>() with this type. More...
template<typename T >
	operator std::vector< T > () const
	Check conversion exceptions. More...
template<typename T , size_t N>
	operator std::array< T, N > () const
	Cast array of keys to a std::array of length N. More...
	operator ReactionsBitSet () const
	Set ReactionBitSet from configuration values. More...
	operator std::set< ThermodynamicQuantity > () const
	Set thermodynamic quantity from configuration values. More...
	operator CalculationFrame () const
	Set calculation frame from configuration values. More...
	operator FermiMotion () const
	(De-)Activate Fermi motion from configuration values. More...
	operator DensityType () const
	Set density type from configuration values. More...
	operator ExpansionMode () const
	Set expansion mode from configuration values. More...
	operator TimeStepMode () const
	Set time step mode from configuration values. More...
	operator BoxInitialCondition () const
	Set initial condition for box setup from configuration values. More...
	operator SphereInitialCondition () const
	Set initial condition for sphere setup from configuration values. More...
	operator NNbarTreatment () const
	Set treatment of N-Nbar reactions from configuration values. More...
	operator Sampling () const
	Set cross-section sampling method from configuration values. More...
	operator ThermalizationAlgorithm () const
	Set algorithm for forced thermalization from configuration values. More...

Private Member Functions
	Value (const YAML::Node &n, const char *key)
	Constructs the Value wrapper from a YAML::Node. More...

Private Attributes
const YAML::Node	node_
	a YAML leaf node More...
const char *const	key_
	The key to be interpreted. More...

Friends
class	Configuration

Constructor & Destructor Documentation

smash::Configuration::Value::Value ( const YAML::Node &  n, const char *  key  )

inlineprivate

Constructs the Value wrapper from a YAML::Node.

Note

This constructor must be implicit, otherwise it's impossible to return an rvalue Value object - because the copy constructor is deleted.

Definition at line 359 of file configuration.h.

                                              : 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());
      }
    }

smash::Configuration::Value::Value ( const Value &  )

delete

If you want to copy this you're doing it wrong.

Member Function Documentation

Value& smash::Configuration::Value::operator= ( const Value &  )

delete

If you want to copy this you're doing it wrong.

template<typename T >

T smash::Configuration::Value::convert_for ( const T &  ) const

inline

Convert the value to the type of the supplied argument.

The argument itself is not used other than to determine its type. This function is necessary because in some situations the overload resolution rules lead to the correct conversion becoming hidden. Then you'll see a compiler error with a list of ambiguous constructor calls as candidates. Use this function as a workaround. Example:

// this doesn't compile:
const PdgCode code0(config.take({"key"}));
// this compiles (because PdgCode::operator= is not overloaded), but note
// that it cannot be used in constructor initializer lists:
const PdgCode code1 = config.take({"key"});

// Thus, for class member variables use the following pattern:
class X {
 public:
  X() : code_(config.take({"key"}).convert_for(code_)) {}

 private:
  const PdgCode code_;
};

Definition at line 401 of file configuration.h.

                                   {
      return *this;
    }

template<typename T >

smash::Configuration::Value::operator T ( ) const

inline

This function determines the type it is assigned to and calls YAML::Node::as<T>() with this type.

This makes reading values more convenient than calling as<type>() explicitly.

Exceptions

IncorrectTypeInAssignment

Definition at line 414 of file configuration.h.

                       {
      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 >

smash::Configuration::Value::operator std::vector< T > ( ) const

inline

Check conversion exceptions.

Exceptions

IncorrectTypeInAssignment

in case type conversion failed.

Definition at line 430 of file configuration.h.

                                  {
      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>

smash::Configuration::Value::operator std::array< T, N > ( ) const

inline

Cast array of keys to a std::array of length N.

Returns

Array of std::array type.

Exceptions

IncorrectTypeInAssignment

in case the number of keys does not match the length of the newly generated array.

Definition at line 456 of file configuration.h.

                                    {
      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;
    }

smash::Configuration::Value::operator ReactionsBitSet ( ) const

inline

Set ReactionBitSet from configuration values.

Returns

ReactionBitSet with all included reaction types.

Exceptions

IncorrectTypeInAssignment

in case a reaction type that is not available is provided as a configuration value.

Definition at line 480 of file configuration.h.

                                     {
      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 {
          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\" or \"strangeness_exchange\","
              " or any combination of these.");
        }
      }
      return s;
    }

smash::Configuration::Value::operator std::set< ThermodynamicQuantity > ( ) const

inline

Set thermodynamic quantity from configuration values.

Returns

Set of thermodynamic quantity.

Exceptions

IncorrectTypeInAssignment

in case a thermodynamic quantity that is not available is provided as a configuration value.

Definition at line 517 of file configuration.h.

                                                   {
      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;
    }

smash::Configuration::Value::operator CalculationFrame ( ) const

inline

Set calculation frame from configuration values.

Returns

string of calculation frame.

Exceptions

IncorrectTypeInAssignment

in case a calculation frame that is not available is provided as a configuration value.

Definition at line 548 of file configuration.h.

                                      {
      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\".");
    }

smash::Configuration::Value::operator FermiMotion ( ) const

inline

(De-)Activate Fermi motion from configuration values.

Returns

Fermi motion setup.

Exceptions

IncorrectTypeInAssignment

in case a Fermi motion value that is not available is provided as a configuration value.

Definition at line 572 of file configuration.h.

                                 {
      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\".");
    }

smash::Configuration::Value::operator DensityType ( ) const

inline

Set density type from configuration values.

Returns

Density type.

Exceptions

IncorrectTypeInAssignment

in case a density type that is not available is provided as a configuration value.

Definition at line 595 of file configuration.h.

                                 {
      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\".");
    }

smash::Configuration::Value::operator ExpansionMode ( ) const

inline

Set expansion mode from configuration values.

Returns

Expansion mode.

Exceptions

IncorrectTypeInAssignment

in case an expansion mode that is not available is provided as a configuration value.

Definition at line 629 of file configuration.h.

                                   {
      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\".");
    }

smash::Configuration::Value::operator TimeStepMode ( ) const

inline

Set time step mode from configuration values.

Returns

time step mode.

Exceptions

IncorrectTypeInAssignment

in case a time step mode that is not available is provided as a configuration value.

Definition at line 656 of file configuration.h.

                                  {
      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\".");
    }

smash::Configuration::Value::operator BoxInitialCondition ( ) const

inline

Set initial condition for box setup from configuration values.

Returns

Initial condition for box setup.

Exceptions

IncorrectTypeInAssignment

in case an initial conditions that is not available is provided as a configuration value.

Definition at line 676 of file configuration.h.

                                         {
      const std::string s = operator std::string();
      if (s == "thermal momenta") {
        return BoxInitialCondition::ThermalMomenta;
      }
      if (s == "peaked momenta") {
        return BoxInitialCondition::PeakedMomenta;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"thermal momenta\" or \"peaked momenta\".");
    }

smash::Configuration::Value::operator SphereInitialCondition ( ) const

inline

Set initial condition for sphere setup from configuration values.

Returns

Initial condition for sphere setup.

Exceptions

IncorrectTypeInAssignment

in case an initial conditions that is not available is provided as a configuration value.

Definition at line 696 of file configuration.h.

                                            {
      const std::string s = operator std::string();
      if (s == "thermal momenta") {
        return SphereInitialCondition::ThermalMomenta;
      }
      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\", \"IC_ES\", " +
          "\"IC_1M\", \"IC_2M\" or" + "\"IC_Massive\".");
    }

smash::Configuration::Value::operator NNbarTreatment ( ) const

inline

Set treatment of N-Nbar reactions from configuration values.

Returns

N-Nbar treatment.

Exceptions

IncorrectTypeInAssignment

in case an N-Nbar treatment that is not available is provided as a configuration value.

Definition at line 726 of file configuration.h.

                                    {
      const std::string s = operator std::string();
      if (s == "no annihilation") {
        return NNbarTreatment::NoAnnihilation;
      }
      if (s == "resonances") {
        return NNbarTreatment::Resonances;
      }
      if (s == "strings") {
        return NNbarTreatment::Strings;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) + "\" should be " +
          "\"no annihilation\", \"detailed balance\", or \"strings\".");
    }

smash::Configuration::Value::operator Sampling ( ) const

inline

Set cross-section sampling method from configuration values.

Returns

Sampling method of cross-section.

Exceptions

IncorrectTypeInAssignment

in case a sampling method that is not available is provided as a configuration value.

Definition at line 749 of file configuration.h.

                              {
      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\".");
    }

smash::Configuration::Value::operator ThermalizationAlgorithm ( ) const

inline

Set algorithm for forced thermalization from configuration values.

Returns

Algorithm for forced thermalization.

Exceptions

IncorrectTypeInAssignment

in case a thermalization algorithm that is not available is provided as a configuration value.

Definition at line 772 of file configuration.h.

                                             {
      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\".");
    }

Friends And Related Function Documentation

friend class Configuration

friend

Definition at line 346 of file configuration.h.

Member Data Documentation

const YAML::Node smash::Configuration::Value::node_

private

a YAML leaf node

Todo:

(steinberg) What is that?

Definition at line 349 of file configuration.h.

const char* const smash::Configuration::Value::key_

private

The key to be interpreted.

Definition at line 351 of file configuration.h.

---

The documentation for this class was generated from the following file:

• src/include/smash/configuration.h