Plus

- Minimal XML for C++

(Version 0.9.2)

Giancarlo Niccolai

mxml_node.h

Go to the documentation of this file.

/*
   Mini XML lib PLUS for C++

   Node class

   Author: Giancarlo Niccolai <gian@niccolai.ws>

   $Id: mxml_node.h,v 1.10 2004/04/10 23:50:29 jonnymind Exp $
*/

#ifndef MXML_NODE_H
#define MXML_NODE_H

#include <string>
#include <iostream>
#include <list>
#include <cassert>

#include <mxml_error.h>
#include <mxml_attribute.h>

namespace MXML
{

typedef std::list<Attribute *>   AttribList;
typedef AttribList::iterator AttribListIter;


template <class __Node>
class __iterator
{
protected:
   __Node *m_base;
   __Node *m_node;
   friend class Node;

   //__iterator( __iterator &src ) { copy( src ); }
   void copy( __iterator &src ) { m_base = src.m_base; m_node = src.m_node; }

   virtual __iterator &__next() {
      assert ( m_node != 0 );
      m_node = m_node->next();
      return *this;
   }
   virtual __iterator &__prev();
public:
   __iterator( __Node *nd=0 ) { m_base = m_node = nd; }
   inline __iterator &operator=( __iterator src ) {
      copy( src );
      return *this;
   }
   inline __Node &operator*() const { return *m_node; }
   inline __Node *operator->() const { return &(operator*()); }

   virtual inline __iterator &operator++(){ return __next(); }
   virtual inline  __iterator &operator--() { return __prev(); }

   virtual inline __iterator operator++(int) {
      __iterator tmp = *this;
      operator++();
      return tmp;
   }

   virtual inline __iterator operator--(int) {
      __iterator tmp = *this;
      operator++();
      return tmp;
   }

   inline bool operator==(const __iterator &conf) const
      { return m_node == conf.m_node; }
   inline bool operator!=( const __iterator &conf)
      { return m_node != conf.m_node; }
   inline __iterator &operator+=(const int count);
   inline __iterator &operator-=(const int count);
   inline __iterator operator+(const int count);
   inline __iterator operator-(const int count);
   inline __iterator operator[](const int count) { return operator+(count); }

};

template <class __Node>
class __deep_iterator:public __iterator< __Node>
{
protected:
   friend class Node;

   virtual inline __iterator<__Node> &__next();
   virtual inline __iterator<__Node> &__prev();
public:
   __deep_iterator( __Node *nd=0 ):__iterator< __Node>( nd ) {};
};

template <class __Node>
class __find_iterator:public __deep_iterator< __Node>
{
   std::string m_name;
   std::string m_attr;
   std::string m_valattr;
   std::string m_data;
   int m_maxmatch;

protected:
   friend class Node;
   __find_iterator( __Node *nd, std::string name, std::string attr,
               std::string valatt, std::string data);
   virtual inline __iterator<__Node> &__next();
   virtual inline __iterator<__Node> &__prev();
   virtual inline __iterator<__Node> &__find();
public:
   __find_iterator( __Node *nd=0 );

};

template <class __Node>
class __path_iterator:public __iterator< __Node>
{
   std::string m_path;
   virtual inline __Node *subfind( __Node *parent, std::string::size_type begin );

protected:
   friend class Node;
   __path_iterator( __Node *nd, std::string path );
   virtual inline __iterator<__Node> &__next();
   virtual inline __iterator<__Node> &__prev();
   virtual inline __iterator<__Node> &__find();
public:
   __path_iterator( __Node *nd=0 );
};

class Node: public Element
{

public:

   enum type
   {
      typeTag=0,
      typeXMLDecl,
      typeComment,
      typePI,
      typeDirective,
      typeData,
      typeDocument,   // used for document level root node
      typeFakeClosing // fake node type for </name> closing tags
   };

private:
   type m_type;
   std::string m_name;
   std::string m_data;
   AttribList m_attrib;
   AttribList::iterator m_lastFound;

   Node *m_parent;
   Node *m_child;
   Node *m_last_child;
   Node *m_next;
   Node *m_prev;

protected:
   void nodeIndent( std::ostream &out, const int depth, const int style ) const;

   void readData( std::istream in, const int iStyle );

public:
   Node( std::istream &in, const int style = 0, const int line=1, const int pos=0  )
      throw( MalformedError );

   /* Creates a new node
      Depending on the types the node could have a name, a data or both.
      \todo chech for name validity and throw an error
      @param tp one of the MXML::Node::type enum
      @param name the name of the newborn node
      @param type the value of the newborn attribute
   */
   Node( const type tp, const std::string &name = "", const std::string &data = "" ):
      Element()
   {
      m_type = tp;
      m_name = name;
      m_data = data;
      m_lastFound = m_attrib.end();

      m_child = m_last_child = m_prev = m_next = m_parent = 0;
   }

   Node( Node & );

   ~Node();

   const type nodeType() const { return m_type; }

   const std::string name() const { return m_name; }
   const std::string data() const { return m_data; }

   void name( const std::string &new_name ) { m_name = new_name; }

   void data( const std::string &new_value ) { m_data = new_value; }

   void addAttribute( Attribute *attrib )
   {
      m_attrib.push_back( attrib );
   }

   const std::string getAttribute( const std::string name ) const
      throw( NotFoundError );

   void setAttribute( const std::string name, const std::string value )
      throw( NotFoundError );

   bool hasAttribute( const std::string name ) const;

   void unlink();

   Node * unlinkComplete();

   void Node::removeChild( Node *child ) throw( NotFoundError );


   Node *parent() const { return m_parent; }
   Node *child() const { return m_child; }
   Node *next() const { return m_next; }
   Node *prev() const { return m_prev; }
   Node *lastChild() const { return m_last_child; }


   void addBelow( Node * );
   void insertBelow( Node * );
   void insertBefore( Node * );
   void insertAfter( Node * );

   int Node::depth() const;

   std::string Node::path() const;


   /* Clones the node and all its children.
      This effectively creates a copy of the tree of this object.
      @return the new node already linked to its children.
   */
   Node *clone();

   virtual void write( std::ostream &out, const int style ) const;


   typedef __iterator<Node> iterator;
   typedef __iterator<const Node> const_iterator;
   typedef __deep_iterator<Node> deep_iterator;
   typedef __deep_iterator<const Node> const_deep_iterator;
   typedef __find_iterator<Node> find_iterator;
   typedef __find_iterator<const Node> const_find_iterator;
   typedef __path_iterator<Node> path_iterator;
   typedef __path_iterator<const Node> const_path_iterator;

   iterator begin() { return  m_child; }
   iterator end() { return static_cast<Node *>(0); }
   const_iterator const_begin() const { return static_cast<const Node *>(m_child); }
   const_iterator const_end() { return static_cast<const Node *>(0); }
   deep_iterator deep_begin() { return  m_child; }

   find_iterator find( std::string name, std::string attrib="", std::string valatt="", std::string data="" );
   
   path_iterator find_path( std::string path );
};

#include <mxml_iterator.h>

} //namespace


#endif
/* end of mxml_node.cpp */

---