YamlHelper.h File Reference

Utility functions for handling YAML nodes. More...

#include <iostream>
#include <fstream>
#include <string>
#include <cxxabi.h>
#include <regex>
#include "Manager/MaCh3Exception.h"
#include "Manager/Core.h"
#include "TMacro.h"
#include "TList.h"
#include "TObjString.h"
#include "yaml-cpp/yaml.h"

Include dependency graph for YamlHelper.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	M3OpenConfig(filename)   LoadYamlConfig((filename), __FILE__, __LINE__)
	Macro to simplify calling LoadYaml with file and line info. More...
#define	GetBounds(filename)   ParseBounds((filename), __FILE__, __LINE__)
#define	Get2DBounds(filename)   Parse2DBounds((filename), __FILE__, __LINE__)

Functions
template<typename T >
bool	CheckNodeExistsHelper (const T &node)
	Use this like this CheckNodeExists(config, "LikelihoodOptions", "TestStatistic"); KS: Base case for recursion. More...
template<typename T , typename... Args>
bool	CheckNodeExistsHelper (const T &node, const std::string &key, Args... args)
	KS: Recursive function to traverse YAML nodes. More...
template<typename... Args>
bool	CheckNodeExists (const YAML::Node &node, Args... args)
	KS: Wrapper function to call the recursive helper. More...
template<typename T >
T	FindFromManagerHelper (const YAML::Node &node)
template<typename T , typename... Args>
T	FindFromManagerHelper (const YAML::Node &node, const std::string &key, Args... args)
	Recursive function to traverse YAML nodes. More...
template<typename T , typename... Args>
T	FindFromManager (const YAML::Node &node, Args... args)
	Wrapper function to call the recursive helper. More...
YAML::Node	STRINGtoYAML (const std::string &yaml_string)
	Function to convert a YAML string to a YAML node. More...
std::string	YAMLtoSTRING (const YAML::Node &node)
	KS: Convert a YAML node to a string representation. More...
std::string	TMacroToString (const TMacro &macro)
	KS: Convert a ROOT TMacro object to a string representation. More...
YAML::Node	TMacroToYAML (const TMacro &macro)
	KS: Convert a ROOT TMacro object to a YAML node. More...
TMacro	YAMLtoTMacro (const YAML::Node &yaml_node, const std::string &name)
	Convert a YAML node to a ROOT TMacro object. More...
bool	compareYAMLNodes (const YAML::Node &node1, const YAML::Node &node2)
	Compare if yaml nodes are identical. More...
template<typename TValue >
void	OverrideConfig (YAML::Node node, std::string const &key, TValue val)
	Overrides the configuration settings based on provided arguments. More...
template<typename... Args>
void	OverrideConfig (YAML::Node node, std::string const &key, Args... args)
	Overrides the configuration settings based on provided arguments. More...
std::string	DemangleTypeName (const std::string &mangledName)
	Function to demangle type names. More...
template<typename Type >
Type	Get (const YAML::Node &node, const std::string File, const int Line)
	Get content of config file. More...
template<typename Type >
Type	GetFromManager (const YAML::Node &node, Type defval, const std::string File="", const int Line=1)
	Get content of config file if node is not found take default value specified. More...
YAML::Node	LoadYamlConfig (const std::string &filename, const std::string &File, const int Line)
	Open YAML file. More...
const YAML::Node &	Cnode (const YAML::Node &n)
	KS: Convenience wrapper to return a YAML node as-is. More...
YAML::Node	MergeNodes (YAML::Node a, YAML::Node b)
	KS: Recursively merges two YAML nodes. More...
std::vector< double >	ParseBounds (const YAML::Node &node, const std::string &File, const int Line)
	KS: Get bounds from YAML for example for selection cuts. More...
std::vector< std::vector< double > >	Parse2DBounds (const YAML::Node &node, const std::string &File, const int Line)
	KS: Get 2D bounds from YAML for example for selection cuts. More...

Detailed Description

Utility functions for handling YAML nodes.

Note

you can read more about Yaml: here

Author

Kamil Skwarczynski

Luke Pickering

Definition in file YamlHelper.h.

Macro Definition Documentation

Get2DBounds

#define Get2DBounds

(

filename

)

Parse2DBounds((filename), __FILE__, __LINE__)

Definition at line 563 of file YamlHelper.h.

GetBounds

#define GetBounds

(

filename

)

ParseBounds((filename), __FILE__, __LINE__)

Definition at line 562 of file YamlHelper.h.

M3OpenConfig

#define M3OpenConfig

(

filename

)

LoadYamlConfig((filename), __FILE__, __LINE__)

Macro to simplify calling LoadYaml with file and line info.

Definition at line 561 of file YamlHelper.h.

Function Documentation

CheckNodeExists()

template<typename... Args>

bool CheckNodeExists	(	const YAML::Node &	node,
		Args...	args
	)

KS: Wrapper function to call the recursive helper.

Definition at line 55 of file YamlHelper.h.

                                                         {
// **********************
  return CheckNodeExistsHelper(node, args...);
}

CheckNodeExistsHelper() [1/2]

template<typename T >

bool CheckNodeExistsHelper

(

const T &

node

)

Use this like this CheckNodeExists(config, "LikelihoodOptions", "TestStatistic"); KS: Base case for recursion.

Definition at line 34 of file YamlHelper.h.

                                          {
// **********************
  (void)node;
  return true; // Node exists, return true
}

CheckNodeExistsHelper() [2/2]

template<typename T , typename... Args>

bool CheckNodeExistsHelper	(	const T &	node,
		const std::string &	key,
		Args...	args
	)

KS: Recursive function to traverse YAML nodes.

Definition at line 43 of file YamlHelper.h.

                                                                              {\
// **********************
  if (!node[key]) {
    //std::cerr << "Node " << key << " doesn't exist." << std::endl;
    return false;
  }
  return CheckNodeExistsHelper(node[key], args...);
}

Cnode()

const YAML::Node& Cnode ( const YAML::Node &  n )

inline

KS: Convenience wrapper to return a YAML node as-is.

Parameters

n	Input YAML node.

Returns

Reference to the same YAML node.

Definition at line 390 of file YamlHelper.h.

                                                 {
// **********************
  return n;
}

compareYAMLNodes()

bool compareYAMLNodes ( const YAML::Node &  node1, const YAML::Node &  node2  )

inline

Compare if yaml nodes are identical.

Parameters

node1	The first YAML node to compare.
node2	The second YAML node to compare.

Returns

true If the two nodes are equivalent in type and content.

false If the two nodes differ in structure or content.

Definition at line 180 of file YamlHelper.h.

                                                                           {
// **********************
  // Check if the types of the nodes match
  if (node1.Type() != node2.Type()) {
    return false;
  }
 
  // Compare scalar types (like strings, numbers)
  if (node1.IsScalar() && node2.IsScalar()) {
    return node1.as<std::string>() == node2.as<std::string>();
  }
 
  // Compare sequences (like YAML lists)
  if (node1.IsSequence() && node2.IsSequence()) {
    if (node1.size() != node2.size()) {
      return false;
    }
    for (std::size_t i = 0; i < node1.size(); ++i) {
      if (!compareYAMLNodes(node1[i], node2[i])) {
        return false;
      }
    }
    return true;
  }
 
  // Compare maps (like YAML dictionaries)
  if (node1.IsMap() && node2.IsMap()) {
    if (node1.size() != node2.size()) {
      return false;
    }
    for (auto it1 = node1.begin(); it1 != node1.end(); ++it1) {
      auto key = it1->first.as<std::string>();
      if (!node2[key] || !compareYAMLNodes(it1->second, node2[key])) {
        return false;
      }
    }
    return true;
  }
 
  // Default case: if it's neither scalar, sequence, nor map, consider it unequal
  return false;
}

DemangleTypeName()

std::string DemangleTypeName ( const std::string &  mangledName )

inline

Function to demangle type names.

Definition at line 253 of file YamlHelper.h.

                                                                {
// **********************
  int status = 0;
  char* demangledName = abi::__cxa_demangle(mangledName.c_str(), nullptr, nullptr, &status);
  std::string result = (status == 0) ? demangledName : mangledName;
  free(demangledName);
  return result;
}

FindFromManager()

template<typename T , typename... Args>

T FindFromManager	(	const YAML::Node &	node,
		Args...	args
	)

Wrapper function to call the recursive helper.

Definition at line 84 of file YamlHelper.h.

                                                      {
// **********************
  return FindFromManagerHelper<T>(node, args...);
}

FindFromManagerHelper() [1/2]

template<typename T >

T FindFromManagerHelper

(

const YAML::Node &

node

)

Use this like this FindFromManager<std::string>(config, "LikelihoodOptions", "TestStatistic"); Base case for recursion

Definition at line 64 of file YamlHelper.h.

                                              {
// **********************
  return node.as<T>(); // Convert YAML node to the specified type
}

FindFromManagerHelper() [2/2]

template<typename T , typename... Args>

T FindFromManagerHelper	(	const YAML::Node &	node,
		const std::string &	key,
		Args...	args
	)

Recursive function to traverse YAML nodes.

Definition at line 72 of file YamlHelper.h.

                                                                                  {
  // **********************
  if (!node[key]) {
    MACH3LOG_ERROR("Node {} doesn't exist.", key);
    throw;
    return T();
  }
  return FindFromManagerHelper<T>(node[key], args...); // Recursive call
}

Get()

template<typename Type >

Type Get	(	const YAML::Node &	node,
		const std::string	File,
		const int	Line
	)

Get content of config file.

Parameters

node

Yaml node

Definition at line 266 of file YamlHelper.h.

                                                                     {
// **********************
  try {
    // Attempt to convert the node to the expected type
    return node.as<Type>();
  } catch (const YAML::BadConversion& e) {
    const std::string nodeAsString = YAMLtoSTRING(node);
    MACH3LOG_ERROR("YAML type mismatch: {}", e.what());
    MACH3LOG_ERROR("While trying to access variable {}", nodeAsString);
    throw MaCh3Exception(File , Line );
  } catch (const YAML::InvalidNode& e) {
    std::string key = "<unknown>";
    const std::string msg = e.what();
    const std::string search = "first invalid key: \"";
    auto start = msg.find(search);
    if (start != std::string::npos) {
      start += search.length();
      auto end = msg.find("\"", start);
      if (end != std::string::npos) {
        key = msg.substr(start, end - start);
      }
    }
    MACH3LOG_ERROR("Invalid YAML node: {}", e.what());
    MACH3LOG_ERROR("While trying to access key: {}", key);
    throw MaCh3Exception(File , Line );
  }
}

GetFromManager()

template<typename Type >

Type GetFromManager	(	const YAML::Node &	node,
		Type	defval,
		const std::string	File = "",
		const int	Line = 1
	)

Get content of config file if node is not found take default value specified.

Parameters

node	Yaml node
defval	Default value which will be used in case node doesn't exist

Definition at line 299 of file YamlHelper.h.

                                                                                                      {
// **********************
  if (!node) {
    return defval;
  }
  try {
    // Attempt to convert the node to the expected type
    return node.as<Type>();
  } catch (const YAML::BadConversion& e) {
    const std::string nodeAsString = YAMLtoSTRING(node);
    MACH3LOG_ERROR("YAML type mismatch: {}", e.what());
    MACH3LOG_ERROR("While trying to access variable {}", nodeAsString);
    //const std::string expectedType = DemangleTypeName(typeid(Type).name());
    //MACH3LOG_ERROR("Expected argument is {}", expectedType);
    if(File == "") {
      throw MaCh3Exception(__FILE__ , __LINE__);
    } else {
      throw MaCh3Exception(File , Line );
    }
  }
}

LoadYamlConfig()

YAML::Node LoadYamlConfig ( const std::string &  filename, const std::string &  File, const int  Line  )

inline

Open YAML file.

Parameters

filename	name of filename to open
File	name of file where function is called
Line	number where function is called

Definition at line 326 of file YamlHelper.h.

                                                                                                 {
// **********************
  // KS: YAML can be dumb and not throw error if you pass toml for example...
  if (!(filename.length() >= 5 && filename.compare(filename.length() - 5, 5, ".yaml") == 0) &&
      !(filename.length() >= 4 && filename.compare(filename.length() - 4, 4, ".yml") == 0)) {
      MACH3LOG_ERROR("Invalid file extension: {}\n", filename);
      throw MaCh3Exception(File, Line);
  }
 
  try {
    YAML::Node yamlNode = YAML::LoadFile(filename);
 
    // Convert the YAML file to string
    std::ifstream fileStream(filename);
    std::stringstream buffer;
    buffer << fileStream.rdbuf();
    std::string fileContent = buffer.str();
 
    // Use regex to find any line starting with `-` but not followed by space, digit, or dot
    // This excludes valid numeric negative values like -1760.0
    std::regex linePattern(R"(^\s*-(?![\d\s\.]).*)");
 
    std::istringstream contentStream(fileContent);
    std::string lineconfig;
    int lineNumber = 1;
 
    // KS: Instead of boolean, track flow-style list nesting depth
    int flowListDepth = 0;
 
    while (std::getline(contentStream, lineconfig)) {
      // Ignore YAML document separator
      if (lineconfig.find("---") != std::string::npos) {
        lineNumber++;
        continue;
      }
 
      // Update flow list depth (increment for each '[' and decrement for each ']')
      for (char c : lineconfig) {
        if (c == '[') flowListDepth++;
        else if (c == ']') flowListDepth = std::max(0, flowListDepth - 1);
      }
 
      // Check lines only outside flow-style lists
      if (flowListDepth == 0 && std::regex_match(lineconfig, linePattern)) {
        MACH3LOG_ERROR("Warning: Missing space or tab after '-' at line {}: {}\n", lineNumber, lineconfig);
        throw MaCh3Exception(File, Line);
      }
 
      lineNumber++;
    }
 
    return yamlNode;
 
  } catch (const std::exception& e) {
    MACH3LOG_ERROR("{}\n", e.what());
    MACH3LOG_ERROR("Can't open file {}\n", filename);
    throw MaCh3Exception(File, Line);
  }
}

MergeNodes()

YAML::Node MergeNodes ( YAML::Node  a, YAML::Node  b  )

inline

KS: Recursively merges two YAML nodes.

If both nodes are maps, their keys are merged. Scalar or null values in b will override those in a. If b is null, a is returned unchanged.

Note

Based on https://stackoverflow.com/a/41337824

Parameters

a	The base YAML node.
b	The YAML node to merge into a.

Returns

A new YAML node representing the merged result.

Definition at line 406 of file YamlHelper.h.

                                                   {
// **********************
  if (!b.IsMap()) {
    // If b is not a map, merge result is b, unless b is null
    return b.IsNull() ? a : b;
  }
  if (!a.IsMap()) {
    // If a is not a map, merge result is b
    return b;
  }
  if (!b.size()) {
    // If a is a map, and b is an empty map, return a
    return a;
  }
  // Create a new map 'c' with the same mappings as a, merged with b
  auto c = YAML::Node(YAML::NodeType::Map);
  for (auto n : a) {
    if (n.first.IsScalar()) {
      const std::string & key = n.first.Scalar();
      auto t = (Cnode(b)[key]);
      if (t) {
        c[n.first] = MergeNodes(n.second, t);
        continue;
      }
    }
    c[n.first] = n.second;
  }
  // Add the mappings from 'b' not already in 'c'
  for (auto n : b) {
    if (!n.first.IsScalar() || !Cnode(c)[n.first.Scalar()]) {
      c[n.first] = n.second;
    }
  }
  return c;
}

OverrideConfig() [1/2]

template<typename... Args>

void OverrideConfig	(	YAML::Node	node,
		std::string const &	key,
		Args...	args
	)

Overrides the configuration settings based on provided arguments.

This function allows you to set configuration options in a nested YAML node.

Parameters

node	YAML node that will be modified
args	The arguments to override the configuration. The last argument will be used as the value

Note

Example usage:

OverrideConfig(config, "General", "OutputFile", "Wooimbouttamakeanameformyselfere.root");
OverrideConfig(config, "General", "MyDouble", 5.3);

Definition at line 246 of file YamlHelper.h.

                                                                       {
// **********************
  OverrideConfig(node[key], args...);
}

OverrideConfig() [2/2]

template<typename TValue >

void OverrideConfig	(	YAML::Node	node,
		std::string const &	key,
		TValue	val
	)

Overrides the configuration settings based on provided arguments.

Parameters

node	YAML node that will be modified

Definition at line 227 of file YamlHelper.h.

                                                                     {
// **********************
  node[key] = val;
}

Parse2DBounds()

std::vector<std::vector<double> > Parse2DBounds ( const YAML::Node &  node, const std::string &  File, const int  Line  )

inline

KS: Get 2D bounds from YAML for example for selection cuts.

Parses a YAML node representing 2D selection bounds. Each element in the node must be a sequence of 1 or 2 scalar values. If a single value is given, it is interpreted as the center of a bin and expanded to [value - 0.5, value + 0.5]. If two values are given, they are used as-is. If an element is empty or null, default bounds are used.

This function is useful for interpreting kinematic or classification bounds specified in YAML configuration files.

Example YAML input:

bounds2D:
  - [1]
  - [0.2, 0.8]
  - ["", "2.0"]

Resulting vector:

[ [0.5, 1.5],
  [0.2, 0.8],
  [M3::KinematicLowBound, 2.0] ]

Parameters

node	The YAML node containing a sequence of bounds (each being a 1- or 2-element sequence).
File	The name of the file calling this function (for error reporting).
Line	The line number in the file calling this function (for error reporting).

Returns

std::vector<std::vector<double>> A list of bound pairs for each selection region.

Definition at line 539 of file YamlHelper.h.

                                                                                                               {
// **********************
  std::vector<std::vector<double>> bounds;
  if (!node || !node.IsSequence()) {
    MACH3LOG_ERROR("Expected a sequence node for 2D bounds");
    throw MaCh3Exception(File, Line);
  }
 
  // Case 1: Single pair like [0.25, 0.5]
  if (node.size() == 2 && node[0].IsScalar()) {
    bounds.push_back(ParseBounds(node, File, Line));
  } else { // Case 2: List of pairs like [[0.25, 0.5], [0.75, 1.0]]
    for (std::size_t i = 0; i < node.size(); ++i) {
      const YAML::Node& subnode = node[i];
      bounds.push_back(ParseBounds(subnode, File, Line));
    }
  }
 
  return bounds;
}

ParseBounds()

std::vector<double> ParseBounds ( const YAML::Node &  node, const std::string &  File, const int  Line  )

inline

KS: Get bounds from YAML for example for selection cuts.

This function expects a YAML node of exactly two elements. If any of the elements is an empty string or null, it is replaced with a default kinematic bound. If the element is a non-empty string and cannot be converted to a double, an exception is thrown.

Parameters

node	The YAML node containing the bounds.
File	The name of the file calling this function (for error context).
Line	The line number in the file calling this function.

Returns

std::vector<double> A vector of size 2 with the parsed bounds.

Definition at line 455 of file YamlHelper.h.

                                                                                                  {
// **********************
  std::vector<double> bounds;
 
  if (!node || !node.IsSequence() || (node.size() != 1 && node.size() != 2)) {
    MACH3LOG_ERROR("Bounds must be a sequence of 1 or 2 elements, got size {}", static_cast<int>(node.size()));
    throw MaCh3Exception(File, Line);
  }
 
  if (node.size() == 1) {
    const YAML::Node& val = node[0];
 
    if (!val || val.IsNull() || (val.IsScalar() && val.Scalar().empty())) {
      MACH3LOG_ERROR("Single-element bounds must contain a valid numeric value.");
      throw MaCh3Exception(File, Line);
    } else if (val.IsScalar()) {
      try {
        const double center = val.as<double>();
        if (std::floor(center) != center) {
          MACH3LOG_ERROR("Invalid center value in Bounds[0]: '{}'. Expected an integer (e.g., 0 or 1).", static_cast<std::string>(val.Scalar()));
          throw MaCh3Exception(File, Line);
        }
        bounds = {center - 0.5, center + 0.5};
      } catch (const YAML::BadConversion& e) {
        MACH3LOG_ERROR("Invalid value in Bounds[0]: '{}'. Expected a number.", static_cast<std::string>(val.Scalar()));
        throw MaCh3Exception(File, Line);
      }
    } else {
      MACH3LOG_ERROR("Invalid type in Bounds[0]");
      throw MaCh3Exception(File, Line);
    }
  } else {
    for (std::size_t i = 0; i < 2; ++i) {
      const YAML::Node& val = node[i];
 
      if (!val || val.IsNull() || (val.IsScalar() && val.Scalar().empty())) {
        bounds.push_back(i == 0 ? M3::KinematicLowBound : M3::KinematicUpBound);
      } else if (val.IsScalar()) {
        try {
          bounds.push_back(val.as<double>());
        } catch (const YAML::BadConversion& e) {
          MACH3LOG_ERROR("Invalid value in Bounds[{}]: '{}'. Expected a number or empty string.",
                         static_cast<int>(i), static_cast<std::string>(val.Scalar()));
          throw MaCh3Exception(File, Line);
        }
      } else {
        MACH3LOG_ERROR("Invalid type in Bounds[{}]", static_cast<int>(i));
        throw MaCh3Exception(File, Line);
      }
    }
  }
  return bounds;
}

STRINGtoYAML()

YAML::Node STRINGtoYAML ( const std::string &  yaml_string )

inline

Function to convert a YAML string to a YAML node.

Parameters

yaml_string

String which will be converted to yaml node

Definition at line 92 of file YamlHelper.h.

                                                          {
// **********************
  try {
    return YAML::Load(yaml_string);
  } catch (const YAML::ParserException& e) {
    MACH3LOG_ERROR("Error parsing YAML string: {}", e.what());
    return YAML::Node();
  }
}

TMacroToString()

std::string TMacroToString ( const TMacro &  macro )

inline

KS: Convert a ROOT TMacro object to a string representation.

Parameters

macro

The ROOT TMacro object to convert.

Returns

std::string The string representation of the TMacro object.

Definition at line 118 of file YamlHelper.h.

                                                     {
// **********************
  std::stringstream ss;
 
  // Retrieve lines from TMacro
  TList* linesList = macro.GetListOfLines();
  if (!linesList) {
    MACH3LOG_ERROR("Failed to retrieve lines from TMacro.");
    return "";
  }
 
  TIter nextLine(linesList);
  TObject *obj = nullptr;
  while ((obj = nextLine())) {
    TObjString* line = dynamic_cast<TObjString*>(obj);
    if (!line) {
      MACH3LOG_ERROR("Failed to cast object to TObjString.");
      continue;
    }
    ss << line->GetString() << std::endl;
  }
 
  return ss.str();
}

TMacroToYAML()

YAML::Node TMacroToYAML ( const TMacro &  macro )

inline

KS: Convert a ROOT TMacro object to a YAML node.

Parameters

macro

The ROOT TMacro object to convert.

Returns

YAML::Node The YAML node representing the TMacro object.

Definition at line 147 of file YamlHelper.h.

                                                  {
// **********************
  std::string yaml_string = TMacroToString(macro);
 
  // Convert the YAML string to a YAML node
  YAML::Node yaml_node = STRINGtoYAML(yaml_string);
 
  return yaml_node;
}

YAMLtoSTRING()

std::string YAMLtoSTRING ( const YAML::Node &  node )

inline

KS: Convert a YAML node to a string representation.

Parameters

node	The YAML node to convert to a string.

Returns

std::string The string representation of the YAML node.

Warning

YAML is weird and drops " " for string so output may not be identical to yaml you provided

Definition at line 107 of file YamlHelper.h.

                                                    {
// **********************
  YAML::Emitter emitter;
  emitter << node;
  return emitter.c_str();
}

YAMLtoTMacro()

TMacro YAMLtoTMacro ( const YAML::Node &  yaml_node, const std::string &  name  )

inline

Convert a YAML node to a ROOT TMacro object.

Parameters

yaml_node	The YAML node to convert to a TMacro.
name	Name of TMacro that will be saved

Returns

TMacro The TMacro object constructed from the YAML node.

Definition at line 162 of file YamlHelper.h.

                                                                             {
// **********************
  // Convert the YAML node to a string representation
  std::string macro_string = YAMLtoSTRING(yaml_node);
 
  // Create a TMacro object with the collected lines
  TMacro macro(name.c_str(), name.c_str());
  macro.AddLine(macro_string.c_str());
 
  return macro;
}