smash::anonymous_namespace{configuration.cc} Namespace Reference

Classes
struct	IsStdMap
	A utility type to be specialized to check if a type is a std::map . More...
struct	IsStdMap< std::map< MapKey, MapValue > >
	A specialization of IsStdMap<T> for cases where the boolean value should be set to true. More...

Functions
void	descend_one_existing_level (std::optional< YAML::Node > &node, std::string_view key)
	Reset the passed in node to that one at the provided key, which is expected to exist in the node. More...
YAML::Node	remove_empty_maps (YAML::Node root)
	Remove all empty maps of a YAML::Node. More...
YAML::Node	operator|= (YAML::Node a, const YAML::Node &b)
	Merge two YAML::Nodes. More...
std::string	join_quoted (std::vector< std::string_view > keys)
	Build a string with a list of keys as specified in the code. More...
void	fill_list_of_labels_per_key_in_yaml_tree (const YAML::Node &root_node, std::vector< KeyLabels > &list, KeyLabels &new_list_entry)
	Implementation of the algorithm to translate a YAML tree into lists of labels, each identifying a key from the YAML root node. More...
auto	get_list_of_labels_per_key_in_yaml_tree (const YAML::Node &root_node)
	Create a list of lists of key labels present in the passed YAML node considered to be the root one of a YAML tree. More...
auto	collect_input_keys_taken_as_maps ()
	Extract from the InputKeys database the labels of keys that have a std::map as type. More...
void	adjust_list_of_labels_dealing_with_keys_taken_as_maps (std::vector< KeyLabels > &list_of_input_key_labels)
	Remove last labels of keys that are taken as maps in SMASH and remove duplicates from the resulting list. More...
Configuration::Is	validate_key (const KeyLabels &labels)
	Given some YAML labels (assumed to be in order from the top section), it is checked whether any valid SMASH key with the same key exists. More...
void	accumulate_validation (Configuration::Is &result_so_far, Configuration::Is new_value)
	Utility function to accumulate validation results of keys. More...

Function Documentation

descend_one_existing_level()

void smash::anonymous_namespace{configuration.cc}::descend_one_existing_level	(	std::optional< YAML::Node > &	node,
		std::string_view	key
	)

Reset the passed in node to that one at the provided key, which is expected to exist in the node.

If this is not the case, the node is set to std::nullopt.

Parameters

[in,out]	node	An optional node to be reset.
[in]	key	The key expected to exist in the given node.

Definition at line 40 of file configuration.cc.

                                                    {
  if (node) {
    for (const auto &section : node.value()) {
      /* Two remarks:
           1) The Node::operator[] creates an undefined node in the YAML tree if
              the node corresponding to the passed key does not exist and hence
              in this function, which descend one level which is expected to
              exist, we need to use it only if we are sure the node exists.
           2) Node::reset does what you might expect Node::operator= to do. But
              operator= assigns a value to the node and so
                 node = node[key]
              would lead to a further modification of the data structure and
              this function would not be simply traversal. Note that node and
              root_node_ point to the same memory and modification to the first
              would affect the second, too. */
      if (section.first.Scalar() == key) {
        node.value().reset(node.value()[key]);
        return;
      }
    }
    node = std::nullopt;
  }
}

remove_empty_maps()

YAML::Node smash::anonymous_namespace{configuration.cc}::remove_empty_maps

(

YAML::Node

root

)

Remove all empty maps of a YAML::Node.

Parameters

[in]

root

YAML::Node that contains empty maps.

Returns

YAML::Node from above without empty maps.

Definition at line 71 of file configuration.cc.

                                          {
  if (root.IsMap()) {
    std::vector<std::string> to_remove(root.size());
    for (auto n : root) {
      remove_empty_maps(n.second);
      // If the node is an empty sequence, we do NOT remove it!
      if (n.second.IsMap() && n.second.size() == 0) {
        to_remove.emplace_back(n.first.Scalar());
      }
    }
    for (const auto &key : to_remove) {
      root.remove(key);
    }
  }
  return root;
}

operator|=()

YAML::Node smash::anonymous_namespace{configuration.cc}::operator|=	(	YAML::Node	a,
		const YAML::Node &	b
	)

Merge two YAML::Nodes.

Parameters

[in]	a	YAML::Node into which b is merged.
[in]	b	YAML::Node that is merged into a.

Returns

YAML::Node which is the merge of a and b.

Definition at line 95 of file configuration.cc.

                                                   {
  if (b.IsMap()) {
    for (auto n0 : b) {
      a[n0.first.Scalar()] |= n0.second;
    }
  } else {
    a = b;
  }
  return a;
}

join_quoted()

std::string smash::anonymous_namespace{configuration.cc}::join_quoted

(

std::vector< std::string_view >

keys

)

Build a string with a list of keys as specified in the code.

Parameters

keys	The list of keys.

Returns

A std::string with the desired result.

Definition at line 112 of file configuration.cc.

                                                      {
  return std::accumulate(keys.begin(), keys.end(), std::string{"{"},
                         [](const std::string &ss, const std::string_view &s) {
                           return ss + ((ss.size() == 1) ? "\"" : ", \"") +
                                  std::string{s} +  // NOLINT(whitespace/braces)
                                  "\"";
                         }) +
         "}";
}

fill_list_of_labels_per_key_in_yaml_tree()

void smash::anonymous_namespace{configuration.cc}::fill_list_of_labels_per_key_in_yaml_tree	(	const YAML::Node &	root_node,
		std::vector< KeyLabels > &	list,
		KeyLabels &	new_list_entry
	)

Implementation of the algorithm to translate a YAML tree into lists of labels, each identifying a key from the YAML root node.

Since the level of nesting sections in a YAML input file is arbitrary, this is a typical task to be solved using recursion. The main idea here is to take advantage of YAML functionality and in particular of the possibility to iterate over trees and test for nature of a node (is it a Map or not?). Roughly speaking, from the tree top-level all upmost nodes are extracted and for each of them, recursively, the same procedure is done over and over again if they are maps. If a non-map node is found, i.e. a key value is found, then recursion ends and a new entry is added to list .

Parameters

[in]	root_node	The root YAML node to extract from.
[in,out]	list	The list of lists of labels to be filled.
[in,out]	new_list_entry	New list of labels in process to be filled during recursion.

Definition at line 410 of file configuration.cc.

                                                                         {
  // Here sub_node is an iterator value, i.e. a key/value pair of nodes,
  // not a single YAML node (that's how YAML library works)
  for (const auto &sub_node : root_node) {
    new_list_entry.push_back(sub_node.first.as<std::string>());
    if (sub_node.second.IsMap())
      fill_list_of_labels_per_key_in_yaml_tree(sub_node.second, list,
                                               new_list_entry);
    else
      list.push_back(new_list_entry);
    new_list_entry.pop_back();
  }
}

get_list_of_labels_per_key_in_yaml_tree()

auto smash::anonymous_namespace{configuration.cc}::get_list_of_labels_per_key_in_yaml_tree

(

const YAML::Node &

root_node

)

Create a list of lists of key labels present in the passed YAML node considered to be the root one of a YAML tree.

Given a YAML::Node, for each key having a value, all labels to reach the given key from the passed node are collected and a std::vector containing them is built and inserted into the given list. This function is calling the actual implementation preparing auxiliary needed variables.

Parameters

[in]

root_node

The root node of the YAML tree to be considered.

Returns

A std::vector<KeyLabels> containing the desired information.

Definition at line 439 of file configuration.cc.

                                                                        {
  std::vector<KeyLabels> list{};
  KeyLabels aux{};
  fill_list_of_labels_per_key_in_yaml_tree(root_node, list, aux);
  return list;
}

collect_input_keys_taken_as_maps()

auto smash::anonymous_namespace{configuration.cc}::collect_input_keys_taken_as_maps

(

)

Extract from the InputKeys database the labels of keys that have a std::map as type.

Returns

A list of key labels.

Definition at line 483 of file configuration.cc.

                                        {
  std::vector<KeyLabels> labels_of_keys_taken_as_map{};
  for (const auto &keys_variant : smash::InputKeys::list) {
    std::visit(
        [&labels_of_keys_taken_as_map](auto &&var) {
          /*
           * The following if checks if the SMASH input key has a map as value
           * and it deserves some explanation about the type extraction:
           *
           *   - arg -> object of type: std::cref(const Key<T>)
           *   - arg.get() -> object of type: const Key<T>&
           *   - decltype(arg.get()) ->  type: const Key<T>&
           *   - std::decay_t<decltype(arg.get())>::type -> type: Key<T>
           *   - std::decay_t<decltype(arg.get())>::type::value -> type: T
           */
          if constexpr (IsStdMap<typename std::decay_t<
                            decltype(var.get())>::type>::value)
            labels_of_keys_taken_as_map.push_back(var.get().labels());
        },
        keys_variant);
  }
  return labels_of_keys_taken_as_map;
}

adjust_list_of_labels_dealing_with_keys_taken_as_maps()

void smash::anonymous_namespace{configuration.cc}::adjust_list_of_labels_dealing_with_keys_taken_as_maps

(

std::vector< KeyLabels > &

list_of_input_key_labels

)

Remove last labels of keys that are taken as maps in SMASH and remove duplicates from the resulting list.

The keys that are taken as maps in SMASH are here collected using the database InputKeys and the list of keys contained in the configuration must be adjusted by hand. This is a corner case, since YAML nodes that are maps are by definition sections and cannot be distinguished from keys "with a map value" in the recursive process to create the list of key labels.

Parameters

[in,out]

list_of_input_key_labels

The list of key labels to adjust.

Definition at line 519 of file configuration.cc.

                                                    {
  const std::vector<KeyLabels> labels_of_keys_taken_as_map =
      collect_input_keys_taken_as_maps();
  for (const auto &labels : labels_of_keys_taken_as_map) {
    std::for_each(list_of_input_key_labels.begin(),
                  list_of_input_key_labels.end(),
                  [&labels](KeyLabels &labels_of_input_key) {
                    if (std::equal(labels.begin(), labels.end(),
                                   labels_of_input_key.begin(),
                                   labels_of_input_key.begin() + labels.size()))
                      labels_of_input_key = labels;
                  });
  }
  // The identical keys in list are now next to each other and we do
  // not need/want to sort the list before calling std::unique.
  list_of_input_key_labels.erase(std::unique(list_of_input_key_labels.begin(),
                                             list_of_input_key_labels.end()),
                                 list_of_input_key_labels.end());
}

validate_key()

Configuration::Is smash::anonymous_namespace{configuration.cc}::validate_key

(

const KeyLabels &

labels

)

Given some YAML labels (assumed to be in order from the top section), it is checked whether any valid SMASH key with the same key exists.

All possible checks are done in a way such that the user is informed about

• if the key has never been valid;
• if the key was valid in the past but it has been removed;
• if the key is valid but deprecated.

Parameters

[in]

labels

The series of labels identifying the key.

Returns

Configuration::Is::Valid if the key is valid;

Configuration::Is::Deprecated if the key is Deprecated and

Configuration::Is::Invalid if the key is invalid.

Definition at line 555 of file configuration.cc.

                                                      {
  auto key_ref_var_it = std::find_if(
      smash::InputKeys::list.begin(), smash::InputKeys::list.end(),
      [&labels](auto key) {
        return std::visit(
            [&labels](auto &&arg) { return arg.get().has_same_labels(labels); },
            key);
      });
  if (key_ref_var_it == smash::InputKeys::list.end()) {
    logg[LConfiguration].error("Key ", smash::quote(smash::join(labels, ": ")),
                               " is not a valid SMASH input key.");
    return Configuration::Is::Invalid;
  }
 
  smash::InputKeys::key_references_variant found_variant = *key_ref_var_it;
  const auto key_labels =
      std::visit([](auto &&var) { return static_cast<std::string>(var.get()); },
                 found_variant);
 
  if (std::visit([](auto &&var) { return !var.get().is_allowed(); },
                 found_variant)) {
    const auto v_removal = std::visit(
        [](auto &&var) { return var.get().removed_in(); }, found_variant);
    logg[LConfiguration].error("Key ", key_labels,
                               " has been removed in version ", v_removal,
                               " and it is not valid anymore.");
    return Configuration::Is::Invalid;
  }
  if (std::visit([](auto &&var) { return var.get().is_deprecated(); },
                 found_variant)) {
    const auto v_deprecation = std::visit(
        [](auto &&var) { return var.get().deprecated_in(); }, found_variant);
    logg[LConfiguration].warn(
        "Key ", key_labels, " has been deprecated in version ", v_deprecation);
    return Configuration::Is::Deprecated;
  } else {
    logg[LConfiguration].debug("Key ", key_labels, " is valid!");
    return Configuration::Is::Valid;
  }
}

accumulate_validation()

void smash::anonymous_namespace{configuration.cc}::accumulate_validation	(	Configuration::Is &	result_so_far,
		Configuration::Is	new_value
	)

Utility function to accumulate validation results of keys.

This is basically the logic needed to make a full validation of a configuration, considered that we have three possible states. It extend the logical AND between two boolean values.

Parameters

[in,out]	result_so_far	Status of the configuration so far to be combined with the new key state.
[in]	new_value	New key state to be considered.

Definition at line 607 of file configuration.cc.

                                                      {
  switch (result_so_far) {
    case Configuration::Is::Invalid:
      break;
    case Configuration::Is::Deprecated:
      if (new_value != Configuration::Is::Valid) {
        result_so_far = new_value;
      }
      break;
    case Configuration::Is::Valid:
      result_so_far = new_value;
      break;
  }
}