XMLCoreNode.cxx

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration.
 */
 
 
#include "XMLCoreParser/XMLCoreNode.h"
#include <charconv>
#include <iostream>
#include <format>
 
 
static const char* const SPACE = " \t\r\n";
 

ExcXMLCore::ExcXMLCore (const std::string& what)
  : std::runtime_error ("ExcXMLCore: " + what)
{
}
 

XMLCoreNode::XMLCoreNode (NodeType type,
                          const std::string& name,
                          const std::string& value)
  : m_type (type),
    m_name (name),
    m_value (value)
{
}
 

void XMLCoreNode::set_attrib (const std::string& name, const std::string& value)
{
  m_attribs[name] = value;
}
 

XMLCoreNode* XMLCoreNode::add_child (std::unique_ptr<XMLCoreNode> child)
{
  child->set_parent (this);
  m_children.push_back (std::move (child));
  return m_children.back().get();
}
 

XMLCoreNode* XMLCoreNode::get_parent()
{
  return m_parent;
}
 

const XMLCoreNode* XMLCoreNode::get_parent() const
{
  return m_parent;
}
 

XMLCoreNode::NodeType XMLCoreNode::get_type() const
{
  return m_type;
}
 

const std::string& XMLCoreNode::get_name() const
{
  return m_name;
}
 

const std::string& XMLCoreNode::get_value() const
{
  return m_value;
}
 

size_t XMLCoreNode::n_attribs() const
{
  return m_attribs.size();
}
 

std::string XMLCoreNode::get_attrib_name (size_t i) const
{
  if (i >= m_attribs.size()) {
    throw ExcXMLCore ("Out-of-range attribute index " + std::to_string(i) + " in " + m_name);
  }
 
  auto it = m_attribs.begin();
  std::advance (it, i);
  return it->first;
}
 

bool XMLCoreNode::has_attrib (const std::string& name) const
{
  return m_attribs.contains (name);
}
 

template <class T>
std::optional<T> XMLCoreNode::try_attrib (std::string_view name) const
{
  std::optional<T> ret;
  auto it = m_attribs.find (name);
  if (it == m_attribs.end()) return ret;
 
  T val = 0;
  std::string::size_type beg = it->second.find_first_not_of (SPACE);
  std::string::size_type end = it->second.find_last_not_of (SPACE);
  if (beg == std::string::npos || end == std::string::npos) return ret;
  const char* begp = it->second.c_str()+beg;
  const char* endp = it->second.c_str()+end+1;
  auto [ptr, ec] = std::from_chars (begp, endp, val);
  if (ec == std::errc() && ptr == endp)
    ret.emplace (val);
  return ret;
}
 

std::optional<int> XMLCoreNode::try_int_attrib (std::string_view name) const
{
  return try_attrib<int> (name);
}
 

std::optional<double> XMLCoreNode::try_double_attrib (std::string_view name) const
{
  return try_attrib<double> (name);
}
 

const std::string& XMLCoreNode::get_attrib (std::string_view name) const
{
  auto it = m_attribs.find (name);
  if (it == m_attribs.end()) {
    throw ExcXMLCore (std::format("Cannot find attribute {} in {}", name, m_name));
  }
  return it->second;
}
 

int XMLCoreNode::get_int_attrib (std::string_view name) const
{
  std::optional<int> val = try_int_attrib (name);
  if (!val) {
    throw ExcXMLCore (std::format("Bad integer attribute {} in {}", name, m_name));
  }
  return val.value();
}
 

double XMLCoreNode::get_double_attrib (std::string_view name) const
{
  std::optional<double> val = try_double_attrib (name);
  if (!val) {
    throw ExcXMLCore (std::format("Bad double attribute {} in {}", name, m_name));
  }
  return val.value();
}
 

const XMLCoreNode* XMLCoreNode::get_child (const std::string& path) const
{
  std::vector<const XMLCoreNode*> children;
  collect_children (path, children, true);
  if (!children.empty()) {
    return children[0];
  }
  return nullptr;
}
 

std::vector<const XMLCoreNode*>
XMLCoreNode::get_children (const std::string& path /*= "*"*/) const
{
  std::vector<const XMLCoreNode*> children;
  collect_children (path, children, false);
  return children;
}
 
 
/*
 * @brief Print the node structure in XML format (to cout).
 * @param header String to print on hte first line.
 * @param depth Initial nesting depth.
 */
void XMLCoreNode::print (const std::string& header,
                         int depth /*= 0*/) const
{
  print (std::cout, header, depth);
}
 
 
/*
 * @brief Print the node structure in XML format.
 * @param os Stream to which to print.
 * @param header String to print on hte first line.
 * @param depth Initial nesting depth.
 */
void XMLCoreNode::print (std::ostream& os,
                         const std::string& header,
                         int depth /*= 0*/) const
{
  if (!header.empty()) {
    os << header << std::endl;
  }
 
  if (m_type == TEXT_NODE) {
    bool allspace = m_value.find_last_of(SPACE) == std::string::npos;
    if (!allspace)
      os << m_value << std::endl;
    return;
  }
 
  for (int i = 0; i < depth; i++) os << "  ";
 
  if (m_type == COMMENT_NODE) {
    os << "<!--" << m_value << "-->" << std::endl;
    return;
  }
 
  os << "<" << m_name;
 
  for (const auto& p : m_attribs) {
    os << " " << p.first << "='" << p.second << "'";
  }
 
  os << ">" << std::endl;
 
  for (const auto& child : m_children) {
    child->print (os, "", depth+1);
  }
 
  for (int i = 0; i < depth; i++) os << "  ";
  os << "</" << m_name << ">" << std::endl;
  return;
}
 

void XMLCoreNode::set_parent (XMLCoreNode* parent)
{
  m_parent = parent;
}
 

void XMLCoreNode::collect_children (const std::string& path,
                                    std::vector<const XMLCoreNode*>& children,
                                    bool only_one) const
{
  std::string::size_type pos = path.find ('/');
  std::string name = path.substr (0, pos);
  std::string tail;
  if  (pos != std::string::npos) {
    tail = path.substr (pos+1);
  }
 
  for (const auto& child : m_children) {
    if (name == "*" || child->get_name() == name) {
      if (tail.empty()) {
        children.push_back (child.get());
      }
      else {
        child->collect_children (tail, children, only_one);
      }
    }
    if (only_one && !children.empty()) break;
  }
}