XmlNode.cc

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* XmlNode.cc                                                  (C) 2000-2023 */
/*                                                                           */
/* Any node in a DOM tree.                                                   */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/XmlNode.h"
 
#include "arcane/utils/StringBuilder.h"
#include "arcane/utils/NotImplementedException.h"
#include "arcane/utils/Iterator.h"
#include "arcane/utils/ValueConvert.h"
#include "arcane/utils/Iostream.h"
#include "arcane/utils/TraceInfo.h"
#include "arcane/utils/FatalErrorException.h"
 
#include "arcane/core/XmlException.h"
#include "arcane/core/XmlNodeList.h"
#include "arcane/core/XmlNodeIterator.h"
#include "arcane/core/DomUtils.h"
 
#include <algorithm>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class XmlNodeSameName
{
 public:
 
  XmlNodeSameName(const String& name)
  : m_name(name)
  {}
 
 public:
 
  bool operator()(const XmlNode& node)
  {
    return node.name() == m_name;
  }
 
 private:
 
  String m_name;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
_nullNode() const
{
  return XmlNode(m_rm);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
child(const String& child_name) const
{
  if (m_node._null())
    return _nullNode();
  XmlNodeSameName same_name(child_name);
  XmlNodeConstIterator i = ARCANE_STD::find_if(begin(), end(), same_name);
  if (i != end())
    return *i;
  return XmlNode(m_rm);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
expectedChild(const String& child_name) const
{
  if (m_node._null())
    return _nullNode();
  XmlNode c = child(child_name);
  if (c.null())
    ARCANE_FATAL("Can not find a child named '{0}' for node '{1}'", child_name, xpathFullName());
  return c;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNodeList XmlNode::
children(const String& child_name) const
{
  XmlNodeList nodes;
  if (m_node._null())
    return nodes;
  XmlNodeSameName same_name(child_name);
  for (XmlNodeConstIterator n = begin(); n != end(); ++n)
    if (same_name(*n))
      nodes.add(*n);
  return nodes;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNodeList XmlNode::
children() const
{
  XmlNodeList nodes;
  if (m_node._null())
    return nodes;
  for (XmlNodeConstIterator n = begin(); n != end(); ++n)
    nodes.add(*n);
  return nodes;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode::eType XmlNode::
type() const
{
  return static_cast<eType>(m_node.nodeType());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String XmlNode::
name() const
{
  if (m_node._null())
    return String();
  return String(m_node.nodeName());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String XmlNode::
xpathFullName() const
{
  StringBuilder full_name;
  if (m_node._null())
    return full_name;
 
  XmlNode p = parent();
  if (!p.null()) {
    full_name = p.xpathFullName();
    full_name.append("/");
 
    if (m_node.nodeType() == dom::Node::ATTRIBUTE_NODE) {
      full_name += "@";
      full_name += name();
    }
    else if (m_node.nodeType() == dom::Node::ELEMENT_NODE) {
      full_name.append(name());
      Integer nb_occurence = 1;
      for (XmlNode i = p.front(); i != (*this); ++i)
        if (i.isNamed(name()))
          ++nb_occurence;
      if (nb_occurence > 1) {
        full_name += "[";
        full_name += nb_occurence;
        full_name += "]";
      }
    }
    else
      full_name += "?";
  }
  else {
    if (m_node.nodeType() == dom::Node::ATTRIBUTE_NODE) {
      full_name = ownerElement().xpathFullName();
      full_name += "/@";
      full_name += name();
    }
    else {
      full_name = String("/");
    }
  }
  return full_name;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool XmlNode::
isNamed(const String& name) const
{
  return m_node.nodeName() == name;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String XmlNode::
value() const
{
  if (null())
    return String();
  return _value();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void XmlNode::
setValue(const String& v)
{
  if (m_node._null())
    return;
  if (m_node.nodeType() == dom::Node::ELEMENT_NODE) {
    domutils::textContent(m_node, v);
    return;
  }
  m_node.nodeValue(v);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String XmlNode::
attrValue(const String& name, bool throw_exception) const
{
  String s = domutils::attrValue(m_node, name);
  if (s.null() && throw_exception) {
    ARCANE_THROW(XmlException, "No attribute named '{0}' child of '{1}'",
                 name, xpathFullName());
  }
  return s;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void XmlNode::
setAttrValue(const String& name, const String& value)
{
  domutils::setAttr(m_node, name, value);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
attr(const String& name, bool throw_exception) const
{
  dom::Element elem(m_node);
  if (elem._null())
    return _nullNode();
 
  XmlNode attr_node(m_rm, elem.getAttributeNode(name));
  if (throw_exception && attr_node.null()) {
    ARCANE_THROW(XmlException, "No attribute named '{0}' child of '{1}'",
                 name, xpathFullName());
  }
  return attr_node;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
forceAttr(const String& name)
{
  dom::Element elem(m_node);
  if (elem._null())
    return _nullNode();
  dom::Attr attr = elem.getAttributeNode(name);
  if (attr._null()) {
    attr = elem.ownerDocument().createAttribute(name);
    attr = elem.setAttributeNode(attr);
  }
  return XmlNode(m_rm, attr);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void XmlNode::
removeAttr(const String& name) const
{
  dom::Element elem(m_node);
  elem.removeAttribute(name);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void XmlNode::
clear()
{
  // Removes child nodes.
  XmlNode n = front();
  while (!n.null()) {
    remove(n);
    n = front();
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void XmlNode::
remove()
{
  if (m_node._null())
    return;
  dom::Node parent = m_node.parentNode();
  if (parent._null())
    return;
  parent.removeChild(m_node);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void XmlNode::
remove(const XmlNode& child_node)
{
  dom::Node child = m_node.removeChild(child_node.domNode());
  child.releaseNode();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
nextWithName(const String& name) const
{
  //\todo to test
  if (m_node._null())
    return _nullNode();
  XmlNode n(next());
  while (!n.null() && !n.isNamed(name))
    ++n;
  return n;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
prevWithName(const String& name) const
{
  //\todo to test
  if (m_node._null())
    return _nullNode();
  XmlNode n(prev());
  while (!n.null() && !n.isNamed(name))
    --n;
  return n;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
nextSameType() const
{
  //\todo to test
  if (m_node._null())
    return _nullNode();
  XmlNode n(next());
  while (!n.null() && n.type() != type())
    ++n;
  return n;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
prevSameType() const
{
  //\todo to test
  if (m_node._null())
    return _nullNode();
  XmlNode n(prev());
  while (!n.null() && n.type() != type())
    --n;
  return n;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void XmlNode::
replace(const XmlNode& new_node, XmlNode& ref_node)
{
  if (m_node._null() || new_node.null() || ref_node.null())
    return;
  m_node.replaceChild(new_node.domNode(), ref_node.domNode());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void XmlNode::
_throwBadConvert(const char* type_name, const String& value) const
{
  ARCANE_THROW(XmlException, "XML Node '{0}' can not convert value '{1}' to type '{2}'",
               xpathFullName(), value, type_name);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool XmlNode::
valueAsBoolean(bool throw_exception) const
{
  if (null())
    return false;
  String value = _value();
  if (value == "false" || value == "0")
    return false;
  if (value == "true" || value == "1")
    return true;
  if (throw_exception)
    ARCANE_THROW(XmlException, "XML Node '{0}' can not convert value '{1}' to type 'bool'."
                               " Valid values are 'true', 'false', '0' (zero) or '1'.",
                 xpathFullName(), value);
  return false;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Integer XmlNode::
valueAsInteger(bool throw_exception) const
{
  if (null())
    return 0;
  String value = _value();
  Integer v = 0;
  if (builtInGetValue(v, value))
    if (throw_exception)
      _throwBadConvert("Integer", value);
  return v;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Int64 XmlNode::
valueAsInt64(bool throw_exception) const
{
  if (null())
    return 0;
  String value = _value();
  Int64 v = 0;
  if (builtInGetValue(v, value))
    if (throw_exception)
      _throwBadConvert("Int64", value);
  return v;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Real XmlNode::
valueAsReal(bool throw_exception) const
{
  if (null())
    return 0.0;
  String value = _value();
  Real v = 0.0;
  if (builtInGetValue(v, value))
    if (throw_exception)
      _throwBadConvert("Real", value);
  return v;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
childWithAttr(const String& elem_name, const String& attr_name,
              const String& attr_value) const
{
  String name;
  if (null())
    return _nullNode();
  for (XmlNode::const_iter i(*this); i(); ++i) {
    if (!i->isNamed(elem_name))
      continue;
    name = i->attrValue(attr_name);
    if (name == attr_value)
      return *i;
  }
  return XmlNode(m_rm);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
childWithNameAttr(const String& elem_name, const String& attr_value) const
{
  return childWithAttr(elem_name, String("name"), attr_value);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
xpathNode(const String& xpath_expr) const
{
  return XmlNode(m_rm, domutils::nodeFromXPath(m_node, xpath_expr));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String XmlNode::
_value() const
{
  if (m_node.nodeType() == dom::Node::ELEMENT_NODE)
    return domutils::textContent(m_node);
  return String(m_node.nodeValue());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void XmlNode::
assignDomNode(const dom::Node& node)
{
  m_node = node;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
insertAfter(const XmlNode& new_child, const XmlNode& ref_node)
{
  if (new_child.null())
    return _nullNode();
  XmlNode next = ref_node;
  if (!next.null())
    ++next;
  if (next.null())
    append(new_child);
  else
    m_node.insertBefore(new_child.domNode(), next.domNode());
  return new_child;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
documentElement() const
{
  dom::Document doc(m_node);
  if (doc._null())
    return _nullNode();
  return _build(doc.documentElement());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
ownerElement() const
{
  dom::Attr attr(m_node);
  if (attr._null())
    return _nullNode();
  return _build(attr.ownerElement());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
createElement(const String& name)
{
  return createNode(ELEMENT, name);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
createAndAppendElement(const String& name, const String& value)
{
  XmlNode n = createNode(ELEMENT, name, value);
  append(n);
  return n;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
createAndAppendElement(const String& name)
{
  XmlNode n = createNode(ELEMENT, name);
  append(n);
  return n;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
createNode(eType type, const String& name_or_value)
{
  dom::Document doc(m_node);
  if (doc._null())
    doc = m_node.ownerDocument();
  XmlNode ret_node(m_rm);
  String nov = name_or_value;
  switch (type) {
  case ELEMENT:
    ret_node.assignDomNode(doc.createElement(nov));
    break;
  case TEXT:
    ret_node.assignDomNode(doc.createTextNode(nov));
    break;
  default:
    ARCANE_THROW(NotImplementedException,
                 "createNode() not implemented for node type {0}", (int)type);
  }
  return ret_node;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
createText(const String& value)
{
  return createNode(TEXT, value);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
createNode(eType type, const String& name, const String& value)
{
  dom::Document doc(m_node);
  if (doc._null())
    doc = m_node.ownerDocument();
  XmlNode ret_node(m_rm);
  switch (type) {
  case ELEMENT:
    ret_node.assignDomNode(doc.createElement(name));
    ret_node.setValue(value);
    break;
  case TEXT:
    ret_node.assignDomNode(doc.createTextNode(value));
    break;
  default:
    ARCANE_THROW(NotImplementedException,
                 "createNode() not implemented for node type {0}", (int)type);
  }
  return ret_node;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNode XmlNode::
_build(const dom::Node& node) const
{
  return XmlNode(m_rm, node);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlElement::
XmlElement(XmlNode& parent, const String& name, const String& value)
: XmlNode(parent)
{
  _setNode(parent.createAndAppendElement(name, value).domNode());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlElement::
XmlElement(XmlNode& parent, const String& name)
: XmlNode(parent)
{
  _setNode(parent.createAndAppendElement(name).domNode());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNodeNameIterator::
XmlNodeNameIterator(const XmlNode& from, const String& ref_name)
: m_parent(from)
, m_current(0)
, m_ref_name(ref_name)
{
  _findNextValid(true);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
XmlNodeNameIterator::
XmlNodeNameIterator(const XmlNode& from, const char* ref_name)
: m_parent(from)
, m_current(0)
, m_ref_name(String(ref_name))
{
  _findNextValid(true);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void XmlNodeNameIterator::
_findNextValid(bool is_init)
{
  if (is_init)
    m_current = m_parent.front();
  else {
    if (m_current.null())
      return;
    ++m_current;
  }
  while (!m_current.null()) {
    if (m_current.isNamed(m_ref_name))
      break;
    ++m_current;
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/