mirror of
https://github.com/reactos/reactos.git
synced 2024-08-26 05:08:39 +00:00
335 lines
11 KiB
C++
335 lines
11 KiB
C++
/*
|
|
*
|
|
* Copyright (c) 1994
|
|
* Hewlett-Packard Company
|
|
*
|
|
* Copyright (c) 1996-1998
|
|
* Silicon Graphics Computer Systems, Inc.
|
|
*
|
|
* Copyright (c) 1997
|
|
* Moscow Center for SPARC Technology
|
|
*
|
|
* Copyright (c) 1999
|
|
* Boris Fomitchev
|
|
*
|
|
* This material is provided "as is", with absolutely no warranty expressed
|
|
* or implied. Any use is at your own risk.
|
|
*
|
|
* Permission to use or copy this software for any purpose is hereby granted
|
|
* without fee, provided the above notices are retained on all copies.
|
|
* Permission to modify the code and to distribute modified code is granted,
|
|
* provided the above notices are retained, and a notice that the code was
|
|
* modified is included with the above copyright notice.
|
|
*
|
|
*/
|
|
|
|
/* NOTE: This is an internal header file, included by other STL headers.
|
|
* You should not attempt to use it directly.
|
|
*/
|
|
|
|
#ifndef _STLP_INTERNAL_ITERATOR_OLD_H
|
|
#define _STLP_INTERNAL_ITERATOR_OLD_H
|
|
|
|
#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
|
|
# include <stl/_iterator_base.h>
|
|
#endif
|
|
|
|
_STLP_BEGIN_NAMESPACE
|
|
|
|
#ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
|
|
|
|
template <class _Container>
|
|
inline output_iterator_tag _STLP_CALL
|
|
iterator_category(const back_insert_iterator<_Container>&) { return output_iterator_tag(); }
|
|
template <class _Container>
|
|
inline output_iterator_tag _STLP_CALL
|
|
iterator_category(const front_insert_iterator<_Container>&) { return output_iterator_tag(); }
|
|
template <class _Container>
|
|
inline output_iterator_tag _STLP_CALL
|
|
iterator_category(const insert_iterator<_Container>&) { return output_iterator_tag(); }
|
|
|
|
#endif
|
|
|
|
template <class _BidirectionalIterator, class _Tp,
|
|
_STLP_DFL_TMPL_PARAM(_Reference, _Tp& ),
|
|
#if defined (_STLP_MSVC50_COMPATIBILITY)
|
|
# define __Reference _Reference, class _Pointer
|
|
# define Reference__ _Reference, _Pointer
|
|
_STLP_DFL_TMPL_PARAM(_Pointer, _Tp*),
|
|
#else
|
|
# define __Reference _Reference
|
|
# define Reference__ _Reference
|
|
#endif
|
|
_STLP_DFL_TYPE_PARAM(_Distance, ptrdiff_t)>
|
|
class reverse_bidirectional_iterator {
|
|
typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
|
|
Reference__, _Distance> _Self;
|
|
// friend inline bool operator== _STLP_NULL_TMPL_ARGS (const _Self& x, const _Self& y);
|
|
protected:
|
|
_BidirectionalIterator current;
|
|
public:
|
|
typedef bidirectional_iterator_tag iterator_category;
|
|
typedef _Tp value_type;
|
|
typedef _Distance difference_type;
|
|
# if defined (_STLP_MSVC50_COMPATIBILITY)
|
|
typedef _Pointer pointer;
|
|
# else
|
|
typedef _Tp* pointer;
|
|
# endif
|
|
typedef _Reference reference;
|
|
|
|
reverse_bidirectional_iterator() {}
|
|
explicit reverse_bidirectional_iterator(_BidirectionalIterator __x)
|
|
: current(__x) {}
|
|
_BidirectionalIterator base() const { return current; }
|
|
_Reference operator*() const {
|
|
_BidirectionalIterator __tmp = current;
|
|
return *(--__tmp);
|
|
}
|
|
|
|
_STLP_DEFINE_ARROW_OPERATOR
|
|
|
|
_Self& operator++() {
|
|
--current;
|
|
return *this;
|
|
}
|
|
_Self operator++(int) {
|
|
_Self __tmp = *this;
|
|
--current;
|
|
return __tmp;
|
|
}
|
|
_Self& operator--() {
|
|
++current;
|
|
return *this;
|
|
}
|
|
_Self operator--(int) {
|
|
_Self __tmp = *this;
|
|
++current;
|
|
return __tmp;
|
|
}
|
|
};
|
|
|
|
#ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
|
|
template <class _BidirectionalIterator, class _Tp, class __Reference,
|
|
class _Distance>
|
|
inline bidirectional_iterator_tag _STLP_CALL
|
|
iterator_category(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, Reference__, _Distance>&)
|
|
{ return bidirectional_iterator_tag(); }
|
|
template <class _BidirectionalIterator, class _Tp, class __Reference,
|
|
class _Distance>
|
|
inline _Tp* _STLP_CALL
|
|
value_type(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, Reference__, _Distance>&)
|
|
{ return (_Tp*) 0; }
|
|
template <class _BidirectionalIterator, class _Tp, class __Reference,
|
|
class _Distance>
|
|
inline _Distance* _STLP_CALL
|
|
distance_type(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, Reference__, _Distance>&)
|
|
{ return (_Distance*) 0; }
|
|
#endif
|
|
|
|
template <class _BidirectionalIterator, class _Tp, class __Reference,
|
|
class _Distance>
|
|
inline bool _STLP_CALL operator==(
|
|
const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
|
|
Reference__, _Distance>& __x,
|
|
const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
|
|
Reference__, _Distance>& __y)
|
|
{ return __x.base() == __y.base(); }
|
|
|
|
#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
|
|
|
|
template <class _BiIter, class _Tp, class __Reference, class _Distance>
|
|
inline bool _STLP_CALL operator!=(
|
|
const reverse_bidirectional_iterator<_BiIter, _Tp, Reference__, _Distance>& __x,
|
|
const reverse_bidirectional_iterator<_BiIter, _Tp, Reference__, _Distance>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
#endif
|
|
|
|
#if !defined ( _STLP_CLASS_PARTIAL_SPECIALIZATION )
|
|
|
|
// This is the old version of reverse_iterator, as found in the original
|
|
// HP STL. It does not use partial specialization.
|
|
|
|
template <class _RandomAccessIterator, class _Tp,
|
|
_STLP_DFL_TMPL_PARAM(_Reference,_Tp&),
|
|
# if defined (_STLP_MSVC50_COMPATIBILITY)
|
|
_STLP_DFL_TMPL_PARAM(_Pointer, _Tp*),
|
|
# endif
|
|
_STLP_DFL_TYPE_PARAM(_Distance,ptrdiff_t)>
|
|
class reverse_iterator {
|
|
typedef reverse_iterator<_RandomAccessIterator, _Tp, Reference__, _Distance> _Self;
|
|
protected:
|
|
_RandomAccessIterator __current;
|
|
public:
|
|
typedef random_access_iterator_tag iterator_category;
|
|
typedef _Tp value_type;
|
|
typedef _Distance difference_type;
|
|
# if defined (_STLP_MSVC50_COMPATIBILITY)
|
|
typedef _Pointer pointer;
|
|
# else
|
|
typedef _Tp* pointer;
|
|
# endif
|
|
typedef _Reference reference;
|
|
|
|
reverse_iterator() {}
|
|
reverse_iterator(const _Self& __x) : __current(__x.base()) {}
|
|
explicit reverse_iterator(_RandomAccessIterator __x) : __current(__x) {}
|
|
_Self& operator=(const _Self& __x) {__current = __x.base(); return *this; }
|
|
|
|
_RandomAccessIterator base() const { return __current; }
|
|
_Reference operator*() const { return *(__current - (difference_type)1); }
|
|
|
|
_STLP_DEFINE_ARROW_OPERATOR
|
|
|
|
_Self& operator++() {
|
|
--__current;
|
|
return *this;
|
|
}
|
|
_Self operator++(int) {
|
|
_Self __tmp = *this;
|
|
--__current;
|
|
return __tmp;
|
|
}
|
|
_Self& operator--() {
|
|
++__current;
|
|
return *this;
|
|
}
|
|
_Self operator--(int) {
|
|
_Self __tmp = *this;
|
|
++__current;
|
|
return __tmp;
|
|
}
|
|
_Self operator+(_Distance __n) const {
|
|
return _Self(__current - __n);
|
|
}
|
|
_Self& operator+=(_Distance __n) {
|
|
__current -= __n;
|
|
return *this;
|
|
}
|
|
_Self operator-(_Distance __n) const {
|
|
return _Self(__current + __n);
|
|
}
|
|
_Self& operator-=(_Distance __n) {
|
|
__current += __n;
|
|
return *this;
|
|
}
|
|
_Reference operator[](_Distance __n) const { return *(*this + __n); }
|
|
};
|
|
|
|
# ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
|
|
template <class _RandomAccessIterator, class _Tp,
|
|
class __Reference, class _Distance>
|
|
inline random_access_iterator_tag _STLP_CALL
|
|
iterator_category(const reverse_iterator<_RandomAccessIterator, _Tp, Reference__, _Distance>&)
|
|
{ return random_access_iterator_tag(); }
|
|
template <class _RandomAccessIterator, class _Tp,
|
|
class __Reference, class _Distance>
|
|
inline _Tp* _STLP_CALL value_type(const reverse_iterator<_RandomAccessIterator, _Tp, Reference__, _Distance>&)
|
|
{ return (_Tp*) 0; }
|
|
template <class _RandomAccessIterator, class _Tp,
|
|
class __Reference, class _Distance>
|
|
inline _Distance* _STLP_CALL
|
|
distance_type(const reverse_iterator<_RandomAccessIterator, _Tp, Reference__, _Distance>&)
|
|
{ return (_Distance*) 0; }
|
|
# endif
|
|
|
|
template <class _RandomAccessIterator, class _Tp,
|
|
class __Reference, class _Distance>
|
|
inline bool _STLP_CALL
|
|
operator==(const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __x,
|
|
const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __y)
|
|
{
|
|
return __x.base() == __y.base();
|
|
}
|
|
|
|
template <class _RandomAccessIterator, class _Tp,
|
|
class __Reference, class _Distance>
|
|
inline bool _STLP_CALL
|
|
operator<(const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __x,
|
|
const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __y)
|
|
{
|
|
return __y.base() < __x.base();
|
|
}
|
|
|
|
# ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
|
|
|
|
template <class _RandomAccessIterator, class _Tp,
|
|
class __Reference, class _Distance>
|
|
inline bool _STLP_CALL
|
|
operator!=(const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __x,
|
|
const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __y) {
|
|
return !(__x == __y);
|
|
}
|
|
|
|
template <class _RandomAccessIterator, class _Tp,
|
|
class __Reference, class _Distance>
|
|
inline bool _STLP_CALL
|
|
operator>(const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __x,
|
|
const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __y) {
|
|
return __y < __x;
|
|
}
|
|
|
|
template <class _RandomAccessIterator, class _Tp,
|
|
class __Reference, class _Distance>
|
|
inline bool _STLP_CALL
|
|
operator<=(const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __x,
|
|
const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __y) {
|
|
return !(__y < __x);
|
|
}
|
|
|
|
template <class _RandomAccessIterator, class _Tp,
|
|
class __Reference, class _Distance>
|
|
inline bool _STLP_CALL
|
|
operator>=(const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __x,
|
|
const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __y) {
|
|
return !(__x < __y);
|
|
}
|
|
|
|
# endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
|
|
|
|
template <class _RandomAccessIterator, class _Tp,
|
|
class __Reference, class _Distance>
|
|
inline _Distance _STLP_CALL
|
|
operator-(const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __x,
|
|
const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __y)
|
|
{
|
|
return __y.base() - __x.base();
|
|
}
|
|
|
|
template <class _RandomAccessIterator, class _Tp,
|
|
class __Reference, class _Distance>
|
|
inline reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance> _STLP_CALL
|
|
operator+(_Distance __n,
|
|
const reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>& __x)
|
|
{
|
|
return reverse_iterator<_RandomAccessIterator, _Tp,
|
|
Reference__, _Distance>(__x.base() - __n);
|
|
}
|
|
|
|
#endif /* ! defined ( _STLP_CLASS_PARTIAL_SPECIALIZATION ) */
|
|
|
|
_STLP_END_NAMESPACE
|
|
|
|
#endif /* _STLP_INTERNAL_ITERATOR_H */
|
|
|
|
// Local Variables:
|
|
// mode:C++
|
|
// End:
|