1/*
2 *
3 * Copyright (c) 1994
4 * Hewlett-Packard Company
5 *
6 * Copyright (c) 1996-1998
7 * Silicon Graphics Computer Systems, Inc.
8 *
9 * Copyright (c) 1997
10 * Moscow Center for SPARC Technology
11 *
12 * Copyright (c) 1999
13 * Boris Fomitchev
14 *
15 * This material is provided "as is", with absolutely no warranty expressed
16 * or implied. Any use is at your own risk.
17 *
18 * Permission to use or copy this software for any purpose is hereby granted
19 * without fee, provided the above notices are retained on all copies.
20 * Permission to modify the code and to distribute modified code is granted,
21 * provided the above notices are retained, and a notice that the code was
22 * modified is included with the above copyright notice.
23 *
24 */
25
26/* NOTE: This is an internal header file, included by other STL headers.
27 *   You should not attempt to use it directly.
28 */
29
30#ifndef _STLP_INTERNAL_ITERATOR_OLD_H
31#define _STLP_INTERNAL_ITERATOR_OLD_H
32
33#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
34#  include <stl/_iterator_base.h>
35#endif
36
37_STLP_BEGIN_NAMESPACE
38
39#ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
40
41template <class _Container>
42inline output_iterator_tag _STLP_CALL
43iterator_category(const back_insert_iterator<_Container>&) { return output_iterator_tag(); }
44template <class _Container>
45inline output_iterator_tag _STLP_CALL
46iterator_category(const front_insert_iterator<_Container>&) { return output_iterator_tag(); }
47template <class _Container>
48inline output_iterator_tag _STLP_CALL
49iterator_category(const insert_iterator<_Container>&) { return output_iterator_tag(); }
50
51#endif
52
53template <class _BidirectionalIterator, class _Tp,
54          _STLP_DFL_TMPL_PARAM(_Reference, _Tp& ),
55#if defined (_STLP_MSVC50_COMPATIBILITY)
56#  define __Reference _Reference, class _Pointer
57#  define Reference__ _Reference, _Pointer
58          _STLP_DFL_TMPL_PARAM(_Pointer, _Tp*),
59#else
60#  define __Reference _Reference
61#  define Reference__ _Reference
62#endif
63          _STLP_DFL_TYPE_PARAM(_Distance, ptrdiff_t)>
64class reverse_bidirectional_iterator {
65  typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
66                                         Reference__, _Distance> _Self;
67  //  friend inline bool operator== _STLP_NULL_TMPL_ARGS (const _Self& x, const _Self& y);
68protected:
69  _BidirectionalIterator current;
70public:
71  typedef bidirectional_iterator_tag iterator_category;
72  typedef _Tp                        value_type;
73  typedef _Distance                  difference_type;
74#  if defined (_STLP_MSVC50_COMPATIBILITY)
75  typedef _Pointer                   pointer;
76#  else
77  typedef _Tp*                       pointer;
78#  endif
79  typedef _Reference                 reference;
80
81  reverse_bidirectional_iterator() {}
82  explicit reverse_bidirectional_iterator(_BidirectionalIterator __x)
83    : current(__x) {}
84  _BidirectionalIterator base() const { return current; }
85  _Reference operator*() const {
86    _BidirectionalIterator __tmp = current;
87    return *(--__tmp);
88  }
89
90  _STLP_DEFINE_ARROW_OPERATOR
91
92  _Self& operator++() {
93    --current;
94    return *this;
95  }
96  _Self operator++(int) {
97    _Self __tmp = *this;
98    --current;
99    return __tmp;
100  }
101  _Self& operator--() {
102    ++current;
103    return *this;
104  }
105  _Self operator--(int) {
106    _Self __tmp = *this;
107    ++current;
108    return __tmp;
109  }
110};
111
112#ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
113template <class _BidirectionalIterator, class _Tp, class __Reference,
114          class _Distance>
115inline bidirectional_iterator_tag _STLP_CALL
116iterator_category(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, Reference__, _Distance>&)
117{ return bidirectional_iterator_tag(); }
118template <class _BidirectionalIterator, class _Tp, class __Reference,
119  class _Distance>
120inline _Tp* _STLP_CALL
121value_type(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, Reference__, _Distance>&)
122{ return (_Tp*) 0; }
123template <class _BidirectionalIterator, class _Tp, class __Reference,
124          class _Distance>
125inline _Distance* _STLP_CALL
126distance_type(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, Reference__, _Distance>&)
127{ return (_Distance*) 0; }
128#endif
129
130template <class _BidirectionalIterator, class _Tp, class __Reference,
131          class _Distance>
132inline bool  _STLP_CALL operator==(
133    const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
134                                               Reference__, _Distance>& __x,
135    const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
136                                               Reference__, _Distance>& __y)
137{ return __x.base() == __y.base(); }
138
139#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
140
141template <class _BiIter, class _Tp, class __Reference, class _Distance>
142inline bool  _STLP_CALL operator!=(
143    const reverse_bidirectional_iterator<_BiIter, _Tp, Reference__, _Distance>& __x,
144    const reverse_bidirectional_iterator<_BiIter, _Tp, Reference__, _Distance>& __y)
145{ return !(__x == __y); }
146
147#endif
148
149#if !defined ( _STLP_CLASS_PARTIAL_SPECIALIZATION )
150
151// This is the old version of reverse_iterator, as found in the original
152//  HP STL.  It does not use partial specialization.
153
154template <class _RandomAccessIterator, class _Tp,
155          _STLP_DFL_TMPL_PARAM(_Reference,_Tp&),
156#  if defined (_STLP_MSVC50_COMPATIBILITY)
157          _STLP_DFL_TMPL_PARAM(_Pointer, _Tp*),
158#  endif
159          _STLP_DFL_TYPE_PARAM(_Distance,ptrdiff_t)>
160class reverse_iterator {
161  typedef reverse_iterator<_RandomAccessIterator, _Tp, Reference__, _Distance> _Self;
162protected:
163  _RandomAccessIterator __current;
164public:
165  typedef random_access_iterator_tag iterator_category;
166  typedef _Tp                        value_type;
167  typedef _Distance                  difference_type;
168#  if defined (_STLP_MSVC50_COMPATIBILITY)
169  typedef _Pointer                   pointer;
170#  else
171  typedef _Tp*                       pointer;
172#  endif
173  typedef _Reference                 reference;
174
175  reverse_iterator() {}
176  reverse_iterator(const _Self& __x) : __current(__x.base()) {}
177  explicit reverse_iterator(_RandomAccessIterator __x) : __current(__x) {}
178  _Self& operator=(const _Self& __x) {__current = __x.base(); return *this; }
179
180  _RandomAccessIterator base() const { return __current; }
181  _Reference operator*() const { return *(__current - (difference_type)1); }
182
183  _STLP_DEFINE_ARROW_OPERATOR
184
185  _Self& operator++() {
186    --__current;
187    return *this;
188  }
189  _Self operator++(int) {
190    _Self __tmp = *this;
191    --__current;
192    return __tmp;
193  }
194  _Self& operator--() {
195    ++__current;
196    return *this;
197  }
198  _Self operator--(int) {
199    _Self __tmp = *this;
200    ++__current;
201    return __tmp;
202  }
203  _Self operator+(_Distance __n) const {
204    return _Self(__current - __n);
205  }
206  _Self& operator+=(_Distance __n) {
207    __current -= __n;
208    return *this;
209  }
210  _Self operator-(_Distance __n) const {
211    return _Self(__current + __n);
212  }
213  _Self& operator-=(_Distance __n) {
214    __current += __n;
215    return *this;
216  }
217  _Reference operator[](_Distance __n) const { return *(*this + __n); }
218};
219
220#  ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
221template <class _RandomAccessIterator, class _Tp,
222          class __Reference, class _Distance>
223inline random_access_iterator_tag _STLP_CALL
224iterator_category(const reverse_iterator<_RandomAccessIterator, _Tp, Reference__, _Distance>&)
225{ return random_access_iterator_tag(); }
226template <class _RandomAccessIterator, class _Tp,
227  class __Reference, class _Distance>
228inline _Tp*  _STLP_CALL value_type(const reverse_iterator<_RandomAccessIterator, _Tp, Reference__, _Distance>&)
229{ return (_Tp*) 0; }
230template <class _RandomAccessIterator, class _Tp,
231          class __Reference, class _Distance>
232inline _Distance*  _STLP_CALL
233distance_type(const reverse_iterator<_RandomAccessIterator, _Tp, Reference__, _Distance>&)
234{ return (_Distance*) 0; }
235#  endif
236
237template <class _RandomAccessIterator, class _Tp,
238          class __Reference, class _Distance>
239inline bool  _STLP_CALL
240operator==(const reverse_iterator<_RandomAccessIterator, _Tp,
241                                  Reference__, _Distance>& __x,
242           const reverse_iterator<_RandomAccessIterator, _Tp,
243                                  Reference__, _Distance>& __y)
244{
245  return __x.base() == __y.base();
246}
247
248template <class _RandomAccessIterator, class _Tp,
249          class __Reference, class _Distance>
250inline bool _STLP_CALL
251operator<(const reverse_iterator<_RandomAccessIterator, _Tp,
252                                 Reference__, _Distance>& __x,
253          const reverse_iterator<_RandomAccessIterator, _Tp,
254                                 Reference__, _Distance>& __y)
255{
256  return __y.base() < __x.base();
257}
258
259#  ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
260
261template <class _RandomAccessIterator, class _Tp,
262          class __Reference, class _Distance>
263inline bool _STLP_CALL
264operator!=(const reverse_iterator<_RandomAccessIterator, _Tp,
265                                  Reference__, _Distance>& __x,
266           const reverse_iterator<_RandomAccessIterator, _Tp,
267                                  Reference__, _Distance>& __y) {
268  return !(__x == __y);
269}
270
271template <class _RandomAccessIterator, class _Tp,
272          class __Reference, class _Distance>
273inline bool _STLP_CALL
274operator>(const reverse_iterator<_RandomAccessIterator, _Tp,
275                                 Reference__, _Distance>& __x,
276          const reverse_iterator<_RandomAccessIterator, _Tp,
277                                 Reference__, _Distance>& __y) {
278  return __y < __x;
279}
280
281template <class _RandomAccessIterator, class _Tp,
282          class __Reference, class _Distance>
283inline bool _STLP_CALL
284operator<=(const reverse_iterator<_RandomAccessIterator, _Tp,
285                                  Reference__, _Distance>& __x,
286           const reverse_iterator<_RandomAccessIterator, _Tp,
287                                  Reference__, _Distance>& __y) {
288  return !(__y < __x);
289}
290
291template <class _RandomAccessIterator, class _Tp,
292          class __Reference, class _Distance>
293inline bool _STLP_CALL
294operator>=(const reverse_iterator<_RandomAccessIterator, _Tp,
295                                  Reference__, _Distance>& __x,
296           const reverse_iterator<_RandomAccessIterator, _Tp,
297                                  Reference__, _Distance>& __y) {
298  return !(__x < __y);
299}
300
301#  endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
302
303template <class _RandomAccessIterator, class _Tp,
304          class __Reference, class _Distance>
305inline _Distance  _STLP_CALL
306operator-(const reverse_iterator<_RandomAccessIterator, _Tp,
307                                 Reference__, _Distance>& __x,
308          const reverse_iterator<_RandomAccessIterator, _Tp,
309                                 Reference__, _Distance>& __y)
310{
311  return __y.base() - __x.base();
312}
313
314template <class _RandomAccessIterator, class _Tp,
315          class __Reference, class _Distance>
316inline reverse_iterator<_RandomAccessIterator, _Tp,
317                        Reference__, _Distance>  _STLP_CALL
318operator+(_Distance __n,
319          const reverse_iterator<_RandomAccessIterator, _Tp,
320                                 Reference__, _Distance>& __x)
321{
322  return reverse_iterator<_RandomAccessIterator, _Tp,
323                          Reference__, _Distance>(__x.base() - __n);
324}
325
326#endif /* ! defined ( _STLP_CLASS_PARTIAL_SPECIALIZATION ) */
327
328_STLP_END_NAMESPACE
329
330#endif /* _STLP_INTERNAL_ITERATOR_H */
331
332// Local Variables:
333// mode:C++
334// End:
335