1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
/* Ptr_Iterator class declaration.
Copyright (C) 2001-2010 Roberto Bagnara <bagnara@cs.unipr.it>
Copyright (C) 2010-2011 BUGSENG srl (http://bugseng.com)
This file is part of the Parma Polyhedra Library (PPL).
The PPL is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 3 of the License, or (at your
option) any later version.
The PPL is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.
For the most up-to-date information see the Parma Polyhedra Library
site: http://www.cs.unipr.it/ppl/ . */
#ifndef PPL_Ptr_Iterator_defs_hh
#define PPL_Ptr_Iterator_defs_hh 1
#include "Ptr_Iterator.types.hh"
#include <iterator>
namespace Parma_Polyhedra_Library {
namespace Implementation {
template<typename Q, typename R>
bool operator==(const Ptr_Iterator<Q>& x, const Ptr_Iterator<R>& y);
template<typename Q, typename R>
bool operator!=(const Ptr_Iterator<Q>& x, const Ptr_Iterator<R>& y);
template<typename Q, typename R>
bool operator<(const Ptr_Iterator<Q>& x, const Ptr_Iterator<R>& y);
template<typename Q, typename R>
bool operator<=(const Ptr_Iterator<Q>& x, const Ptr_Iterator<R>& y);
template<typename Q, typename R>
bool operator>(const Ptr_Iterator<Q>& x, const Ptr_Iterator<R>& y);
template<typename Q, typename R>
bool operator>=(const Ptr_Iterator<Q>& x, const Ptr_Iterator<R>& y);
template<typename Q, typename R>
typename Ptr_Iterator<Q>::difference_type operator-(const Ptr_Iterator<Q>& x,
const Ptr_Iterator<R>& y);
template<typename P>
Ptr_Iterator<P> operator+(typename Ptr_Iterator<P>::difference_type m,
const Ptr_Iterator<P>& y);
} // namespace Implementation
} // namespace Parma_Polyhedra_Library
#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
//! A class to define STL const and non-const iterators from pointer types.
#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
template <typename P>
class Parma_Polyhedra_Library::Implementation::Ptr_Iterator
: public std::iterator<typename std::iterator_traits<P>::iterator_category,
typename std::iterator_traits<P>::value_type,
typename std::iterator_traits<P>::difference_type,
typename std::iterator_traits<P>::pointer,
typename std::iterator_traits<P>::reference> {
public:
typedef typename std::iterator_traits<P>::difference_type difference_type;
typedef typename std::iterator_traits<P>::reference reference;
typedef typename std::iterator_traits<P>::pointer pointer;
//! Default constructor: no guarantees.
Ptr_Iterator();
//! Construct an iterator pointing at \p q.
explicit Ptr_Iterator(const P& q);
/*! \brief
Copy constructor allowing the construction of a const_iterator
from a non-const iterator.
*/
template<typename Q>
Ptr_Iterator(const Ptr_Iterator<Q>& q);
//! Dereference operator.
reference operator*() const;
//! Indirect member selector.
pointer operator->() const;
//! Subscript operator.
reference operator[](const difference_type m) const;
//! Prefix increment operator.
Ptr_Iterator& operator++();
//! Postfix increment operator.
Ptr_Iterator operator++(int);
//! Prefix decrement operator
Ptr_Iterator& operator--();
//! Postfix decrement operator.
Ptr_Iterator operator--(int);
//! Assignment-increment operator.
Ptr_Iterator& operator+=(const difference_type m);
//! Assignment-decrement operator.
Ptr_Iterator& operator-=(const difference_type m);
//! Returns the difference between \p *this and \p y.
difference_type operator-(const Ptr_Iterator& y) const;
//! Returns the sum of \p *this and \p m.
Ptr_Iterator operator+(const difference_type m) const;
//! Returns the difference of \p *this and \p m.
Ptr_Iterator operator-(const difference_type m) const;
private:
//! The base pointer implementing the iterator.
P p;
//! Returns the hidden pointer.
const P& base() const;
template <typename Q, typename R>
friend bool Parma_Polyhedra_Library::Implementation::
operator==(const Ptr_Iterator<Q>& x, const Ptr_Iterator<R>& y);
template <typename Q, typename R>
friend bool Parma_Polyhedra_Library::Implementation::
operator!=(const Ptr_Iterator<Q>& x, const Ptr_Iterator<R>& y);
template<typename Q, typename R>
friend bool Parma_Polyhedra_Library::Implementation::
operator<(const Ptr_Iterator<Q>& x, const Ptr_Iterator<R>& y);
template<typename Q, typename R>
friend bool Parma_Polyhedra_Library::Implementation::
operator<=(const Ptr_Iterator<Q>& x, const Ptr_Iterator<R>& y);
template<typename Q, typename R>
friend bool Parma_Polyhedra_Library::Implementation::
operator>(const Ptr_Iterator<Q>& x, const Ptr_Iterator<R>& y);
template<typename Q, typename R>
friend bool Parma_Polyhedra_Library::Implementation::
operator>=(const Ptr_Iterator<Q>& x, const Ptr_Iterator<R>& y);
template<typename Q, typename R>
friend typename Ptr_Iterator<Q>::difference_type
Parma_Polyhedra_Library::Implementation::
operator-(const Ptr_Iterator<Q>& x, const Ptr_Iterator<R>& y);
friend Ptr_Iterator<P>
Parma_Polyhedra_Library::Implementation::
operator+<>(typename Ptr_Iterator<P>::difference_type m,
const Ptr_Iterator<P>& y);
};
#include "Ptr_Iterator.inlines.hh"
#endif // !defined(PPL_Ptr_Iterator_defs_hh)
|
