/*
*
* 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.
*
*/
#ifndef _STLP_DBG_ITERATOR_H
# define _STLP_DBG_ITERATOR_H
# include <stl/_pair.h>
# include <stl/_alloc.h>
# define _STLP_DBG_ALLOCATOR_SELECT( _Tp ) _STLP_DEFAULT_ALLOCATOR_SELECT( _Tp )
_STLP_BEGIN_NAMESPACE
//============================================================
template <class _Iterator>
void _Decrement(_Iterator& __it, const bidirectional_iterator_tag &) {
--__it;
}
template <class _Iterator>
void _Decrement(_Iterator& __it, const random_access_iterator_tag &) {
--__it;
}
template <class _Iterator>
void _Decrement(_Iterator& __it, const forward_iterator_tag &) {
_STLP_ASSERT(0)
}
template <class _Iterator>
void _Advance(_Iterator&, ptrdiff_t, const forward_iterator_tag &) {
_STLP_ASSERT(0)
}
template <class _Iterator>
void _Advance(_Iterator& __it, ptrdiff_t, const bidirectional_iterator_tag &) {
_STLP_ASSERT(0)
}
template <class _Iterator>
void _Advance(_Iterator& __it, ptrdiff_t __n, const random_access_iterator_tag &) {
__it += __n;
}
template <class _Iterator>
ptrdiff_t _DBG_distance(const _Iterator& __x, const _Iterator& __y, const random_access_iterator_tag &) {
return __x - __y;
}
template <class _Iterator>
ptrdiff_t _DBG_distance(const _Iterator&, const _Iterator&, const forward_iterator_tag &) {
_STLP_ASSERT(0)
return 0;
}
template <class _Iterator>
ptrdiff_t _DBG_distance(const _Iterator&, const _Iterator&, const bidirectional_iterator_tag &) {
_STLP_ASSERT(0)
return 0;
}
template <class _Iterator>
bool _CompareIt(const _Iterator&, const _Iterator&, const forward_iterator_tag &) {
_STLP_ASSERT(0)
return false;
}
template <class _Iterator>
bool _CompareIt(const _Iterator&, const _Iterator&, const bidirectional_iterator_tag &) {
_STLP_ASSERT(0)
return false;
}
template <class _Iterator>
bool _CompareIt(const _Iterator& __x, const _Iterator& __y, const random_access_iterator_tag &) {
return __x < __y;
}
template <class _Iterator>
bool _Dereferenceable(_Iterator __it) {
return (__it._Get_container_ptr() !=0) && !(__it._M_iterator == (__it._Get_container_ptr())->end());
}
template <class _Iterator>
bool _Incrementable(const _Iterator& __it, ptrdiff_t __n, const forward_iterator_tag &) {
return (__n == 1) && _Dereferenceable(__it);
}
template <class _Iterator>
bool _Incrementable(const _Iterator& __it, ptrdiff_t __n, const bidirectional_iterator_tag &) {
typedef typename _Iterator::_Container_type __container_type;
__container_type* __c = __it._Get_container_ptr();
return (__c!=0) && ((__n == 1 && __it._M_iterator != __c->end() ) ||
(__n == -1 && __it._M_iterator != __c->begin()));
}
template <class _Iterator>
bool _Incrementable(const _Iterator& __it, ptrdiff_t __n, const random_access_iterator_tag &) {
typedef typename _Iterator::_Container_type __container_type;
__container_type* __c = __it._Get_container_ptr();
if (!__c) return false;
ptrdiff_t __new_pos = (__it._M_iterator - __c->begin()) + __n;
return (__new_pos >=0) && (__STATIC_CAST(typename __container_type::size_type,__new_pos) <=__c->size());
}
template <class _Container>
struct _DBG_iter_base : public __owned_link {
public:
typedef typename _Container::value_type value_type;
typedef typename _Container::reference reference;
typedef typename _Container::pointer pointer;
typedef ptrdiff_t difference_type;
//private:
typedef typename _Container::iterator _Nonconst_iterator;
typedef typename _Container::const_iterator _Const_iterator;
typedef _Container _Container_type;
# ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
typedef typename iterator_traits<_Const_iterator>::iterator_category _Iterator_category;
# else
typedef typename _Container::_Iterator_category _Iterator_category;
# endif
typedef _Iterator_category iterator_category;
_DBG_iter_base() : __owned_link(0) {}
_DBG_iter_base(const __owned_list* __c, const _Const_iterator& __it) :
# ifdef __HP_aCC
__owned_link(__c), _M_iterator(*__REINTERPRET_CAST(const _Nonconst_iterator *, &__it)) {}
# else
__owned_link(__c), _M_iterator(*(const _Nonconst_iterator*)&__it) {}
# endif
_Container* _Get_container_ptr() const {
return (_Container*)__stl_debugger::_Get_container_ptr(this);
}
void __increment() {
_STLP_DEBUG_CHECK(_Incrementable(*this,1,_Iterator_category()))
++_M_iterator;
}
void __decrement() {
_STLP_DEBUG_CHECK(_Incrementable(*this,-1,_Iterator_category()))
_Decrement(_M_iterator, _Iterator_category());
}
void __advance(difference_type __n) {
_STLP_DEBUG_CHECK(_Incrementable(*this,__n, _Iterator_category()))
_Advance(_M_iterator,__n, _Iterator_category());
}
// protected:
_Nonconst_iterator _M_iterator;
};
template <class _Container>
ptrdiff_t operator-(const _DBG_iter_base<_Container>& __x,
const _DBG_iter_base<_Container>& __y ) {
typedef typename _DBG_iter_base<_Container>::_Iterator_category _Iterator_category;
_STLP_DEBUG_CHECK(__check_same_owner(__x, __y))
return _DBG_distance(__x._M_iterator,__y._M_iterator, _Iterator_category());
}
template <class _Container, class _Traits>
struct _DBG_iter_mid : public _DBG_iter_base<_Container>
{
typedef _DBG_iter_mid<_Container, typename _Traits::_Non_const_traits> _Nonconst_self;
typedef typename _Container::iterator _Nonconst_iterator;
typedef typename _Container::const_iterator _Const_iterator;
_DBG_iter_mid() {}
explicit _DBG_iter_mid(const _Nonconst_self& __it) :
_DBG_iter_base<_Container>(__it) {}
_DBG_iter_mid(const __owned_list* __c, const _Const_iterator& __it) :
_DBG_iter_base<_Container>(__c, __it) {}
};
template <class _Container, class _Traits>
struct _DBG_iter : public _DBG_iter_mid<_Container, _Traits> {
typedef _DBG_iter_base<_Container> _Base;
public:
typedef typename _Base::value_type value_type;
typedef typename _Base::difference_type difference_type;
typedef typename _Traits::reference reference;
typedef typename _Traits::pointer pointer;
private:
typedef typename _Base::_Nonconst_iterator _Nonconst_iterator;
typedef typename _Base::_Const_iterator _Const_iterator;
typedef _DBG_iter<_Container, _Traits> _Self;
typedef _DBG_iter_mid<_Container, typename _Traits::_Non_const_traits> _Nonconst_mid;
public:
# ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
typedef typename _Base::iterator_category iterator_category;
# endif
typedef typename _Base::_Iterator_category _Iterator_category;
public:
_DBG_iter() {}
// boris : real type of iter would be nice
_DBG_iter(const __owned_list* __c, const _Const_iterator& __it) :
_DBG_iter_mid<_Container, _Traits>(__c, __it) {}
// This allows conversions from iterator to const_iterator without being
// redundant with the copy constructor below.
_DBG_iter(const _Nonconst_mid& __rhs) :
_DBG_iter_mid<_Container, _Traits>(__rhs) {}
_DBG_iter(const _Self& __rhs) :
_DBG_iter_mid<_Container, _Traits>(__rhs) {}
// This allows conversions from iterator to const_iterator without being
// redundant with the copy assignment operator below.
_Self& operator=(const _Nonconst_mid& __rhs)
{
(_Base&)*this = __rhs;
return *this;
}
_Self& operator=(const _Self& __rhs)
{
(_Base&)*this = __rhs;
return *this;
}
reference operator*() const {
_STLP_DEBUG_CHECK(_Dereferenceable(*this))
return *this->_M_iterator;
}
_STLP_DEFINE_ARROW_OPERATOR
_Self& operator++() {
this->__increment();
return *this;
}
_Self operator++(int) {
_Self __tmp = *this;
this->__increment();
return __tmp;
}
_Self& operator--() {
this->__decrement();
return *this;
}
_Self operator--(int) {
_Self __tmp = *this;
this->__decrement();
return __tmp;
}
_Self& operator+=(difference_type __n) {
this->__advance(__n);
return *this;
}
_Self& operator-=(difference_type __n) {
this->__advance(-__n);
return *this;
}
_Self operator+(difference_type __n) const {
_Self __tmp(*this);
__tmp.__advance(__n);
return __tmp;
}
_Self operator-(difference_type __n) const {
_Self __tmp(*this);
__tmp.__advance(-__n);
return __tmp;
}
reference operator[](difference_type __n) const { return *(*this + __n); }
};
template <class _Container>
inline bool
operator==(const _DBG_iter_base<_Container>& __x, const _DBG_iter_base<_Container>& __y) {
_STLP_DEBUG_CHECK(__check_same_owner_or_null(__x, __y))
return __x._M_iterator==__y._M_iterator;
}
template <class _Container>
inline bool
operator<(const _DBG_iter_base<_Container>& __x, const _DBG_iter_base<_Container>& __y) {
_STLP_DEBUG_CHECK(__check_same_owner_or_null(__x, __y))
typedef typename _DBG_iter_base<_Container>::_Iterator_category _Category;
return _CompareIt(__x._M_iterator , __y._M_iterator, _Category());
}
template <class _Container>
inline bool
operator>(const _DBG_iter_base<_Container>& __x,
const _DBG_iter_base<_Container>& __y) {
typedef typename _DBG_iter_base<_Container>::_Iterator_category _Category;
return _CompareIt(__y._M_iterator , __x._M_iterator, _Category());
}
template <class _Container>
inline bool
operator>=(const _DBG_iter_base<_Container>& __x, const _DBG_iter_base<_Container>& __y) {
_STLP_DEBUG_CHECK(__check_same_owner_or_null(__x, __y))
typedef typename _DBG_iter_base<_Container>::_Iterator_category _Category;
return !_CompareIt(__x._M_iterator , __y._M_iterator, _Category());
}
template <class _Container>
inline bool
operator<=(const _DBG_iter_base<_Container>& __x,
const _DBG_iter_base<_Container>& __y) {
typedef typename _DBG_iter_base<_Container>::_Iterator_category _Category;
return !_CompareIt(__y._M_iterator , __x._M_iterator, _Category());
}
template <class _Container>
inline bool
operator!=(const _DBG_iter_base<_Container>& __x,
const _DBG_iter_base<_Container>& __y) {
_STLP_DEBUG_CHECK(__check_same_owner_or_null(__x, __y))
return __x._M_iterator != __y._M_iterator;
}
//------------------------------------------
template <class _Container, class _Traits>
inline _DBG_iter<_Container, _Traits>
operator+(ptrdiff_t __n, const _DBG_iter<_Container, _Traits>& __it) {
_DBG_iter<_Container, _Traits> __tmp(__it);
return __tmp += __n;
}
# ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
# if defined (_STLP_NESTED_TYPE_PARAM_BUG) \
|| ( defined (__SUNPRO_CC) && __SUNPRO_CC < 0x600) \
|| ( defined (_STLP_MSVC) && (_STLP_MSVC < 1100) )
# define _STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS 1
# endif
template <class _Container>
inline ptrdiff_t*
distance_type(const _DBG_iter_base<_Container>&) { return (ptrdiff_t*) 0; }
# if !defined (_STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS)
template <class _Container>
inline _STLP_TYPENAME_ON_RETURN_TYPE _DBG_iter_base<_Container>::value_type*
value_type(const _DBG_iter_base<_Container>&) {
typedef typename _DBG_iter_base<_Container>::value_type _Val;
return (_Val*)0;
}
template <class _Container>
inline _STLP_TYPENAME_ON_RETURN_TYPE _DBG_iter_base<_Container>::_Iterator_category
iterator_category(const _DBG_iter_base<_Container>&) {
typedef typename _DBG_iter_base<_Container>::_Iterator_category _Category;
return _Category();
}
# endif
# endif /* _STLP_USE_OLD_HP_ITERATOR_QUERIES */
# define _Get_iter(__x) __x
# define _Debug_iter(__x, __y) __y
_STLP_END_NAMESPACE
#endif /* INTERNAL_H */
// Local Variables:
// mode:C++
// End: