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 506 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 MultiParticleReactionsBitSet () const
	Set MultiParticleReactionsBitSet 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 DerivativesMode () const
	Set DerivativesMode. More...
	operator RestFrameDensityDerivativesMode () const
	Set RestFrameDensityDerivatives mode. More...
	operator FieldDerivativesMode () const
	Set FieldDerivatives mode. More...
	operator SmearingMode () const
	Set SmearingMode. 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...
	operator CollisionCriterion () const
	Set collision criterion from configuration values. More...
	operator OutputOnlyFinal () const
	Set OutputOnlyFinal for particles output 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

Value() [1/2]

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

Value() [2/2]

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

delete

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

Member Function Documentation

operator=()

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

delete

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

convert_for()

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 562 of file configuration.h.

                                   {
      return *this;
    }

operator T()

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

operator std::vector< T >()

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

operator std::array< T, N >()

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

operator ReactionsBitSet()

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 641 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 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()

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

inline

Set MultiParticleReactionsBitSet from configuration values.

Returns

MultiParticleReactionsBitSet 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 688 of file configuration.h.

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

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

operator CalculationFrame()

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

operator FermiMotion()

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

operator DensityType()

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

operator ExpansionMode()

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

operator DerivativesMode()

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

inline

Set DerivativesMode.

Definition at line 857 of file configuration.h.

                                     {
      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 RestFrameDensityDerivativesMode()

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

inline

Set RestFrameDensityDerivatives mode.

Definition at line 877 of file configuration.h.

                                                     {
      const std::string s = operator std::string();
      if (s == "On") {
        return RestFrameDensityDerivativesMode::On;
      }
      if (s == "Off") {
        return RestFrameDensityDerivativesMode::Off;
      }
      throw IncorrectTypeInAssignment("The value for key \"" +
                                      std::string(key_) +
                                      "\" should be \"On\" or \"Off\".");
    }

operator FieldDerivativesMode()

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

inline

Set FieldDerivatives mode.

Definition at line 893 of file configuration.h.

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

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

inline

Set SmearingMode.

Definition at line 909 of file configuration.h.

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

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

operator BoxInitialCondition()

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 953 of file configuration.h.

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

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 977 of file configuration.h.

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

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 1010 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 == "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()

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

operator ThermalizationAlgorithm()

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

operator CollisionCriterion()

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

inline

Set collision criterion from configuration values.

Returns

CollisionCriterion.

Exceptions

IncorrectTypeInAssignment

in case an collision criterion that is not available is provided as a configuration value.

Definition at line 1083 of file configuration.h.

                                        {
      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 OutputOnlyFinal()

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

inline

Set OutputOnlyFinal for particles output from configuration values.

Returns

OutputOnlyFinal.

Exceptions

IncorrectTypeInAssignment

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

Definition at line 1106 of file configuration.h.

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

Friends And Related Function Documentation

Configuration

friend class Configuration

friend

Definition at line 507 of file configuration.h.

Member Data Documentation

node_

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

private

a YAML leaf node

Todo:

(steinberg) What is that?

Definition at line 510 of file configuration.h.

key_

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

private

The key to be interpreted.

Definition at line 512 of file configuration.h.

---

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

• src/include/smash/configuration.h