XmlNode.h

// -*- 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.h                                                   (C) 2000-2023 */
/*                                                                           */
/* Any node in a DOM tree.                                                   */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_XMLNODE_H
#define ARCANE_CORE_XMLNODE_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/String.h"
#include "arcane/core/Dom.h"
 
#include <iterator>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class IRessourceMng;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class XmlNodeIterator;
class XmlNodeConstIterator;
class XmlNodeList;

class ARCANE_CORE_EXPORT XmlNode
{
 public:

  typedef XmlNode value_type;
  typedef XmlNodeIterator iterator;
  typedef XmlNodeConstIterator const_iterator;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef Integer size_type;
  typedef int difference_type;

  typedef IterT<XmlNode> iter;
  typedef ConstIterT<XmlNode> const_iter;
 
 public:

  enum eType
  {
    ELEMENT = 1,
    ATTRIBUTE = 2,
    TEXT = 3,
    CDATA_SECTION = 4,
    ENTITY_REFERENCE = 5,
    ENTITY = 6,
    PROCESSING_INSTRUCTION = 7,
    COMMENT = 8,
    DOCUMENT = 9,
    DOCUMENT_TYPE = 10,
    DOCUMENT_FRAGMENT = 11,
    NOTATION = 12
  };
 
 public:
 
  XmlNode(IRessourceMng* m, const dom::Node& node)
  : m_rm(m)
  , m_node(node)
  {}
  //TODO: to be removed
  explicit XmlNode(IRessourceMng* m)
  : m_rm(m)
  , m_node()
  {}
  XmlNode()
  : m_rm(nullptr)
  , m_node()
  {}
 
 public:

  inline iterator begin();
  inline iterator end();
  inline const_iterator begin() const;
  inline const_iterator end() const;
 
 public:

  eType type() const;

  String name() const;

  String xpathFullName() const;

  bool isNamed(const String& name) const;

  String value() const;

  Integer valueAsInteger(bool throw_exception = false) const;

  Int64 valueAsInt64(bool throw_exception = false) const;

  bool valueAsBoolean(bool throw_exception = false) const;

  Real valueAsReal(bool throw_exception = false) const;

  void setValue(const String& value);

  String attrValue(const String& name, bool throw_exception = false) const;

  void setAttrValue(const String& name, const String& value);

  XmlNode attr(const String& name, bool throw_exception = false) const;

  XmlNode forceAttr(const String& name);

  void removeAttr(const String& name) const;

  XmlNode documentElement() const;

  XmlNode ownerElement() const;

  void clear();

  XmlNode child(const String& name) const;

  XmlNode expectedChild(const String& name) const;

  XmlNodeList children(const String& name) const;

  XmlNodeList children() const;

  XmlNode parent() const { return XmlNode(m_rm, m_node.parentNode()); }

  void append(const XmlNode& child_node) { m_node.appendChild(child_node.domNode()); }
  void remove(const XmlNode& child_node);
  void replace(const XmlNode& new_node, XmlNode& ref_node);
  void remove();
  XmlNode front() const { return XmlNode(m_rm, m_node.firstChild()); }
  XmlNode last() const { return XmlNode(m_rm, m_node.lastChild()); }
  XmlNode next() const { return XmlNode(m_rm, m_node.nextSibling()); }
  XmlNode prev() const { return XmlNode(m_rm, m_node.previousSibling()); }
  XmlNode nextWithName(const String& name) const;
  XmlNode prevWithName(const String& name) const;
  XmlNode nextSameType() const;
  XmlNode prevSameType() const;
  void operator++() { m_node = m_node.nextSibling(); }
  void operator--() { m_node = m_node.previousSibling(); }

  bool null() const { return m_node._null(); }
  bool operator!() const { return null(); }

  dom::Node domNode() const { return m_node; }
  void assignDomNode(const dom::Node& node);

  XmlNode insertAfter(const XmlNode& new_child, const XmlNode& ref_node);

  XmlNode childWithAttr(const String& elem_name, const String& attr_name,
                        const String& attr_value) const;
  XmlNode childWithNameAttr(const String& elem_name,
                            const String& attr_value) const;

  XmlNode xpathNode(const String& xpath_expr) const;

  XmlNode createNode(eType type, const String& name, const String& value);

  XmlNode createNode(eType type, const String& name_or_value);

  XmlNode createText(const String& value);
 
  XmlNode createElement(const String& name);
 
  XmlNode createAndAppendElement(const String& name);
 
  XmlNode createAndAppendElement(const String& name, const String& value);
 
  XmlNode ownerDocument() const { return XmlNode(m_rm, m_node.ownerDocument()); }
 
  IRessourceMng* rm() const { return m_rm; }
 
 private:
 
  IRessourceMng* m_rm;
  dom::Node m_node;
 
 protected:
 
  String _value() const;
  XmlNode _build(const dom::Node& node) const;
  XmlNode _nullNode() const;
  void _setNode(const dom::Node& n) { m_node = n; }
  inline void _throwBadConvert(const char* type_name, const String& value) const;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_CORE_EXPORT XmlElement
: public XmlNode
{
 public:

  XmlElement(XmlNode& parent, const String& name, const String& value);
  XmlElement(XmlNode& parent, const String& name);
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline bool
operator==(const XmlNode& n1, const XmlNode& n2)
{
  return n1.domNode() == n2.domNode();
}
 
inline bool
operator!=(const XmlNode& n1, const XmlNode& n2)
{
  return n1.domNode() != n2.domNode();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif