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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
#pragma once
#include "Iterator.h"
#ifndef DOXYGEN_GENERATING_OUTPUT
namespace nCine
{
/// A generic reverse iterator
template<class Iterator>
class ReverseIterator
{
public:
/// Pointer type which respects iterator constness
using Pointer = typename IteratorTraits<Iterator>::Pointer;
/// Reference type which respects iterator constness
using Reference = typename IteratorTraits<Iterator>::Reference;
explicit ReverseIterator(Iterator it)
: it_(it) {}
/// Converting constructor between compatible reverse iterators
template <typename Iter>
ReverseIterator(const ReverseIterator<Iter>& reverseIt)
: it_(reverseIt.base()) {}
/// Deferencing operator
Reference operator*() const;
/// Iterates to the next element (reversed prefix)
ReverseIterator& operator++();
/// Iterates to the next element (reversed postfix)
ReverseIterator operator++(int);
/// Iterates to the previous element (reversed prefix)
ReverseIterator& operator--();
/// Iterates to the previous element (reversed postfix)
ReverseIterator operator--(int);
/// Compound addition operator (reversed)
ReverseIterator& operator+=(std::int32_t n);
/// Compound subtraction operator (reversed)
ReverseIterator& operator-=(std::int32_t n);
/// Addition operator (reversed)
ReverseIterator operator+(std::int32_t n) const;
/// Subtraction operator (reversed)
ReverseIterator operator-(std::int32_t n) const;
/// Pointer subtraction operator (reversed)
friend inline std::int32_t operator-(const ReverseIterator& lhs, const ReverseIterator& rhs) {
return -std::int32_t(lhs.it_ - rhs.it_);
}
/// Pointer subtraction operator for compatible reverse iterators (reversed)
template <typename Iter>
friend inline std::int32_t operator-(const ReverseIterator& lhs, const ReverseIterator<Iter>& rhs) {
return -std::int32_t(lhs.it_ - rhs.base());
}
/// Subscript operator
Reference operator[](std::int32_t n) const;
/// Equality operator
friend inline bool operator==(const ReverseIterator& lhs, const ReverseIterator& rhs) {
return lhs.it_ == rhs.it_;
}
/// Equality operator for compatible reverse iterators
template <typename Iter>
friend inline bool operator==(const ReverseIterator& lhs, const ReverseIterator<Iter>& rhs) {
return lhs.it_ == rhs.base();
}
/// Inequality operator
friend inline bool operator!=(const ReverseIterator& lhs, const ReverseIterator& rhs) {
return lhs.it_ != rhs.it_;
}
/// Inequality operator for compatible reverse iterators
template <typename Iter>
friend inline bool operator!=(const ReverseIterator& lhs, const ReverseIterator<Iter>& rhs) {
return lhs.it_ != rhs.base();
}
/// Greater than operator (reversed)
friend inline bool operator>(const ReverseIterator& lhs, const ReverseIterator& rhs) {
return lhs.it_ < rhs.it_;
}
template <typename Iter>
/// Greater than operator for compatible reverse iterators (reversed)
friend inline bool operator>(const ReverseIterator& lhs, const ReverseIterator<Iter>& rhs) {
return lhs.it_ < rhs.base();
}
/// Less than operator (reversed)
friend inline bool operator<(const ReverseIterator& lhs, const ReverseIterator& rhs) {
return lhs.it_ > rhs.it_;
}
/// Less than operator for compatible reverse iterators (reversed)
template <typename Iter>
friend inline bool operator<(const ReverseIterator& lhs, const ReverseIterator<Iter>& rhs) {
return lhs.it_ > rhs.base();
}
/// Greater than or equal to operator (reversed)
friend inline bool operator>=(const ReverseIterator& lhs, const ReverseIterator& rhs) {
return lhs.it_ <= rhs.it_;
}
/// Greater than or equal to operator for compatible reverse iterators (reversed)
template <typename Iter>
friend inline bool operator>=(const ReverseIterator& lhs, const ReverseIterator<Iter>& rhs) {
return lhs.it_ <= rhs.base();
}
/// Less than or equal to operator (reversed)
friend inline bool operator<=(const ReverseIterator& lhs, const ReverseIterator& rhs) {
return lhs.it_ >= rhs.it_;
}
/// Less than or equal to operator for compatible reverse iterators (reversed)
template <typename Iter>
friend inline bool operator<=(const ReverseIterator& lhs, const ReverseIterator<Iter>& rhs) {
return lhs.it_ >= rhs.base();
}
/// Returns the base iterator
Iterator base() const;
private:
Iterator it_;
};
/// Iterator traits structure specialization for `ReverseIterator` class
template<class Iterator>
struct IteratorTraits<ReverseIterator<Iterator>>
{
/// Type of the values deferenced by the iterator
using ValueType = typename Iterator::ValueType;
/// Pointer to the type of the values deferenced by the iterator
using Pointer = typename Iterator::Pointer;
/// Reference to the type of the values deferenced by the iterator
using Reference = typename Iterator::Reference;
/// Type trait for iterator category
static inline decltype(Iterator::IteratorCategory()) IteratorCategory() {
return Iterator::IteratorCategory();
}
};
template<class Iterator>
inline typename ReverseIterator<Iterator>::Reference ReverseIterator<Iterator>::operator*() const
{
return *it_;
}
template<class Iterator>
ReverseIterator<Iterator>& ReverseIterator<Iterator>::operator++()
{
--it_;
return *this;
}
template<class Iterator>
ReverseIterator<Iterator> ReverseIterator<Iterator>::operator++(int)
{
// Create an unmodified copy to return
ReverseIterator<Iterator> iterator = *this;
--it_;
return iterator;
}
template<class Iterator>
ReverseIterator<Iterator>& ReverseIterator<Iterator>::operator--()
{
++it_;
return *this;
}
template<class Iterator>
ReverseIterator<Iterator> ReverseIterator<Iterator>::operator--(int)
{
// Create an unmodified copy to return
ReverseIterator<Iterator> iterator = *this;
++it_;
return iterator;
}
template<class Iterator>
ReverseIterator<Iterator>& ReverseIterator<Iterator>::operator+=(std::int32_t n)
{
it_ -= n;
return *this;
}
template<class Iterator>
ReverseIterator<Iterator>& ReverseIterator<Iterator>::operator-=(std::int32_t n)
{
it_ += n;
return *this;
}
template<class Iterator>
ReverseIterator<Iterator> ReverseIterator<Iterator>::operator+(std::int32_t n) const
{
ReverseIterator<Iterator> iterator = *this;
iterator.it_ -= n;
return iterator;
}
template<class Iterator>
ReverseIterator<Iterator> ReverseIterator<Iterator>::operator-(std::int32_t n) const
{
ReverseIterator<Iterator> iterator = *this;
iterator.it_ += n;
return iterator;
}
template<class Iterator>
inline typename ReverseIterator<Iterator>::Reference ReverseIterator<Iterator>::operator[](std::int32_t n) const
{
return *(it_ - n);
}
template<class Iterator>
inline Iterator ReverseIterator<Iterator>::base() const
{
return it_;
}
}
#endif
|
