smash::Configuration Class Reference

#include <configuration.h>

Interface to the SMASH configuration files.

The configuration is created from a YAML file and then stores a nested map of maps (normally a tree, but YAML allows it to be cyclic - even though we don't want that feature). Since the resource owned by the object is a YAML::Node that handle memory in a similar way as a pointer does, it is forbidden (nor should it be needed) to copy instances of this class, while moving is fine (see special members documentation for more information).

The typical usage of a Configuration is to create it, consume (i.e. take) all its values and let it being destructed. Since this is the contact point with SMASH input file, the class is meant to be strict in its usage, so that it is possible to help the inexpert user, who might being using a wrong input file and/or e.g. specify an unused key hoping in an effect that indeed does not occur. Therefore, it is imposed that all keys must be parsed before an instance gets destroyed. If this is not the case, an exception will be thrown.

For the typical usage in SMASH one needs to read the value once. In that case, use the Configuration::take function, for example:

double sigma = config.take({"General", "SIGMA"});

Note the curly braces in the function call. It is a std::initializer_list of strings. This allows an arbitrary nesting depth via the same function. But as a consequence the keys must all be given as constant strings at compile time.

The opposite operation of take is the Configuration::set_value method, which has a similar syntax, but needs the new value to be assigned, e.g.

config.set_value({"General", "SIGMA"}, 3.1415);

If you need to delegate parsing of a section to some object, you can use the Configuration::extract_sub_configuration method, which is taking a full section and returning a new, distinct Configuration instance.

Last but not least, the Configuration::validate method is used by SMASH to check that all given keys are allowed in the present version of the codebase. This is achieved by querying the "database" InputKeys class.

Attention

As the Configuration is implemented, it does not make sense in practice to have constant instances, because their keys could not be taken and their destruction would lead to an exception being thrown. However, it still makes perfectly sense to have constant methods (think e.g. of a const Configuration& being passed to a function).

Definition at line 276 of file configuration.h.

Classes
struct	FileDoesNotExist
	Thrown if the file does not exist. More...
struct	IncorrectTypeInAssignment
	Thrown when the types in the config file and C++ don't match. More...
struct	ParseError
	Thrown for YAML parse errors. More...
class	Value
	Return type of Configuration::take that automatically determines the target type. More...

Public Types
enum class	GetEmpty { Yes , No }
	Flag to tune method(s) behavior such that it is descriptive from the caller side. More...
enum class	Is { Invalid , Deprecated , Valid }
	Return type of Configuration::validate which conveys more information that simply a two-state boolean variable. More...

Public Member Functions
	Configuration (const std::filesystem::path &path)
	Read config.yaml from the specified path. More...
	Configuration (const std::filesystem::path &path, const std::filesystem::path &filename)
	Read a YAML config file from the specified path. More...
	Configuration (const char *yaml, const char sflag)
	Initialize configuration with a YAML formatted string. More...
	Configuration (const char *yaml)
	Configuration (const Configuration &)=delete
	Prevent Configuration objects from being copied. More...
Configuration &	operator= (const Configuration &)=delete
	Prevent Configuration objects from being copy-assigned. More...
	Configuration (Configuration &&)
	Provide class with move constructor. More...
Configuration &	operator= (Configuration &&)
	Provide class with move assignment operator. More...
	~Configuration () noexcept(false)
	Destroy the object, optionally throwing if not all keys were taken. More...
void	merge_yaml (const std::string &yaml)
	Merge the configuration in yaml into the existing tree. More...
std::vector< std::string >	list_upmost_nodes ()
	Lists all YAML::Nodes from the configuration setup. More...
Value	take (std::initializer_list< const char * > keys)
	The default interface for SMASH to read configuration values. More...
template<typename T >
T	take (std::initializer_list< const char * > keys, T default_value)
Value	read (std::initializer_list< const char * > keys) const
	Additional interface for SMASH to read configuration values without removing them. More...
template<typename T >
T	read (std::initializer_list< const char * > keys, T default_value)
template<typename T >
void	set_value (std::initializer_list< const char * > keys, T &&value)
	Overwrite the value of the specified YAML node. More...
void	remove_all_entries_in_section_but_one (const std::string &key, std::initializer_list< const char * > section={})
	Remove all entries in the given section except for key. More...
Configuration	extract_sub_configuration (std::initializer_list< const char * > keys, Configuration::GetEmpty empty_if_not_existing=Configuration::GetEmpty::No)
	Create a new configuration from a then-removed section of the present object. More...
bool	has_value_including_empty (std::initializer_list< const char * > keys) const
	Return whether there is a (maybe empty) value behind the requested keys. More...
bool	has_value (std::initializer_list< const char * > keys) const
	Return whether there is a non-empty value behind the requested keys. More...
bool	is_empty () const
std::string	to_string () const
	Return a string of the current YAML tree. More...
void	clear ()
	Erase the Configuration content. More...
Is	validate (bool full_validation=true) const
	Validate content of configuration in terms of YAML keys. More...

Static Public Attributes
static const char	InitializeFromYAMLString = 'S'
	Flag to mark initialization with a YAML formatted string. More...

Private Member Functions
	Configuration (const YAML::Node &node)
	Create a subobject that has its root node at the given node. More...
YAML::Node	find_node_creating_it_if_not_existing (std::vector< const char * > keys) const
	Descend in and if needed modify the YAML tree from the given node using the provided keys. More...
std::optional< YAML::Node >	find_existing_node (std::vector< const char * > keys) const
	Descend in the YAML tree from the given node using the provided keys. More...

Private Attributes
YAML::Node	root_node_ {YAML::NodeType::Map}
	The general_config.yaml contents - fully parsed. More...
int	uncaught_exceptions_ {std::uncaught_exceptions()}
	Counter to be able to optionally throw in destructor. More...

Member Enumeration Documentation

GetEmpty

enum smash::Configuration::GetEmpty

strong

Flag to tune method(s) behavior such that it is descriptive from the caller side.

For example, see extract_sub_configuration.

Enumerator
Yes
No

Definition at line 971 of file configuration.h.

{ Yes, No };

Is

enum smash::Configuration::Is

strong

Return type of Configuration::validate which conveys more information that simply a two-state boolean variable.

Enumerator
Invalid
Deprecated
Valid

Definition at line 977 of file configuration.h.

{ Invalid, Deprecated, Valid };

Constructor & Destructor Documentation

Configuration() [1/7]

smash::Configuration::Configuration ( const std::filesystem::path &  path )

explicit

Read config.yaml from the specified path.

Parameters

[in]

path

The directory where the SMASH config files are located.

Definition at line 122 of file configuration.cc.

    : Configuration(path, "config.yaml") {}

Configuration() [2/7]

smash::Configuration::Configuration ( const std::filesystem::path &  path, const std::filesystem::path &  filename  )

explicit

Read a YAML config file from the specified path.

Parameters

[in]	path	The directory where the SMASH config files are located.
[in]	filename	The filename (without path) of the YAML config file, in case you don't want the default "config.yaml".

Definition at line 126 of file configuration.cc.

                                                                {
  const auto file_path = path / filename;
  if (!std::filesystem::exists(file_path)) {
    throw FileDoesNotExist("The configuration file was expected at '" +
                           file_path.native() +
                           "', but the file does not exist.");
  }
  if (has_crlf_line_ending(read_all(std::ifstream((file_path))))) {
    throw std::runtime_error(
        "The configuration file has CR LF line endings. Please use LF "
        "line endings.");
  }
  try {
    root_node_ = YAML::LoadFile(file_path.native());
  } catch (YAML::ParserException &e) {
    if (e.msg == "illegal map value" || e.msg == "end of map not found") {
      const auto line = std::to_string(e.mark.line + 1);
      throw ParseError("YAML parse error at\n" + file_path.native() + ':' +
                       line + ": " + e.msg +
                       " (check that the indentation of map keys matches)");
    }
    throw;
  }
}

Configuration() [3/7]

smash::Configuration::Configuration ( const char *  yaml, const char  sflag  )

inlineexplicit

Initialize configuration with a YAML formatted string.

This is useful in 3-rd party application where we may not be able or willing to read in external files.

Parameters

[in]	yaml	YAML formatted configuration data.
[in]	sflag	control flag InitializeFromYAMLString.

Definition at line 1004 of file configuration.h.

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

Configuration() [4/7]

smash::Configuration::Configuration ( const char *  yaml )

inlineexplicit

Unit tests can use this constructor to get a Configuration object from a built-in string.This function is only available to tests and should never be used/needed in actual SMASH code. The intention is to avoid creating a mock object for Configuration to test other classes of SMASH.

Definition at line 1024 of file configuration.h.

                                           : root_node_(YAML::Load(yaml)) {
    if (root_node_.IsNull())
      root_node_ = YAML::Node{YAML::NodeType::Map};
  }

Configuration() [5/7]

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

delete

Prevent Configuration objects from being copied.

Underneath, the resource is a YAML::Node and since this handles memory in a similar way as a pointer would do, copying an object would make several instances point to the same memory and it would make it difficult to use this object correctly. Therefore, copies are not allowed.

Configuration() [6/7]

smash::Configuration::Configuration

(

Configuration &&

other

)

Provide class with move constructor.

In contrast to copying, moving is fine, since this keeps the owner of the resource unique.

Note

Since the class has the peculiar behavior that all keys must be parsed before it gets destroyed (otherwise an exception is thrown), it is important to manually implement the move operations, in order to ensure that objects that are moved from result cleared and their destruction is not leading to any throw. This is not guaranteed if the special members are defaulted to the compiler generated versions.

Definition at line 152 of file configuration.cc.

    : root_node_(std::move(other.root_node_)),
      uncaught_exceptions_(std::move(other.uncaught_exceptions_)) {
  other.root_node_.reset();
  other.uncaught_exceptions_ = 0;
}

~Configuration()

smash::Configuration::~Configuration ( )

noexcept

Destroy the object, optionally throwing if not all keys were taken.

This is a way to enforce that the object has to be consumed (i.e. completely parsed) during its lifetime. Since this object might be destructed during stack unwinding, the destructor has to throw only if it is safe to do so and the uncaught_exceptions_ member is used to properly implement this behavior.

Definition at line 170 of file configuration.cc.

                                              {
  // Make sure that stack unwinding is not taking place befor throwing
  if (std::uncaught_exceptions() == uncaught_exceptions_) {
    // In this scenario is fine to throw
    if (root_node_.size() != 0) {
      throw std::logic_error(
          "Configuration object destroyed with unused keys:\n" + to_string());
    }
  }
  /* If this destructor is called during stack unwinding, it is irrelevant
     that the Configuration has not be completely parsed. */
}

Configuration() [7/7]

smash::Configuration::Configuration ( const YAML::Node &  node )

inlineprivate

Create a subobject that has its root node at the given node.

Note

This constructor is not explicit because it can be called only from inside Configuration and by making it explicit a return would require the copy constructor.

Definition at line 1272 of file configuration.h.

      : root_node_(YAML::Clone(node)) {}

Member Function Documentation

operator=() [1/2]

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

delete

Prevent Configuration objects from being copy-assigned.

See copy constructor Configuration(const Configuration &) for more information.

operator=() [2/2]

Configuration & smash::Configuration::operator=

(

Configuration &&

other

)

Provide class with move assignment operator.

See move constructor Configuration(Configuration &&) for more information.

Definition at line 159 of file configuration.cc.

                                                             {
  // YAML does not offer != operator between nodes
  if (!(root_node_ == other.root_node_)) {
    root_node_ = std::move(other.root_node_);
    uncaught_exceptions_ = std::move(other.uncaught_exceptions_);
    other.root_node_.reset();
    other.uncaught_exceptions_ = 0;
  }
  return *this;
}

merge_yaml()

void smash::Configuration::merge_yaml

(

const std::string &

yaml

)

Merge the configuration in yaml into the existing tree.

The function parses the string in yaml into its internal tree representation. Then it merges the nodes from the new tree into the existing tree. The merge resolves conflicts by taking the value from yaml.

Parameters

[in]

yaml

A string with YAML (or JSON) content that is to be merged.

Definition at line 183 of file configuration.cc.

                                                    {
  try {
    root_node_ |= YAML::Load(yaml);
  } catch (YAML::ParserException &e) {
    if (e.msg == "illegal map value" || e.msg == "end of map not found") {
      const auto line = std::to_string(e.mark.line + 1);
      throw ParseError("YAML parse error in:\n" + yaml + "\nat line " + line +
                       ": " + e.msg +
                       " (check that the indentation of map keys matches)");
    }
    throw;
  }
}

list_upmost_nodes()

std::vector< std::string > smash::Configuration::list_upmost_nodes

(

)

Lists all YAML::Nodes from the configuration setup.

Definition at line 197 of file configuration.cc.

                                                      {
  std::vector<std::string> r;
  r.reserve(root_node_.size());
  for (auto i : root_node_) {
    r.emplace_back(i.first.Scalar());
  }
  return r;
}

take() [1/2]

Configuration::Value smash::Configuration::take

(

std::initializer_list< const char * >

keys

)

The default interface for SMASH to read configuration values.

The function returns the value at the specified keys and removes it from the Configuration object. Therefore, a subsequent call to take or has_value with the same keys returns an undefined value / false. By removing the value, the Configuration object keeps track which settings were never read.

Note

If taking a key leaves the parent key without a value, then this is in turn removed and so on. From a performance point of view, it might be argued that this is not needed to be checkend and done at every take operation and it might be done once for all. However, on one hand it is a natural behaviour to expect and on the other hand this is hardly going to be an application bottle-neck.

Parameters

[in]

keys

You can pass an arbitrary number of keys inside curly braces, following the nesting structure in the config file. For example, given Group: Key: Value call string value = config.take({"Group", "Key"}); to read the value. This will make the key "Group" also be removed from the configuration, since it remains without any value.

Returns

A proxy object that converts to the correct type automatically on assignment.

Definition at line 206 of file configuration.cc.

                                            {
  assert(keys.size() > 0);
  /* Here we want to descend the YAML tree but not all the way to the last key,
     because we need the node associated to the previous to last key in order to
     remove the taken key. */
  auto last_key_it = keys.end() - 1;
  auto previous_to_last_node = find_existing_node({keys.begin(), last_key_it});
  auto to_be_returned{previous_to_last_node};
  descend_one_existing_level(to_be_returned, *last_key_it);
  if (!previous_to_last_node || !to_be_returned) {
    throw std::invalid_argument(
        "Attempt to take value of a not existing key: " + join_quoted(keys));
  }
  previous_to_last_node.value().remove(*last_key_it);
  root_node_ = remove_empty_maps(root_node_);
  return {to_be_returned.value(), *last_key_it};
}

take() [2/2]

template<typename T >

T smash::Configuration::take ( std::initializer_list< const char * >  keys, T  default_value  )

inline

See also

take

Definition at line 1129 of file configuration.h.

                                                                  {
    if (has_value(keys)) {
      return take(keys);
    }
    return default_value;
  }

read() [1/2]

Configuration::Value smash::Configuration::read

(

std::initializer_list< const char * >

keys

)

const

Additional interface for SMASH to read configuration values without removing them.

The function returns the value at the specified keys but does not remove it from the Configuration object. Semantically, this means the value was not used.

Parameters

[in]

keys

You can pass an arbitrary number of keys inside curly braces, following the nesting structure in the config file.

Returns

A proxy object that converts to the correct type automatically on assignment.

Definition at line 225 of file configuration.cc.

                                                  {
  auto found_node = find_existing_node(keys);
  if (found_node) {
    return {found_node.value(), keys.begin()[keys.size() - 1]};
  } else {
    throw std::invalid_argument(
        "Attempt to read value of a not existing key: " + join_quoted(keys));
  }
}

read() [2/2]

template<typename T >

T smash::Configuration::read ( std::initializer_list< const char * >  keys, T  default_value  )

inline

See also

read

Definition at line 1154 of file configuration.h.

                                                                  {
    if (has_value(keys)) {
      return read(keys);
    }
    return default_value;
  }

set_value()

template<typename T >

void smash::Configuration::set_value ( std::initializer_list< const char * >  keys, T &&  value  )

inline

Overwrite the value of the specified YAML node.

Parameters

[in]	keys	You can pass an arbitrary number of keys inside curly braces, following the nesting structure in the config file.
[in]	value	An arbitrary value that yaml-cpp can convert into YAML representation. Any builtin type, strings, maps, and vectors can be used here.

Definition at line 1171 of file configuration.h.

                                                                    {
    auto node = find_node_creating_it_if_not_existing(keys);
    node = std::forward<T>(value);
  }

remove_all_entries_in_section_but_one()

void smash::Configuration::remove_all_entries_in_section_but_one	(	const std::string &	key,
		std::initializer_list< const char * >	section = {}
	)

Remove all entries in the given section except for key.

Parameters

[in]	key	The key of the map entry to keep.
[in]	section	You can pass an arbitrary number of keys inside curly braces, following the nesting structure in the config file, in order to specify the section where to delete entries. Omitting the section is equivalent to specifying {} and the top-level section is understood.

Definition at line 236 of file configuration.cc.

                                                                     {
  auto found_node = find_existing_node(section);
  if (found_node) {
    std::vector<std::string> to_remove{};
    bool key_exists = false;
    for (auto i : found_node.value()) {
      if (i.first.Scalar() != key) {
        to_remove.push_back(i.first.Scalar());
      } else {
        key_exists = true;
      }
    }
    if (!key_exists) {
      std::string section_string{" section "};
      if (section.size() > 0) {
        section_string += join_quoted(section) + " ";
      } else {
        section_string = " top-level" + section_string;
      }
      throw std::invalid_argument("Attempt to remove all keys in" +
                                  section_string +
                                  "except not existing one: \"" + key + "\"");
    } else {
      for (auto i : to_remove) {
        found_node.value().remove(i);
      }
    }
  } else {
    throw std::invalid_argument(
        "Attempt to remove entries in not existing section: " +
        join_quoted(section));
  }
}

extract_sub_configuration()

Configuration smash::Configuration::extract_sub_configuration	(	std::initializer_list< const char * >	keys,
		Configuration::GetEmpty	empty_if_not_existing = Configuration::GetEmpty::No
	)

Create a new configuration from a then-removed section of the present object.

This method is meant to be used to deal with sections only, i.e. it will throw if used to extract a key value that is not a section (namely a map in YAML language). Use take for that purpose, instead.

Parameters

[in]	keys	You can pass an arbitrary number of keys inside curly braces, following the nesting structure in the config file.
[in]	empty_if_not_existing	Specify Configuration::GetEmpty::Yes if you want an empty Configuration in case the requested section does not exist.

Exceptions

std::runtime_error

if the method is used to access a scalar or sequence value; to access a key that has no value or is an empty map; to access a not existing key (unless explicitly allowed).

Returns

A new Configuration containing the chosen section.

Definition at line 271 of file configuration.cc.

                                                 {
  // Same logic as in take method
  assert(keys.size() > 0);
  auto last_key_it = keys.end() - 1;
  auto previous_to_section_node =
      find_existing_node({keys.begin(), last_key_it});
  auto sub_conf_root_node{previous_to_section_node};
  descend_one_existing_level(sub_conf_root_node, *last_key_it);
  if (!previous_to_section_node || !sub_conf_root_node) {
    if (empty_if_not_existing == Configuration::GetEmpty::Yes)
      return Configuration(YAML::Node{});
    else
      throw std::runtime_error("Attempt to extract not existing section " +
                               join_quoted(keys));
  }
  /* Here sub_conf_root_node cannot be a nullopt, since if it was the function
     would have returned before and it cannot be that previous_to_section_node
     is nullopt and sub_conf_root_node is not */
  else if (sub_conf_root_node->IsNull() ||  // NOLINT[whitespace/newline]
           (sub_conf_root_node->IsMap() && sub_conf_root_node->size() == 0)) {
    // Here we put together the cases of a key without value or with
    // an empty map {} as value (no need at the moment to distinguish)
    throw std::runtime_error("Attempt to extract empty section " +
                             join_quoted(keys));
  } else if (sub_conf_root_node->IsMap() && sub_conf_root_node->size() != 0) {
    Configuration sub_config{*sub_conf_root_node};
    previous_to_section_node->remove(*last_key_it);
    root_node_ = remove_empty_maps(root_node_);
    return sub_config;
  } else {  // sequence or scalar or any future new YAML type
    throw std::runtime_error("Tried to extract configuration section at " +
                             join_quoted(keys) +
                             " to get a key value. Use take instead!");
  }
}

has_value_including_empty()

bool smash::Configuration::has_value_including_empty

(

std::initializer_list< const char * >

keys

)

const

Return whether there is a (maybe empty) value behind the requested keys.

Parameters

[in]

keys

List of keys to be checked for

Definition at line 309 of file configuration.cc.

                                                  {
  const auto found_node = find_existing_node(keys);
  return found_node.has_value();
}

has_value()

bool smash::Configuration::has_value

(

std::initializer_list< const char * >

keys

)

const

Return whether there is a non-empty value behind the requested keys.

Parameters

[in]

keys

List of keys to be checked for

Definition at line 315 of file configuration.cc.

                                                                          {
  const auto found_node = find_existing_node(keys);
  return found_node.has_value() && !(found_node.value().IsNull());
}

is_empty()

bool smash::Configuration::is_empty ( ) const

inline

Returns

true if the object is empty;

false if at least one key exists.

Definition at line 1230 of file configuration.h.

{ return root_node_.size() == 0; }

to_string()

std::string smash::Configuration::to_string

(

)

const

Return a string of the current YAML tree.

Definition at line 320 of file configuration.cc.

                                         {
  std::stringstream s;
  s << root_node_;
  return s.str();
}

clear()

void smash::Configuration::clear ( )

inline

Erase the Configuration content.

This function is useful e.g. in tests to clean up not taken keys that would trigger an exception being thrown at by the destructor.

Definition at line 1243 of file configuration.h.

{ root_node_.reset(); }

validate()

Configuration::Is smash::Configuration::validate

(

bool

full_validation = true

)

const

Validate content of configuration in terms of YAML keys.

A warning or error message is printed for deprecated or invalid keys, respectively, together with information about SMASH versions, if possible.

Note

Here a full validation is done by default and all keys are checked, although the validation might be shortened by returning false as soon as an invalid key is found. However, a full validation is more user-friendly, since as much information as possible about the input file is provided.

Parameters

[in]

full_validation

Whether all keys are checked or not.

Returns

Is::Valid if the object contains valid keys only;

Is::Deprecated if the object is valid but has deprecated key(s);

Is::Invalid if the object contains at least one invalid key.

Definition at line 585 of file configuration.cc.

                                                                  {
  auto list = get_list_of_labels_per_key_in_yaml_tree(root_node_);
  adjust_list_of_labels_dealing_with_keys_taken_as_maps(list);
  Is validation_result{Is::Valid};
  for (const auto &key_labels : list) {
    Is key_state = validate_key(key_labels);
    if (full_validation) {
      accumulate_validation(validation_result, key_state);
    } else {
      if (key_state != Is::Valid)
        return key_state;
    }
  }
  return validation_result;
}

find_node_creating_it_if_not_existing()

YAML::Node smash::Configuration::find_node_creating_it_if_not_existing ( std::vector< const char * >  keys ) const

private

Descend in and if needed modify the YAML tree from the given node using the provided keys.

After this call nodes corresponding to the passed keys are guaranteed to exist in the tree.

Parameters

[in]

keys

Keys that will be possibly added to the YAML tree.

Returns

Node in the tree reached by using the provided keys.

Definition at line 339 of file configuration.cc.

                                        {
  assert(keys.size() > 0);
  YAML::Node node{root_node_};
  for (const auto &key : keys) {
    // See comments in descend_one_existing_level function
    node.reset(node[key]);
  }
  return node;
}

find_existing_node()

std::optional< YAML::Node > smash::Configuration::find_existing_node ( std::vector< const char * >  keys ) const

private

Descend in the YAML tree from the given node using the provided keys.

This function must not use the YAML::Node subscript operator, which is at the very bottom level creating an undefined node in the YAML tree, hence "wasting" some memory. Note that the fact that this method is marked as const does not forbid to use the access operator on root_node_, because of how the YAML library works. We want the tree to be completely untouched by this method.

Parameters

[in]

keys

Keys that will be used to descend the YAML tree.

Returns

std::optional<YAML::Node> containing the node in the tree reached by using the provided keys, if it exists;

std::nullopt otherwise.

Note

It has been decided to return an optional value rather than throwing an exception because this method is going to be used in other methods like has_value and putting there a try-catch block would probably cause a performance cost that can be avoided (exceptions on the exceptional path are expensive).

Definition at line 326 of file configuration.cc.

                                        {
  /* Here we do not assert(keys.size()>0) and allow to pass in an empty vector,
     in which case the passed in YAML:Node is simply returned. This might happen
     e.g. in the take or extract_sub_configuration methods if called with a
     label of a key at top level of the configuration file. */
  std::optional<YAML::Node> node{root_node_};
  for (const auto &key : keys) {
    descend_one_existing_level(node, key);
  }
  return node;
}

Member Data Documentation

InitializeFromYAMLString

const char smash::Configuration::InitializeFromYAMLString = 'S'

static

Flag to mark initialization with a YAML formatted string.

Definition at line 965 of file configuration.h.

root_node_

YAML::Node smash::Configuration::root_node_ {YAML::NodeType::Map}

private

The general_config.yaml contents - fully parsed.

Definition at line 1315 of file configuration.h.

uncaught_exceptions_

int smash::Configuration::uncaught_exceptions_ {std::uncaught_exceptions()}

private

Counter to be able to optionally throw in destructor.

Definition at line 1318 of file configuration.h.

---

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

• src/include/smash/configuration.h
• src/configuration.cc