Dune::ArrayListIterator< T, N, A > Class Template Reference
[Common]

#include <arraylist.hh>

Inheritance diagram for Dune::ArrayListIterator< T, N, A >:

Dune::RandomAccessIteratorFacade< T, V, R, D >

List of all members.


Detailed Description

template<class T, int N, class A>
class Dune::ArrayListIterator< T, N, A >

A random access iterator for the Dune::ArrayList class.

Public Types

enum  { chunkSize_ = (N > 0)? N : 1 }
typedef A::value_type MemberType
 The member type.
typedef T DerivedType
 The type of derived iterator.
typedef V Value
 The type of value accessed through the iterator.
typedef V * Pointer
 The pointer to the Value.
typedef D DifferenceType
 The type of the difference between two positions.
typedef R Reference
 The type of the reference to the values accessed.

Public Member Functions

bool equals (const ArrayListIterator< MemberType, N, A > &other) const
 Comares two iterators.
bool equals (const ConstArrayListIterator< MemberType, N, A > &other) const
 Comares two iterators.
void increment ()
 Increment the iterator.
void decrement ()
 decrement the iterator.
MemberTypeelementAt (size_type i) const
 Get the value of the list at an arbitrary position.
MemberTypedereference () const
 Access the element at the current position.
void eraseToHere ()
 Erase all entries before the current position and the one at the current position.
size_type position ()
void advance (difference_type n)
difference_type distanceTo (const ArrayListIterator< T, N, A > &other) const
ArrayListIterator< T, N, A > & operator= (const ArrayListIterator< T, N, A > &other)
 ArrayListIterator ()
 Standard constructor.
Reference operator* () const
 Dereferencing operator.
Reference operator[] (DifferenceType n) const
 Get the element n positions from the current one.
DerivedTypeoperator++ ()
 Preincrement operator.
DerivedType operator++ (int)
 Postincrement operator.
DerivedTypeoperator-- ()
 Predecrement operator.
DerivedType operator-- (int)
 Postdecrement operator.

Member Typedef Documentation

template<class T, class V, class R = V&, class D = std::ptrdiff_t>
typedef T Dune::RandomAccessIteratorFacade< T, V, R, D >::DerivedType [inherited]

The type of derived iterator.

The iterator has to define following functions have to be present:

 // Access the value referred to.
 Reference dereference() const;

 // Compare for equality with j
 equals(i);

 // position the iterator at the next element.
 void increment()

 // position the iterator at the previous element.
 void decrement()

 // advance the iterator by a number of positions-
 void advance(DifferenceType n);
 // calculate the distance to another iterator.
 // One should incorporate an assertion wether
 // the same containers are referenced
 DifferenceType distanceTo(j) const;

For an elaborate explanation see the STL Documentation


Member Enumeration Documentation

template<class T, int N, class A>
anonymous enum

Enumerator:
chunkSize_  The number of elements in one chunk of the list.

This has to be at least one. The default is 100.


Member Function Documentation

template<class T, int N, class A>
size_type Dune::ArrayListIterator< T, N, A >::position (  )  [inline]

Todo:
Please doc me!

template<class T, class V, class R = V&, class D = std::ptrdiff_t>
Reference Dune::RandomAccessIteratorFacade< T, V, R, D >::operator[] ( DifferenceType  n  )  const [inline, inherited]

Get the element n positions from the current one.

Parameters:
n The distance to the element.
Returns:
The element at that distance.


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

Generated on Thu Apr 2 10:39:54 2009 for dune-common by  doxygen 1.5.6