Loading...
Searching...
No Matches
Common

foundation classes More...

Collaboration diagram for Common:

## Topics

| Allocators
| Implementations of the STL allocator concept.
| Utilities
| Collection of helper classes, type traits, etc.
| Numbers
| Class implementing different number representations and helper functions.
| Debug output
| Dense Matrix and Vector Template Library
| Type traits to retrieve the field and the real type of classes.
| Exception handling
| Iterator facades
| Iterator facades for writing stl conformant iterators.
| Parallel Communication
| Abstractions for parallel computing.
| Vectorization
| Abstractions for using vectorization libraries.

## Files

file | indent.hh
| Utility class for handling nested indentation in output.
file | ios_state.hh
| Utility class for storing and resetting stream attributes.
file | sllist.hh
| Implements a singly linked list together with the necessary iterators.
file | timer.hh
| A simple timing class.

## Namespaces

namespace | Dune::Indices
| Namespace with predefined compile time indices for the range [0,19].
namespace | Dune::Indices::Literals

## Classes

class | Dune::ArrayList< T, N, A >
| A dynamically growing random access list. More...
class | Dune::ArrayListIterator< T, N, A >
| A random access iterator for the Dune::ArrayList class. More...
class | Dune::ConstArrayListIterator< T, N, A >
| A constant random access iterator for the Dune::ArrayList class. More...
struct | Dune::ImplementationDefined
| Dummy struct used for documentation purposes. More...
struct | Dune::IsVector< T, class >
struct | Dune::IsVector< T, std::void_t< typename T::field_type > >
class | Dune::EmptySet< TA >
| An empty set. More...
class | Dune::AllSet< TA >
| A set containing everything. More...
class | Dune::EnumItem< TA, item >
| A set consisting only of one item. More...
class | Dune::EnumRange< TA, from, end >
| A set representing a range including the borders. More...
class | Dune::NegateSet< S >
| The negation of a set. An item is contained in the set if and only if it is not contained in the negated set. More...
class | Dune::Combine< TI1, TI2, TA >
| A set combining two other sets. More...
class | Dune::Indent
| Utility class for handling nested indentation in output. More...
class | Dune::ios_base_all_saver
| Utility class for storing and resetting stream attributes. More...
class | Dune::ParameterTree
| Hierarchical structure of string parameters. More...
class | Dune::ParameterTreeParser
| Parsers to set up a ParameterTree from various input sources. More...
struct | Dune::PromotionTraits< T1, T2 >
| Compute type of the result of an arithmetic operation involving two different number types. More...
struct | Dune::PromotionTraits< T1, T1 >
class | Dune::SLListIterator< T, A >
| A mutable iterator for the SLList. More...
class | Dune::SLListConstIterator< T, A >
| A constant iterator for the SLList. More...
class | Dune::SLListModifyIterator< T, A >
| A mutable iterator for the SLList. More...
class | Dune::SLList< T, A >
| A single linked list. More...
class | Dune::Timer
| A simple stop watch. More...

## Macros

#define | DUNE_ASSERT_BOUNDS(cond)
| If DUNE_CHECK_BOUNDS is defined: check if condition cond holds; otherwise, do nothing.

## Typedefs

template<std::size_t i>
using | Dune::index_constant = std::integral_constant<std::size_t, i>
| An index constant with value i.
typedef std::ios_base | Dune::ios_base_all_saver::state_type
| Export type of object we save the state for.
typedef A::size_type | Dune::SLList< T, A >::size_type
| The size type.
typedef T | Dune::SLList< T, A >::MemberType
| The type we store.
using | Dune::SLList< T, A >::Allocator = typename std::allocator_traits<A>::template rebind_alloc<Element>
| The allocator to use.
typedef SLListIterator< T, A > | Dune::SLList< T, A >::iterator
| The mutable iterator of the list.
typedef SLListConstIterator< T, A > | Dune::SLList< T, A >::const_iterator
| The constant iterator of the list.
typedef SLListModifyIterator< T, A > | Dune::SLList< T, A >::ModifyIterator
| The type of the iterator capable of deletion and insertion.

## Functions

template<class A, class B>
auto | Dune::dot (const A &a, const B &b) -> typename std::enable_if< IsNumber< A >::value &&!IsVector< A >::value &&!std::is_same< typename FieldTraits< A >::field_type, typename FieldTraits< A >::real_type > ::value, decltype(conj(a) *b)>::type
| computes the dot product for fundamental data types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b
template<class A, class B>
auto | Dune::dot (const A &a, const B &b) -> typename std::enable_if< IsNumber< A >::value &&!IsVector< A >::value &&std::is_same< typename FieldTraits< A >::field_type, typename FieldTraits< A >::real_type >::value, decltype(a *b)>::type
| computes the dot product for fundamental data types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b
template<typename A, typename B>
auto | Dune::dot (const A &a, const B &b) -> typename std::enable_if< IsVector< A >::value, decltype(a.dot(b))>::type
| computes the dot product for various dune vector types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b
template<class A, class B>
auto | Dune::dotT (const A &a, const B &b) -> decltype(a *b)
| Computes an indefinite vector dot product for fundamental data types according to Petsc's VectTDot function: dotT(a,b) := a*b.
template<typename TA, int i>
std::ostream & | Dune::operator<< (std::ostream &os, const EnumItem< TA, i > &)
template<typename TA, int from, int to>
std::ostream & | Dune::operator<< (std::ostream &os, const EnumRange< TA, from, to > &)
template<class TI1, class TI2>
Combine< TI1, TI2, typename TI1::Type > | Dune::combine (const TI1 &set1, const TI2 &set2)
template<class TI1, class TI2, class T>
std::ostream & | Dune::operator<< (std::ostream &os, const Combine< TI1, TI2, T > &)
template<std::size_t n, class T>
constexpr std::array< T, n > | Dune::filledArray (const T &t)
| Return an array filled with the provided value.
| Dune::Indent::Indent (const std::string &basic_indent_=" ", unsigned level_=0)
| setup without parent
| Dune::Indent::Indent (unsigned level_)
| setup without parent and basic_indentation of two spaces
| Dune::Indent::Indent (const Indent *parent_, const std::string &basic_indent_=" ", unsigned level_=1)
| setup with parent
| Dune::Indent::Indent (const Indent *parent_, unsigned level_)
| setup with parent
Indent | Dune::Indent::operator+ (const std::string &newindent) const
| create new indentation object with this one as parent
Indent | Dune::Indent::operator+ (unsigned morelevel) const
| create a copy of this indentation object with raised level
Indent & | Dune::Indent::operator++ ()
| raise indentation level
Indent & | Dune::Indent::operator-- ()
| lower indentation level
std::ostream & | Dune::operator<< (std::ostream &s, const Indent &indent)
| write indentation to a stream
template<class F, class I, I... i>
decltype(auto) constexpr | Dune::unpackIntegerSequence (F &&f, std::integer_sequence< I, i... > sequence)
| Unpack an std::integer_sequence<I,i...> to std::integral_constant<I,i>...
template<char... digits>
constexpr auto | Dune::Indices::Literals::operator""_ic ()
| Literal to create an index compile-time constant.
template<char... digits>
constexpr auto | Dune::Indices::Literals::operator""_uc ()
| Literal to create an unsigned integer compile-time constant.
template<char... digits>
constexpr auto | Dune::Indices::Literals::operator""_sc ()
| Literal to create a signed integer compile-time constant.
template<class T, T value>
constexpr auto | Dune::Indices::Literals::operator- (std::integral_constant< T, value >)
| Negation operator for integral constants.
| Dune::ios_base_all_saver::ios_base_all_saver (state_type &ios_)
| Constructor that stores the currently used flags.
| Dune::ios_base_all_saver::~ios_base_all_saver ()
| Destructor that restores the flags stored by the constructor.
void | Dune::ios_base_all_saver::restore ()
| Restore flags now.
| Dune::SLList< T, A >::SLList ()
| Constructor.
template<typename T1, typename A1>
| Dune::SLList< T, A >::SLList (const SLList< T1, A1 > &other)
| Copy constructor with type conversion.
| Dune::SLList< T, A >::SLList (const SLList< T, A > &other)
| Copy constructor.
| Dune::SLList< T, A >::~SLList ()
| Destructor.
SLList< T, A > & | Dune::SLList< T, A >::operator= (const SLList< T, A > &other)
| Assignment operator.
void | Dune::SLList< T, A >::push_back (const MemberType &item)
| Add a new entry to the end of the list.
void | Dune::SLList< T, A >::push_front (const MemberType &item)
| Add a new entry to the beginning of the list.
void | Dune::SLList< T, A >::pop_front ()
| Remove the first item in the list.
void | Dune::SLList< T, A >::clear ()
| Remove all elements from the list.
iterator | Dune::SLList< T, A >::begin ()
| Get an iterator pointing to the first element in the list.
const_iterator | Dune::SLList< T, A >::begin () const
| Get an iterator pointing to the first element in the list.
ModifyIterator | Dune::SLList< T, A >::beginModify ()
| Get an iterator capable of deleting and inserting elements.
ModifyIterator | Dune::SLList< T, A >::endModify ()
| Get an iterator capable of deleting and inserting elements.
iterator | Dune::SLList< T, A >::end ()
| Get an iterator pointing to the end of the list.
const_iterator | Dune::SLList< T, A >::end () const
| Get an iterator pointing to the end of the list.
bool | Dune::SLList< T, A >::empty () const
| Check whether the list is empty.
int | Dune::SLList< T, A >::size () const
| Get the number of elements the list contains.
bool | Dune::SLList< T, A >::operator== (const SLList &sl) const
bool | Dune::SLList< T, A >::operator!= (const SLList &sl) const
| Dune::SLList< T, A >::Element::Element (const MemberType &item, Element *next_=0)
| Dune::SLList< T, A >::Element::Element ()
| Dune::SLList< T, A >::Element::~Element ()
| Dune::SLListIterator< T, A >::SLListIterator (typename SLList< T, A >::Element *item, SLList< T, A > *sllist)
| Dune::SLListIterator< T, A >::SLListIterator ()
| Dune::SLListIterator< T, A >::SLListIterator (const SLListModifyIterator< T, A > &other)
T & | Dune::SLListIterator< T, A >::dereference () const
| Dereferencing function for the iterator facade.
bool | Dune::SLListIterator< T, A >::equals (const SLListConstIterator< T, A > &other) const
| Equality test for the iterator facade.
bool | Dune::SLListIterator< T, A >::equals (const SLListIterator< T, A > &other) const
| Equality test for the iterator facade.
bool | Dune::SLListIterator< T, A >::equals (const SLListModifyIterator< T, A > &other) const
| Equality test for the iterator facade.
void | Dune::SLListIterator< T, A >::increment ()
| Increment function for the iterator facade.
void | Dune::SLListIterator< T, A >::insertAfter (const T &v) const
| Insert an element in the underlying list after the current position.
void | Dune::SLListIterator< T, A >::deleteNext () const
| Delete the entry after the current position.
| Dune::SLListConstIterator< T, A >::SLListConstIterator ()
| Dune::SLListConstIterator< T, A >::SLListConstIterator (typename SLList< T, A >::Element *item)
| Dune::SLListConstIterator< T, A >::SLListConstIterator (const SLListIterator< T, A > &other)
| Dune::SLListConstIterator< T, A >::SLListConstIterator (const SLListModifyIterator< T, A > &other)
const T & | Dune::SLListConstIterator< T, A >::dereference () const
| Dereferencing function for the facade.
bool | Dune::SLListConstIterator< T, A >::equals (const SLListConstIterator< T, A > &other) const
| Equality test for the iterator facade.
void | Dune::SLListConstIterator< T, A >::increment ()
| Increment function for the iterator facade.
| Dune::SLListModifyIterator< T, A >::SLListModifyIterator (SLListIterator< T, A > beforeIterator, SLListIterator< T, A > _iterator)
| Dune::SLListModifyIterator< T, A >::SLListModifyIterator ()
T & | Dune::SLListModifyIterator< T, A >::dereference () const
| Dereferencing function for the iterator facade.
bool | Dune::SLListModifyIterator< T, A >::equals (const SLListConstIterator< T, A > &other) const
| Test whether another iterator is equal.
bool | Dune::SLListModifyIterator< T, A >::equals (const SLListIterator< T, A > &other) const
| Test whether another iterator is equal.
bool | Dune::SLListModifyIterator< T, A >::equals (const SLListModifyIterator< T, A > &other) const
| Test whether another iterator is equal.
void | Dune::SLListModifyIterator< T, A >::increment ()
| Increment function for the iterator facade.
void | Dune::SLListModifyIterator< T, A >::insert (const T &v)
| Insert an element at the current position.
void | Dune::SLListModifyIterator< T, A >::remove ()
| Delete the entry at the current position.
template<typename T, typename A>
std::ostream & | Dune::operator<< (std::ostream &os, const SLList< T, A > &sllist)
template<typename... Ts>
std::ostream & | Dune::operator<< (std::ostream &stream, const std::tuple< Ts... > &t)
| Print a std::tuple.
template<typename... Ts>
std::istream & | Dune::operator>> (std::istream &stream, std::tuple< Ts... > &t)
| Read a std::tuple.
template<typename T, std::size_t N>
std::ostream & | Dune::operator<< (std::ostream &stream, const std::array< T, N > &a)
| Print a std::array.
| Dune::ArrayList< T, N, A >::ArrayList ()
| Constructs an Array list with one chunk.
void | Dune::ArrayList< T, N, A >::clear ()
| Delete all entries from the list.
size_type | Dune::ArrayList< T, N, A >::size () const
| Get the number of elements in the list.
void | Dune::ArrayList< T, N, A >::push_back (const_reference entry)
| Append an entry to the list.
reference | Dune::ArrayList< T, N, A >::operator[] (size_type i)
| Get the element at specific position.
const_reference | Dune::ArrayList< T, N, A >::operator[] (size_type i) const
| Get the element at specific position.
iterator | Dune::ArrayList< T, N, A >::begin ()
| Get an iterator that is positioned at the first element.
const_iterator | Dune::ArrayList< T, N, A >::begin () const
| Get a random access iterator that is positioned at the first element.
iterator | Dune::ArrayList< T, N, A >::end ()
| Get a random access iterator positioned after the last element.
const_iterator | Dune::ArrayList< T, N, A >::end () const
| Get a random access iterator positioned after the last element.
void | Dune::ArrayList< T, N, A >::purge ()
| Purge the list.
void | Dune::ArrayListIterator< T, N, A >::advance (difference_type n)
void | Dune::ConstArrayListIterator< T, N, A >::advance (difference_type n)
bool | Dune::ArrayListIterator< T, N, A >::equals (const ArrayListIterator< MemberType, N, A > &other) const
| Compares two iterators.
bool | Dune::ArrayListIterator< T, N, A >::equals (const ConstArrayListIterator< MemberType, N, A > &other) const
| Compares two iterators.
bool | Dune::ConstArrayListIterator< T, N, A >::equals (const ConstArrayListIterator< MemberType, N, A > &other) const
| Compares to iterators.
void | Dune::ArrayListIterator< T, N, A >::increment ()
| Increment the iterator.
void | Dune::ConstArrayListIterator< T, N, A >::increment ()
| Increment the iterator.
void | Dune::ArrayListIterator< T, N, A >::decrement ()
| decrement the iterator.
void | Dune::ConstArrayListIterator< T, N, A >::decrement ()
| decrement the iterator.
reference | Dune::ArrayListIterator< T, N, A >::elementAt (size_type i) const
| Get the value of the list at an arbitrary position.
reference | Dune::ConstArrayListIterator< T, N, A >::elementAt (size_type i) const
| Get the value of the list at an arbitrary position.
reference | Dune::ArrayListIterator< T, N, A >::dereference () const
| Access the element at the current position.
reference | Dune::ConstArrayListIterator< T, N, A >::dereference () const
| Access the element at the current position.
difference_type | Dune::ArrayListIterator< T, N, A >::distanceTo (const ArrayListIterator< T, N, A > &other) const
difference_type | Dune::ConstArrayListIterator< T, N, A >::distanceTo (const ConstArrayListIterator< T, N, A > &other) const
void | Dune::ArrayListIterator< T, N, A >::eraseToHere ()
| Erase all entries before the current position and the one at the current position.
| Dune::ConstArrayListIterator< T, N, A >::ConstArrayListIterator (const ArrayListIterator< T, N, A > &other)
static bool | Dune::EmptySet< TA >::contains (const Type &attribute)
| Always returns false.
static bool | Dune::AllSet< TA >::contains (const Type &attribute)
| Always returns true.
static bool | Dune::EnumItem< TA, item >::contains (const Type &attribute)
| Tests whether an item is in the set.
static bool | Dune::EnumRange< TA, from, end >::contains (const Type &item)
static bool | Dune::Combine< TI1, TI2, TA >::contains (const TA &item)

## Variables

constexpr index_constant< 0 > | Dune::Indices::_0 = {}
| Compile time index with value 0.
constexpr index_constant< 1 > | Dune::Indices::_1 = {}
| Compile time index with value 1.
constexpr index_constant< 2 > | Dune::Indices::_2 = {}
| Compile time index with value 2.
constexpr index_constant< 3 > | Dune::Indices::_3 = {}
| Compile time index with value 3.
constexpr index_constant< 4 > | Dune::Indices::_4 = {}
| Compile time index with value 4.
constexpr index_constant< 5 > | Dune::Indices::_5 = {}
| Compile time index with value 5.
constexpr index_constant< 6 > | Dune::Indices::_6 = {}
| Compile time index with value 6.
constexpr index_constant< 7 > | Dune::Indices::_7 = {}
| Compile time index with value 7.
constexpr index_constant< 8 > | Dune::Indices::_8 = {}
| Compile time index with value 8.
constexpr index_constant< 9 > | Dune::Indices::_9 = {}
| Compile time index with value 9.
constexpr index_constant< 10 > | Dune::Indices::_10 = {}
| Compile time index with value 10.
constexpr index_constant< 11 > | Dune::Indices::_11 = {}
| Compile time index with value 11.
constexpr index_constant< 12 > | Dune::Indices::_12 = {}
| Compile time index with value 12.
constexpr index_constant< 13 > | Dune::Indices::_13 = {}
| Compile time index with value 13.
constexpr index_constant< 14 > | Dune::Indices::_14 = {}
| Compile time index with value 14.
constexpr index_constant< 15 > | Dune::Indices::_15 = {}
| Compile time index with value 15.
constexpr index_constant< 16 > | Dune::Indices::_16 = {}
| Compile time index with value 16.
constexpr index_constant< 17 > | Dune::Indices::_17 = {}
| Compile time index with value 17.
constexpr index_constant< 18 > | Dune::Indices::_18 = {}
| Compile time index with value 18.
constexpr index_constant< 19 > | Dune::Indices::_19 = {}
| Compile time index with value 19.
Element * | Dune::SLList< T, A >::Element::next_
| The next element in the list.
MemberType | Dune::SLList< T, A >::Element::item_
| The element we hold.

## Friends

class | Dune::SLList< T, A >::SLListIterator< T, A >
class | Dune::SLList< T, A >::SLListConstIterator< T, A >
class | Dune::SLListIterator< T, A >::SLListConstIterator< T, A >
class | Dune::SLListIterator< T, A >::SLListModifyIterator< T, A >
class | Dune::SLListIterator< T, A >::SLList< T, A >
class | Dune::SLListConstIterator< T, A >::SLListIterator< T, A >
class | Dune::SLListConstIterator< T, A >::SLList< T, A >
class | Dune::SLListModifyIterator< T, A >::SLListConstIterator< T, A >
class | Dune::SLListModifyIterator< T, A >::SLListIterator< T, A >
std::ostream & | Dune::Indent::operator<< (std::ostream &s, const Indent &indent)
| write indentation to a stream

## Detailed Description

foundation classes

## Macro Definition Documentation

## DUNE_ASSERT_BOUNDS

#define DUNE_ASSERT_BOUNDS | ( |  | cond | ) |

Value:
do { \
if (!(cond)) \
DUNE_THROW(Dune::RangeError, "Index out of bounds."); \
} while (false)
Dune::RangeError
Default exception class for range errors.
Definition exceptions.hh:348

If DUNE_CHECK_BOUNDS is defined: check if condition cond holds; otherwise, do nothing.

Meant to be used for conditions that assure writes and reads do not occur outside of memory limits or pre-defined patterns and related conditions.

## Typedef Documentation

## Allocator

template<typename T, class A = std::allocator<T>>

using Dune::SLList< T, A >::Allocator = typename std::allocator_traits<A>::template rebind_alloc<Element>

The allocator to use.

## const_iterator

template<typename T, class A = std::allocator<T>>

typedef SLListConstIterator<T,A> Dune::SLList< T, A >::const_iterator

The constant iterator of the list.

## index_constant

template<std::size_t i>

using Dune::index_constant = std::integral_constant<std::size_t, i>

An index constant with value i.

An index constant is a simple type alias for an integral_constant. Its main advantages are clarity (it is easier to see that code uses it as an index) and the fact that the integral type is fixed, reducing verbosity and avoiding the problem of maybe trying to overload / specialize using a different integral type.

## iterator

template<typename T, class A = std::allocator<T>>

typedef SLListIterator<T,A> Dune::SLList< T, A >::iterator

The mutable iterator of the list.

## MemberType

template<typename T, class A = std::allocator<T>>

typedef T Dune::SLList< T, A >::MemberType

The type we store.

## ModifyIterator

template<typename T, class A = std::allocator<T>>

typedef SLListModifyIterator<T,A> Dune::SLList< T, A >::ModifyIterator

The type of the iterator capable of deletion and insertion.

## size_type

template<typename T, class A = std::allocator<T>>

typedef A::size_type Dune::SLList< T, A >::size_type

The size type.

## state_type

typedef std::ios_base Dune::ios_base_all_saver::state_type

Export type of object we save the state for.

## Function Documentation

## advance() [1/2]

template<class T, int N, class A>

void Dune::ArrayListIterator< T, N, A >::advance | ( | difference_type | n | ) |

inline

Todo
  Please doc me!

## advance() [2/2]

template<class T, int N, class A>

void Dune::ConstArrayListIterator< T, N, A >::advance | ( | difference_type | n | ) |

inline

Todo
  Please doc me!

## ArrayList()

template<class T, int N, class A>

Dune::ArrayList< T, N, A >::ArrayList | ( |  | ) |

Constructs an Array list with one chunk.

## begin() [1/4]

template<class T, int N, class A>

ArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::begin | ( |  | ) |

Get an iterator that is positioned at the first element.

Returns
  The iterator.

## begin() [2/4]

template<class T, int N, class A>

ConstArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::begin | ( |  | ) | const

Get a random access iterator that is positioned at the first element.

Returns
  The iterator.

## begin() [3/4]

template<typename T, class A>

SLListIterator< T, A > Dune::SLList< T, A >::begin | ( |  | ) |

inline

Get an iterator pointing to the first element in the list.

Returns
  An iterator pointing to the first element or the end if the list is empty.

## begin() [4/4]

template<typename T, class A>

SLListConstIterator< T, A > Dune::SLList< T, A >::begin | ( |  | ) | const

inline

Get an iterator pointing to the first element in the list.

Returns
  An iterator pointing to the first element or the end if the list is empty.

## beginModify()

template<typename T, class A>

SLListModifyIterator< T, A > Dune::SLList< T, A >::beginModify | ( |  | ) |

inline

Get an iterator capable of deleting and inserting elements.

Returns
  Modifying iterator positioned at the beginning of the list.

## clear() [1/2]

template<class T, int N, class A>

void Dune::ArrayList< T, N, A >::clear | ( |  | ) |

inline

Delete all entries from the list.

## clear() [2/2]

template<typename T, class A>

void Dune::SLList< T, A >::clear | ( |  | ) |

inline

Remove all elements from the list.

## combine()

template<class TI1, class TI2>

Combine< TI1, TI2, typename TI1::Type > Dune::combine | ( | const TI1 & | set1,
|  | const TI2 & | set2 )

inline

## ConstArrayListIterator()

template<class T, int N, class A>

Dune::ConstArrayListIterator< T, N, A >::ConstArrayListIterator | ( | const ArrayListIterator< T, N, A > & | other | ) |

inline

## contains() [1/5]

template<typename TA>

bool Dune::AllSet< TA >::contains | ( | const Type & | attribute | ) |

inline static

Always returns true.

## contains() [2/5]

template<class TI1, class TI2, typename TA>

bool Dune::Combine< TI1, TI2, TA >::contains | ( | const TA & | item | ) |

inline static

## contains() [3/5]

template<typename TA>

bool Dune::EmptySet< TA >::contains | ( | const Type & | attribute | ) |

inline static

Always returns false.

## contains() [4/5]

template<typename TA, int i>

bool Dune::EnumItem< TA, i >::contains | ( | const Type & | attribute | ) |

inline static

Tests whether an item is in the set.

Returns
  True if item==Type.

## contains() [5/5]

template<typename TA, int from, int to>

bool Dune::EnumRange< TA, from, to >::contains | ( | const Type & | item | ) |

inline static

## decrement() [1/2]

template<class T, int N, class A>

void Dune::ArrayListIterator< T, N, A >::decrement | ( |  | ) |

inline

decrement the iterator.

## decrement() [2/2]

template<class T, int N, class A>

void Dune::ConstArrayListIterator< T, N, A >::decrement | ( |  | ) |

inline

decrement the iterator.

## deleteNext()

template<typename T, class A>

void Dune::SLListIterator< T, A >::deleteNext | ( |  | ) | const

inline

Delete the entry after the current position.

Warning
  This will invalidate all iterators positioned at the delete position! Use with care!

## dereference() [1/5]

template<class T, int N, class A>

ArrayListIterator< T, N, A >::reference Dune::ArrayListIterator< T, N, A >::dereference | ( |  | ) | const

inline

Access the element at the current position.

Returns
  The element at the current position.

## dereference() [2/5]

template<class T, int N, class A>

ConstArrayListIterator< T, N, A >::reference Dune::ConstArrayListIterator< T, N, A >::dereference | ( |  | ) | const

inline

Access the element at the current position.

Returns
  The element at the current position.

## dereference() [3/5]

template<class T, class A>

const T & Dune::SLListConstIterator< T, A >::dereference | ( |  | ) | const

inline

Dereferencing function for the facade.

Returns
  A reference to the element at the current position.

## dereference() [4/5]

template<typename T, class A>

T & Dune::SLListIterator< T, A >::dereference | ( |  | ) | const

inline

Dereferencing function for the iterator facade.

Returns
  A reference to the element at the current position.

## dereference() [5/5]

template<typename T, class A>

T & Dune::SLListModifyIterator< T, A >::dereference | ( |  | ) | const

inline

Dereferencing function for the iterator facade.

Returns
  A reference to the element at the current position.

## distanceTo() [1/2]

template<class T, int N, class A>

ArrayListIterator< T, N, A >::difference_type Dune::ArrayListIterator< T, N, A >::distanceTo | ( | const ArrayListIterator< T, N, A > & | other | ) | const

inline

Todo
  Please doc me!

## distanceTo() [2/2]

template<class T, int N, class A>

ConstArrayListIterator< T, N, A >::difference_type Dune::ConstArrayListIterator< T, N, A >::distanceTo | ( | const ConstArrayListIterator< T, N, A > & | other | ) | const

inline

Todo
  Please doc me!

## dot() [1/3]

template<class A, class B>

auto Dune::dot | ( | const A & | a,
|  | const B & | b )->typenamestd::enable_if< IsNumber< A >::value &&!IsVector< A >::value &&!std::is_same< typenameFieldTraits< A >::field_type, typenameFieldTraits< A >::real_type >::value, decltype(conj(a) *b)>::type

computes the dot product for fundamental data types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b

See also
  http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Vec/VecDot.html#VecDot

Returns
  conj(a)*b

## dot() [2/3]

template<class A, class B>

auto Dune::dot | ( | const A & | a,
|  | const B & | b )->typenamestd::enable_if< IsNumber< A >::value &&!IsVector< A >::value &&std::is_same< typenameFieldTraits< A >::field_type, typenameFieldTraits< A >::real_type >::value, decltype(a *b)>::type

computes the dot product for fundamental data types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b

Specialization for real first arguments which replaces conj(a) by a.

See also
  http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Vec/VecTDot.html#VecTDot

Returns
  a*b (which is the same as conj(a)*b in this case)

## dot() [3/3]

template<typename A, typename B>

auto Dune::dot | ( | const A & | a,
|  | const B & | b )->typenamestd::enable_if< IsVector< A >::value, decltype(a.dot(b))>::type

computes the dot product for various dune vector types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b

Specialization for real first arguments which replaces conj(a) by a.

See also
  http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Vec/VecTDot.html#VecTDot

Returns
  dot(a,b)

## dotT()

template<class A, class B>

auto Dune::dotT | ( | const A & | a,
|  | const B & | b )->decltype(a *b)

Computes an indefinite vector dot product for fundamental data types according to Petsc's VectTDot function: dotT(a,b) := a*b.

See also
  http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Vec/VecTDot.html#VecTDot

Returns
  a*b

## Element() [1/2]

template<typename T, class A>

Dune::SLList< T, A >::Element::Element | ( |  | ) |

## Element() [2/2]

template<typename T, class A>

Dune::SLList< T, A >::Element::Element | ( | const MemberType & | item,
|  | Element * | next_ = 0 )

## elementAt() [1/2]

template<class T, int N, class A>

ArrayListIterator< T, N, A >::reference Dune::ArrayListIterator< T, N, A >::elementAt | ( | size_type | i | ) | const

inline

Get the value of the list at an arbitrary position.

Returns
  The value at that position.

## elementAt() [2/2]

template<class T, int N, class A>

ConstArrayListIterator< T, N, A >::reference Dune::ConstArrayListIterator< T, N, A >::elementAt | ( | size_type | i | ) | const

inline

Get the value of the list at an arbitrary position.

Returns
  The value at that position.

## empty()

template<typename T, class A>

bool Dune::SLList< T, A >::empty | ( |  | ) | const

inline

Check whether the list is empty.

Returns
  True if the list is empty;

## end() [1/4]

template<class T, int N, class A>

ArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::end | ( |  | ) |

Get a random access iterator positioned after the last element.

## end() [2/4]

template<class T, int N, class A>

ConstArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::end | ( |  | ) | const

Get a random access iterator positioned after the last element.

## end() [3/4]

template<typename T, class A>

SLListIterator< T, A > Dune::SLList< T, A >::end | ( |  | ) |

inline

Get an iterator pointing to the end of the list.

Returns
  An iterator pointing to the end.

## end() [4/4]

template<typename T, class A>

SLListConstIterator< T, A > Dune::SLList< T, A >::end | ( |  | ) | const

inline

Get an iterator pointing to the end of the list.

Returns
  An iterator pointing to the end.

## endModify()

template<typename T, class A>

SLListModifyIterator< T, A > Dune::SLList< T, A >::endModify | ( |  | ) |

inline

Get an iterator capable of deleting and inserting elements.

Returns
  Modifying iterator positioned after the end of the list.

## equals() [1/10]

template<class T, int N, class A>

bool Dune::ArrayListIterator< T, N, A >::equals | ( | const ArrayListIterator< MemberType, N, A > & | other | ) | const

inline

Compares two iterators.

Returns
  True if the iterators are for the same list and at the position.

## equals() [2/10]

template<class T, int N, class A>

bool Dune::ArrayListIterator< T, N, A >::equals | ( | const ConstArrayListIterator< MemberType, N, A > & | other | ) | const

inline

Compares two iterators.

Returns
  True if the iterators are for the same list and at the position.

## equals() [3/10]

template<class T, int N, class A>

bool Dune::ConstArrayListIterator< T, N, A >::equals | ( | const ConstArrayListIterator< MemberType, N, A > & | other | ) | const

inline

Compares to iterators.

Returns
  true if the iterators are for the same list and at the position.

## equals() [4/10]

template<class T, class A>

bool Dune::SLListConstIterator< T, A >::equals | ( | const SLListConstIterator< T, A > & | other | ) | const

inline

Equality test for the iterator facade.

Parameters

  other | The other iterator to check.

Returns
  true If the other iterator is at the same position.

## equals() [5/10]

template<typename T, class A>

bool Dune::SLListIterator< T, A >::equals | ( | const SLListConstIterator< T, A > & | other | ) | const

inline

Equality test for the iterator facade.

Parameters

  other | The other iterator to check.

Returns
  true If the other iterator is at the same position.

## equals() [6/10]

template<typename T, class A>

bool Dune::SLListIterator< T, A >::equals | ( | const SLListIterator< T, A > & | other | ) | const

inline

Equality test for the iterator facade.

Parameters

  other | The other iterator to check.

Returns
  true If the other iterator is at the same position.

## equals() [7/10]

template<typename T, class A>

bool Dune::SLListIterator< T, A >::equals | ( | const SLListModifyIterator< T, A > & | other | ) | const

inline

Equality test for the iterator facade.

Parameters

  other | The other iterator to check.

Returns
  true If the other iterator is at the same position.

## equals() [8/10]

template<typename T, class A>

bool Dune::SLListModifyIterator< T, A >::equals | ( | const SLListConstIterator< T, A > & | other | ) | const

inline

Test whether another iterator is equal.

Returns
  true if the other iterator is at the same position as this one.

## equals() [9/10]

template<typename T, class A>

bool Dune::SLListModifyIterator< T, A >::equals | ( | const SLListIterator< T, A > & | other | ) | const

inline

Test whether another iterator is equal.

Returns
  true if the other iterator is at the same position as this one.

## equals() [10/10]

template<typename T, class A>

bool Dune::SLListModifyIterator< T, A >::equals | ( | const SLListModifyIterator< T, A > & | other | ) | const

inline

Test whether another iterator is equal.

Returns
  true if the other iterator is at the same position as this one.

## eraseToHere()

template<class T, int N, class A>

void Dune::ArrayListIterator< T, N, A >::eraseToHere | ( |  | ) |

inline

Erase all entries before the current position and the one at the current position.

Afterwards the iterator will be positioned at the next unerased entry or the end if the list is empty. This does not invalidate any iterators positioned after the current position but those positioned at previous ones.

## filledArray()

template<std::size_t n, class T>

std::array< T, n > Dune::filledArray | ( | const T & | t | ) |

constexpr

Return an array filled with the provided value.

Template Parameters

  n | Size of the returned array.
  T | Value type of the returned array. This is usually deduced from t.

## increment() [1/5]

template<class T, int N, class A>

void Dune::ArrayListIterator< T, N, A >::increment | ( |  | ) |

inline

Increment the iterator.

## increment() [2/5]

template<class T, int N, class A>

void Dune::ConstArrayListIterator< T, N, A >::increment | ( |  | ) |

inline

Increment the iterator.

## increment() [3/5]

template<class T, class A>

void Dune::SLListConstIterator< T, A >::increment | ( |  | ) |

inline

Increment function for the iterator facade.

## increment() [4/5]

template<typename T, class A>

void Dune::SLListIterator< T, A >::increment | ( |  | ) |

inline

Increment function for the iterator facade.

## increment() [5/5]

template<typename T, class A>

void Dune::SLListModifyIterator< T, A >::increment | ( |  | ) |

inline

Increment function for the iterator facade.

## Indent() [1/4]

Dune::Indent::Indent | ( | const Indent * | parent_,
|  | const std::string & | basic_indent_ = " ",
|  | unsigned | level_ = 1 )

inline

setup with parent

Note
  Initial indentation level is 1 by default for this constructor.

## Indent() [2/4]

Dune::Indent::Indent | ( | const Indent * | parent_,
|  | unsigned | level_ )

inline

setup with parent

## Indent() [3/4]

Dune::Indent::Indent | ( | const std::string & | basic_indent_ = " ",
|  | unsigned | level_ = 0 )

inline

setup without parent

Note
  Initial indentation level is 0 by default for this constructor.

## Indent() [4/4]

Dune::Indent::Indent | ( | unsigned | level_ | ) |

inline

setup without parent and basic_indentation of two spaces

## insert()

template<typename T, class A>

void Dune::SLListModifyIterator< T, A >::insert | ( | const T & | v | ) |

inline

Insert an element at the current position.

Starting from the element at the current position all elements will be shifted by one position to the back. The iterator will point to the same element as before after the insertion, i.e the number of increments to reach the same position from a begin iterator increases by one. This means the inserted element is the one before the one the iterator points to.

Parameters

  v | The value to insert.

## insertAfter()

template<typename T, class A>

void Dune::SLListIterator< T, A >::insertAfter | ( | const T & | v | ) | const

inline

Insert an element in the underlying list after the current position.

Parameters

  v | The value to insert.

## ios_base_all_saver()

Dune::ios_base_all_saver::ios_base_all_saver | ( | state_type & | ios_ | ) |

Constructor that stores the currently used flags.

Parameters

  ios_ | The ios_base object whose flags are to be saved and restored. Any stream object should work here.

Note
  A reference to the ios_base object is store in this object. Thus the ios_base object must remain valid until the destructor of this object has been called.

## operator!=()

template<typename T, class A>

bool Dune::SLList< T, A >::operator!= | ( | const SLList< T, A > & | sl | ) | const

## operator""_ic()

template<char... digits>

auto Dune::Indices::Literals::operator""_ic | ( |  | ) |

constexpr

Literal to create an index compile-time constant.

Example: 1_ic -> std::integral_constant<std::size_t,1>

## operator""_sc()

template<char... digits>

auto Dune::Indices::Literals::operator""_sc | ( |  | ) |

constexpr

Literal to create a signed integer compile-time constant.

Example: 1_sc -> std::integral_constant<int,1>

## operator""_uc()

template<char... digits>

auto Dune::Indices::Literals::operator""_uc | ( |  | ) |

constexpr

Literal to create an unsigned integer compile-time constant.

Example: 1_uc -> std::integral_constant<unsigned,1>

## operator+() [1/2]

Indent Dune::Indent::operator+ | ( | const std::string & | newindent | ) | const

inline

create new indentation object with this one as parent

## operator+() [2/2]

Indent Dune::Indent::operator+ | ( | unsigned | morelevel | ) | const

inline

create a copy of this indentation object with raised level

## operator++()

Indent & Dune::Indent::operator++ | ( |  | ) |

inline

raise indentation level

## operator-()

template<class T, T value>

auto Dune::Indices::Literals::operator- | ( | std::integral_constant< T, value > |  | ) |

constexpr

Negation operator for integral constants.

Example: -1_sc -> std::integral_constant<int,-1>

## operator--()

Indent & Dune::Indent::operator-- | ( |  | ) |

inline

lower indentation level

## operator<<() [1/7]

template<class TI1, class TI2, class T>

std::ostream & Dune::operator<< | ( | std::ostream & | os,
|  | const Combine< TI1, TI2, T > & | )

inline

## operator<<() [2/7]

template<typename TA, int i>

std::ostream & Dune::operator<< | ( | std::ostream & | os,
|  | const EnumItem< TA, i > & | )

inline

## operator<<() [3/7]

template<typename TA, int from, int to>

std::ostream & Dune::operator<< | ( | std::ostream & | os,
|  | const EnumRange< TA, from, to > & | )

inline

## operator<<() [4/7]

template<typename T, typename A>

std::ostream & Dune::operator<< | ( | std::ostream & | os,
|  | const SLList< T, A > & | sllist )

## operator<<() [5/7]

std::ostream & Dune::operator<< | ( | std::ostream & | s,
|  | const Indent & | indent )

inline

write indentation to a stream

## operator<<() [6/7]

template<typename T, std::size_t N>

std::ostream & Dune::operator<< | ( | std::ostream & | stream,
|  | const std::array< T, N > & | a )

inline

Print a std::array.

## operator<<() [7/7]

template<typename... Ts>

std::ostream & Dune::operator<< | ( | std::ostream & | stream,
|  | const std::tuple< Ts... > & | t )

inline

Print a std::tuple.

## operator=()

template<typename T, class A>

SLList< T, A > & Dune::SLList< T, A >::operator= | ( | const SLList< T, A > & | other | ) |

Assignment operator.

## operator==()

template<typename T, class A>

bool Dune::SLList< T, A >::operator== | ( | const SLList< T, A > & | sl | ) | const

## operator>>()

template<typename... Ts>

std::istream & Dune::operator>> | ( | std::istream & | stream,
|  | std::tuple< Ts... > & | t )

inline

Read a std::tuple.

## operator[]() [1/2]

template<class T, int N, class A>

ArrayList< T, N, A >::reference Dune::ArrayList< T, N, A >::operator[] | ( | size_type | i | ) |

inline

Get the element at specific position.

Parameters

  i | The index of the position.

Returns
  The element at that position.

## operator[]() [2/2]

template<class T, int N, class A>

ArrayList< T, N, A >::const_reference Dune::ArrayList< T, N, A >::operator[] | ( | size_type | i | ) | const

inline

Get the element at specific position.

Parameters

  i | The index of the position.

Returns
  The element at that position.

## pop_front()

template<typename T, class A>

void Dune::SLList< T, A >::pop_front | ( |  | ) |

inline

Remove the first item in the list.

## purge()

template<class T, int N, class A>

void Dune::ArrayList< T, N, A >::purge | ( |  | ) |

inline

Purge the list.

If there are empty chunks at the front all nonempty chunks will be moved towards the front and the capacity increases.

## push_back() [1/2]

template<class T, int N, class A>

void Dune::ArrayList< T, N, A >::push_back | ( | const_reference | entry | ) |

inline

Append an entry to the list.

Parameters

  entry | The new entry.

## push_back() [2/2]

template<typename T, class A>

void Dune::SLList< T, A >::push_back | ( | const MemberType & | item | ) |

inline

Add a new entry to the end of the list.

Parameters

  item | The item to add.

## push_front()

template<typename T, class A>

void Dune::SLList< T, A >::push_front | ( | const MemberType & | item | ) |

inline

Add a new entry to the beginning of the list.

Parameters

  item | The item to add.

## remove()

template<typename T, class A>

void Dune::SLListModifyIterator< T, A >::remove | ( |  | ) |

inline

Delete the entry at the current position.

The iterator will be positioned at the next position after the deletion

Warning
  This will invalidate all iterators positioned at the delete position! Use with care!

## restore()

void Dune::ios_base_all_saver::restore | ( |  | ) |

Restore flags now.

The flags will also be restored at destruction time even if this method was used.

## size() [1/2]

template<class T, int N, class A>

size_t Dune::ArrayList< T, N, A >::size | ( |  | ) | const

inline

Get the number of elements in the list.

Returns
  The number of elements.

## size() [2/2]

template<typename T, class A>

int Dune::SLList< T, A >::size | ( |  | ) | const

inline

Get the number of elements the list contains.

## SLList() [1/3]

template<typename T, class A>

Dune::SLList< T, A >::SLList | ( |  | ) |

Constructor.

## SLList() [2/3]

template<typename T, class A>

Dune::SLList< T, A >::SLList | ( | const SLList< T, A > & | other | ) |

Copy constructor.

## SLList() [3/3]

template<typename T, class A>
template<typename T1, class A1>

Dune::SLList< T, A >::SLList | ( | const SLList< T1, A1 > & | other | ) |

Copy constructor with type conversion.

## SLListConstIterator() [1/4]

template<class T, class A>

Dune::SLListConstIterator< T, A >::SLListConstIterator | ( |  | ) |

inline

## SLListConstIterator() [2/4]

template<class T, class A>

Dune::SLListConstIterator< T, A >::SLListConstIterator | ( | const SLListIterator< T, A > & | other | ) |

inline

## SLListConstIterator() [3/4]

template<class T, class A>

Dune::SLListConstIterator< T, A >::SLListConstIterator | ( | const SLListModifyIterator< T, A > & | other | ) |

inline

## SLListConstIterator() [4/4]

template<class T, class A>

Dune::SLListConstIterator< T, A >::SLListConstIterator | ( | typename SLList< T, A >::Element * | item | ) |

inline

## SLListIterator() [1/3]

template<typename T, class A>

Dune::SLListIterator< T, A >::SLListIterator | ( |  | ) |

inline

## SLListIterator() [2/3]

template<typename T, class A>

Dune::SLListIterator< T, A >::SLListIterator | ( | const SLListModifyIterator< T, A > & | other | ) |

inline

## SLListIterator() [3/3]

template<typename T, class A>

Dune::SLListIterator< T, A >::SLListIterator | ( | typename SLList< T, A >::Element * | item,
|  | SLList< T, A > * | sllist )

inline

## SLListModifyIterator() [1/2]

template<typename T, class A>

Dune::SLListModifyIterator< T, A >::SLListModifyIterator | ( |  | ) |

inline

## SLListModifyIterator() [2/2]

template<typename T, class A>

Dune::SLListModifyIterator< T, A >::SLListModifyIterator | ( | SLListIterator< T, A > | beforeIterator,
|  | SLListIterator< T, A > | _iterator )

inline

## unpackIntegerSequence()

template<class F, class I, I... i>

decltype(auto) constexpr Dune::unpackIntegerSequence | ( | F && | f,
|  | std::integer_sequence< I, i... > | sequence )

constexpr

Unpack an std::integer_sequence<I,i...> to std::integral_constant<I,i>...

This forward all entries of the given std::integer_sequence as individual std::integral_constant arguments to the given callback.

Parameters

  f | Callback which has to accept unpacked values
  sequence | Packed std::integer_sequence of values

Returns
  Result of calling f with unpacked integers.

## ~Element()

template<typename T, class A>

Dune::SLList< T, A >::Element::~Element | ( |  | ) |

## ~ios_base_all_saver()

Dune::ios_base_all_saver::~ios_base_all_saver | ( |  | ) |

Destructor that restores the flags stored by the constructor.

## ~SLList()

template<typename T, class A>

Dune::SLList< T, A >::~SLList | ( |  | ) |

Destructor.

Deallocates all elements in the list.

## Variable Documentation

## _0

index_constant< 0> Dune::Indices::_0 = {}

inline constexpr

Compile time index with value 0.

## _1

index_constant< 1> Dune::Indices::_1 = {}

inline constexpr

Compile time index with value 1.

## _10

index_constant<10> Dune::Indices::_10 = {}

inline constexpr

Compile time index with value 10.

## _11

index_constant<11> Dune::Indices::_11 = {}

inline constexpr

Compile time index with value 11.

## _12

index_constant<12> Dune::Indices::_12 = {}

inline constexpr

Compile time index with value 12.

## _13

index_constant<13> Dune::Indices::_13 = {}

inline constexpr

Compile time index with value 13.

## _14

index_constant<14> Dune::Indices::_14 = {}

inline constexpr

Compile time index with value 14.

## _15

index_constant<15> Dune::Indices::_15 = {}

inline constexpr

Compile time index with value 15.

## _16

index_constant<16> Dune::Indices::_16 = {}

inline constexpr

Compile time index with value 16.

## _17

index_constant<17> Dune::Indices::_17 = {}

inline constexpr

Compile time index with value 17.

## _18

index_constant<18> Dune::Indices::_18 = {}

inline constexpr

Compile time index with value 18.

## _19

index_constant<19> Dune::Indices::_19 = {}

inline constexpr

Compile time index with value 19.

## _2

index_constant< 2> Dune::Indices::_2 = {}

inline constexpr

Compile time index with value 2.

## _3

index_constant< 3> Dune::Indices::_3 = {}

inline constexpr

Compile time index with value 3.

## _4

index_constant< 4> Dune::Indices::_4 = {}

inline constexpr

Compile time index with value 4.

## _5

index_constant< 5> Dune::Indices::_5 = {}

inline constexpr

Compile time index with value 5.

## _6

index_constant< 6> Dune::Indices::_6 = {}

inline constexpr

Compile time index with value 6.

## _7

index_constant< 7> Dune::Indices::_7 = {}

inline constexpr

Compile time index with value 7.

## _8

index_constant< 8> Dune::Indices::_8 = {}

inline constexpr

Compile time index with value 8.

## _9

index_constant< 9> Dune::Indices::_9 = {}

inline constexpr

Compile time index with value 9.

## item_

template<typename T, class A = std::allocator<T>>

MemberType Dune::SLList< T, A >::Element::item_

The element we hold.

## next_

template<typename T, class A = std::allocator<T>>

Element* Dune::SLList< T, A >::Element::next_

The next element in the list.

## Friends

## operator<<

std::ostream & operator<< | ( | std::ostream & | s,
|  | const Indent & | indent )

friend

write indentation to a stream

## SLList< T, A > [1/2]

template<class T, class A>

friend class SLList< T, A >

friend

## SLList< T, A > [2/2]

template<typename T, class A>

friend class SLList< T, A >

friend

## SLListConstIterator< T, A > [1/3]

template<typename T, class A = std::allocator<T>>

friend class SLListConstIterator< T, A >

friend

## SLListConstIterator< T, A > [2/3]

template<typename T, class A>

friend class SLListConstIterator< T, A >

friend

## SLListConstIterator< T, A > [3/3]

template<typename T, class A>

friend class SLListConstIterator< T, A >

friend

## SLListIterator< T, A > [1/3]

template<typename T, class A = std::allocator<T>>

friend class SLListIterator< T, A >

friend

## SLListIterator< T, A > [2/3]

template<class T, class A>

friend class SLListIterator< T, A >

friend

## SLListIterator< T, A > [3/3]

template<typename T, class A>

friend class SLListIterator< T, A >

friend

## SLListModifyIterator< T, A >

template<typename T, class A>

friend class SLListModifyIterator< T, A >

friend