bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH > Class Template Reference

#include <bslalg_dequeiterator.h>

Public Member Functions
	DequeIterator ()
	Create a singular iterator (i.e., having internal null pointers).
	DequeIterator (BlockPtr *blockPtrPtr)
	DequeIterator (BlockPtr *blockPtrPtr, VALUE_TYPE *valuePtr)
void	operator++ ()
void	operator-- ()
void	operator+= (std::ptrdiff_t offset)
	Advance this iterator by the specified offset.
void	operator-= (std::ptrdiff_t offset)
	Move this iterator backward by the specified offset.
void	nextBlock ()
	Set this iterator to point to the first element of the next block.
void	previousBlock ()
void	setBlock (BlockPtr *blockPtrPtr)
void	valuePtrDecrement ()
void	valuePtrIncrement ()
VALUE_TYPE &	operator* () const
DequeIterator	operator+ (std::ptrdiff_t offset) const
DequeIterator	operator- (std::ptrdiff_t offset) const
std::ptrdiff_t	operator- (const DequeIterator &rhs) const
VALUE_TYPE *	blockBegin () const
VALUE_TYPE *	blockEnd () const
BlockPtr *	blockPtr () const
	Return the address of the block pointer pointed to by this iterator.
std::size_t	offsetInBlock () const
std::size_t	remainingInBlock () const
VALUE_TYPE *	valuePtr () const

Friends
bool	operator== (const DequeIterator &lhs, const DequeIterator &rhs)
bool	operator!= (const DequeIterator &lhs, const DequeIterator &rhs)
bool	operator< (const DequeIterator &lhs, const DequeIterator &rhs)

Detailed Description

template<class VALUE_TYPE, int BLOCK_LENGTH>
class bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >

Implementation of a deque iterator, parameterized by the VALUE_TYPE, for a deque with the parameterized BLOCK_LENGTH, and suitable for use by the bslstl::RandomAccessIterator adapter. Note that BLOCK_LENGTH is the number of items of VALUE_TYPE within a block, not the size of a block in bytes.

See bslalg_dequeiterator

Constructor & Destructor Documentation

DequeIterator() [1/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::DequeIterator ( )

inline

DequeIterator() [2/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::DequeIterator ( BlockPtr *  blockPtrPtr )

inlineexplicit

Create an iterator pointing to the first element in the block pointed to by the specified blockPtrPtr.

DequeIterator() [3/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::DequeIterator ( BlockPtr *  blockPtrPtr, VALUE_TYPE *  valuePtr  )

inline

Create an iterator pointing to the element at the specified valuePtr address in the block pointed to by the specified blockPtrPtr. The behavior is undefined unless valuePtr points into the block *blockPtrPtr.

Member Function Documentation

blockBegin()

template<class VALUE_TYPE , int BLOCK_LENGTH>

VALUE_TYPE * bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::blockBegin ( ) const

inline

Return the address of the first element in the block pointed to by this iterator.

blockEnd()

template<class VALUE_TYPE , int BLOCK_LENGTH>

VALUE_TYPE * bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::blockEnd ( ) const

inline

Return the address of (one-past) the last element in the block pointed to by this iterator.

blockPtr()

template<class VALUE_TYPE , int BLOCK_LENGTH>

DequeImpUtil< VALUE_TYPE, BLOCK_LENGTH >::BlockPtr * bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::blockPtr ( ) const

inline

nextBlock()

template<class VALUE_TYPE , int BLOCK_LENGTH>

void bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::nextBlock ( )

inline

offsetInBlock()

template<class VALUE_TYPE , int BLOCK_LENGTH>

std::size_t bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::offsetInBlock ( ) const

inline

Return the offset of the element pointed to by this iterator, from the beginning of the block containing it.

operator*()

template<class VALUE_TYPE , int BLOCK_LENGTH>

VALUE_TYPE & bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::operator* ( ) const

inline

Return a reference to the parameterized VALUE_TYPE object pointed to by this iterator. Note that this value is modifiable if VALUE_TYPE is modifiable, and non-modifiable if it is not.

operator+()

template<class VALUE_TYPE , int BLOCK_LENGTH>

DequeIterator< VALUE_TYPE, BLOCK_LENGTH > bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::operator+ ( std::ptrdiff_t  offset ) const

inline

Return an iterator pointing the element at the specified offset after this iterator.

operator++()

template<class VALUE_TYPE , int BLOCK_LENGTH>

void bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::operator++

(

)

Increment this iterator to point to the next element in the corresponding deque (i.e., the element following the current one in the same block or, if the current element is the last one in the block, the first element in the next block).

operator+=()

template<class VALUE_TYPE , int BLOCK_LENGTH>

void bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::operator+=

(

std::ptrdiff_t

offset

)

operator-() [1/2]

template<class VALUE_TYPE , int BLOCK_LENGTH>

std::ptrdiff_t bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::operator-

(

const DequeIterator< VALUE_TYPE, BLOCK_LENGTH > &

rhs

)

const

Return the distance between this iterator and the specified rhs iterator.

operator-() [2/2]

template<class VALUE_TYPE , int BLOCK_LENGTH>

DequeIterator< VALUE_TYPE, BLOCK_LENGTH > bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::operator- ( std::ptrdiff_t  offset ) const

inline

Return an iterator pointing the element at the specified offset before this iterator.

operator--()

template<class VALUE_TYPE , int BLOCK_LENGTH>

void bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::operator--

(

)

Decrement this iterator to point to the previous element in the corresponding deque (i.e., the element preceding the current one in the same block or, if the current element is the first one in the block, the last element in the previous block).

operator-=()

template<class VALUE_TYPE , int BLOCK_LENGTH>

void bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::operator-= ( std::ptrdiff_t  offset )

inline

previousBlock()

template<class VALUE_TYPE , int BLOCK_LENGTH>

void bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::previousBlock ( )

inline

Set this iterator to point to the first (not the last) element of the previous block.

remainingInBlock()

template<class VALUE_TYPE , int BLOCK_LENGTH>

std::size_t bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::remainingInBlock ( ) const

inline

Return the number of elements in the block pointed to by this iterator, until the end of this block, starting at (and including) the element pointed to by this iterator.

setBlock()

template<class VALUE_TYPE , int BLOCK_LENGTH>

void bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::setBlock ( BlockPtr *  blockPtrPtr )

inline

Set this iterator to point to the first element of the block pointed to by the specified blockPtrPtr.

valuePtr()

template<class VALUE_TYPE , int BLOCK_LENGTH>

VALUE_TYPE * bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::valuePtr ( ) const

inline

Return the address of the parameterized VALUE_TYPE object pointed to by this iterator.

valuePtrDecrement()

template<class VALUE_TYPE , int BLOCK_LENGTH>

void bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::valuePtrDecrement ( )

inline

Decrement this iterator to point to the next element in the block of the corresponding deque. The behavior is undefined unless this iterator is pointed to a valid position of the deque. Note that this method is used only for optimization purposes in bslstl_Deque, and clients of this package should not use this directly.

valuePtrIncrement()

template<class VALUE_TYPE , int BLOCK_LENGTH>

void bslalg::DequeIterator< VALUE_TYPE, BLOCK_LENGTH >::valuePtrIncrement ( )

inline

Increment this iterator to point to the next element in the block of the corresponding deque. The behavior is undefined unless this iterator is pointed to a valid position of the deque. Note that this method is used only for optimization purposes in bslstl_Deque, and clients of this package should not use this directly.

Friends And Related Symbol Documentation

operator!=

template<class VALUE_TYPE , int BLOCK_LENGTH>

bool operator!= ( const DequeIterator< VALUE_TYPE, BLOCK_LENGTH > &  lhs, const DequeIterator< VALUE_TYPE, BLOCK_LENGTH > &  rhs  )

friend

Return true if the specified lhs iterator points to a different element in the same block as the specified rhs iterator, or points to an element in a different block to the rhs iterator, and false otherwise. The behavior is undefined unless lhs and rhs are iterators over the same deque. Note that this friend is a regular functon, not a function template, so there is no way to declare it outside the class in order to provide the definition.

operator<

template<class VALUE_TYPE , int BLOCK_LENGTH>

bool operator< ( const DequeIterator< VALUE_TYPE, BLOCK_LENGTH > &  lhs, const DequeIterator< VALUE_TYPE, BLOCK_LENGTH > &  rhs  )

friend

Return true if the specified lhs iterator points to an element in a previous block or in a previous position in the same block as the specified rhs iterator, and false otherwise. The behavior is undefined unless lhs and rhs are iterators over the same deque. Note that this friend is a regular functon, not a function template, so there is no way to declare it outside the class in order to provide the definition.

operator==

template<class VALUE_TYPE , int BLOCK_LENGTH>

bool operator== ( const DequeIterator< VALUE_TYPE, BLOCK_LENGTH > &  lhs, const DequeIterator< VALUE_TYPE, BLOCK_LENGTH > &  rhs  )

friend

Return true if the specified lhs iterator points to the same element in the same block as the specified rhs iterator, and false otherwise. The behavior is undefined unless lhs and rhs are iterators over the same deque. Note that this friend is a regular functon, not a function template, so there is no way to declare it outside the class in order to provide the definition.

---

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

• bslalg_dequeiterator.h