#include <bslstl_randomaccessiterator.h>

Inheritance diagram for bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >:

Detailed Description

template<class T, class ITER_IMP, class TAG_TYPE = std::random_access_iterator_tag>
class bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >

Given an ITER_IMP type that implements a minimal subset of an iterator interface, this template generates a complete iterator that meets all of the requirements of a "random-access iterator" in the C++ standard. If T is const-qualified, then the resulting type is a const iterator. T shall not be a function, reference type or void. ITER_IMP must provide public operations so that, for objects i and j of type ITER_IMP and n of an integral type, the following operations are supported:

   ITER_IMP i;                            default construction
   ITER_IMP j(i);                         copy construction
   i = j                                  assignment
   ++i                                    increment to next element
   --i                                    decrement to previous element
   i += n                                 increment by n elements
   i -= n                                 decrement by n elements
   j - i  // convertible to ptrdiff_t     distance from i to j
   i == j // convertible to bool          equality comparison
   i < j  // convertible to bool          less-than comparison
   *i     // reference convertible to T&  element access (dereference)

Public Types
typedef UnCvqT	value_type

typedef std::ptrdiff_t	difference_type

typedef T *	pointer

typedef T &	reference

typedef std::random_access_iterator_tag	iterator_category

Public Types inherited from bslstl::BidirectionalIterator< T, ITER_IMP, TAG_TYPE >
typedef UnCvqT	value_type

typedef std::ptrdiff_t	difference_type

typedef T *	pointer

typedef T &	reference

typedef std::bidirectional_iterator_tag	iterator_category

Public Types inherited from bslstl::ForwardIterator< T, ITER_IMP, TAG_TYPE >
typedef UnCvqT	value_type

typedef std::ptrdiff_t	difference_type

typedef T *	pointer

typedef T &	reference

typedef std::forward_iterator_tag	iterator_category

Public Member Functions
	RandomAccessIterator ()

	RandomAccessIterator (const ITER_IMP &implementation)

	RandomAccessIterator (const RandomAccessIterator< UnCvqT, ITER_IMP, TAG_TYPE > &other)

	~RandomAccessIterator ()

RandomAccessIterator &	operator= (const RandomAccessIterator< UnCvqT, ITER_IMP, TAG_TYPE > &other)

RandomAccessIterator &	operator++ ()

RandomAccessIterator &	operator-- ()

RandomAccessIterator &	operator+= (difference_type offset)

RandomAccessIterator &	operator-= (difference_type offset)

T &	operator[] (difference_type index) const

Public Member Functions inherited from bslstl::BidirectionalIterator< T, ITER_IMP, TAG_TYPE >
	BidirectionalIterator ()

	BidirectionalIterator (const ITER_IMP &implementation)

	BidirectionalIterator (const BidirectionalIterator &original)

	BidirectionalIterator (const BidirectionalNonConstIterator &other)

	~BidirectionalIterator ()

BidirectionalIterator &	operator= (const BidirectionalIterator &rhs)

BidirectionalIterator &	operator= (const BidirectionalNonConstIterator &rhs)

BidirectionalIterator &	operator++ ()

BidirectionalIterator &	operator-- ()

Public Member Functions inherited from bslstl::ForwardIterator< T, ITER_IMP, TAG_TYPE >
	ForwardIterator ()

	ForwardIterator (const ITER_IMP &implementation)

	ForwardIterator (const ForwardIterator &original)

	ForwardIterator (const ForwardNonConstIterator &other)

	~ForwardIterator ()

ForwardIterator &	operator= (const ForwardIterator &rhs)

ForwardIterator &	operator= (const ForwardNonConstIterator &rhs)

ForwardIterator &	operator++ ()

ITER_IMP &	imp ()

T &	operator* () const

T *	operator-> () const

const ITER_IMP &	imp () const

Member Typedef Documentation

◆ difference_type

template<class T , class ITER_IMP , class TAG_TYPE = std::random_access_iterator_tag>

typedef std::ptrdiff_t bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::difference_type

◆ iterator_category

template<class T , class ITER_IMP , class TAG_TYPE = std::random_access_iterator_tag>

typedef std::random_access_iterator_tag bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::iterator_category

◆ pointer

template<class T , class ITER_IMP , class TAG_TYPE = std::random_access_iterator_tag>

typedef T* bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::pointer

◆ reference

template<class T , class ITER_IMP , class TAG_TYPE = std::random_access_iterator_tag>

typedef T& bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::reference

◆ value_type

template<class T , class ITER_IMP , class TAG_TYPE = std::random_access_iterator_tag>

typedef UnCvqT bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::value_type

Constructor & Destructor Documentation

◆ RandomAccessIterator() [1/3]

template<class T , class ITER_IMP , class TAG_TYPE >

bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::RandomAccessIterator ( )

inline

Construct the default value for this iterator type. All default- constructed RandomAccessIterator objects represent non-dereferenceable iterators into the same empty range. They do not have a singular value unless an object of the type specified by the template parameter ITER_IMP has a singular value after value-initialization.

◆ RandomAccessIterator() [2/3]

template<class T , class ITER_IMP , class TAG_TYPE >

bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::RandomAccessIterator ( const ITER_IMP & implementation )

inline

Construct a random access iterator having the specified implementation of the parameterized ITER_IMP type.

◆ RandomAccessIterator() [3/3]

template<class T , class ITER_IMP , class TAG_TYPE >

bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::RandomAccessIterator ( const RandomAccessIterator< UnCvqT, ITER_IMP, TAG_TYPE > & other )

inline

Construct a random access iterator from another (compatible) RandomAccessIterator type, e.g., a mutable iterator of the same type.

Note: Note that this constructor may be the copy constructor (inhibiting the implicit declaration of a copy constructor above), or may be an additional overload.

◆ ~RandomAccessIterator()

template<class T , class ITER_IMP , class TAG_TYPE = std::random_access_iterator_tag>

bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::~RandomAccessIterator ( )

Member Function Documentation

◆ operator++()

template<class T , class ITER_IMP , class TAG_TYPE >

RandomAccessIterator< T, ITER_IMP, TAG_TYPE > & bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::operator++ ( )

inline

Increment to the next element. Return a reference to this modifiable iterator.

Precondition: The behavior is undefined if, on entry, this iterator has the past-the-end value for an iterator over the underlying sequence.

◆ operator+=()

template<class T , class ITER_IMP , class TAG_TYPE >

RandomAccessIterator< T, ITER_IMP, TAG_TYPE > & bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::operator+= ( difference_type offset )

inline

Increment by the specified offset number of elements. Return a reference to this modifiable iterator.

Precondition: The behavior is undefined unless the iterator, after incrementing by offset, is within the bounds of the underlying sequence.

◆ operator--()

template<class T , class ITER_IMP , class TAG_TYPE >

RandomAccessIterator< T, ITER_IMP, TAG_TYPE > & bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::operator-- ( )

inline

Decrement to the previous element. Return a reference to this modifiable iterator.

Precondition: The behavior is undefined if, on entry, this iterator has the same value as an iterator to the start of the underlying sequence.

◆ operator-=()

template<class T , class ITER_IMP , class TAG_TYPE >

RandomAccessIterator< T, ITER_IMP, TAG_TYPE > & bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::operator-= ( difference_type offset )

inline

Decrement by the specified offset number of elements. Return a reference to this modifiable iterator.

Precondition: The behavior is undefined unless the iterator, after decrementing by offset, is within the bounds of the underlying sequence.

◆ operator=()

template<class T , class ITER_IMP , class TAG_TYPE >

RandomAccessIterator< T, ITER_IMP, TAG_TYPE > & bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::operator= ( const RandomAccessIterator< UnCvqT, ITER_IMP, TAG_TYPE > & other )

inline

Copy the value of the specified rhs to this iterator. Return a reference to this modifiable iterator.

◆ operator[]()

template<class T , class ITER_IMP , class TAG_TYPE >

T & bslstl::RandomAccessIterator< T, ITER_IMP, TAG_TYPE >::operator[] ( difference_type index ) const

inline

Return a reference to the element at the specified index positions past the current one.

Precondition: The behavior is undefined unless the referenced position lies within the underlying sequence.

Note: Note that index may be negative.

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

bslstl_randomaccessiterator.h

Detailed Description

Public Types

Public Member Functions

Member Typedef Documentation

◆ difference_type

◆ iterator_category

◆ pointer

◆ reference

◆ value_type

Constructor & Destructor Documentation

◆ RandomAccessIterator() [1/3]

◆ RandomAccessIterator() [2/3]

◆ RandomAccessIterator() [3/3]

◆ ~RandomAccessIterator()

Member Function Documentation

◆ operator++()

◆ operator+=()

◆ operator--()

◆ operator-=()

◆ operator=()

◆ operator[]()