Modules
	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 paralle computing.

	FloatCmp

	Filesystem Paths

Files
file	alignment.hh
	This file implements a template class to determine alignment requirements of types at compile time.

file	function.hh
	Simple base class templates for functions.

file	gcd.hh
	Statically compute the greatest common divisor of two integers.

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.

file	tuples.hh
	Fallback implementation of the std::tuple class.

Classes
struct	Dune::AlignmentOf< T >
	Calculates the alignment requirement of a type. More...

class	Dune::array< T, N >
	Simple fixed size array class. This replaces std::array, if that is not available. More...

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::MPITraits< T >
	A traits class describing the mapping of types onto MPI_Datatypes. More...

class	Dune::bigunsignedint< k >
	Portable very large unsigned integers. 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::fvector_assigner< T, s >
	fvector assignment operator More...

class	Dune::fmatrix_assigner< T, n, m >
	fmatrix assignment operator 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...

struct	Dune::Gcd< a, b >
	Calculator of the greatest common divisor. 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::StaticPower< m, 0 >
	end of recursion via specialization More...

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

class	Dune::SharedCount
	The object we reference. More...

class	Dune::shared_ptr< T >
	A reference counting smart pointer. 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...

struct	Dune::AlwaysFalse< T >
	template which always yields a false value More...

struct	Dune::AlwaysTrue< T >
	template which always yields a true value More...

class	Dune::TimerError
	Exception thrown by the Timer class More...

class	Dune::Timer
	A simple stop watch. More...

struct	Dune::Nil
	An empty class. More...

struct	Dune::Pair< T1, TT >
	A tuple consisting of two objects. More...

struct	Dune::Pair< T1, Nil >
	A tuple consisting of one object. Specialization of Pair that really is a single value. More...

struct	Dune::TupleToPairs< T1, T2, T3, T4, T5, T6, T7, T8, T9 >
	Converts the Tuple to a list of pairs. More...

struct	Dune::TupleToPairs< T1, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil >
	Specialization for a tuple consisting only of one type. More...

class	Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >
	A Tuple of objects. More...

struct	Dune::tuple_element< N, Tuple >
	Get the type of the N-th element of the tuple. More...

struct	Dune::tuple_element< 0, Pair< T1, T2 > >
	Get the type of the first element of the tuple. More...

struct	Dune::Element< N >
	Get the N-th element of a tuple. More...

struct	Dune::Element< 0 >
	Get the first element of a tuple. More...

struct	Dune::tuple_size< T >
	Template meta_programm to query the size of a tuple. More...

struct	Dune::Empty
	Just an empty class. More...

class	Dune::TypeTraits< T >
	General type traits class to check whether type is reference or pointer type. More...

struct	Dune::ConstantVolatileTraits< T >
	Determines wether a type is const or volatile and provides the unqualified types. More...

struct	Dune::IsVolatile< T >
	Tests wether a type is volatile. More...

struct	Dune::IsConst< T >
	Tests wether a type is constant. More...

struct	Dune::remove_const< T >
	Removes a const qualifier while preserving others. More...

struct	Dune::remove_reference< T >
	Remove a reference from a type. More...

class	Dune::Conversion< From, To >
	Checks wether a type is convertible to another. More...

class	Dune::IsBaseOf< Base, Derived >
	Checks wether a type is derived from another. More...

struct	Dune::IsInteroperable< T1, T2 >
	Checks wether two types are interoperable. More...

struct	Dune::enable_if< b, T >
	Enable typedef if condition is met. More...

struct	Dune::EnableIfInterOperable< T1, T2, Type >
	Enable typedef if two types are interoperable. More...

struct	Dune::is_same< T1, T2 >
	Compile time test for testing whether two types are the same. More...

struct	Dune::SelectType< first, T1, T2 >
	Select a type based on a condition. More...

struct	Dune::conditional< first, T1, T2 >
	Select a type based on a condition. More...

struct	Dune::integral_constant< T, v >
	Generate a type for a given integral constant. More...

struct	Dune::is_pointer< T >
	is_pointer More...

struct	Dune::is_lvalue_reference< T >
	Determine whether a type is a lvalue reference type. More...

struct	Dune::remove_pointer< _Tp >
	Return the type a pointer type points to. More...

Macros
#define	DUNE_DEPRECATED
	Mark some entity as deprecated. More...

#define	DUNE_DEPRECATED_MSG(text) DUNE_DEPRECATED
	Mark some entity as deprecated. More...

#define	dune_static_assert(COND, MSG)
	Helper template so that compilation fails if condition is not true. More...

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

typedef A::template rebind< Element >::other	Dune::SLList< T, A >::Allocator
	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.

typedef T1	Dune::Pair< T1, TT >::Type1
	The type of the first field.

typedef TT	Dune::Pair< T1, TT >::Type2
	The type of the second field.

typedef T1	Dune::Pair< T1, Nil >::Type1
	The type of the first field.

typedef Nil	Dune::Pair< T1, Nil >::Type2
	The type of the (non-existent) second field is Nil. This typedef is useful in template metaprogramming, since it allows you to specialise for Nil instead of Pair<T, Nil>

typedef TupleToPairs< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::Type	Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::FirstPair
	Type of the first Pair defining the Tuple.

typedef tuple_element< N, typename Tuple::FirstPair >::type	Dune::tuple_element< N, Tuple >::type
	The type of the N-th element of the tuple.

typedef tuple_element< N-1, T2 >::Type	Dune::tuple_element< N, Pair< T1, T2 > >::type
	The type of the N-th element of the tuple.

typedef T1	Dune::tuple_element< 0, Pair< T1, T2 > >::type
	The type of the first element of the tuple.

typedef integral_constant< bool, true >	Dune::true_type
	type for true

typedef integral_constant< bool, false >	Dune::false_type
	type for false

Enumerations
enum
	power stores m^p

enum
	m^0 = 1

Functions
template<class T , size_t N>
std::ostream &	Dune::operator<< (std::ostream &s, const array< T, N > &e)
	Output operator for array.

template<class T >
array< T, 10 >	Dune::make_array (const T &t0, const T &t1, const T &t2, const T &t3, const T &t4, const T &t5, const T &t6, const T &t7, const T &t8, const T &t9)
	create an initialize an array More...

template<typename T , std::size_t n>
array< T, n >	Dune::fill_array (const T &t)
	Create an array and fill it with copies of the provided value. More...

template<class A , class B >
enable_if<!IsVector< A >::value &&!is_same< typename FieldTraits< A >::field_type, typename FieldTraits< A >::real_type >::value, typename PromotionTraits< A, B >::PromotedType >::type	Dune::dot (const A &a, const B &b)
	computes the dot product for fundamental data types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b More...

	operator double ()
	Conversion operator to double.

	operator int ()
	Conversion operator to int.

	Dune::fvector_assigner< T, s >::fvector_assigner (fvector_assigner &a)
	Copy Constructor.

	Dune::fvector_assigner< T, s >::fvector_assigner (FieldVector< T, s > &_v, bool t)
	Constructor from vector and temporary flag. More...

	Dune::fvector_assigner< T, s >::~fvector_assigner ()
	Destructor checks for complete initialization of the vector. The check is skipped, if this object is marked temporary.

fvector_assigner &	Dune::fvector_assigner< T, s >::append (const T &t)
	append data to this vector

fvector_assigner &	Dune::fvector_assigner< T, s >::append (Zero z)
	append zeros to this vector

fvector_assigner &	Dune::fvector_assigner< T, s >::operator, (const T &t)
	append data to this vector the overloaded comma operator is used to assign a comma separated list of values to the vector

fvector_assigner &	Dune::fvector_assigner< T, s >::operator, (Zero z)
	append zeros to this vector the overloaded comma operator is used to stop the assign of values to the vector, all remaining entries are assigned 0.

template<class T , class K , int s>
fvector_assigner< T, s >	Dune::operator<<= (FieldVector< T, s > &v, const K &t)
	fvector assignment operator More...

template<class T , int s>
fvector_assigner< T, s >	Dune::operator<<= (FieldVector< T, s > &v, Zero z)
	fvector assignment operator More...

	Dune::fmatrix_assigner< T, n, m >::fmatrix_assigner (fmatrix_assigner &a)
	Copy Constructor.

	Dune::fmatrix_assigner< T, n, m >::fmatrix_assigner (FieldMatrix< T, n, m > &_A, bool t)
	Constructor from matrix and temporary flag. More...

	Dune::fmatrix_assigner< T, n, m >::~fmatrix_assigner ()
	Destructor checks for complete initialization of the matrix. The check is skipped, if this object is marked temporary.

fmatrix_assigner &	Dune::fmatrix_assigner< T, n, m >::append (const T &t)
	append data to this matrix

fmatrix_assigner &	Dune::fmatrix_assigner< T, n, m >::append (Zero z)
	append zeros to this matrix

fmatrix_assigner &	Dune::fmatrix_assigner< T, n, m >::append (NextRow nr)
	move to next row of the matrix

fmatrix_assigner &	Dune::fmatrix_assigner< T, n, m >::operator, (const T &t)
	append data to this matrix the overloaded comma operator is used to assign a comma separated list of values to the matrix

fmatrix_assigner &	Dune::fmatrix_assigner< T, n, m >::operator, (Zero z)
	append zeros to this matrix the overloaded comma operator is used to stop the assign of values to the matrix, all remaining entries are assigned 0.

fmatrix_assigner &	Dune::fmatrix_assigner< T, n, m >::operator, (NextRow nr)
	append zeros to this matrix the overloaded comma operator is used to stop the assign of values to the current row, it will be checked whether all entries have been assigned values.

template<class T , class K , int n, int m>
fmatrix_assigner< T, n, m >	Dune::operator<<= (FieldMatrix< T, n, m > &v, const K &t)
	FieldMatrix assignment operator. More...

template<class T , int n, int m>
fmatrix_assigner< T, n, m >	Dune::operator<<= (FieldMatrix< T, n, m > &v, Zero z)
	FieldMatrix assignment operator. 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 indetation 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

	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 C >
bool	Dune::hasPrefix (const C &c, const char *prefix)
	Check whether a character container has a given prefix. More...

template<typename C >
bool	Dune::hasSuffix (const C &c, const char *suffix)
	Check whether a character container has a given suffix. More...

template<typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
	Dune::Pair< T1, TT >::Pair (typename TupleAccessTraits< T1 >::ParameterType t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9)
	Constructor. More...

	Dune::Pair< T1, TT >::Pair (typename TupleAccessTraits< Type1 >::ParameterType t1, TT &t2)
	Constructor. More...

template<typename U1 , typename U2 >
	Dune::Pair< T1, TT >::Pair (const Pair< U1, U2 > &other)
	Copy Constructor for implicit type conversion. More...

template<typename U1 , typename U2 >
Pair &	Dune::Pair< T1, TT >::operator= (const Pair< U1, U2 > &other)
	Assignment operator for implicit type conversion. More...

TupleAccessTraits< Type1 >::NonConstType	Dune::Pair< T1, TT >::first ()
	Get the first value. More...

TupleAccessTraits< Type1 >::ConstType	Dune::Pair< T1, TT >::first () const
	Get the first value. More...

TupleAccessTraits< Type2 >::NonConstType	Dune::Pair< T1, TT >::second ()
	Get the second value. More...

TupleAccessTraits< Type2 >::ConstType	Dune::Pair< T1, TT >::second () const
	Get the second value. More...

	Dune::Pair< T1, Nil >::Pair (typename TupleAccessTraits< T1 >::ParameterType first, const Nil &, const Nil &, const Nil &, const Nil &, const Nil &, const Nil &, const Nil &, const Nil &)
	Constructor. More...

	Dune::Pair< T1, Nil >::Pair (typename TupleAccessTraits< T1 >::ParameterType first, const Nil &)
	Constructor. More...

template<typename T2 >
	Dune::Pair< T1, Nil >::Pair (const Pair< T2, Nil > &other)
	Copy constructor for type conversion.

template<typename T2 >
Pair &	Dune::Pair< T1, Nil >::operator= (const Pair< T2, Nil > &other)
	Assignment operator for type conversion.

Pair &	Dune::Pair< T1, Nil >::operator= (const Pair &other)
	Assignment operator.

TupleAccessTraits< Type1 >::NonConstType	Dune::Pair< T1, Nil >::first ()
	Get the first value. More...

TupleAccessTraits< Type1 >::ConstType	Dune::Pair< T1, Nil >::first () const
	Get the first value. More...

template<typename T1 , typename T2 >
static TupleAccessTraits< typename tuple_element< N, Pair< T1, T2 > >::type >::NonConstType	Dune::Element< N >::get (Pair< T1, T2 > &tuple)
	Get the N-th element of the tuple. More...

template<typename T1 , typename T2 >
static TupleAccessTraits< typename tuple_element< N, Pair< T1, T2 > >::type >::ConstType	Dune::Element< N >::get (const Pair< T1, T2 > &tuple)
	Get the N-th element of the tuple. More...

template<typename T1 , typename T2 >
static TupleAccessTraits< T1 >::NonConstType	Dune::Element< 0 >::get (Pair< T1, T2 > &tuple)
	Get the first element of the tuple. More...

template<typename T1 , typename T2 >
static TupleAccessTraits< T1 >::ConstType	Dune::Element< 0 >::get (const Pair< T1, T2 > &tuple)
	Get the first element of the tuple. More...

template<typename T1 , typename T2 , typename U1 , typename U2 >
bool	Dune::operator== (const Pair< T1, T2 > &tuple1, const Pair< U1, U2 > &tuple2)
	Equality comparison operator for tuples. More...

template<typename T1 , typename T2 , typename U1 , typename U2 >
bool	Dune::operator!= (const Pair< T1, T2 > &tuple1, const Pair< U1, U2 > &tuple2)
	Inequality comparison operator for tuples. More...

template<typename T1 , typename T2 , typename U1 , typename U2 >
bool	Dune::operator< (const Pair< T1, T2 > &tuple1, const Pair< U1, U2 > &tuple2)
	Less operator for tuples. More...

template<typename T1 , typename U1 >
bool	Dune::operator== (const Pair< T1, Nil > &tuple1, const Pair< U1, Nil > &tuple2)
	Equality comparison operator for tuples. More...

template<typename T1 , typename U1 >
bool	Dune::operator!= (const Pair< T1, Nil > &tuple1, const Pair< U1, Nil > &tuple2)
	Inequality comparison operator for tuples. More...

template<typename T1 , typename U1 >
bool	Dune::operator< (const Pair< T1, Nil > &tuple1, const Pair< U1, Nil > &tuple2)
	Less operator for tuples. More...

template<typename T1 , typename U1 , typename U2 >
bool	Dune::operator== (const Pair< T1, Nil > &tuple1, const Pair< U1, U2 > &tuple2)
	Equality comparison operator for tuples. More...

template<typename T1 , typename U1 , typename U2 >
bool	Dune::operator!= (const Pair< T1, Nil > &tuple1, const Pair< U1, U2 > &tuple2)
	Inequality comparison operator for tuples. More...

template<typename T1 , typename T2 , typename U1 >
bool	Dune::operator== (const Pair< T1, T2 > &tuple1, const Pair< U1, Nil > &tuple2)
	Equality comparison operator for tuples. More...

template<typename T1 , typename T2 , typename U1 >
bool	Dune::operator!= (const Pair< T1, T2 > &tuple1, const Pair< U1, Nil > &tuple2)
	Inequality comparison operator for tuples. More...

template<typename T1 , typename T2 >
Pair< T1, T2 >	Dune::makePair (const T1 &first, const T2 &second)
	Create a tuple and initialize it. More...

template<typename T1 , typename T2 >
std::ostream &	Dune::operator<< (std::ostream &os, const Pair< T1, T2 > &pair)
	Print a pair or tuple.

template<typename T1 , typename T2 >
std::istream &	Dune::operator>> (std::istream &is, Pair< T1, T2 > &pair)
	Read a pair or tuple.

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

	Dune::bigunsignedint< k >::bigunsignedint ()
	Construct uninitialized.

	Dune::bigunsignedint< k >::bigunsignedint (int x)
	Construct from signed int.

	Dune::bigunsignedint< k >::bigunsignedint (std::size_t x)
	Construct from unsigned int.

unsigned int	Dune::bigunsignedint< k >::touint () const
	export to other types

double	Dune::bigunsignedint< k >::todouble () const
	Convert to a double. More...

void	Dune::bigunsignedint< k >::print (std::ostream &s) const
	Print number in hex notation.

bigunsignedint< k >	Dune::bigunsignedint< k >::operator+ (const bigunsignedint< k > &x) const
	add

bigunsignedint< k >	Dune::bigunsignedint< k >::operator- (const bigunsignedint< k > &x) const
	subtract

bigunsignedint< k >	Dune::bigunsignedint< k >::operator* (const bigunsignedint< k > &x) const
	multiply

bigunsignedint< k > &	Dune::bigunsignedint< k >::operator++ ()
	prefix increment

bigunsignedint< k >	Dune::bigunsignedint< k >::operator/ (const bigunsignedint< k > &x) const

bigunsignedint< k >	Dune::bigunsignedint< k >::operator% (const bigunsignedint< k > &x) const

bigunsignedint< k >	Dune::bigunsignedint< k >::operator& (const bigunsignedint< k > &x) const
	bitwise and

bigunsignedint< k >	Dune::bigunsignedint< k >::operator^ (const bigunsignedint< k > &x) const
	bitwise exor

bigunsignedint< k >	Dune::bigunsignedint< k >::operator\| (const bigunsignedint< k > &x) const
	bitwise or

bigunsignedint< k >	Dune::bigunsignedint< k >::operator~ () const
	bitwise komplement

bigunsignedint< k >	Dune::bigunsignedint< k >::operator<< (int i) const
	left shift1/

bigunsignedint< k >	Dune::bigunsignedint< k >::operator>> (int i) const
	right shift

bool	Dune::bigunsignedint< k >::operator!= (const bigunsignedint< k > &x) const
	not equal

bool	Dune::bigunsignedint< k >::operator== (const bigunsignedint< k > &x) const
	equal

bool	Dune::bigunsignedint< k >::operator< (const bigunsignedint< k > &x) const
	less than

bool	Dune::bigunsignedint< k >::operator<= (const bigunsignedint< k > &x) const
	less than or equal

bool	Dune::bigunsignedint< k >::operator> (const bigunsignedint< k > &x) const
	greater than

bool	Dune::bigunsignedint< k >::operator>= (const bigunsignedint< k > &x) const
	greater or equal

static bool	Dune::EmptySet< TA >::contains (const Type &attribute)
	Always returns false.

static bool	Dune::AllSet< TA >::contains (const Type &attribute)
	Always returns false.

static bool	Dune::EnumItem< TA, item >::contains (const Type &attribute)
	Tests whether an item is in the set. More...

template<class T1 >
	Dune::shared_ptr< T >::shared_ptr (T1 *pointer)
	Constructs a new smart pointer from a preallocated Object. More...

template<class T1 , class Deleter >
	Dune::shared_ptr< T >::shared_ptr (T1 *pointer, Deleter deleter)
	Constructs a new smart pointer from a preallocated Object. More...

	Dune::shared_ptr< T >::shared_ptr ()
	Constructs a new smart pointer and allocates the referenced Object.

template<class T1 >
	Dune::shared_ptr< T >::shared_ptr (const shared_ptr< T1 > &pointer)
	Copy constructor. More...

	Dune::shared_ptr< T >::shared_ptr (const shared_ptr &pointer)
	Copy constructor. More...

shared_ptr &	Dune::shared_ptr< T >::operator= (const shared_ptr &pointer)
	Assignment operator.

	Dune::shared_ptr< T >::~shared_ptr ()
	Destructor.

element_type &	Dune::shared_ptr< T >::operator* ()
	Dereference as object.

element_type *	Dune::shared_ptr< T >::operator-> ()
	Dereference as pointer.

const element_type &	Dune::shared_ptr< T >::operator* () const
	Dereference as const object.

const element_type *	Dune::shared_ptr< T >::operator-> () const
	Dereference as const pointer.

int	Dune::shared_ptr< T >::use_count () const
	The number of shared_ptrs pointing to the object we point to.

void	Dune::shared_ptr< T >::swap (shared_ptr &other)
	Swap content of this shared_ptr and another.

void	Dune::shared_ptr< T >::reset ()
	Decrease the reference count by one and free the memory if the reference count has reached 0.

template<class T1 >
void	Dune::shared_ptr< T >::reset (T1 *pointer)
	Detach shared pointer and set it anew for the given pointer.

Variables
static const long	Dune::Lcm< m, n >::value = (m/Gcd<m,n>::value)*n
	The least common multiple of the template parameters m and n.

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

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

static const bool	Dune::AlwaysFalse< T >::value = false
	always a false value

static const bool	Dune::AlwaysTrue< T >::value = true
	always a true value

Type1	Dune::Pair< T1, TT >::first_
	The value of the first field.

Type2	Dune::Pair< T1, TT >::second_
	The value of the second field.

Type1	Dune::Pair< T1, Nil >::first_
	The value of the first field.

Detailed Description

@{

Macro Definition Documentation

◆ DUNE_DEPRECATED

#define DUNE_DEPRECATED

Mark some entity as deprecated.

#include <dune/common/deprecated.hh>

deprecated.hh

Definition of the DUNE_DEPRECATED macro for the case that config.h is not available.

This is a preprocessor define which can be used to mark functions, typedefs, enums and other stuff deprecated. If something is marked deprecated, users are advised to migrate to the new interface, since it will probably be removed in the next release of Dune.

DUNE_DEPRECATED currently works with g++ and clang++. For other compilers it will be defined empty. This way the user will not get any deprecation warning, but at least his code still compiles (well, until the next Dune release, that is).

Here are some examples how to mark different stuff deprecated:

Classes
class DUNE_DEPRECATED Class {}; // 1)

class Class {} DUNE_DEPRECATED; // 2)

DUNE_DEPRECATED
#define DUNE_DEPRECATED
Mark some entity as deprecated.
Definition: deprecated.hh:84

Both forms do not work properly with g++-4.1: no deprecation warning will be given, although the code still compiles. 1) should be preferred over 2) since 2) does not work with clang++-1.1 (again, no warning given but code still compiles, works with clang++-3.1)
Template classes
template<class T>

class DUNE_DEPRECATED Class {}; // 1)

template<class T>

class Class {} DUNE_DEPRECATED; // 2)

This works works with g++ >=4.3 only; g++-4.1 and clang++ compile the code without warning in both cases. Furthermore, the warning is only triggered when copying an object of that template class, neither making a typedef nor simply creating such an object emit the warning. It is thus recommended that some essential class member be marked deprecated as well, if possible.
Member constants
template<typename T> struct Class {

static const int c0 DUNE_DEPRECATED = 0;

static const int DUNE_DEPRECATED c1 = 1;

};

Works with g++-4.1, g++ >=4.3 and clang++3.1. No warning but clean compile with clang++-1.1.
Member enumerators
template<typename T> struct Class {

enum enumeration { enumerator = 0 };

};

No form of deprecation is known that does not trigger an error on most compilers.
Member functions
template<typename T> struct Class {

void frob() DUNE_DEPRECATED {}

}; // 1)

template<typename T> struct Class {

void DUNE_DEPRECATED frob() {}

}; // 2)

template<typename T> struct Class {

DUNE_DEPRECATED void frob() {}

}; // 3)

With g++ only 2) emits a warning for templated member functions.

◆ DUNE_DEPRECATED_MSG

#define DUNE_DEPRECATED_MSG ( text ) DUNE_DEPRECATED

Mark some entity as deprecated.

#include <dune/common/deprecated.hh>

This is a preprocessor define which can be used to mark functions, typedefs, enums and other stuff deprecated and to also specify a hint what replaces the given functionality. If something is marked deprecated, users are advised to migrate to the new interface, since it will probably be removed in the next release of Dune.

DUNE_DEPRECATED_MSG currently works only for compilers which support the attribute attribute((deprecated("message")). For other compilers it will be defined empty. This way the user will not get any deprecation warning, but at least his code still compiles (well, until the next Dune release, that is).

Here are some examples how to mark different stuff deprecated:

Classes
class DUNE_DEPRECATED_MSG("In the future, please use 'Glass'") Class {}; // 1)

class Class {} DUNE_DEPRECATED("In the future, please use 'Glass'"); // 2)

DUNE_DEPRECATED_MSG
#define DUNE_DEPRECATED_MSG(text)
Mark some entity as deprecated.
Definition: deprecated.hh:169

For both forms, deprecation warnings and the additional hint "In the future, please use 'Glass'" will be printed on compilers which support it (e.g. G++ >= 4.5.0, clang++ >= 1.1). For compilers which support deprecating but do not take an additional hint (e.g. G++ < 4.5.0), only the deprecation warning is printed, and finally compilers which do not support deprecation of code won't print anything, but the code will still compile. 1) should be preferred over 2) since 2) does not work with clang++-1.1 (again, no warning will be given but code still compiles)
Template classes
template<class T>

class DUNE_DEPRECATED_MSG("In the future, please use 'Glass'") Class {}; // 1)

template<class T>

class Class {} DUNE_DEPRECATED_MSG("In the future, please use 'Glass'"); // 2)

This works works with g++ >= 4.5, clang++ until at least version 1.1 will compile the code without warning in both cases. Furthermore, the warning is only triggered when copying an object of that template class, neither making a typedef nor simply creating such an object emit the warning. It is thus recommended that some essential class member be marked deprecated as well, if possible.
Member constants
template<typename T> struct Class {

static const int c0 DUNE_DEPRECATED_MSG("c2 is the new hype") = 0;

static const int DUNE_DEPRECATED_MSG("c2 is the new hype") c1 = 1;

};

Works without printing the hint on g++-4.1, g++-4.3, g++-4.4 and fully on g++ >= 4.5. Works for clang++-3.1. No warning but clean compile with clang++-1.1.
Member enumerators
template<typename T> struct Class {

enum enumeration { enumerator = 0 };

};

No form of deprecation is known that does not trigger an error on most compilers.
Member functions
template<typename T> struct Class {

void frob() DUNE_DEPRECATED_MSG("use frog") {}

}; // 1)

template<typename T> struct Class {

void DUNE_DEPRECATED_MSG("use frog") frob() {}

}; // 2)

template<typename T> struct Class {

DUNE_DEPRECATED_MSG("use frog") void frob() {}

}; // 3)

With g++ only 2) emits a warning for templated member functions.

◆ dune_static_assert

#define dune_static_assert	(	COND,
		MSG
	)

Value:

  typedef static_assert_test<                         \
    sizeof(static_assert_failure< (bool)( COND )>)\
    > CPPMAGIC_JOIN (dune_static_assert_typedef_, __LINE__)

Helper template so that compilation fails if condition is not true.

#include <dune/common/static_assert.hh>

dune_static_assert(CONDITION, ERRORMSG);

dune_static_assert

#define dune_static_assert(COND, MSG)

Helper template so that compilation fails if condition is not true.

Definition: static_assert.hh:79

static_assert.hh

Fallback implementation of the C++0x static_assert feature.

If CONDITION is not true, dune_static_assert fails.

If the C++0x language feature static_assert is available, dune_static_assert forwards everything to static_assert. Otherwise dune_static_assert implements a test that triggers a compile time error if the condition is false.

Example:

dune_static_assert(1<=2, "error");
dune_static_assert((is_same<int,int>::value),  "error msg");
dune_static_assert((is_same<bool,int>::value), "error msg"); // false, will trigger a compile time error

Note: dune_static_assert(false, "error");

will usually not do what was intended, see Dune::AlwaysFalse for a way to achieve the desired result.

Be aware that...

dune_static_assert is not in the namespace Dune
you must use extra parentheses if your condition contains ','. This is because dune_static_assert is a preprocessor macro

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

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

enable_if<!IsVector<A>::value && !is_same<typename FieldTraits<A>::field_type,typename FieldTraits<A>::real_type>::value, typename PromotionTraits<A,B>::PromotedType>::type Dune::dot	(	const A &	a,
		const B &	b
	)

inline

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

Parameters

a
b

Returns: conj(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 postion.

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

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

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

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

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

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

◆ fill_array()

template<typename T , std::size_t n>

array<T,n> Dune::fill_array ( const T & t )

Create an array and fill it with copies of the provided value.

Note: This method is Dune-specific and not part of any C++ standard.

◆ first() [1/4]

template<typename T1 , typename T2 >

TupleAccessTraits< T1 >::NonConstType Dune::Pair< T1, T2 >::first

inline

Get the first value.

Returns: The first value

Referenced by Dune::Element< 0 >::get(), Dune::operator!=(), Dune::operator<(), Dune::operator<<(), Dune::operator==(), and Dune::operator>>().

◆ first() [2/4]

template<typename T1 >

TupleAccessTraits< T1 >::NonConstType Dune::Pair< T1, Nil >::first

inline

Get the first value.

Returns: The first value

References Dune::Pair< T1, TT >::first_.

Referenced by Dune::operator!=(), Dune::operator<(), and Dune::operator==().

◆ first() [3/4]

template<typename T1 , typename T2 >

TupleAccessTraits< T1 >::ConstType Dune::Pair< T1, T2 >::first

inline

Get the first value.

Returns: The first value

◆ first() [4/4]

template<typename T1 >

TupleAccessTraits< T1 >::ConstType Dune::Pair< T1, Nil >::first

inline

Get the first value.

Returns: The first value

References Dune::Pair< T1, TT >::first_.

◆ fmatrix_assigner()

template<class T , int n, int m>

Dune::fmatrix_assigner< T, n, m >::fmatrix_assigner	(	FieldMatrix< T, n, m > &	_A,
		bool	t
	)

inline

Constructor from matrix and temporary flag.

Parameters

_A	matrix which should be initialized
t	bool indicating, that this is a temporary object (see ~fmatrix_assigner)

◆ fvector_assigner()

template<class T , int s>

Dune::fvector_assigner< T, s >::fvector_assigner	(	FieldVector< T, s > &	_v,
		bool	t
	)

inline

Constructor from vector and temporary flag.

Parameters

_v	vector which should be initialized
t	bool indicating, that this is a temporary object (see ~fvector_assigner)

◆ get() [1/4]

template<int N>

template<typename T1 , typename T2 >

static TupleAccessTraits< typename tuple_element<N,Pair<T1,T2> >::type >::ConstType Dune::Element< N >::get ( const Pair< T1, T2 > & tuple )

inlinestatic

Get the N-th element of the tuple.

Parameters

tuple The tuple whose N-th element we want.

Returns: The N-th element of the tuple.

References Dune::Element< N >::get(), and Dune::Pair< T1, TT >::second().

◆ get() [2/4]

template<typename T1 , typename T2 >

static TupleAccessTraits<T1>::ConstType Dune::Element< 0 >::get ( const Pair< T1, T2 > & tuple )

inlinestatic

Get the first element of the tuple.

Parameters

tuple The tuple whose first element we want.

Returns: The first element of the tuple.

References Dune::Pair< T1, TT >::first().

◆ get() [3/4]

template<int N>

template<typename T1 , typename T2 >

static TupleAccessTraits< typename tuple_element<N,Pair<T1,T2> >::type >::NonConstType Dune::Element< N >::get ( Pair< T1, T2 > & tuple )

inlinestatic

Get the N-th element of the tuple.

Parameters

tuple The tuple whose N-th element we want.

Returns: The N-th element of the tuple.

References Dune::Pair< T1, TT >::second().

Referenced by Dune::Element< N >::get().

◆ get() [4/4]

template<typename T1 , typename T2 >

static TupleAccessTraits<T1>::NonConstType Dune::Element< 0 >::get ( Pair< T1, T2 > & tuple )

inlinestatic

Get the first element of the tuple.

Parameters

tuple The tuple whose first element we want.

Returns: The first element of the tuple.

References Dune::Pair< T1, TT >::first().

◆ hasPrefix()

template<typename C >

bool Dune::hasPrefix	(	const C &	c,
		const char *	prefix
	)

Check whether a character container has a given prefix.

The container must support the begin() and size() methods.

Referenced by Dune::processPath(), and Dune::relativePath().

◆ hasSuffix()

template<typename C >

bool Dune::hasSuffix	(	const C &	c,
		const char *	suffix
	)

Check whether a character container has a given suffix.

The container must support the the begin() and size() methods and the const_iterator member type.

Note: This is slow for containers which don't have random access iterators. In the case of containers with bidirectional iterators, this slowness is unnecessary.

Referenced by Dune::concatPaths(), Dune::pathIndicatesDirectory(), and Dune::prettyPath().

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

◆ make_array()

template<class T >

array<T, 10> Dune::make_array	(	const T &	t0,
		const T &	t1,
		const T &	t2,
		const T &	t3,
		const T &	t4,
		const T &	t5,
		const T &	t6,
		const T &	t7,
		const T &	t8,
		const T &	t9
	)

create an initialize an array

Note: There are overloads for this method which take fewer arguments (minimum 1). The current maximum of 10 arguments is arbitrary and can be raised on demand.; This method is Dune-specific and not part of any C++-standard.

◆ makePair()

template<typename T1 , typename T2 >

Pair<T1,T2> Dune::makePair	(	const T1 &	first,
		const T2 &	second
	)

inline

Create a tuple and initialize it.

Parameters

first	The value of the first field.
second	The value of the second field.

◆ operator!=() [1/4]

template<typename T1 , typename U1 >

bool Dune::operator!=	(	const Pair< T1, Nil > &	tuple1,
		const Pair< U1, Nil > &	tuple2
	)

inline

Inequality comparison operator for tuples.

Parameters

tuple1	The first tuple.
tuple2	The second tuple,

References dune_static_assert, Dune::Pair< T1, TT >::first(), and Dune::Pair< T1, Nil >::first().

◆ operator!=() [2/4]

template<typename T1 , typename U1 , typename U2 >

bool Dune::operator!=	(	const Pair< T1, Nil > &	tuple1,
		const Pair< U1, U2 > &	tuple2
	)

inline

Inequality comparison operator for tuples.

Parameters

tuple1	The first tuple.
tuple2	The second tuple.

Returns: True as the type of the compared objects are different.

◆ operator!=() [3/4]

template<typename T1 , typename T2 , typename U1 >

bool Dune::operator!=	(	const Pair< T1, T2 > &	tuple1,
		const Pair< U1, Nil > &	tuple2
	)

inline

Inequality comparison operator for tuples.

Parameters

tuple1	The first tuple.
tuple2	The second tuple.

Returns: True as the type of the compared objects are different.

◆ operator!=() [4/4]

template<typename T1 , typename T2 , typename U1 , typename U2 >

bool Dune::operator!=	(	const Pair< T1, T2 > &	tuple1,
		const Pair< U1, U2 > &	tuple2
	)

inline

Inequality comparison operator for tuples.

Parameters

tuple1	The first tuple.
tuple2	The second tuple,

References Dune::Pair< T1, TT >::first(), and Dune::Pair< T1, TT >::second().

◆ operator%()

template<int k>

bigunsignedint< k > Dune::bigunsignedint< k >::operator% ( const bigunsignedint< k > & x ) const

inline

modulo

Warning: This function is very slow and its usage should be prevented if possible

◆ operator/()

template<int k>

bigunsignedint< k > Dune::bigunsignedint< k >::operator/ ( const bigunsignedint< k > & x ) const

inline

divide

Warning: This function is very slow and its usage should be prevented if possible

References DUNE_THROW.

◆ operator<() [1/2]

template<typename T1 , typename U1 >

bool Dune::operator<	(	const Pair< T1, Nil > &	tuple1,
		const Pair< U1, Nil > &	tuple2
	)

inline

Less operator for tuples.

Parameters

tuple1	The first tuple.
tuple2	The second tuple,

References Dune::Pair< T1, TT >::first(), and Dune::Pair< T1, Nil >::first().

◆ operator<() [2/2]

template<typename T1 , typename T2 , typename U1 , typename U2 >

bool Dune::operator<	(	const Pair< T1, T2 > &	tuple1,
		const Pair< U1, U2 > &	tuple2
	)

inline

Less operator for tuples.

Parameters

tuple1	The first tuple.
tuple2	The second tuple,

References Dune::Pair< T1, TT >::first(), and Dune::Pair< T1, TT >::second().

◆ operator<<=() [1/4]

template<class T , class K , int n, int m>

fmatrix_assigner<T,n,m> Dune::operator<<=	(	FieldMatrix< T, n, m > &	v,
		const K &	t
	)

FieldMatrix assignment operator.

overload operator <<= for FieldMatrix assignment from comma separated list of values

◆ operator<<=() [2/4]

template<class T , int n, int m>

fmatrix_assigner<T,n,m> Dune::operator<<=	(	FieldMatrix< T, n, m > &	v,
		Zero	z
	)

FieldMatrix assignment operator.

overload operator <<= for FieldMatrix row assignment from Dune::Zero

◆ operator<<=() [3/4]

template<class T , class K , int s>

fvector_assigner<T,s> Dune::operator<<=	(	FieldVector< T, s > &	v,
		const K &	t
	)

fvector assignment operator

overload operator <<= for fvector assignment from comma separated list of values

◆ operator<<=() [4/4]

template<class T , int s>

fvector_assigner<T,s> Dune::operator<<=	(	FieldVector< T, s > &	v,
		Zero	z
	)

fvector assignment operator

overload operator <<= for fvector assignment from Dune::Zero

◆ operator=() [1/2]

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=() [2/2]

template<typename T1 , typename TT >

template<typename U1 , typename U2 >

Pair& Dune::Pair< T1, TT >::operator= ( const Pair< U1, U2 > & other )

Assignment operator for implicit type conversion.

Parameters

other The tuple to assign.

◆ operator==() [1/4]

template<typename T1 , typename U1 >

bool Dune::operator==	(	const Pair< T1, Nil > &	tuple1,
		const Pair< U1, Nil > &	tuple2
	)

inline

Equality comparison operator for tuples.

Parameters

tuple1	The first tuple.
tuple2	The second tuple,

References Dune::Pair< T1, TT >::first(), and Dune::Pair< T1, Nil >::first().

◆ operator==() [2/4]

template<typename T1 , typename U1 , typename U2 >

bool Dune::operator==	(	const Pair< T1, Nil > &	tuple1,
		const Pair< U1, U2 > &	tuple2
	)

inline

Equality comparison operator for tuples.

Parameters

tuple1	The first tuple.
tuple2	The second tuple.

Returns: False as the type of the compared objects are different.

◆ operator==() [3/4]

template<typename T1 , typename T2 , typename U1 >

bool Dune::operator==	(	const Pair< T1, T2 > &	tuple1,
		const Pair< U1, Nil > &	tuple2
	)

inline

Equality comparison operator for tuples.

Parameters

tuple1	The first tuple.
tuple2	The second tuple.

Returns: False as the type of the compared objects are different.

◆ operator==() [4/4]

template<typename T1 , typename T2 , typename U1 , typename U2 >

bool Dune::operator==	(	const Pair< T1, T2 > &	tuple1,
		const Pair< U1, U2 > &	tuple2
	)

inline

Equality comparison operator for tuples.

Parameters

tuple1	The first tuple.
tuple2	The second tuple,

References Dune::Pair< T1, TT >::first(), and Dune::Pair< T1, TT >::second().

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

◆ Pair() [1/5]

template<typename T1 , typename T2 >

template<typename U1 , typename U2 >

Dune::Pair< T1, T2 >::Pair ( const Pair< U1, U2 > & other )

inline

Copy Constructor for implicit type conversion.

Parameters

other The tuple to copy.

◆ Pair() [2/5]

template<typename T1 >

Dune::Pair< T1, Nil >::Pair	(	typename TupleAccessTraits< T1 >::ParameterType	first,
		const Nil &
	)

inline

Constructor.

Parameters

first The values for the first field.

◆ Pair() [3/5]

template<typename T1 >

Dune::Pair< T1, Nil >::Pair	(	typename TupleAccessTraits< T1 >::ParameterType	first,
		const Nil &	,
		const Nil &	,
		const Nil &	,
		const Nil &	,
		const Nil &	,
		const Nil &	,
		const Nil &	,
		const Nil &
	)

inline

Constructor.

Parameters

first The values for the first field.

◆ Pair() [4/5]

template<typename T1 , typename TT >

template<typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >

Dune::Pair< T1, TT >::Pair	(	typename TupleAccessTraits< T1 >::ParameterType	t1,
		T2 &	t2,
		T3 &	t3,
		T4 &	t4,
		T5 &	t5,
		T6 &	t6,
		T7 &	t7,
		T8 &	t8,
		T9 &	t9
	)

inline

Constructor.

Parameters

t1	The value of the first field.
t2	The value of the second field.
t3	The value of the third field.
t4	The value of the 4th field.
t5	The value of the 5th field.
t6	The value of the 6th field.
t7	The value of the 7th field.
t8	The value of the 8th field.
t9	The value of the 9th field.

◆ Pair() [5/5]

template<typename T1 , typename TT >

Dune::Pair< T1, TT >::Pair	(	typename TupleAccessTraits< Type1 >::ParameterType	t1,
		TT &	t2
	)

inline

Constructor.

Parameters

t1	The value of the first field.
t2	The value of the second field.

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

◆ 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 postion 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().

◆ second() [1/2]

template<typename T1 , typename T2 >

TupleAccessTraits< T2 >::NonConstType Dune::Pair< T1, T2 >::second

inline

Get the second value.

Returns: The second value

Referenced by Dune::Element< N >::get(), Dune::operator!=(), Dune::operator<(), Dune::operator<<(), Dune::operator==(), and Dune::operator>>().

◆ second() [2/2]

template<typename T1 , typename T2 >

TupleAccessTraits< T2 >::ConstType Dune::Pair< T1, T2 >::second

inline

Get the second value.

Returns: The second value

◆ shared_ptr() [1/4]

template<class T >

Dune::shared_ptr< T >::shared_ptr ( const shared_ptr< T > & pointer )

inline

Copy constructor.

Parameters

pointer The object to copy.

References Dune::SharedCount::count_.

◆ shared_ptr() [2/4]

template<class T >

template<class T1 >

Dune::shared_ptr< T >::shared_ptr ( const shared_ptr< T1 > & pointer )

inline

Copy constructor.

Parameters

pointer The object to copy.

References Dune::SharedCount::count_.

◆ shared_ptr() [3/4]

template<class T >

template<class T1 >

Dune::shared_ptr< T >::shared_ptr ( T1 * pointer )

inline

Constructs a new smart pointer from a preallocated Object.

Parameters

pointer Raw pointer to the shared data

note: the object must be allocated on the heap and after handing the pointer to shared_ptr the ownership of the pointer is also handed to the shared_ptr.

◆ shared_ptr() [4/4]

template<class T >

template<class T1 , class Deleter >

Dune::shared_ptr< T >::shared_ptr	(	T1 *	pointer,
		Deleter	deleter
	)

inline

Constructs a new smart pointer from a preallocated Object.

Template Parameters

Deleter This class must by copyconstructable, the copy constructor must not throw an exception and it must implement void operator() (T*) const

Parameters

pointer	Raw pointer to the shared data
deleter	A copy of this deleter is stored

note: the object must be allocated on the heap and after handing the pointer to shared_ptr the ownership of the pointer is also handed to the shared_ptr.

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

◆ todouble()

template<int k>

double Dune::bigunsignedint< k >::todouble

inline

Convert to a double.

Warning: Subject to rounding errors!

◆ ~SLList()

template<typename T , class A >

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

Destructor.

Deallocates all elements in the list.

Modules

Files

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ DUNE_DEPRECATED

◆ DUNE_DEPRECATED_MSG

◆ dune_static_assert

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()

◆ fill_array()

◆ first() [1/4]

◆ first() [2/4]

◆ first() [3/4]

◆ first() [4/4]

◆ fmatrix_assigner()

◆ fvector_assigner()

◆ get() [1/4]

◆ get() [2/4]

◆ get() [3/4]

◆ get() [4/4]

◆ hasPrefix()

◆ hasSuffix()

◆ Indent() [1/2]

◆ Indent() [2/2]

◆ insert()

◆ insertAfter()

◆ ios_base_all_saver()

◆ make_array()

◆ makePair()

◆ operator!=() [1/4]

◆ operator!=() [2/4]

◆ operator!=() [3/4]

◆ operator!=() [4/4]

◆ operator%()

◆ operator/()

◆ operator<() [1/2]

◆ operator<() [2/2]

◆ operator<<=() [1/4]

◆ operator<<=() [2/4]

◆ operator<<=() [3/4]

◆ operator<<=() [4/4]