← Back to branch summary

~tapaal-ltl/verifypn/scc-optimise

« back to all changes in this revision

Viewing changes to PetriParse/rapidxml/rapidxml_iterators.hpp

  • Committer: srba.jiri at gmail
  • Date: 2020-09-11 14:23:39 UTC
  • mfrom: (213.1.151 interval_tar)
  • Revision ID: srba.jiri@gmail.com-20200911142339-bq9328s1gppw24uj
merged in lp:~verifypn-maintainers/verifypn/interval_tar doing 
- Implements TAR w/o z3, but using a simple integer inference engine for Hoare logic.
 - Replaces LP-Solve with GLPK, reduces computation-time and memory overhead
 - Implements new global properties, translated into CTL formulae.

Show diffs side-by-side

added added

removed removed

Lines of Context:
PetriParse/rapidxml/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