-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathiterator.hpp
300 lines (257 loc) · 13.2 KB
/
iterator.hpp
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
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* iterator.hpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mannouao <mannouao@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/07/04 18:25:49 by mannouao #+# #+# */
/* Updated: 2022/07/31 10:46:40 by mannouao ### ########.fr */
/* */
/* ************************************************************************** */
# ifndef ITERATOR_HPP
# define ITERATOR_HPP
# include "type_traits.hpp"
namespace ft
{
// iterator_traits ---------------------------------------------------------------------------------------------------------------
template<typename _Tp>
struct iterator_traits
{
typedef typename _Tp::difference_type difference_type;
typedef typename _Tp::value_type value_type;
typedef typename _Tp::pointer pointer;
typedef typename _Tp::reference reference;
typedef typename _Tp::iterator_category iterator_category;
};
template<typename _Tp>
struct iterator_traits <_Tp *>
{
typedef ptrdiff_t difference_type;
typedef _Tp value_type;
typedef _Tp* pointer;
typedef _Tp& reference;
typedef std::random_access_iterator_tag iterator_category;
};
template<typename _Tp>
struct iterator_traits <const _Tp *>
{
typedef ptrdiff_t difference_type;
typedef _Tp value_type;
typedef const _Tp* pointer;
typedef const _Tp& reference;
typedef std::random_access_iterator_tag iterator_category;
};
// -------------------------------------------------------------------------------------------------------------------------------
// iterator ----------------------------------------------------------------------------------------------------------------------
template <typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
typename _Pointer = _Tp*, typename _Reference = _Tp&>
struct iterator
{
typedef _Tp value_type;
typedef _Distance difference_type;
typedef _Pointer pointer;
typedef _Reference reference;
typedef _Category iterator_category;
};
// -------------------------------------------------------------------------------------------------------------------------------
// __wrap_iter -------------------------------------------------------------------------------------------------------------------
template<typename _Iter>
class __wrap_iter
{
public:
typedef _Iter iterator_type;
typedef typename ft::iterator_traits<iterator_type>::iterator_category iterator_category;
typedef typename ft::iterator_traits<iterator_type>::value_type value_type;
typedef typename ft::iterator_traits<iterator_type>::difference_type difference_type;
typedef typename ft::iterator_traits<iterator_type>::pointer pointer;
typedef typename ft::iterator_traits<iterator_type>::reference reference;
private:
iterator_type __i;
public:
__wrap_iter() {}
template<class _Up> __wrap_iter(const ft::__wrap_iter<_Up>& __u) : __i(__u.base()) {}
template<class _Up> __wrap_iter& operator = (const ft::__wrap_iter<_Up>& __u) { __i = __u.base(); return *this; }
reference operator * () const { return *__i; }
pointer operator -> () const { return __i; }
__wrap_iter& operator ++ () { ++__i; return *this; }
__wrap_iter operator ++ (int) { __wrap_iter __tmp(*this); ++__i; return __tmp; }
__wrap_iter& operator -- () { --__i; return *this; }
__wrap_iter operator -- (int) { __wrap_iter __tmp(*this); --__i; return __tmp; }
__wrap_iter operator + (difference_type __n) const { __wrap_iter __w(*this); __w += __n; return __w; }
__wrap_iter& operator += (difference_type __n) { __i += __n; return *this; }
__wrap_iter operator - (difference_type __n) const { return *this + (-__n); }
__wrap_iter& operator -= (difference_type __n) { __i -= __n; return *this; }
reference operator [] (difference_type __n) const { return __i[__n]; }
iterator_type base() const { return __i; }
__wrap_iter(iterator_type __x) : __i(__x) {}
};
template<typename _Iter1, typename _Iter2>
bool operator == (const ft::__wrap_iter<_Iter1>& __x, const ft::__wrap_iter<_Iter2>& __y)
{ return __x.base() == __y.base(); }
template<typename _Iter1, typename _Iter2>
bool operator < (const ft::__wrap_iter<_Iter1>& __x, const ft::__wrap_iter<_Iter2>& __y)
{ return __x.base() < __y.base(); }
template<typename _Iter1, typename _Iter2>
bool operator != (const ft::__wrap_iter<_Iter1>& __x, const ft::__wrap_iter<_Iter2>& __y)
{ return !(__x == __y); }
template<typename _Iter1, typename _Iter2>
bool operator > (const ft::__wrap_iter<_Iter1>& __x, const ft::__wrap_iter<_Iter2>& __y)
{ return __y < __x; }
template<typename _Iter1, typename _Iter2>
bool operator >= (const ft::__wrap_iter<_Iter1>& __x, const ft::__wrap_iter<_Iter2>& __y)
{ return !(__x < __y); }
template<typename _Iter1, typename _Iter2>
bool operator <= (const ft::__wrap_iter<_Iter1>& __x, const ft::__wrap_iter<_Iter2>& __y)
{ return !(__y < __x); }
template<typename _Iter1, typename _Iter2>
typename __wrap_iter<_Iter1>::difference_type operator - (const ft::__wrap_iter<_Iter1>& __x, const ft::__wrap_iter<_Iter2>& __y)
{ return __x.base() - __y.base(); }
template<typename _Iter>
__wrap_iter<_Iter> operator + (typename ft::__wrap_iter<_Iter>::difference_type __n, ft::__wrap_iter<_Iter> __x)
{ __x += __n; return __x; }
// -------------------------------------------------------------------------------------------------------------------------------
// reverse_iterator --------------------------------------------------------------------------------------------------------------
template<typename _Iter>
class reverse_iterator
: public ft::iterator<typename ft::iterator_traits<_Iter>::iterator_category,
typename ft::iterator_traits<_Iter>::value_type,
typename ft::iterator_traits<_Iter>::difference_type,
typename ft::iterator_traits<_Iter>::pointer,
typename ft::iterator_traits<_Iter>::reference>
{
protected:
_Iter current;
public:
typedef _Iter iterator_type;
typedef typename ft::iterator_traits<_Iter>::difference_type difference_type;
typedef typename ft::iterator_traits<_Iter>::reference reference;
typedef typename ft::iterator_traits<_Iter>::pointer pointer;
reverse_iterator () : current() {}
explicit reverse_iterator (_Iter __x) : current(__x) {}
template<typename _Up> reverse_iterator (const ft::reverse_iterator<_Up>& __u) : current(__u.base()) {}
template<typename _Up>
reverse_iterator& operator = (const ft::reverse_iterator<_Up>& __u) { current = __u.base(); return *this; }
_Iter base() const { return current; }
reference operator * () const { _Iter __tmp = current; return *--__tmp; }
pointer operator -> () const { return &operator*(); }
reverse_iterator& operator ++ () { --current; return *this; }
reverse_iterator operator ++ (int) { reverse_iterator __tmp(*this); --current; return __tmp; }
reverse_iterator& operator -- () { ++current; return *this; }
reverse_iterator operator -- (int) { reverse_iterator __tmp(*this); ++current; return __tmp; }
reverse_iterator operator + (difference_type __n) const { return reverse_iterator(current - __n); }
reverse_iterator& operator += (difference_type __n) { current -= __n; return *this; }
reverse_iterator operator - (difference_type __n) const { return reverse_iterator(current + __n); }
reverse_iterator& operator -= (difference_type __n) { current += __n; return *this; }
reference operator [] (difference_type __n) { return *(*this + __n); }
};
template<typename _Iter1, typename _Iter2>
bool operator == (const ft::reverse_iterator<_Iter1>& __x, const ft::reverse_iterator<_Iter2>& __y)
{ return __x.base() == __y.base(); }
template<typename _Iter1, typename _Iter2>
bool operator < (const ft::reverse_iterator<_Iter1>& __x, const ft::reverse_iterator<_Iter2>& __y)
{ return __x.base() > __y.base(); }
template<typename _Iter1, typename _Iter2>
bool operator != (const ft::reverse_iterator<_Iter1>& __x, const ft::reverse_iterator<_Iter2>& __y)
{ return __x.base() != __y.base(); }
template<typename _Iter1, typename _Iter2>
bool operator > (const ft::reverse_iterator<_Iter1>& __x, const ft::reverse_iterator<_Iter2>& __y)
{ return __x.base() < __y.base(); }
template<typename _Iter1, typename _Iter2>
bool operator >= (const ft::reverse_iterator<_Iter1>& __x, const ft::reverse_iterator<_Iter2>& __y)
{ return __x.base() <= __y.base(); }
template<typename _Iter1, typename _Iter2>
bool operator <= (const ft::reverse_iterator<_Iter1>& __x, const ft::reverse_iterator<_Iter2>& __y)
{ return __x.base() >= __y.base(); }
template<typename _Iter1, typename _Iter2>
typename ft::reverse_iterator<_Iter1>::difference_type
operator - (const ft::reverse_iterator<_Iter1>& __x, const ft::reverse_iterator<_Iter2>& __y)
{ return __y.base() - __x.base(); }
template<typename _Iter>
ft::reverse_iterator<_Iter> operator + (typename ft::reverse_iterator<_Iter>::difference_type __n, const ft::reverse_iterator<_Iter>& __x)
{ return ft::reverse_iterator<_Iter>(__x.base() - __n); }
// -------------------------------------------------------------------------------------------------------------------------------
// distance ----------------------------------------------------------------------------------------------------------------------
template<typename _InputIter>
typename ft::iterator_traits<_InputIter>::difference_type
distance(_InputIter __first, _InputIter __last, std::input_iterator_tag)
{
typename ft::iterator_traits<_InputIter>::difference_type __i(0);
for (; __first != __last ; ++__first)
++__i;
return __i;
}
template<typename _InputIter>
typename ft::iterator_traits<_InputIter>::difference_type
distance(_InputIter __first, _InputIter __last, std::random_access_iterator_tag)
{ return __last - __first; }
template<typename _InputIter>
typename ft::iterator_traits<_InputIter>::difference_type
distance(_InputIter __first, _InputIter __last)
{
return distance(__first, __last, typename ft::iterator_traits<_InputIter>::iterator_category());
}
// -------------------------------------------------------------------------------------------------------------------------------
// __map_iter --------------------------------------------------------------------------------------------------------------------
template<class _Iter, class _Node_ptr>
class __map_iter
{
public:
typedef _Iter iterator_type;
typedef std::bidirectional_iterator_tag iterator_category;
typedef typename ft::iterator_traits<iterator_type>::value_type value_type;
typedef typename ft::iterator_traits<iterator_type>::difference_type difference_type;
typedef typename ft::iterator_traits<iterator_type>::pointer pointer;
typedef typename ft::iterator_traits<iterator_type>::reference reference;
private:
_Node_ptr __i;
public:
__map_iter() {}
template<class _Up, class _Up_node>
__map_iter(const __map_iter<_Up, _Up_node>& __u) : __i((_Node_ptr)__u.base()) {}
template<class _Up, class _Up_node>
__map_iter& operator = (const ft::__map_iter<_Up, _Up_node>& __u) { __i = (_Node_ptr)__u.base(); return *this; }
reference operator * () const { return *(__i->__value_); }
pointer operator -> () const { return __i->__value_; }
__map_iter& operator ++ ()
{
if (__i->__right_ != NULL)
for(__i = __i->__right_; __i->__left_ != NULL;)
__i = __i->__left_;
else
{
while (__i == __i->__parent_->__right_)
__i = __i->__parent_;
__i = __i->__parent_;
}
return *this;
}
__map_iter operator ++ (int) { __map_iter __tmp(*this); ++*this; return __tmp; }
__map_iter& operator -- ()
{
if (__i->__left_ != NULL)
for (__i = __i->__left_; __i->__right_ != NULL;)
__i = __i->__right_;
else
{
while(__i == __i->__parent_->__left_)
__i = __i->__parent_;
__i = __i->__parent_;
}
return *this;
}
__map_iter operator -- (int) {__map_iter __tmp(*this); --*this; return __tmp; }
__map_iter(_Node_ptr __x) : __i(__x) {}
_Node_ptr base() const { return (__i); }
template<class _Iter1, class _Node_ptr1, class _Iter2, class _Node_ptr2>
friend bool operator == (const __map_iter<_Iter1, _Node_ptr1>& __x, const __map_iter<_Iter2, _Node_ptr2>& __y);
};
template<class _Iter1, class _Node_ptr1, class _Iter2, class _Node_ptr2>
bool operator == (const __map_iter<_Iter1, _Node_ptr1>& __x, const __map_iter<_Iter2, _Node_ptr2>& __y)
{ return __x.__i == (_Node_ptr1)__y.__i; }
template<class _Iter1, class _Node_ptr1, class _Iter2, class _Node_ptr2>
bool operator != (const __map_iter<_Iter1, _Node_ptr1>& __x, const __map_iter<_Iter2, _Node_ptr2>& __y)
{ return !(__x == __y); }
// -------------------------------------------------------------------------------------------------------------------------------
} // ft
# endif