YamlHelper.h

Go to the documentation of this file.

#pragma once
 
// C++ Includes
#include <iostream>
#include <fstream>
#include <string>
#include <cxxabi.h>
#include <regex>
 
// MaCh3 Includes
#include "Manager/MaCh3Exception.h"
#include "Manager/Core.h"
 
_MaCh3_Safe_Include_Start_ //{
// ROOT Includes
#include "TMacro.h"
#include "TList.h"
#include "TObjString.h"
 
// yaml Includes
#include "yaml-cpp/yaml.h"
_MaCh3_Safe_Include_End_ //}
 
 
// **********************
template<typename T>
bool CheckNodeExistsHelper(const T& node) {
// **********************
  (void)node;
  return true; // Node exists, return true
}
 
// **********************
template<typename T, typename... Args>
bool CheckNodeExistsHelper(const T& node, const std::string& key, Args... args) {\
// **********************
  if (!node[key]) {
    //std::cerr << "Node " << key << " doesn't exist." << std::endl;
    return false;
  }
  return CheckNodeExistsHelper(node[key], args...);
}
 
// **********************
template<typename... Args>
bool CheckNodeExists(const YAML::Node& node, Args... args) {
// **********************
  return CheckNodeExistsHelper(node, args...);
}
 
// **********************
template<typename T>
T FindFromManagerHelper(const YAML::Node& node) {
// **********************
  return node.as<T>(); // Convert YAML node to the specified type
}
 
// **********************
template<typename T, typename... Args>
T FindFromManagerHelper(const YAML::Node& node, const std::string& key, Args... args) {
  // **********************
  if (!node[key]) {
    MACH3LOG_ERROR("Node {} doesn't exist.", key);
    throw;
    return T();
  }
  return FindFromManagerHelper<T>(node[key], args...); // Recursive call
}
// **********************
template<typename T, typename... Args>
T FindFromManager(const YAML::Node& node, Args... args) {
// **********************
  return FindFromManagerHelper<T>(node, args...);
}
 
// **********************
inline YAML::Node STRINGtoYAML(const std::string& yaml_string){
// **********************
  try {
    return YAML::Load(yaml_string);
  } catch (const YAML::ParserException& e) {
    MACH3LOG_ERROR("Error parsing YAML string: {}", e.what());
    return YAML::Node();
  }
}
 
// **********************
inline std::string YAMLtoSTRING(const YAML::Node& node) {
// **********************
  YAML::Emitter emitter;
  emitter << node;
  return emitter.c_str();
}
 
// **********************
inline std::string TMacroToString(const TMacro& macro) {
// **********************
  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();
}
 
// **********************
inline YAML::Node TMacroToYAML(const TMacro& macro) {
// **********************
  std::string yaml_string = TMacroToString(macro);
 
  // Convert the YAML string to a YAML node
  YAML::Node yaml_node = STRINGtoYAML(yaml_string);
 
  return yaml_node;
}
 
// **********************
inline TMacro YAMLtoTMacro(const YAML::Node& yaml_node, const std::string& name) {
// **********************
  // 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;
}
 
// **********************
inline bool compareYAMLNodes(const YAML::Node& node1, const YAML::Node& node2) {
// **********************
  // 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;
}
 
// **********************
template <typename TValue>
void OverrideConfig(YAML::Node node, std::string const &key, TValue val) {
// **********************
  node[key] = val;
}
 
// **********************
template <typename... Args>
void OverrideConfig(YAML::Node node, std::string const &key, Args... args) {
// **********************
  OverrideConfig(node[key], args...);
}
 
// **********************
inline std::string DemangleTypeName(const std::string& mangledName) {
// **********************
  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;
}
 
// **********************
template<typename Type>
Type Get(const YAML::Node& node, const std::string File, const int Line) {
// **********************
  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 );
  }
}
 
// **********************
template<typename Type>
Type GetFromManager(const YAML::Node& node, Type defval, const std::string File = "", const int Line = 1) {
// **********************
  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 );
    }
  }
}
 
// **********************
inline YAML::Node LoadYamlConfig(const std::string& filename, const std::string& File, const int Line) {
// **********************
  // 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);
  }
}
 
// **********************
inline const YAML::Node & Cnode(const YAML::Node &n) {
// **********************
  return n;
}
 
// **********************
inline YAML::Node MergeNodes(YAML::Node a, YAML::Node b) {
// **********************
  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;
}
 
 
// **********************
inline std::vector<double> ParseBounds(const YAML::Node& node, const std::string& File, const int Line) {
// **********************
  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;
}
 
// **********************
inline std::vector<std::vector<double>> Parse2DBounds(const YAML::Node& node, const std::string& File, const int Line) {
// **********************
  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;
}
 
#define M3OpenConfig(filename) LoadYamlConfig((filename), __FILE__, __LINE__)
#define GetBounds(filename) ParseBounds((filename), __FILE__, __LINE__)
#define Get2DBounds(filename) Parse2DBounds((filename), __FILE__, __LINE__)