Inheritance diagram for _Deque_const_iterator< _Mydeque >:

Public Types
enum	{ _EEN_DS = _DEQUESIZ }

typedef _Deque_const_iterator< _Mydeque >	_Myiter

typedef random_access_iterator_tag	iterator_category

typedef _Mydeque::value_type	value_type

typedef _Mydeque::size_type	size_type

typedef _Mydeque::difference_type	difference_type

typedef _Mydeque::const_pointer	pointer

typedef _Mydeque::const_reference	reference

typedef _Mydeque	_Mydeque_t

typedef _Deque_unchecked_const_iterator< _Mydeque >	_Unchecked_type

Public Member Functions
	_Deque_const_iterator ()

	_Deque_const_iterator (size_type _Off, const _Container_base12 *_Pdeque)

_Myiter &	_Rechecked (_Unchecked_type _Right)

_Unchecked_type	_Unchecked () const

reference	operator* () const

pointer	operator-> () const

_Myiter &	operator++ ()

_Myiter	operator++ (int)

_Myiter &	operator-- ()

_Myiter	operator-- (int)

_Myiter &	operator+= (difference_type _Off)

_Myiter	operator+ (difference_type _Off) const

_Myiter &	operator-= (difference_type _Off)

_Myiter	operator- (difference_type _Off) const

difference_type	operator- (const _Myiter &_Right) const

reference	operator[] (difference_type _Off) const

bool	operator== (const _Myiter &_Right) const

bool	operator!= (const _Myiter &_Right) const

bool	operator< (const _Myiter &_Right) const

bool	operator> (const _Myiter &_Right) const

bool	operator<= (const _Myiter &_Right) const

bool	operator>= (const _Myiter &_Right) const

void	_Compat (const _Myiter &) const

void	_Setcont (const _Mydeque *_Pdeque)

Public Member Functions inherited from _Iterator_base12
	_Iterator_base12 ()

	_Iterator_base12 (const _Iterator_base12 &_Right)

_Iterator_base12 &	operator= (const _Iterator_base12 &_Right)

	~_Iterator_base12 () _NOEXCEPT

void	_Adopt (const _Container_base12 *_Parent)

void	_Clrcont ()

const _Container_base12 *	_Getcont () const

_Iterator_base12 **	_Getpnext ()

void	_Orphan_me ()

Public Attributes
size_type	_Myoff

Public Attributes inherited from _Iterator_base12
_Container_proxy *	_Myproxy

_Iterator_base12 *	_Mynextiter

Member Typedef Documentation

template<class _Mydeque>

typedef _Mydeque _Deque_const_iterator< _Mydeque >::_Mydeque_t

template<class _Mydeque>

typedef _Deque_const_iterator<_Mydeque> _Deque_const_iterator< _Mydeque >::_Myiter

template<class _Mydeque>

typedef _Deque_unchecked_const_iterator<_Mydeque> _Deque_const_iterator< _Mydeque >::_Unchecked_type

template<class _Mydeque>

typedef _Mydeque::difference_type _Deque_const_iterator< _Mydeque >::difference_type

template<class _Mydeque>

typedef random_access_iterator_tag _Deque_const_iterator< _Mydeque >::iterator_category

template<class _Mydeque>

typedef _Mydeque::const_pointer _Deque_const_iterator< _Mydeque >::pointer

template<class _Mydeque>

typedef _Mydeque::const_reference _Deque_const_iterator< _Mydeque >::reference

template<class _Mydeque>

typedef _Mydeque::size_type _Deque_const_iterator< _Mydeque >::size_type

template<class _Mydeque>

typedef _Mydeque::value_type _Deque_const_iterator< _Mydeque >::value_type

Member Enumeration Documentation

template<class _Mydeque>

anonymous enum

Enumerator
_EEN_DS

295 {_EEN_DS = _DEQUESIZ}; // helper for expression evaluator

_DEQUESIZ

#define _DEQUESIZ

Definition: deque:19

_Deque_const_iterator::_EEN_DS

Definition: deque:295

Constructor & Destructor Documentation

template<class _Mydeque>

_Deque_const_iterator< _Mydeque >::_Deque_const_iterator ( )

inline

         {   // construct with null pointer
         _Setcont(0);
         _Myoff = 0;
         }

template<class _Mydeque>

_Deque_const_iterator< _Mydeque >::_Deque_const_iterator	(	size_type	_Off,
		const _Container_base12 *	_Pdeque
	)

inline

         {   // construct with offset _Off in *_Pdeque
         _Setcont((_Mydeque *)_Pdeque);
         _Myoff = _Off;
         }

Member Function Documentation

template<class _Mydeque>

void _Deque_const_iterator< _Mydeque >::_Compat ( const _Myiter & ) const

inline

526 { // test for compatible iterator pair

527 }

template<class _Mydeque>

_Myiter& _Deque_const_iterator< _Mydeque >::_Rechecked ( _Unchecked_type _Right )

inline

         {   // reset from unchecked iterator
         this->_Myoff = _Right._Myoff;
         return (*this);
         }

template<class _Mydeque>

void _Deque_const_iterator< _Mydeque >::_Setcont ( const _Mydeque * _Pdeque )

inline

         {   // set container pointer
         this->_Adopt(_Pdeque);
         }

template<class _Mydeque>

_Unchecked_type _Deque_const_iterator< _Mydeque >::_Unchecked ( ) const

inline

         {   // make an unchecked iterator
         return (_Unchecked_type(_Myoff, this->_Getcont()));
         }

template<class _Mydeque>

bool _Deque_const_iterator< _Mydeque >::operator!= ( const _Myiter & _Right ) const

inline

         {   // test for iterator inequality
         return (!(*this == _Right));
         }

template<class _Mydeque>

reference _Deque_const_iterator< _Mydeque >::operator* ( ) const

inline

         {   // return designated object
         _Mydeque *_Mycont = ((_Mydeque *)this->_Getcont());
 
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_Mycont == 0
             || this->_Myoff < _Mycont->_Myoff
             || _Mycont->_Myoff + _Mycont->_Mysize <= this->_Myoff)
         {   // report error
         _DEBUG_ERROR("deque iterator not dereferencable");
         _SCL_SECURE_OUT_OF_RANGE;
         }
 
  #elif _ITERATOR_DEBUG_LEVEL == 1
         _SCL_SECURE_VALIDATE(_Mycont != 0);
         _SCL_SECURE_VALIDATE_RANGE(_Mycont->_Myoff <= this->_Myoff
             && this->_Myoff < _Mycont->_Myoff + _Mycont->_Mysize);
  #endif /* _ITERATOR_DEBUG_LEVEL */
 
         _Analysis_assume_(_Mycont != 0);
 
         size_type _Block = _Mycont->_Getblock(_Myoff);
         size_type _Off = _Myoff % _DEQUESIZ;
         return (_Mycont->_Map[_Block][_Off]);
         }

template<class _Mydeque>

_Myiter _Deque_const_iterator< _Mydeque >::operator+ ( difference_type _Off ) const

inline

         {   // return this + integer
         _Myiter _Tmp = *this;
         return (_Tmp += _Off);
         }

template<class _Mydeque>

_Myiter& _Deque_const_iterator< _Mydeque >::operator++ ( )

inline

         {   // preincrement
  #if _ITERATOR_DEBUG_LEVEL == 2
         _Mydeque *_Mycont = ((_Mydeque *)this->_Getcont());
         if (_Mycont == 0
             || _Mycont->_Myoff + _Mycont->_Mysize <= this->_Myoff)
         {   // report error
         _DEBUG_ERROR("deque iterator not incrementable");
         _SCL_SECURE_OUT_OF_RANGE;
         }
 
  #elif _ITERATOR_DEBUG_LEVEL == 1
         _Mydeque *_Mycont = ((_Mydeque *)this->_Getcont());
         _SCL_SECURE_VALIDATE(_Mycont != 0);
         _SCL_SECURE_VALIDATE_RANGE(
             this->_Myoff < _Mycont->_Myoff + _Mycont->_Mysize);
  #endif /* _ITERATOR_DEBUG_LEVEL */
 
         ++_Myoff;
         return (*this);
         }

template<class _Mydeque>

_Myiter _Deque_const_iterator< _Mydeque >::operator++ ( int )

inline

         {   // postincrement
         _Myiter _Tmp = *this;
         ++*this;
         return (_Tmp);
         }

template<class _Mydeque>

_Myiter& _Deque_const_iterator< _Mydeque >::operator+= ( difference_type _Off )

inline

         {   // increment by integer
  #if _ITERATOR_DEBUG_LEVEL == 2
         _Mydeque *_Mycont = ((_Mydeque *)this->_Getcont());
         if (_Mycont == 0
             || this->_Myoff + _Off < _Mycont->_Myoff
             || _Mycont->_Myoff + _Mycont->_Mysize < this->_Myoff + _Off)
             {   // report error
             _DEBUG_ERROR("deque iterator + offset out of range");
             _SCL_SECURE_OUT_OF_RANGE;
             }
 
  #elif _ITERATOR_DEBUG_LEVEL == 1
         _Mydeque *_Mycont = ((_Mydeque *)this->_Getcont());
         _SCL_SECURE_VALIDATE(_Mycont != 0);
         _SCL_SECURE_VALIDATE_RANGE(_Mycont->_Myoff <= this->_Myoff + _Off
             && this->_Myoff + _Off <= _Mycont->_Myoff + _Mycont->_Mysize);
  #endif /* _ITERATOR_DEBUG_LEVEL */
 
         _Myoff += _Off;
         return (*this);
         }

template<class _Mydeque>

_Myiter _Deque_const_iterator< _Mydeque >::operator- ( difference_type _Off ) const

inline

         {   // return this - integer
         _Myiter _Tmp = *this;
         return (_Tmp -= _Off);
         }

template<class _Mydeque>

difference_type _Deque_const_iterator< _Mydeque >::operator- ( const _Myiter & _Right ) const

inline

         {   // return difference of iterators
         _Compat(_Right);
         return (_Right._Myoff <= this->_Myoff
             ? this->_Myoff - _Right._Myoff
             : -(difference_type)(_Right._Myoff - this->_Myoff));
         }

template<class _Mydeque>

_Myiter& _Deque_const_iterator< _Mydeque >::operator-- ( )

inline

         {   // predecrement
  #if _ITERATOR_DEBUG_LEVEL == 2
         _Mydeque *_Mycont = ((_Mydeque *)this->_Getcont());
         if (_Mycont == 0
             || this->_Myoff <= _Mycont->_Myoff)
         {   // report error
         _DEBUG_ERROR("deque iterator not decrementable");
         _SCL_SECURE_OUT_OF_RANGE;
         }
 
  #elif _ITERATOR_DEBUG_LEVEL == 1
         _Mydeque *_Mycont = ((_Mydeque *)this->_Getcont());
         _SCL_SECURE_VALIDATE(_Mycont != 0);
         _SCL_SECURE_VALIDATE_RANGE(_Mycont->_Myoff < this->_Myoff);
  #endif /* _ITERATOR_DEBUG_LEVEL */
 
         --_Myoff;
         return (*this);
         }

template<class _Mydeque>

_Myiter _Deque_const_iterator< _Mydeque >::operator-- ( int )

inline

         {   // postdecrement
         _Myiter _Tmp = *this;
         --*this;
         return (_Tmp);
         }

template<class _Mydeque>

_Myiter& _Deque_const_iterator< _Mydeque >::operator-= ( difference_type _Off )

inline

         {   // decrement by integer
         return (*this += -_Off);
         }

template<class _Mydeque>

pointer _Deque_const_iterator< _Mydeque >::operator-> ( ) const

inline

         {   // return pointer to class object
         return (_STD pointer_traits<pointer>::pointer_to(**this));
         }

template<class _Mydeque>

bool _Deque_const_iterator< _Mydeque >::operator< ( const _Myiter & _Right ) const

inline

         {   // test if this < _Right
         _Compat(_Right);
         return (this->_Myoff < _Right._Myoff);
         }

template<class _Mydeque>

bool _Deque_const_iterator< _Mydeque >::operator<= ( const _Myiter & _Right ) const

inline

         {   // test if this <= _Right
         return (!(_Right < *this));
         }

template<class _Mydeque>

bool _Deque_const_iterator< _Mydeque >::operator== ( const _Myiter & _Right ) const

inline

         {   // test for iterator equality
         _Compat(_Right);
         return (this->_Myoff == _Right._Myoff);
         }

template<class _Mydeque>

bool _Deque_const_iterator< _Mydeque >::operator> ( const _Myiter & _Right ) const

inline

         {   // test if this > _Right
         return (_Right < *this);
         }

template<class _Mydeque>

bool _Deque_const_iterator< _Mydeque >::operator>= ( const _Myiter & _Right ) const

inline

         {   // test if this >= _Right
         return (!(*this < _Right));
         }

template<class _Mydeque>

reference _Deque_const_iterator< _Mydeque >::operator[] ( difference_type _Off ) const

inline

         {   // subscript
         return (*(*this + _Off));
         }

Member Data Documentation

template<class _Mydeque>

size_type _Deque_const_iterator< _Mydeque >::_Myoff

The documentation for this class was generated from the following file:

VS2013/inc/deque

Public Types

Public Member Functions

Public Attributes

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation