service/soft-sensor-manager/SSMCore/src/Common/rapidxml_iterators.hpp

   1 #ifndef RAPIDXML_ITERATORS_HPP_INCLUDED
   2 #define RAPIDXML_ITERATORS_HPP_INCLUDED
   3
   4 // Copyright (C) 2006, 2009 Marcin Kalicinski
   5 // Version 1.13
   6 // Revision $DateTime: 2009/05/13 01:46:17 $
   7 //! \file rapidxml_iterators.hpp This file contains rapidxml iterators
   8
   9 #include "rapidxml.hpp"
  10
  11 namespace rapidxml
  12 {
  13
  14     //! Iterator of child nodes of xml_node
  15     template<class Ch>
  16     class node_iterator
  17     {
  18
  19     public:
  20
  21         typedef typename xml_node<Ch> value_type;
  22         typedef typename xml_node<Ch> &reference;
  23         typedef typename xml_node<Ch> *pointer;
  24         typedef std::ptrdiff_t difference_type;
  25         typedef std::bidirectional_iterator_tag iterator_category;
  26
  27         node_iterator()
  28             : m_node(0)
  29         {
  30         }
  31
  32         node_iterator(xml_node<Ch> *node)
  33             : m_node(node->first_node())
  34         {
  35         }
  36
  37         reference operator *() const
  38         {
  39             assert(m_node);
  40             return *m_node;
  41         }
  42
  43         pointer operator->() const
  44         {
  45             assert(m_node);
  46             return m_node;
  47         }
  48
  49         node_iterator& operator++()
  50         {
  51             assert(m_node);
  52             m_node = m_node->next_sibling();
  53             return *this;
  54         }
  55
  56         node_iterator operator++(int)
  57         {
  58             node_iterator tmp = *this;
  59             ++this;
  60             return tmp;
  61         }
  62
  63         node_iterator& operator--()
  64         {
  65             assert(m_node && m_node->previous_sibling());
  66             m_node = m_node->previous_sibling();
  67             return *this;
  68         }
  69
  70         node_iterator operator--(int)
  71         {
  72             node_iterator tmp = *this;
  73             ++this;
  74             return tmp;
  75         }
  76
  77         bool operator ==(const node_iterator<Ch> &rhs)
  78         {
  79             return m_node == rhs.m_node;
  80         }
  81
  82         bool operator !=(const node_iterator<Ch> &rhs)
  83         {
  84             return m_node != rhs.m_node;
  85         }
  86
  87     private:
  88
  89         xml_node<Ch> *m_node;
  90
  91     };
  92
  93     //! Iterator of child attributes of xml_node
  94     template<class Ch>
  95     class attribute_iterator
  96     {
  97
  98     public:
  99
 100         typedef typename xml_attribute<Ch> value_type;
 101         typedef typename xml_attribute<Ch> &reference;
 102         typedef typename xml_attribute<Ch> *pointer;
 103         typedef std::ptrdiff_t difference_type;
 104         typedef std::bidirectional_iterator_tag iterator_category;
 105
 106         attribute_iterator()
 107             : m_attribute(0)
 108         {
 109         }
 110
 111         attribute_iterator(xml_node<Ch> *node)
 112             : m_attribute(node->first_attribute())
 113         {
 114         }
 115
 116         reference operator *() const
 117         {
 118             assert(m_attribute);
 119             return *m_attribute;
 120         }
 121
 122         pointer operator->() const
 123         {
 124             assert(m_attribute);
 125             return m_attribute;
 126         }
 127
 128         attribute_iterator& operator++()
 129         {
 130             assert(m_attribute);
 131             m_attribute = m_attribute->next_attribute();
 132             return *this;
 133         }
 134
 135         attribute_iterator operator++(int)
 136         {
 137             attribute_iterator tmp = *this;
 138             ++this;
 139             return tmp;
 140         }
 141
 142         attribute_iterator& operator--()
 143         {
 144             assert(m_attribute && m_attribute->previous_attribute());
 145             m_attribute = m_attribute->previous_attribute();
 146             return *this;
 147         }
 148
 149         attribute_iterator operator--(int)
 150         {
 151             attribute_iterator tmp = *this;
 152             ++this;
 153             return tmp;
 154         }
 155
 156         bool operator ==(const attribute_iterator<Ch> &rhs)
 157         {
 158             return m_attribute == rhs.m_attribute;
 159         }
 160
 161         bool operator !=(const attribute_iterator<Ch> &rhs)
 162         {
 163             return m_attribute != rhs.m_attribute;
 164         }
 165
 166     private:
 167
 168         xml_attribute<Ch> *m_attribute;
 169
 170     };
 171
 172 }
 173
 174 #endif