dune-common 2.9.0
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Attributes | List of all members
Dune::ConstArrayListIterator< T, N, A > Class Template Reference

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

#include <dune/common/arraylist.hh>

Inheritance diagram for Dune::ConstArrayListIterator< T, N, A >:
Inheritance graph

Public Types

typedef A::value_type MemberType
 The member type.
 
typedef A::difference_type difference_type
 
typedef A::size_type size_type
 
using reference = typename A::value_type &
 
using const_reference = typename A::value_type const &
 
using iterator_category = std::random_access_iterator_tag
 
using value_type = typename std::remove_const< V >::type
 
using pointer = V *
 
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 ConstArrayListIterator< MemberType, N, A > &other) const
 Comares to iterators.
 
void increment ()
 Increment the iterator.
 
void decrement ()
 decrement the iterator.
 
void advance (difference_type n)
 
difference_type distanceTo (const ConstArrayListIterator< T, N, A > &other) const
 
const_reference elementAt (size_type i) const
 Get the value of the list at an arbitrary position.
 
const_reference dereference () const
 Access the element at the current position.
 
 ConstArrayListIterator ()
 
 ConstArrayListIterator (const ArrayListIterator< T, N, A > &other)
 
Reference operator* () const
 Dereferencing operator.
 
Pointer operator-> () const
 
Reference operator[] (DifferenceType n) const
 Get the element n positions from the current one.
 
DerivedTypeoperator++ ()
 Preincrement operator.
 
DerivedType operator++ (int)
 Postincrement operator.
 
DerivedTypeoperator+= (DifferenceType n)
 
DerivedType operator+ (DifferenceType n) const
 
DerivedTypeoperator-- ()
 Predecrement operator.
 
DerivedType operator-- (int)
 Postdecrement operator.
 
DerivedTypeoperator-= (DifferenceType n)
 
DerivedType operator- (DifferenceType n) const
 

Static Public Attributes

static constexpr int chunkSize_ = (N > 0) ? N : 1
 The number of elements in one chunk of the list.
 

Detailed Description

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

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

Member Typedef Documentation

◆ const_reference

template<class T , int N, class A >
using Dune::ConstArrayListIterator< T, N, A >::const_reference = typename A::value_type const&

◆ DerivedType

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.
// Access the value at some other location
// Compare for equality with j
bool equals(j);
// 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-
// calculate the distance to another iterator.
// One should incorporate an assertion whether
// the same containers are referenced
void increment()
Increment the iterator.
Definition arraylist.hh:605
const_reference elementAt(size_type i) const
Get the value of the list at an arbitrary position.
Definition arraylist.hh:629
void decrement()
decrement the iterator.
Definition arraylist.hh:617
void advance(difference_type n)
Definition arraylist.hh:566
const_reference dereference() const
Access the element at the current position.
Definition arraylist.hh:641
bool equals(const ConstArrayListIterator< MemberType, N, A > &other) const
Comares to iterators.
Definition arraylist.hh:591
difference_type distanceTo(const ConstArrayListIterator< T, N, A > &other) const
Definition arraylist.hh:655
D DifferenceType
The type of the difference between two positions.
Definition iteratorfacades.hh:492
R Reference
The type of the reference to the values accessed.
Definition iteratorfacades.hh:497

For an elaborate explanation see the STL Documentation

◆ difference_type

template<class T , int N, class A >
typedef A::difference_type Dune::ConstArrayListIterator< T, N, A >::difference_type

◆ DifferenceType

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

The type of the difference between two positions.

◆ iterator_category

template<class T , class V , class R = V&, class D = std::ptrdiff_t>
using Dune::RandomAccessIteratorFacade< T, V, R, D >::iterator_category = std::random_access_iterator_tag
inherited

◆ MemberType

template<class T , int N, class A >
typedef A::value_type Dune::ConstArrayListIterator< T, N, A >::MemberType

The member type.

◆ pointer

template<class T , class V , class R = V&, class D = std::ptrdiff_t>
using Dune::RandomAccessIteratorFacade< T, V, R, D >::pointer = V*
inherited

◆ Pointer

template<class T , class V , class R = V&, class D = std::ptrdiff_t>
typedef V* Dune::RandomAccessIteratorFacade< T, V, R, D >::Pointer
inherited

The pointer to the Value.

◆ reference

template<class T , int N, class A >
using Dune::ConstArrayListIterator< T, N, A >::reference = typename A::value_type &

◆ Reference

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

The type of the reference to the values accessed.

◆ size_type

template<class T , int N, class A >
typedef A::size_type Dune::ConstArrayListIterator< T, N, A >::size_type

◆ Value

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

The type of value accessed through the iterator.

◆ value_type

template<class T , class V , class R = V&, class D = std::ptrdiff_t>
using Dune::RandomAccessIteratorFacade< T, V, R, D >::value_type = typename std::remove_const<V>::type
inherited

Constructor & Destructor Documentation

◆ ConstArrayListIterator()

template<class T , int N, class A >
Dune::ConstArrayListIterator< T, N, A >::ConstArrayListIterator ( )
inline

Member Function Documentation

◆ operator*()

template<class T , class V , class R = V&, class D = std::ptrdiff_t>
Reference Dune::RandomAccessIteratorFacade< T, V, R, D >::operator* ( ) const
inlineinherited

Dereferencing operator.

◆ operator+()

template<class T , class V , class R = V&, class D = std::ptrdiff_t>
DerivedType Dune::RandomAccessIteratorFacade< T, V, R, D >::operator+ ( DifferenceType  n) const
inlineinherited

◆ operator++() [1/2]

template<class T , class V , class R = V&, class D = std::ptrdiff_t>
DerivedType & Dune::RandomAccessIteratorFacade< T, V, R, D >::operator++ ( )
inlineinherited

Preincrement operator.

◆ operator++() [2/2]

template<class T , class V , class R = V&, class D = std::ptrdiff_t>
DerivedType Dune::RandomAccessIteratorFacade< T, V, R, D >::operator++ ( int  )
inlineinherited

Postincrement operator.

◆ operator+=()

template<class T , class V , class R = V&, class D = std::ptrdiff_t>
DerivedType & Dune::RandomAccessIteratorFacade< T, V, R, D >::operator+= ( DifferenceType  n)
inlineinherited

◆ operator-()

template<class T , class V , class R = V&, class D = std::ptrdiff_t>
DerivedType Dune::RandomAccessIteratorFacade< T, V, R, D >::operator- ( DifferenceType  n) const
inlineinherited

◆ operator--() [1/2]

template<class T , class V , class R = V&, class D = std::ptrdiff_t>
DerivedType & Dune::RandomAccessIteratorFacade< T, V, R, D >::operator-- ( )
inlineinherited

Predecrement operator.

◆ operator--() [2/2]

template<class T , class V , class R = V&, class D = std::ptrdiff_t>
DerivedType Dune::RandomAccessIteratorFacade< T, V, R, D >::operator-- ( int  )
inlineinherited

Postdecrement operator.

◆ operator-=()

template<class T , class V , class R = V&, class D = std::ptrdiff_t>
DerivedType & Dune::RandomAccessIteratorFacade< T, V, R, D >::operator-= ( DifferenceType  n)
inlineinherited

◆ operator->()

template<class T , class V , class R = V&, class D = std::ptrdiff_t>
Pointer Dune::RandomAccessIteratorFacade< T, V, R, D >::operator-> ( ) const
inlineinherited

◆ operator[]()

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

Get the element n positions from the current one.

Parameters
nThe distance to the element.
Returns
The element at that distance.

Member Data Documentation

◆ chunkSize_

template<class T , int N, class A >
constexpr int Dune::ConstArrayListIterator< T, N, A >::chunkSize_ = (N > 0) ? N : 1
staticconstexpr

The number of elements in one chunk of the list.

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


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