foundation classes More...

Modules
	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	function.hh
	Simple base class templates for functions.

file	indent.hh
	Utility class for handling nested indentation in output.

file	ios_state.hh
	Utility class for storing and resetting stream attributes.

file	lcm.hh
	Statically compute the least common multiple of two integers.

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].

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...

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::Function< Domain, Range >
	Base class template for function classes. More...

class	Dune::VirtualFunction< DomainType, RangeType >
	Virtual base class template for function classes. 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...

struct	Dune::Lcm< m, n >
	Calculate the least common multiple of two numbers. 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::StaticPower< m, p >
	Calculates m^p at compile time. More...

struct	Dune::Power< p >
	Compute power for a run-time mantissa and a compile-time integer exponent. More...

struct	Dune::PromotionTraits< T1, T2 >
	Compute type of the result of an arithmetic operation involving two different number types. More...

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. More...

Typedefs
template<std::size_t i>
using	Dune::index_constant = std::integral_constant< std::size_t, i >
	An index constant with value i. More...

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<!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 More...

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. More...

template<typename Domain , typename Range , typename F >
Impl::LambdaVirtualFunction< Domain, Range, std::decay_t< F > >	Dune::makeVirtualFunction (F &&f)
	make `VirtualFunction` out of a function object More...

	Dune::Indent::Indent (const std::string &basic_indent_=" ", unsigned level_=0)
	setup without parent More...

	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 More...

	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)	Dune::unpackIntegerSequence (F &&f, std::integer_sequence< I, i... > sequence)
	Unpack an std::integer_sequence<I,i...> to std::integral_constant<I,i>... More...

	Dune::ios_base_all_saver::ios_base_all_saver (state_type &ios_)
	Constructor that stores the currently used flags. More...

	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. More...

	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. More...

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. More...

void	Dune::SLList< T, A >::push_front (const MemberType &item)
	Add a new entry to the beginning of the list. More...

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. More...

const_iterator	Dune::SLList< T, A >::begin () const
	Get an iterator pointing to the first element in the list. More...

ModifyIterator	Dune::SLList< T, A >::beginModify ()
	Get an iterator capable of deleting and inserting elements. More...

ModifyIterator	Dune::SLList< T, A >::endModify ()
	Get an iterator capable of deleting and inserting elements. More...

iterator	Dune::SLList< T, A >::end ()
	Get an iterator pointing to the end of the list. More...

const_iterator	Dune::SLList< T, A >::end () const
	Get an iterator pointing to the end of the list. More...

bool	Dune::SLList< T, A >::empty () const
	Check whether the list is empty. More...

int	Dune::SLList< T, A >::size () const
	Get the number of elements the list contains.

T &	Dune::SLListIterator< T, A >::dereference () const
	Dereferencing function for the iterator facade. More...

bool	Dune::SLListIterator< T, A >::equals (const SLListConstIterator< T, A > &other) const
	Equality test for the iterator facade. More...

bool	Dune::SLListIterator< T, A >::equals (const SLListIterator< T, A > &other) const
	Equality test for the iterator facade. More...

bool	Dune::SLListIterator< T, A >::equals (const SLListModifyIterator< T, A > &other) const
	Equality test for the iterator facade. More...

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. More...

void	Dune::SLListIterator< T, A >::deleteNext () const
	Delete the entry after the current position. More...

const T &	Dune::SLListConstIterator< T, A >::dereference () const
	Dereferencing function for the facade. More...

bool	Dune::SLListConstIterator< T, A >::equals (const SLListConstIterator< T, A > &other) const
	Equality test for the iterator facade. More...

void	Dune::SLListConstIterator< T, A >::increment ()
	Increment function for the iterator facade.

T &	Dune::SLListModifyIterator< T, A >::dereference () const
	Dereferencing function for the iterator facade. More...

bool	Dune::SLListModifyIterator< T, A >::equals (const SLListConstIterator< T, A > &other) const
	Test whether another iterator is equal. More...

bool	Dune::SLListModifyIterator< T, A >::equals (const SLListIterator< T, A > &other) const
	Test whether another iterator is equal. More...

bool	Dune::SLListModifyIterator< T, A >::equals (const SLListModifyIterator< T, A > &other) const
	Test whether another iterator is equal. More...

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. More...

void	Dune::SLListModifyIterator< T, A >::remove ()
	Delete the entry at the current position. More...

template<typename Stream , typename... Ts>
Stream &	Dune::operator<< (Stream &stream, const std::tuple< Ts... > &t)
	Print a std::tuple.

template<typename Stream , typename... Ts>
Stream &	Dune::operator>> (Stream &stream, std::tuple< Ts... > &t)
	Read a std::tuple.

template<typename Stream , typename T , std::size_t N>
Stream &	Dune::operator<< (Stream &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. More...

void	Dune::ArrayList< T, N, A >::push_back (const_reference entry)
	Append an entry to the list. More...

reference	Dune::ArrayList< T, N, A >::operator[] (size_type i)
	Get the element at specific position. More...

const_reference	Dune::ArrayList< T, N, A >::operator[] (size_type i) const
	Get the element at specific position. More...

iterator	Dune::ArrayList< T, N, A >::begin ()
	Get an iterator that is positioned at the first element. More...

const_iterator	Dune::ArrayList< T, N, A >::begin () const
	Get a random access iterator that is positioned at the first element. More...

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. More...

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
	Comares two iterators. More...

bool	Dune::ArrayListIterator< T, N, A >::equals (const ConstArrayListIterator< MemberType, N, A > &other) const
	Comares two iterators. More...

bool	Dune::ConstArrayListIterator< T, N, A >::equals (const ConstArrayListIterator< MemberType, N, A > &other) const
	Comares to iterators. More...

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. More...

const_reference	Dune::ConstArrayListIterator< T, N, A >::elementAt (size_type i) const
	Get the value of the list at an arbitrary position. More...

reference	Dune::ArrayListIterator< T, N, A >::dereference () const
	Access the element at the current position. More...

const_reference	Dune::ConstArrayListIterator< T, N, A >::dereference () const
	Access the element at the current position. More...

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

ArrayListIterator< T, N, A > &	Dune::ArrayListIterator< T, N, A >::operator= (const ArrayListIterator< T, N, A > &other)

void	Dune::ArrayListIterator< T, N, A >::eraseToHere ()
	Erase all entries before the current position and the one at the current position. More...

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. More...

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.

static constexpr long	Dune::Lcm< m, n >::value = std::lcm(m,n)
	The least common multiple of the template parameters m and n.

static constexpr int	Dune::StaticPower< m, p >::power = Dune::power(m,p)
	power stores m^p

Element *	Dune::SLList< T, A >::Element::next_
	The next element in the list.

MemberType	Dune::SLList< T, A >::Element::item_
	The element we hold.

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)

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

◆ index_constant

template<std::size_t i>

using Dune::index_constant = typedef 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.

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!

◆ 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<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.

Referenced by Dune::CollectiveIterator< T, A >::CollectiveIterator(), and Dune::IndicesSyncer< T >::sync().

◆ begin() [3/4]

template<class T , int N, class A >

ConstArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::begin

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

Returns: The iterator.

◆ begin() [4/4]

template<typename T , class A >

SLListConstIterator< 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.

◆ 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.

Referenced by Dune::IndicesSyncer< T >::Iterators::reset().

◆ contains()

template<typename TA , int i>

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

inlinestatic

Tests whether an item is in the set.

Returns: True if item==Type.

◆ 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

inline

Access the element at the current position.

Returns: The element at the current position.

References Dune::ArrayListIterator< T, N, A >::elementAt().

◆ dereference() [2/5]

template<class T , int N, class A >

ConstArrayListIterator< T, N, A >::const_reference Dune::ConstArrayListIterator< T, N, A >::dereference

inline

Access the element at the current position.

Returns: The element at the current position.

References Dune::ConstArrayListIterator< T, N, A >::elementAt().

◆ dereference() [3/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() [4/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() [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()

template<class A , class B >

auto Dune::dot	(	const A &	a,
		const B &	b
	)		-> typename std::enable_if<!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

computes the dot product for various dune vector 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

Parameters

a
b

Returns: 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

Parameters

a
b

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

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

Parameters

a
b

Returns: dot(a,b)

Referenced by Dune::DenseVector< V >::dot(), Dune::ParameterTree::hasKey(), Dune::ParameterTree::hasSub(), Dune::ParameterTree::operator[](), and Dune::ParameterTree::sub().

◆ 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.

Referenced by Dune::ArrayListIterator< T, N, A >::dereference().

◆ elementAt() [2/2]

template<class T , int N, class A >

ConstArrayListIterator< T, N, A >::const_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.

Referenced by Dune::ConstArrayListIterator< T, N, A >::dereference().

◆ empty()

template<typename T , class A >

bool Dune::SLList< T, A >::empty

inline

Check whether the list is empty.

Returns: True if the list is empty;

◆ end() [1/2]

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.

Referenced by Dune::CollectiveIterator< T, A >::CollectiveIterator(), and Dune::IndicesSyncer< T >::sync().

◆ end() [2/2]

template<typename T , class A >

SLListConstIterator< 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.

◆ 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

Comares 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

Comares 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

Comares to iterators.

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

◆ equals() [4/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() [5/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() [6/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() [7/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() [8/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() [9/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() [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.

Returns: An iterator to the first position after the deleted ones or to the end if the list is empty.

◆ filledArray()

template<std::size_t n, class T >

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

constexpr

Return an array filled with the provided value.

Note: This function is constexpr only in C++17, or, more precisely, when std::array::begin() and std::array::end() are constexpr.

Template Parameters

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

◆ Indent() [1/2]

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/2]

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.

Referenced by Dune::Indent::operator+().

◆ 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.

◆ makeVirtualFunction()

template<typename Domain , typename Range , typename F >

Impl::LambdaVirtualFunction< Domain, Range, std::decay_t< F > > Dune::makeVirtualFunction ( F && f )

make VirtualFunction out of a function object

This helper function wraps a function object into a class implementing the VirtualFunction interface. It allows for easy use of lambda expressions in places that expect a VirtualFunction:

void doSomething(const VirtualFunction<double, double>& f);
 
auto f = makeVirtualFunction<double, double>(
    [](double x) { return x*x; });
doSomething(f);

Returns: object of a class derived from VirtualFunction<Domain, Range>

Template Parameters

Domain	domain of the function
Range	range of the function

◆ operator=()

template<class T , int N, class A >

ArrayListIterator< T, N, A > & Dune::ArrayListIterator< T, N, A >::operator= ( const ArrayListIterator< T, N, A > & other )

inline

Todo:: Please doc me!

◆ 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.

References Dune::Hybrid::elementAt().

◆ 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.

References Dune::Hybrid::elementAt().

◆ 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<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.

Referenced by Dune::IndicesSyncer< T >::sync().

◆ push_back() [2/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_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.

Referenced by Dune::ios_base_all_saver::~ios_base_all_saver().

◆ size()

template<class T , int N, class A >

size_t Dune::ArrayList< T, N, A >::size

inline

Get the number of elements in the list.

Returns: The number of elements.

◆ unpackIntegerSequence()

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

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

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.

◆ ~SLList()

template<typename T , class A >

Dune::SLList< T, A >::~SLList

Destructor.

Deallocates all elements in the list.

Modules

Files

Namespaces

Classes

Macros

Typedefs

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ DUNE_ASSERT_BOUNDS

Typedef Documentation

◆ index_constant

Function Documentation

◆ advance() [1/2]

◆ advance() [2/2]

◆ begin() [1/4]

◆ begin() [2/4]

◆ begin() [3/4]

◆ begin() [4/4]

◆ beginModify()

◆ contains()

◆ deleteNext()

◆ dereference() [1/5]

◆ dereference() [2/5]

◆ dereference() [3/5]

◆ dereference() [4/5]

◆ dereference() [5/5]

◆ distanceTo() [1/2]

◆ distanceTo() [2/2]

◆ dot()

◆ elementAt() [1/2]

◆ elementAt() [2/2]

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ endModify()

◆ equals() [1/10]

◆ equals() [2/10]

◆ equals() [3/10]

◆ equals() [4/10]

◆ equals() [5/10]

◆ equals() [6/10]

◆ equals() [7/10]

◆ equals() [8/10]

◆ equals() [9/10]

◆ equals() [10/10]

◆ eraseToHere()

◆ filledArray()

◆ Indent() [1/2]

◆ Indent() [2/2]

◆ insert()

◆ insertAfter()

◆ ios_base_all_saver()

◆ makeVirtualFunction()

◆ operator=()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ purge()

◆ push_back() [1/2]

◆ push_back() [2/2]

◆ push_front()

◆ remove()

◆ restore()

◆ size()

◆ unpackIntegerSequence()

◆ ~SLList()