XmlNode.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2023 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 */
/*                                                                           */
/* Noeud quelconque d'un arbre DOM.                                          */
/*---------------------------------------------------------------------------*/
#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: à supprimer
  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();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif