dune-common  2.3.0
Modules | Files | Namespaces | Classes | Macros | Typedefs | Enumerations | Enumerator | Functions | Variables | Friends
Common (foundation classes)
Collaboration diagram for Common (foundation classes):

Modules

 Allocators
 Implementations of the STL allocator concept.
 GeometryType
 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.

Namespaces

namespace  Dune
 Dune namespace.

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...
class  Dune::bigunsignedint< k >
 Portable very large unsigned integers. More...
struct  Dune::AlwaysVoid< T >
struct  Dune::IsVector< T, class >
struct  Dune::IsVector< T, typename AlwaysVoid< typename T::field_type >::type >
class  Dune::EmptySet< TA >
 An empty set. More...
class  Dune::AllSet< TA >
 A set containing everything. More...
class  Dune::EnumItem< TA, item >
 A set consisting only of one item. More...
class  Dune::EnumRange< TA, from, end >
 A set representing a range including the borders. More...
class  Dune::NegateSet< S >
 The negation of a set. An item is contained in the set if and only if it is not contained in the negated set. More...
class  Dune::Combine< TI1, TI2, TA >
 A set combining two other sets. More...
class  Dune::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...
struct  Dune::Power_m_p< m, p >
 Calculates m^p at compile time. More...
struct  Dune::Power_m_p< m, 0 >
 end of recursion via specialization 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...
struct  Dune::PromotionTraits< T1, T2 >
 Class for type promotions. For example, the promotion traits are used for the implementation of dot products.
class  Dune::SharedCount
 The object we reference. More...
class  Dune::shared_ptr< T >
 A reference counting smart pointer. More...
class  Dune::SLList< T, A >
 A single linked list. More...
struct  Dune::SLList< T, A >::Element
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::TimerError
 Exception thrown by the Timer class More...
class  Dune::Timer
 A simple stop watch. More...
struct  Dune::TupleAccessTraits< T >
struct  Dune::TupleAccessTraits< T * >
struct  Dune::TupleAccessTraits< T & >
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< N, Pair< T1, T2 > >
struct  Dune::tuple_element< 0, Pair< T1, T2 > >
 Get the type of the first element of the 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::tuple_size< Pair< T1, T2 > >
struct  Dune::tuple_size< Pair< T1, Nil > >
struct  Dune::tuple_size< Pair< Nil, Nil > >
struct  Dune::tuple_writer< i >
struct  Dune::tuple_writer< 1 >
struct  Dune::tuple_writer< 0 >
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::ConstantVolatileTraits< const T >
struct  Dune::ConstantVolatileTraits< volatile T >
struct  Dune::ConstantVolatileTraits< const volatile T >
struct  Dune::IsVolatile< T >
 Tests wether a type is volatile. More...
struct  Dune::IsConst< T >
 Tests wether a type is constant. More...
struct  Dune::RemoveConstHelper< T, isVolatile >
struct  Dune::RemoveConstHelper< T, true >
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::Conversion< From, void >
class  Dune::Conversion< void, To >
class  Dune::Conversion< int, double >
class  Dune::Conversion< T, T >
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::enable_if< false, T >
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::is_same< T, T >
struct  Dune::SelectType< first, T1, T2 >
 Select a type based on a condition. More...
struct  Dune::SelectType< false, T1, T2 >
struct  Dune::conditional< first, T1, T2 >
 Select a type based on a condition. More...
struct  Dune::conditional< false, T1, T2 >
struct  Dune::integral_constant< T, v >
 Generate a type for a given integral constant. More...
struct  Dune::__is_pointer_helper< typename >
struct  Dune::__is_pointer_helper< T * >
struct  Dune::is_pointer< T >
 is_pointer More...
struct  Dune::__is_lvalue_reference_helper< typename >
struct  Dune::__is_lvalue_reference_helper< T & >
struct  Dune::is_lvalue_reference< T >
 Determine whether a type is a lvalue reference type. More...
struct  Dune::__remove_pointer_helper< _Tp >
struct  Dune::__remove_pointer_helper< _Tp * >
struct  Dune::remove_pointer< _Tp >
 Return the type a pointer type points to. More...

Macros

#define DUNE_DEPRECATED
 Mark some entity as deprecated.
#define DUNE_DEPRECATED_MSG(text)   DUNE_DEPRECATED
 Mark some entity as deprecated.
#define dune_static_assert(COND, MSG)
 Helper template so that compilation fails if condition is not true.

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 ConstantVolatileTraits
< T >::ConstType & 
Dune::TupleAccessTraits< T >::ConstType
typedef T & Dune::TupleAccessTraits< T >::NonConstType
typedef const
ConstantVolatileTraits< T >
::UnqualifiedType & 
Dune::TupleAccessTraits< T >::ParameterType
typedef ConstantVolatileTraits
< T >::ConstType * 
Dune::TupleAccessTraits< T * >::ConstType
typedef T * Dune::TupleAccessTraits< T * >::NonConstType
typedef T * Dune::TupleAccessTraits< T * >::ParameterType
typedef T & Dune::TupleAccessTraits< T & >::ConstType
typedef T & Dune::TupleAccessTraits< T & >::NonConstType
typedef T & Dune::TupleAccessTraits< T & >::ParameterType
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 Pair< T1, typename
TupleToPairs< T2, T3, T4, T5,
T6, T7, T8, T9, Nil >::Type > 
Dune::TupleToPairs< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::Type
typedef Pair< T1, Nil > Dune::TupleToPairs< T1, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil >::Type
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,
typename Tuple::FirstPair >
::type 
Dune::tuple_element< N, Tuple >::Type
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 tuple_element< N-1, T2 >
::Type 
Dune::tuple_element< N, Pair< T1, T2 > >::Type
typedef T1 Dune::tuple_element< 0, Pair< T1, T2 > >::type
 The type of the first element of the tuple.
typedef T1 Dune::tuple_element< 0, Pair< T1, T2 > >::Type
typedef integral_constant
< bool, true > 
Dune::true_type
 type for true
typedef integral_constant
< bool, false > 
Dune::false_type
 type for false

Enumerations

enum  { Dune::StaticPower< m, p >::power = (m * StaticPower<m,p-1>::power ) }
 power stores m^p More...
enum  { Dune::StaticPower< m, 0 >::power = 1 }
 m^0 = 1 More...
enum  { Dune::tuple_size< T >::value = tuple_size<typename T::FirstPair>::value }
enum  { Dune::tuple_size< Pair< T1, T2 > >::value = 1+tuple_size<T2>::value }
enum  { Dune::tuple_size< Pair< T1, Nil > >::value = 1 }
enum  { Dune::tuple_size< Pair< Nil, Nil > >::value = 0 }

Functions

template<class T , size_t N>
bool Dune::operator< (const array< T, N > &a, const array< T, N > &b)
template<class T , size_t N>
bool Dune::operator> (const array< T, N > &a, const array< T, N > &b)
template<class T , size_t N>
bool Dune::operator<= (const array< T, N > &a, const array< T, N > &b)
template<class T , size_t N>
bool Dune::operator>= (const array< T, N > &a, const array< T, N > &b)
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
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.
template<int k>
std::ostream & Dune::operator<< (std::ostream &s, const bigunsignedint< k > &x)
template<int k>
bigunsignedint< k > Dune::operator+ (const bigunsignedint< k > &x, std::size_t y)
template<int k>
bigunsignedint< k > Dune::operator- (const bigunsignedint< k > &x, std::size_t y)
template<int k>
bigunsignedint< k > Dune::operator* (const bigunsignedint< k > &x, std::size_t y)
template<int k>
bigunsignedint< k > Dune::operator/ (const bigunsignedint< k > &x, std::size_t y)
template<int k>
bigunsignedint< k > Dune::operator% (const bigunsignedint< k > &x, std::size_t y)
template<int k>
bigunsignedint< k > Dune::operator+ (std::size_t x, const bigunsignedint< k > &y)
template<int k>
bigunsignedint< k > Dune::operator- (std::size_t x, const bigunsignedint< k > &y)
template<int k>
bigunsignedint< k > Dune::operator* (std::size_t x, const bigunsignedint< k > &y)
template<int k>
bigunsignedint< k > Dune::operator/ (std::size_t x, const bigunsignedint< k > &y)
template<int k>
bigunsignedint< k > Dune::operator% (std::size_t x, const bigunsignedint< k > &y)
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
template<typename TA , int i>
std::ostream & Dune::operator<< (std::ostream &os, const EnumItem< TA, i > &)
template<typename TA , int from, int to>
std::ostream & Dune::operator<< (std::ostream &os, const EnumRange< TA, from, to > &)
template<class TI1 , class TI2 >
Combine< TI1, TI2, typename
TI1::Type > 
Dune::combine (const TI1 &set1, const TI2 &set2)
template<class TI1 , class TI2 , class T >
std::ostream & Dune::operator<< (std::ostream &os, const Combine< TI1, TI2, T > &)
 Zero (int)
 operator double ()
 Conversion operator to double.
 operator int ()
 Conversion operator to int.
 NextRow (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.
 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
template<class T , int s>
fvector_assigner< T, s > Dune::operator<<= (FieldVector< T, s > &v, Zero z)
 fvector assignment operator
 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.
 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.
template<class T , int n, int m>
fmatrix_assigner< T, n, m > Dune::operator<<= (FieldMatrix< T, n, m > &v, Zero z)
 FieldMatrix assignment operator.
 Dune::Indent::Indent (const std::string &basic_indent_=" ", unsigned level_=0)
 setup without parent
 Dune::Indent::Indent (unsigned level_)
 setup without parent and basic_indentation of two spaces
 Dune::Indent::Indent (const Indent *parent_, const std::string &basic_indent_=" ", unsigned level_=1)
 setup with parent
 Dune::Indent::Indent (const Indent *parent_, unsigned level_)
 setup with parent
Indent Dune::Indent::operator+ (const std::string &newindent) const
 create new indentation object with this one as parent
Indent Dune::Indent::operator+ (unsigned morelevel) const
 create a copy of this 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.
 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.
static void Dune::Lcm< m, n >::conceptCheck ()
template<class T >
Dune::SQR (T t)
 Compute the square of T.
std::string Dune::genFilename (const std::string &path, const std::string &fn, int ntime, int precision=6)
 Generate filenames with timestep number in it.
template<typename T >
static T Dune::Power< p >::eval (const T &a)
 Dune::SLList< T, A >::SLList ()
 Constructor.
template<typename T1 , typename A1 >
 Dune::SLList< T, A >::SLList (const SLList< T1, A1 > &other)
 Copy constructor with type conversion.
 Dune::SLList< T, A >::SLList (const SLList< T, A > &other)
 Copy constructor.
 Dune::SLList< T, A >::~SLList ()
 Destructor.
SLList< T, A > & Dune::SLList< T, A >::operator= (const SLList< T, A > &other)
 Assignment operator.
void Dune::SLList< T, A >::push_back (const MemberType &item)
 Add a new entry to the end of the list.
void Dune::SLList< T, A >::push_front (const MemberType &item)
 Add a new entry to the beginning of the list.
void Dune::SLList< T, A >::pop_front ()
 Remove the first item in the list.
void Dune::SLList< T, A >::clear ()
 Remove all elements from the list.
iterator Dune::SLList< T, A >::begin ()
 Get an iterator pointing to the first element in the list.
const_iterator Dune::SLList< T, A >::begin () const
 Get an iterator pointing to the first element in the list.
ModifyIterator Dune::SLList< T, A >::beginModify ()
 Get an iterator capable of deleting and inserting elements.
ModifyIterator Dune::SLList< T, A >::endModify ()
 Get an iterator capable of deleting and inserting elements.
iterator Dune::SLList< T, A >::end ()
 Get an iterator pointing to the end of the list.
const_iterator Dune::SLList< T, A >::end () const
 Get an iterator pointing to the end of the list.
bool Dune::SLList< T, A >::empty () const
 Check whether the list is empty.
int Dune::SLList< T, A >::size () const
 Get the number of elements the list contains.
bool Dune::SLList< T, A >::operator== (const SLList &sl) const
bool Dune::SLList< T, A >::operator!= (const SLList &sl) const
 Dune::SLList< T, A >::Element::Element (const MemberType &item, Element *next_=0)
 Dune::SLList< T, A >::Element::Element ()
 Dune::SLList< T, A >::Element::~Element ()
 Dune::SLListIterator< T, A >::SLListIterator (typename SLList< T, A >::Element *item, SLList< T, A > *sllist)
 Dune::SLListIterator< T, A >::SLListIterator ()
 Dune::SLListIterator< T, A >::SLListIterator (const SLListModifyIterator< T, A > &other)
T & Dune::SLListIterator< T, A >::dereference () const
 Dereferencing function for the iterator facade.
bool Dune::SLListIterator< T, A >::equals (const SLListConstIterator< T, A > &other) const
 Equality test for the iterator facade.
bool Dune::SLListIterator< T, A >::equals (const SLListIterator< T, A > &other) const
 Equality test for the iterator facade.
bool Dune::SLListIterator< T, A >::equals (const SLListModifyIterator< T, A > &other) const
 Equality test for the iterator facade.
void Dune::SLListIterator< T, A >::increment ()
 Increment function for the iterator facade.
void Dune::SLListIterator< T, A >::insertAfter (const T &v) const
 Insert an element in the underlying list after the current position.
void Dune::SLListIterator< T, A >::deleteNext () const
 Delete the entry after the current position.
 Dune::SLListConstIterator< T, A >::SLListConstIterator ()
 Dune::SLListConstIterator< T, A >::SLListConstIterator (typename SLList< T, A >::Element *item)
 Dune::SLListConstIterator< T, A >::SLListConstIterator (const SLListIterator< T, A > &other)
 Dune::SLListConstIterator< T, A >::SLListConstIterator (const SLListConstIterator< T, A > &other)
 Dune::SLListConstIterator< T, A >::SLListConstIterator (const SLListModifyIterator< T, A > &other)
const T & Dune::SLListConstIterator< T, A >::dereference () const
 Dereferencing function for the facade.
bool Dune::SLListConstIterator< T, A >::equals (const SLListConstIterator< T, A > &other) const
 Equality test for the iterator facade.
void Dune::SLListConstIterator< T, A >::increment ()
 Increment function for the iterator facade.
 Dune::SLListModifyIterator< T, A >::SLListModifyIterator (SLListIterator< T, A > beforeIterator, SLListIterator< T, A > _iterator)
 Dune::SLListModifyIterator< T, A >::SLListModifyIterator (const SLListModifyIterator< T, A > &other)
 Dune::SLListModifyIterator< T, A >::SLListModifyIterator ()
T & Dune::SLListModifyIterator< T, A >::dereference () const
 Dereferencing function for the iterator facade.
bool Dune::SLListModifyIterator< T, A >::equals (const SLListConstIterator< T, A > &other) const
 Test whether another iterator is equal.
bool Dune::SLListModifyIterator< T, A >::equals (const SLListIterator< T, A > &other) const
 Test whether another iterator is equal.
bool Dune::SLListModifyIterator< T, A >::equals (const SLListModifyIterator< T, A > &other) const
 Test whether another iterator is equal.
void Dune::SLListModifyIterator< T, A >::increment ()
 Increment function for the iterator facade.
void Dune::SLListModifyIterator< T, A >::insert (const T &v)
 Insert an element at the current position.
void Dune::SLListModifyIterator< T, A >::remove ()
 Delete the entry at the current position.
template<typename T , typename A >
ostream & std::operator<< (ostream &os, const Dune::SLList< T, A > sllist)
template<typename C >
bool Dune::hasPrefix (const C &c, const char *prefix)
 Check whether a character container has a given prefix.
template<typename C >
bool Dune::hasSuffix (const C &c, const char *suffix)
 Check whether a character container has a given suffix.
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)
 The number of values we hold.
 Dune::Pair< T1, TT >::Pair (typename TupleAccessTraits< Type1 >::ParameterType t1, TT &t2)
 Constructor.
 Dune::Pair< T1, TT >::Pair ()
template<typename U1 , typename U2 >
 Dune::Pair< T1, TT >::Pair (const Pair< U1, U2 > &other)
 Copy Constructor for implicit type conversion.
template<typename U1 , typename U2 >
Pair & Dune::Pair< T1, TT >::operator= (const Pair< U1, U2 > &other)
 Assignment operator for implicit type conversion.
Pair & Dune::Pair< T1, TT >::operator= (const Pair &other)
TupleAccessTraits< Type1 >
::NonConstType 
Dune::Pair< T1, TT >::first ()
 Get the first value.
TupleAccessTraits< Type1 >
::ConstType 
Dune::Pair< T1, TT >::first () const
 Get the first value.
TupleAccessTraits< Type2 >
::NonConstType 
Dune::Pair< T1, TT >::second ()
 Get the second value.
TupleAccessTraits< Type2 >
::ConstType 
Dune::Pair< T1, TT >::second () const
 Get the second value.
 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.
 Dune::Pair< T1, Nil >::Pair (typename TupleAccessTraits< T1 >::ParameterType first, const Nil &)
 Constructor.
 Dune::Pair< T1, Nil >::Pair ()
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.
TupleAccessTraits< Type1 >
::ConstType 
Dune::Pair< T1, Nil >::first () const
 Get the first value.
 Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple ()
 Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple (typename TupleAccessTraits< T1 >::ParameterType t1)
 Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple (typename TupleAccessTraits< T1 >::ParameterType t1, typename TupleAccessTraits< T2 >::ParameterType t2)
 Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple (typename TupleAccessTraits< T1 >::ParameterType t1, typename TupleAccessTraits< T2 >::ParameterType t2, typename TupleAccessTraits< T3 >::ParameterType t3)
 Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple (typename TupleAccessTraits< T1 >::ParameterType t1, typename TupleAccessTraits< T2 >::ParameterType t2, typename TupleAccessTraits< T3 >::ParameterType t3, typename TupleAccessTraits< T4 >::ParameterType t4)
 Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple (typename TupleAccessTraits< T1 >::ParameterType t1, typename TupleAccessTraits< T2 >::ParameterType t2, typename TupleAccessTraits< T3 >::ParameterType t3, typename TupleAccessTraits< T4 >::ParameterType t4, typename TupleAccessTraits< T5 >::ParameterType t5)
 Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple (typename TupleAccessTraits< T1 >::ParameterType t1, typename TupleAccessTraits< T2 >::ParameterType t2, typename TupleAccessTraits< T3 >::ParameterType t3, typename TupleAccessTraits< T4 >::ParameterType t4, typename TupleAccessTraits< T5 >::ParameterType t5, typename TupleAccessTraits< T6 >::ParameterType t6)
 Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple (typename TupleAccessTraits< T1 >::ParameterType t1, typename TupleAccessTraits< T2 >::ParameterType t2, typename TupleAccessTraits< T3 >::ParameterType t3, typename TupleAccessTraits< T4 >::ParameterType t4, typename TupleAccessTraits< T5 >::ParameterType t5, typename TupleAccessTraits< T6 >::ParameterType t6, typename TupleAccessTraits< T7 >::ParameterType t7)
 Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple (typename TupleAccessTraits< T1 >::ParameterType t1, typename TupleAccessTraits< T2 >::ParameterType t2, typename TupleAccessTraits< T3 >::ParameterType t3, typename TupleAccessTraits< T4 >::ParameterType t4, typename TupleAccessTraits< T5 >::ParameterType t5, typename TupleAccessTraits< T6 >::ParameterType t6, typename TupleAccessTraits< T7 >::ParameterType t7, typename TupleAccessTraits< T8 >::ParameterType t8)
 Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple (typename TupleAccessTraits< T1 >::ParameterType t1, typename TupleAccessTraits< T2 >::ParameterType t2, typename TupleAccessTraits< T3 >::ParameterType t3, typename TupleAccessTraits< T4 >::ParameterType t4, typename TupleAccessTraits< T5 >::ParameterType t5, typename TupleAccessTraits< T6 >::ParameterType t6, typename TupleAccessTraits< T7 >::ParameterType t7, typename TupleAccessTraits< T8 >::ParameterType t8, typename TupleAccessTraits< T9 >::ParameterType t9)
template<class U1 , class U2 >
tuple & Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::operator= (const Pair< U1, U2 > &other)
 Assignment operator for implicit type conversion.
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.
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.
template<typename T1 , typename T2 >
static TupleAccessTraits< T1 >
::NonConstType 
Dune::Element< 0 >::get (Pair< T1, T2 > &tuple)
 Get the first element of the tuple.
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.
template<int i, typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
TupleAccessTraits< typename
tuple_element< i, tuple< T1,
T2, T3, T4, T5, T6, T7, T8, T9 >
>::type >::NonConstType 
Dune::get (tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > &t)
template<int i, typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
TupleAccessTraits< typename
tuple_element< i, tuple< T1,
T2, T3, T4, T5, T6, T7, T8, T9 >
>::type >::ConstType 
Dune::get (const tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > &t)
template<class T >
static std::ostream & Dune::tuple_writer< i >::put (std::ostream &os, const T &t, const char *delim=", ")
template<class T >
static std::istream & Dune::tuple_writer< i >::get (std::istream &is, T &t, const char *delim=",")
template<class T >
static std::ostream & Dune::tuple_writer< 1 >::put (std::ostream &os, const T &t, const char *delim=", ")
template<class T >
static std::istream & Dune::tuple_writer< 1 >::get (std::istream &is, T &t, const char *delim=", ")
template<class T >
static std::ostream & Dune::tuple_writer< 0 >::put (std::ostream &os, const T &t, const char *delim=", ")
template<class T >
static std::istream & Dune::tuple_writer< 0 >::get (std::istream &is, T &t, const char *delim=", ")
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.
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.
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.
template<typename T1 , typename U1 >
bool Dune::operator== (const Pair< T1, Nil > &tuple1, const Pair< U1, Nil > &tuple2)
 Equality comparison operator for tuples.
template<typename T1 , typename U1 >
bool Dune::operator!= (const Pair< T1, Nil > &tuple1, const Pair< U1, Nil > &tuple2)
 Inequality comparison operator for tuples.
template<typename T1 , typename U1 >
bool Dune::operator< (const Pair< T1, Nil > &tuple1, const Pair< U1, Nil > &tuple2)
 Less operator for tuples.
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.
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.
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.
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.
template<typename T1 , typename T2 >
Pair< T1, T2 > Dune::makePair (const T1 &first, const T2 &second)
 Create a tuple and initialize it.
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 >
std::ostream & Dune::operator<< (std::ostream &os, const Pair< T1, Nil > &pair)
template<typename T1 , typename T2 >
std::istream & Dune::operator>> (std::istream &is, Pair< T1, T2 > &pair)
 Read a pair or tuple.
template<typename T1 >
std::istream & Dune::operator>> (std::istream &is, Pair< T1, Nil > &pair)
template<class T1 >
tuple< T1 & > Dune::tie (T1 &t1)
template<class T1 , class T2 >
tuple< T1 &, T2 & > Dune::tie (T1 &t1, T2 &t2)
template<class T1 , class T2 , class T3 >
tuple< T1 &, T2 &, T3 & > Dune::tie (T1 &t1, T2 &t2, T3 &t3)
template<class T1 , class T2 , class T3 , class T4 >
tuple< T1 &, T2 &, T3 &, T4 & > Dune::tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4)
template<class T1 , class T2 , class T3 , class T4 , class T5 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 & > 
Dune::tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 &, T6 & > 
Dune::tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 &, T6 &, T7 & > 
Dune::tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 &, T6 &, T7 &, T8 & > 
Dune::tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 &, T6 &, T7 &, T8 &, T9 & > 
Dune::tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9)
template<class T1 >
tuple< T1 > Dune::make_tuple (const T1 &t1)
template<class T1 , class T2 >
tuple< T1, T2 > Dune::make_tuple (const T1 &t1, const T2 &t2)
template<class T1 , class T2 , class T3 >
tuple< T1, T2, T3 > Dune::make_tuple (const T1 &t1, const T2 &t2, const T3 &t3)
template<class T1 , class T2 , class T3 , class T4 >
tuple< T1, T2, T3, T4 > Dune::make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4)
template<class T1 , class T2 , class T3 , class T4 , class T5 >
tuple< T1, T2, T3, T4, T5 > Dune::make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
tuple< T1, T2, T3, T4, T5, T6 > Dune::make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
tuple< T1, T2, T3, T4, T5, T6, T7 > Dune::make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
tuple< T1, T2, T3, T4, T5, T6,
T7, T8 > 
Dune::make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
tuple< T1, T2, T3, T4, T5, T6,
T7, T8, T9 > 
Dune::make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8, const T9 &t9)
 Dune::ArrayList< T, N, A >::ArrayList ()
 Constructs an Array list with one chunk.
void Dune::ArrayList< T, N, A >::clear ()
 Delete all entries from the list.
size_type Dune::ArrayList< T, N, A >::size () const
 Get the number of elements in the list.
void Dune::ArrayList< T, N, A >::push_back (const_reference entry)
 Append an entry to the list.
reference Dune::ArrayList< T, N, A >::operator[] (size_type i)
 Get the element at specific position.
const_reference Dune::ArrayList< T, N, A >::operator[] (size_type i) const
 Get the element at specific position.
iterator Dune::ArrayList< T, N, A >::begin ()
 Get an iterator that is positioned at the first element.
const_iterator Dune::ArrayList< T, N, A >::begin () const
 Get a random access iterator that is positioned at the first element.
iterator Dune::ArrayList< T, N, A >::end ()
 Get a random access iterator positioned after the last element.
const_iterator Dune::ArrayList< T, N, A >::end () const
 Get a random access iterator positioned after the last element.
void Dune::ArrayList< T, N, A >::purge ()
 Purge the list.
void Dune::ArrayListIterator< T, N, A >::advance (difference_type n)
void Dune::ConstArrayListIterator< T, N, A >::advance (difference_type n)
bool Dune::ArrayListIterator< T, N, A >::equals (const ArrayListIterator< MemberType, N, A > &other) const
 Comares two iterators.
bool Dune::ArrayListIterator< T, N, A >::equals (const ConstArrayListIterator< MemberType, N, A > &other) const
 Comares two iterators.
bool Dune::ConstArrayListIterator< T, N, A >::equals (const ConstArrayListIterator< MemberType, N, A > &other) const
 Comares to iterators.
void Dune::ArrayListIterator< T, N, A >::increment ()
 Increment the iterator.
void Dune::ConstArrayListIterator< T, N, A >::increment ()
 Increment the iterator.
void Dune::ArrayListIterator< T, N, A >::decrement ()
 decrement the iterator.
void Dune::ConstArrayListIterator< T, N, A >::decrement ()
 decrement the iterator.
reference Dune::ArrayListIterator< T, N, A >::elementAt (size_type i) const
 Get the value of the list at an arbitrary position.
const_reference Dune::ConstArrayListIterator< T, N, A >::elementAt (size_type i) const
 Get the value of the list at an arbitrary position.
reference Dune::ArrayListIterator< T, N, A >::dereference () const
 Access the element at the current position.
const_reference Dune::ConstArrayListIterator< T, N, A >::dereference () const
 Access the element at the current position.
difference_type Dune::ArrayListIterator< T, N, A >::distanceTo (const ArrayListIterator< T, N, A > &other) const
difference_type Dune::ConstArrayListIterator< T, N, A >::distanceTo (const ConstArrayListIterator< T, N, A > &other) const
ArrayListIterator< T, N, A > & Dune::ArrayListIterator< T, N, A >::operator= (const ArrayListIterator< T, N, A > &other)
const ConstArrayListIterator
< T, N, A > & 
Dune::ConstArrayListIterator< T, N, A >::operator= (const ConstArrayListIterator< 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.
 Dune::ConstArrayListIterator< T, N, A >::ConstArrayListIterator (const ArrayListIterator< T, N, A > &other)
 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.
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.
static bool Dune::EnumRange< TA, from, end >::contains (const Type &item)
static bool Dune::Combine< TI1, TI2, TA >::contains (const TA &item)
template<class T1 >
 Dune::shared_ptr< T >::shared_ptr (T1 *pointer)
 Constructs a new smart pointer from a preallocated Object.
 Dune::shared_ptr< T >::shared_ptr (nullptr_t null)
template<class T1 , class Deleter >
 Dune::shared_ptr< T >::shared_ptr (T1 *pointer, Deleter deleter)
 Constructs a new smart pointer from a preallocated Object.
template<class T1 >
 Dune::shared_ptr< T >::shared_ptr (const shared_ptr< T1 > &pointer)
 Copy constructor.
 Dune::shared_ptr< T >::shared_ptr (const shared_ptr &pointer)
 Copy constructor.
template<class T1 >
shared_ptr & Dune::shared_ptr< T >::operator= (const shared_ptr< T1 > &pointer)
 Assignment operator.
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.
template<class T1 , class Deleter >
void Dune::shared_ptr< T >::reset (T1 *pointer, Deleter deleter)

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

Friends

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

Detailed Description

Macro Definition Documentation

#define 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. 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)
    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.
#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)
    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.
#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.

dune_static_assert(CONDITION, ERRORMSG);

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

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

Referenced by Dune::Lcm< m, n >::conceptCheck(), Dune::FieldVector< T, COLS >::FieldVector(), Dune::RemoteIndexListModifier< T, A, mode >::insert(), Dune::operator!=(), Dune::Pool< T, s >::Pool(), and Dune::put().

Typedef Documentation

template<typename T, class A = std::allocator<T>>
typedef A::template rebind<Element>::other Dune::SLList< T, A >::Allocator

The allocator to use.

template<typename T, class A = std::allocator<T>>
typedef SLListConstIterator<T,A> Dune::SLList< T, A >::const_iterator

The constant iterator of the list.

template<class T>
typedef ConstantVolatileTraits<T>::ConstType& Dune::TupleAccessTraits< T >::ConstType
template<class T >
typedef ConstantVolatileTraits<T>::ConstType* Dune::TupleAccessTraits< T * >::ConstType
template<class T >
typedef T& Dune::TupleAccessTraits< T & >::ConstType
typedef integral_constant<bool, false> Dune::false_type

type for false

template<typename T1 = Nil, typename T2 = Nil, typename T3 = Nil, typename T4 = Nil, typename T5 = Nil, typename T6 = Nil, typename T7 = Nil, typename T8 = Nil, typename T9 = 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.

template<typename T, class A = std::allocator<T>>
typedef SLListIterator<T,A> Dune::SLList< T, A >::iterator

The mutable iterator of the list.

template<typename T, class A = std::allocator<T>>
typedef T Dune::SLList< T, A >::MemberType

The type we store.

template<typename T, class A = std::allocator<T>>
typedef SLListModifyIterator<T,A> Dune::SLList< T, A >::ModifyIterator

The type of the iterator capable of deletion and insertion.

template<class T>
typedef T& Dune::TupleAccessTraits< T >::NonConstType
template<class T >
typedef T* Dune::TupleAccessTraits< T * >::NonConstType
template<class T >
typedef T& Dune::TupleAccessTraits< T & >::NonConstType
template<class T>
typedef const ConstantVolatileTraits<T>::UnqualifiedType& Dune::TupleAccessTraits< T >::ParameterType
template<class T >
typedef T* Dune::TupleAccessTraits< T * >::ParameterType
template<class T >
typedef T& Dune::TupleAccessTraits< T & >::ParameterType
template<typename T, class A = std::allocator<T>>
typedef A::size_type Dune::SLList< T, A >::size_type

The size type.

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

Export type of object we save the state for.

typedef integral_constant<bool, true> Dune::true_type

type for true

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
typedef Pair<T1, typename TupleToPairs<T2,T3,T4,T5,T6,T7,T8,T9,Nil>::Type > Dune::TupleToPairs< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::Type
template<typename T1 >
typedef Pair<T1,Nil> Dune::TupleToPairs< T1, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil >::Type
template<int N, class 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.

template<int N, class Tuple>
typedef tuple_element<N,typename Tuple::FirstPair>::type Dune::tuple_element< N, Tuple >::Type
template<int N, typename T1 , typename T2 >
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.

template<int N, typename T1 , typename T2 >
typedef tuple_element<N-1,T2>::Type Dune::tuple_element< N, Pair< T1, T2 > >::Type
template<typename T1 , typename T2 >
typedef T1 Dune::tuple_element< 0, Pair< T1, T2 > >::type

The type of the first element of the tuple.

template<typename T1 , typename T2 >
typedef T1 Dune::tuple_element< 0, Pair< T1, T2 > >::Type
template<typename T1, typename TT>
typedef T1 Dune::Pair< T1, TT >::Type1
static

The type of the first field.

template<typename T1 >
typedef T1 Dune::Pair< T1, Nil >::Type1

The type of the first field.

template<typename T1, typename TT>
typedef TT Dune::Pair< T1, TT >::Type2

The type of the second field.

template<typename T1 >
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>

Enumeration Type Documentation

template<int m, int p>
anonymous enum

power stores m^p

Enumerator:
power 
template<int m>
anonymous enum

m^0 = 1

Enumerator:
power 
template<class T >
anonymous enum
Enumerator:
value 
template<typename T1 , typename T2 >
anonymous enum
Enumerator:
value 
template<typename T1 >
anonymous enum
Enumerator:
value 
anonymous enum
Enumerator:
value 

Function Documentation

template<class T , int N, class A >
void Dune::ArrayListIterator< T, N, A >::advance ( difference_type  n)
inline
Todo:
Please doc me!

References position_.

template<class T , int N, class A >
void Dune::ConstArrayListIterator< T, N, A >::advance ( difference_type  n)
inline
Todo:
Please doc me!

References position_.

template<class T, int s>
fvector_assigner& Dune::fvector_assigner< T, s >::append ( const T &  t)
inline

append data to this vector

References t.

Referenced by Dune::fvector_assigner< T, s >::operator,().

template<class T, int s>
fvector_assigner& Dune::fvector_assigner< T, s >::append ( Zero  z)
inline

append zeros to this vector

References DUNE_UNUSED_PARAMETER.

template<class T, int n, int m>
fmatrix_assigner& Dune::fmatrix_assigner< T, n, m >::append ( const T &  t)
inline

append data to this matrix

References DUNE_THROW, and t.

Referenced by Dune::fmatrix_assigner< T, n, m >::operator,().

template<class T, int n, int m>
fmatrix_assigner& Dune::fmatrix_assigner< T, n, m >::append ( Zero  z)
inline

append zeros to this matrix

References DUNE_UNUSED_PARAMETER.

template<class T, int n, int m>
fmatrix_assigner& Dune::fmatrix_assigner< T, n, m >::append ( NextRow  nr)
inline

move to next row of the matrix

References DUNE_UNUSED_PARAMETER.

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

Constructs an Array list with one chunk.

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.
template<class T , int N, class A >
ConstArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::begin ( ) const

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

Returns
The iterator.
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(), Dune::SLList< T, A >::operator!=(), Dune::SLList< T, A >::operator==(), and Dune::IndicesSyncer< T >::sync().

template<typename T , class A >
SLListConstIterator< T, A > Dune::SLList< T, A >::begin ( ) const
inline

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

Returns
An iterator pointing to the first element or the end if the list is empty.
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().

template<int k>
Dune::bigunsignedint< k >::bigunsignedint ( )

Construct uninitialized.

template<int k>
Dune::bigunsignedint< k >::bigunsignedint ( int  x)

Construct from signed int.

template<int k>
Dune::bigunsignedint< k >::bigunsignedint ( std::size_t  x)

Construct from unsigned int.

template<typename T , class A >
void Dune::SLList< T, A >::clear ( )
inline

Remove all elements from the list.

References size_.

template<class T , int N, class A >
void Dune::ArrayList< T, N, A >::clear ( )
inline

Delete all entries from the list.

References size_.

template<class TI1 , class TI2 >
Combine<TI1,TI2,typename TI1::Type> Dune::combine ( const TI1 &  set1,
const TI2 &  set2 
)
inline
template<long m, long n>
static void Dune::Lcm< m, n >::conceptCheck ( )
inlinestatic

References dune_static_assert.

template<class T, int N, class A>
Dune::ConstArrayListIterator< T, N, A >::ConstArrayListIterator ( const ArrayListIterator< T, N, A > &  other)
inline
template<typename TA >
bool Dune::EmptySet< TA >::contains ( const Type attribute)
inlinestatic

Always returns false.

References DUNE_UNUSED_PARAMETER.

template<typename TA >
bool Dune::AllSet< TA >::contains ( const Type attribute)
inlinestatic

Always returns false.

References DUNE_UNUSED_PARAMETER.

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.
template<typename TA , int from, int to>
bool Dune::EnumRange< TA, from, to >::contains ( const Type item)
inlinestatic
template<class TI1 , class TI2 , typename TA >
bool Dune::Combine< TI1, TI2, TA >::contains ( const TA &  item)
inlinestatic
template<class T , int N, class A >
void Dune::ArrayListIterator< T, N, A >::decrement ( )
inline

decrement the iterator.

References position_.

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

decrement the iterator.

References position_.

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!
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.
template<class T , int N, class A >
ArrayListIterator< T, N, A >::reference Dune::ArrayListIterator< T, N, A >::dereference ( ) const
inline

Access the element at the current position.

Returns
The element at the current position.

References position_.

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.
template<class T , int N, class A >
ConstArrayListIterator< T, N, A >::const_reference Dune::ConstArrayListIterator< T, N, A >::dereference ( ) const
inline

Access the element at the current position.

Returns
The element at the current position.

References position_.

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

References position_.

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!

References position_.

template<class A , class B >
enable_if< IsVector< A >::value, typename PromotionTraits< typename A::field_type, typename B::field_type >::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

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::ParameterTree::hasKey(), Dune::ParameterTree::hasSub(), Dune::ParameterTree::operator[](), and Dune::ParameterTree::sub().

template<typename T , class A >
Dune::SLList< T, A >::Element::Element ( const MemberType item,
Element *  next_ = 0 
)
template<typename T , class A >
Dune::SLList< T, A >::Element::Element ( )
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 position_.

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

template<typename T , class A >
bool Dune::SLList< T, A >::empty ( ) const
inline

Check whether the list is empty.

Returns
True if the list is empty;
template<class T , int N, class A >
ArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::end ( )

Get a random access iterator positioned after the last element.

References size_.

template<class T , int N, class A >
ConstArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::end ( ) const

Get a random access iterator positioned after the last element.

References size_.

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(), Dune::operator<<(), Dune::RemoteIndices< T, A >::operator==(), and Dune::IndicesSyncer< T >::sync().

template<typename T , class A >
SLListConstIterator< T, A > Dune::SLList< T, A >::end ( ) const
inline

Get an iterator pointing to the end of the list.

Returns
An iterator pointing to the end.
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.
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.

References position_.

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.

References position_.

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
otherThe other iterator to check.
Returns
true If the other iterator is at the same position.
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
otherThe other iterator to check.
Returns
true If the other iterator is at the same position.
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
otherThe other iterator to check.
Returns
true If the other iterator is at the same position.
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
otherThe other iterator to check.
Returns
true If the other iterator is at the same position.
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.

References position_.

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

References position_.

template<int p>
template<typename T >
static T Dune::Power< p >::eval ( const T &  a)
inlinestatic
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.

References Dune::array< T, N >::fill().

template<typename T1 , typename T2 >
TupleAccessTraits< T1 >::NonConstType Dune::Pair< T1, T2 >::first ( )
inline
template<typename T1 , typename T2 >
TupleAccessTraits< T1 >::ConstType Dune::Pair< T1, T2 >::first ( ) const
inline

Get the first value.

Returns
The first value
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>>().

template<typename T1 >
TupleAccessTraits< T1 >::ConstType Dune::Pair< T1, Nil >::first ( ) const
inline

Get the first value.

Returns
The first value

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

template<class T, int n, int m>
Dune::fmatrix_assigner< T, n, m >::fmatrix_assigner ( fmatrix_assigner< T, n, m > &  a)
inline

Copy Constructor.

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
_Amatrix which should be initialized
tbool indicating, that this is a temporary object (see ~fmatrix_assigner)
template<class T, int s>
Dune::fvector_assigner< T, s >::fvector_assigner ( fvector_assigner< T, s > &  a)
inline

Copy Constructor.

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
_vvector which should be initialized
tbool indicating, that this is a temporary object (see ~fvector_assigner)
std::string Dune::genFilename ( const std::string &  path,
const std::string &  fn,
int  ntime,
int  precision = 6 
)
inline

Generate filenames with timestep number in it.

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
tupleThe 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(), and Dune::get().

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

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
tupleThe tuple whose first element we want.
Returns
The first element of the tuple.

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

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
tupleThe tuple whose first element we want.
Returns
The first element of the tuple.

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

template<int i, typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
TupleAccessTraits<typename tuple_element<i, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::type>::NonConstType Dune::get ( tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > &  t)

References Dune::Element< N >::get(), and t.

template<int i, typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
TupleAccessTraits<typename tuple_element<i, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::type>::ConstType Dune::get ( const tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > &  t)

References Dune::Element< N >::get(), and t.

template<int i>
template<class T >
static std::istream& Dune::tuple_writer< i >::get ( std::istream &  is,
T &  t,
const char *  delim = "," 
)
inlinestatic

References c, Dune::get(), and t.

template<class T >
static std::istream& Dune::tuple_writer< 1 >::get ( std::istream &  is,
T &  t,
const char *  delim = ", " 
)
inlinestatic

References t.

template<class T >
static std::istream& Dune::tuple_writer< 0 >::get ( std::istream &  is,
T &  t,
const char *  delim = ", " 
)
inlinestatic
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().

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

template<class T , int N, class A >
void Dune::ArrayListIterator< T, N, A >::increment ( )
inline

Increment the iterator.

References position_.

template<typename T, class A>
void Dune::SLListIterator< T, A >::increment ( )
inline

Increment function for the iterator facade.

template<class T, class A>
void Dune::SLListConstIterator< T, A >::increment ( )
inline

Increment function for the iterator facade.

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

Increment the iterator.

References position_.

template<typename T, class A>
void Dune::SLListModifyIterator< T, A >::increment ( )
inline

Increment function for the iterator facade.

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

Dune::Indent::Indent ( unsigned  level_)
inline

setup without parent and basic_indentation of two spaces

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.
Dune::Indent::Indent ( const Indent parent_,
unsigned  level_ 
)
inline

setup with parent

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
vThe value to insert.
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
vThe value to insert.
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.
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.
template<class T1 >
tuple<T1> Dune::make_tuple ( const T1 &  t1)
inline
template<class T1 , class T2 >
tuple<T1, T2> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2 
)
inline
template<class T1 , class T2 , class T3 >
tuple<T1, T2, T3> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3 
)
inline
template<class T1 , class T2 , class T3 , class T4 >
tuple<T1, T2, T3, T4> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4 
)
inline
template<class T1 , class T2 , class T3 , class T4 , class T5 >
tuple<T1, T2, T3, T4, T5> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5 
)
inline
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
tuple<T1, T2, T3, T4, T5, T6> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5,
const T6 &  t6 
)
inline
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
tuple<T1, T2, T3, T4, T5, T6, T7> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5,
const T6 &  t6,
const T7 &  t7 
)
inline
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
tuple<T1, T2, T3, T4, T5, T6, T7, T8> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5,
const T6 &  t6,
const T7 &  t7,
const T8 &  t8 
)
inline
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5,
const T6 &  t6,
const T7 &  t7,
const T8 &  t8,
const T9 &  t9 
)
inline
template<typename T1 , typename T2 >
Pair<T1,T2> Dune::makePair ( const T1 &  first,
const T2 &  second 
)
inline

Create a tuple and initialize it.

Parameters
firstThe value of the first field.
secondThe value of the second field.
nextRow::NextRow ( int  )
explicit

Referenced by Zero().

zero::operator double ( )

Conversion operator to double.

zero::operator int ( )

Conversion operator to int.

template<int k>
bool Dune::bigunsignedint< k >::operator!= ( const bigunsignedint< k > &  x) const
inline

not equal

References Dune::bigunsignedint< k >::n.

template<typename T , class A >
bool Dune::SLList< T, A >::operator!= ( const SLList< T, A > &  sl) const
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
tuple1The first tuple.
tuple2The second tuple,

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

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
tuple1The first tuple.
tuple2The second tuple,

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

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
tuple1The first tuple.
tuple2The second tuple.
Returns
True as the type of the compared objects are different.
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
tuple1The first tuple.
tuple2The second tuple.
Returns
True as the type of the compared objects are different.
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
template<int k>
bigunsignedint<k> Dune::operator% ( const bigunsignedint< k > &  x,
std::size_t  y 
)
inline
template<int k>
bigunsignedint<k> Dune::operator% ( std::size_t  x,
const bigunsignedint< k > &  y 
)
inline
template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator& ( const bigunsignedint< k > &  x) const
inline

bitwise and

References Dune::bigunsignedint< k >::n.

template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator* ( const bigunsignedint< k > &  x) const
inline
template<class T >
T & Dune::shared_ptr< T >::operator* ( )
inline

Dereference as object.

template<class T >
const T & Dune::shared_ptr< T >::operator* ( ) const
inline

Dereference as const object.

template<int k>
bigunsignedint<k> Dune::operator* ( const bigunsignedint< k > &  x,
std::size_t  y 
)
inline
template<int k>
bigunsignedint<k> Dune::operator* ( std::size_t  x,
const bigunsignedint< k > &  y 
)
inline
template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator+ ( const bigunsignedint< k > &  x) const
inline
Indent Dune::Indent::operator+ ( const std::string &  newindent) const
inline

create new indentation object with this one as parent

References Dune::Indent::Indent().

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

create a copy of this indetation object with raised level

References Dune::Indent::Indent().

template<int k>
bigunsignedint<k> Dune::operator+ ( const bigunsignedint< k > &  x,
std::size_t  y 
)
inline
template<int k>
bigunsignedint<k> Dune::operator+ ( std::size_t  x,
const bigunsignedint< k > &  y 
)
inline
template<int k>
bigunsignedint< k > & Dune::bigunsignedint< k >::operator++ ( )
inline
Indent& Dune::Indent::operator++ ( )
inline

raise indentation level

template<class T, int s>
fvector_assigner& Dune::fvector_assigner< T, s >::operator, ( const T &  t)
inline

append data to this vector the overloaded comma operator is used to assign a comma separated list of values to the vector

References Dune::fvector_assigner< T, s >::append().

template<class T, int s>
fvector_assigner& Dune::fvector_assigner< T, s >::operator, ( Zero  z)
inline

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.

References Dune::fvector_assigner< T, s >::append().

template<class T, int n, int m>
fmatrix_assigner& Dune::fmatrix_assigner< T, n, m >::operator, ( const T &  t)
inline

append data to this matrix the overloaded comma operator is used to assign a comma separated list of values to the matrix

References Dune::fmatrix_assigner< T, n, m >::append().

template<class T, int n, int m>
fmatrix_assigner& Dune::fmatrix_assigner< T, n, m >::operator, ( Zero  z)
inline

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.

References Dune::fmatrix_assigner< T, n, m >::append().

template<class T, int n, int m>
fmatrix_assigner& Dune::fmatrix_assigner< T, n, m >::operator, ( NextRow  nr)
inline

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.

References Dune::fmatrix_assigner< T, n, m >::append().

template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator- ( const bigunsignedint< k > &  x) const
inline
template<int k>
bigunsignedint<k> Dune::operator- ( const bigunsignedint< k > &  x,
std::size_t  y 
)
inline
template<int k>
bigunsignedint<k> Dune::operator- ( std::size_t  x,
const bigunsignedint< k > &  y 
)
inline
Indent& Dune::Indent::operator-- ( )
inline

lower indentation level

template<class T >
T * Dune::shared_ptr< T >::operator-> ( )
inline

Dereference as pointer.

template<class T >
const T * Dune::shared_ptr< T >::operator-> ( ) const
inline

Dereference as const pointer.

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.

template<int k>
bigunsignedint<k> Dune::operator/ ( const bigunsignedint< k > &  x,
std::size_t  y 
)
inline
template<int k>
bigunsignedint<k> Dune::operator/ ( std::size_t  x,
const bigunsignedint< k > &  y 
)
inline
template<int k>
bool Dune::bigunsignedint< k >::operator< ( const bigunsignedint< k > &  x) const
inline

less than

References Dune::bigunsignedint< k >::n.

template<class T , size_t N>
bool Dune::operator< ( const array< T, N > &  a,
const array< T, N > &  b 
)
inline
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
tuple1The first tuple.
tuple2The second tuple,

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

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

Less operator for tuples.

Parameters
tuple1The first tuple.
tuple2The second tuple,
template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator<< ( int  i) const
inline
std::ostream& Dune::operator<< ( std::ostream &  s,
const Indent &  indent 
)
inline

write indentation to a stream

template<typename TA , int i>
std::ostream& Dune::operator<< ( std::ostream &  os,
const EnumItem< TA, i > &   
)
inline
template<typename TA , int from, int to>
std::ostream& Dune::operator<< ( std::ostream &  os,
const EnumRange< TA, from, to > &   
)
inline
template<class T , size_t N>
std::ostream& Dune::operator<< ( std::ostream &  s,
const array< T, N > &  e 
)
inline

Output operator for array.

template<class TI1 , class TI2 , class T >
std::ostream& Dune::operator<< ( std::ostream &  os,
const Combine< TI1, TI2, T > &   
)
inline
template<int k>
std::ostream& Dune::operator<< ( std::ostream &  s,
const bigunsignedint< k > &  x 
)
inline
template<typename T , typename A >
ostream& std::operator<< ( ostream &  os,
const Dune::SLList< T, A >  sllist 
)
template<typename T1 , typename T2 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const Pair< T1, T2 > &  pair 
)
inline

Print a pair or tuple.

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

template<typename T1 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const Pair< T1, Nil > &  pair 
)
inline
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

References t.

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

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

References t.

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

template<int k>
bool Dune::bigunsignedint< k >::operator<= ( const bigunsignedint< k > &  x) const
inline

less than or equal

References Dune::bigunsignedint< k >::n.

template<class T , size_t N>
bool Dune::operator<= ( const array< T, N > &  a,
const array< T, N > &  b 
)
inline
template<typename T, class A>
SLList< T, A > & Dune::SLList< T, A >::operator= ( const SLList< T, A > &  other)

Assignment operator.

template<class T >
template<class T1 >
shared_ptr< T > & Dune::shared_ptr< T >::operator= ( const shared_ptr< T1 > &  pointer)
inline

Assignment operator.

template<class T >
shared_ptr< T > & Dune::shared_ptr< T >::operator= ( const shared_ptr< T > &  pointer)
inline

Assignment operator.

template<typename T1 , typename T2 >
template<typename U1 , typename U2 >
Pair< T1, T2 > & Dune::Pair< T1, T2 >::operator= ( const Pair< U1, U2 > &  other)
inline
template<typename T1 , typename T2 >
Pair< T1, T2 > & Dune::Pair< T1, T2 >::operator= ( const Pair< T1, TT > &  other)
inline
template<typename T1 >
template<typename T2 >
Pair< T1, Nil > & Dune::Pair< T1, Nil >::operator= ( const Pair< T2, Nil > &  other)

Assignment operator for type conversion.

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

template<typename T1 >
Pair< T1, Nil > & Dune::Pair< T1, Nil >::operator= ( const Pair< T1, Nil > &  other)

Assignment operator.

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

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!

References position_.

template<typename T1 = Nil, typename T2 = Nil, typename T3 = Nil, typename T4 = Nil, typename T5 = Nil, typename T6 = Nil, typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
template<class U1 , class U2 >
tuple& Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::operator= ( const Pair< U1, U2 > &  other)
inline

Assignment operator for implicit type conversion.

Parameters
otherThe tuple to assign.

Reimplemented from Dune::Pair< T1, TT >.

template<class T, int N, class A>
const ConstArrayListIterator< T, N, A > & Dune::ConstArrayListIterator< T, N, A >::operator= ( const ConstArrayListIterator< T, N, A > &  other)
inline

References position_.

template<int k>
bool Dune::bigunsignedint< k >::operator== ( const bigunsignedint< k > &  x) const
inline

equal

template<typename T , class A >
bool Dune::SLList< T, A >::operator== ( const SLList< T, A > &  sl) const
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
tuple1The first tuple.
tuple2The second tuple,

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

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
tuple1The first tuple.
tuple2The second tuple,

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

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
tuple1The first tuple.
tuple2The second tuple.
Returns
False as the type of the compared objects are different.
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
tuple1The first tuple.
tuple2The second tuple.
Returns
False as the type of the compared objects are different.
template<int k>
bool Dune::bigunsignedint< k >::operator> ( const bigunsignedint< k > &  x) const
inline

greater than

template<class T , size_t N>
bool Dune::operator> ( const array< T, N > &  a,
const array< T, N > &  b 
)
inline
template<int k>
bool Dune::bigunsignedint< k >::operator>= ( const bigunsignedint< k > &  x) const
inline

greater or equal

template<class T , size_t N>
bool Dune::operator>= ( const array< T, N > &  a,
const array< T, N > &  b 
)
inline
template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator>> ( int  i) const
inline
template<typename T1 , typename T2 >
std::istream& Dune::operator>> ( std::istream &  is,
Pair< T1, T2 > &  pair 
)
inline

Read a pair or tuple.

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

template<typename T1 >
std::istream& Dune::operator>> ( std::istream &  is,
Pair< T1, Nil > &  pair 
)
inline
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
iThe index of the position.
Returns
The element at that position.
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
iThe index of the position.
Returns
The element at that position.
template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator^ ( const bigunsignedint< k > &  x) const
inline

bitwise exor

References Dune::bigunsignedint< k >::n.

template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator| ( const bigunsignedint< k > &  x) const
inline

bitwise or

References Dune::bigunsignedint< k >::n.

template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator~ ( ) const
inline

bitwise komplement

References Dune::bigunsignedint< k >::n.

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

The number of values we hold.

Constructor

Parameters
t1The value of the first field.
t2The value of the second field.
t3The value of the third field.
t4The value of the 4th field.
t5The value of the 5th field.
t6The value of the 6th field.
t7The value of the 7th field.
t8The value of the 8th field.
t9The value of the 9th field.
template<typename T1 , typename TT >
Dune::Pair< T1, TT >::Pair ( typename TupleAccessTraits< Type1 >::ParameterType  t1,
TT &  t2 
)
inline

Constructor.

Parameters
t1The value of the first field.
t2The value of the second field.
template<typename T1 , typename T2 >
Dune::Pair< T1, T2 >::Pair ( )
inline
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
otherThe tuple to copy.
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
firstThe values for the first field.
template<typename T1 >
Dune::Pair< T1, Nil >::Pair ( typename TupleAccessTraits< T1 >::ParameterType  first,
const Nil  
)
inline

Constructor.

Parameters
firstThe values for the first field.
template<typename T1 >
Dune::Pair< T1, Nil >::Pair ( )
inline
template<typename T1 >
template<typename T2 >
Dune::Pair< T1, Nil >::Pair ( const Pair< T2, Nil > &  other)
inline

Copy constructor for type conversion.

template<typename T , class A >
void Dune::SLList< T, A >::pop_front ( )
inline

Remove the first item in the list.

template<int k>
void Dune::bigunsignedint< k >::print ( std::ostream &  s) const
inline

Print number in hex notation.

References Dune::bigunsignedint< k >::hexdigits, and Dune::bigunsignedint< k >::n.

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.

References size_.

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
itemThe item to add.

References size_.

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

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
entryThe new entry.

References size_.

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
itemThe item to add.

References size_.

template<int i>
template<class T >
static std::ostream& Dune::tuple_writer< i >::put ( std::ostream &  os,
const T &  t,
const char *  delim = ", " 
)
inlinestatic

References Dune::get(), and t.

template<class T >
static std::ostream& Dune::tuple_writer< 1 >::put ( std::ostream &  os,
const T &  t,
const char *  delim = ", " 
)
inlinestatic

References DUNE_UNUSED_PARAMETER, and t.

template<class T >
static std::ostream& Dune::tuple_writer< 0 >::put ( std::ostream &  os,
const T &  t,
const char *  delim = ", " 
)
inlinestatic
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!
template<class T >
void Dune::shared_ptr< T >::reset ( )
inline

Decrease the reference count by one and free the memory if the reference count has reached 0.

template<class T >
template<class T1 >
void Dune::shared_ptr< T >::reset ( T1 *  pointer)
inline

Detach shared pointer and set it anew for the given pointer.

template<class T >
template<class T1 , class Deleter >
void Dune::shared_ptr< T >::reset ( T1 *  pointer,
Deleter  deleter 
)
inline
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().

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==(), and Dune::operator>>().

template<typename T1 , typename T2 >
TupleAccessTraits< T2 >::ConstType Dune::Pair< T1, T2 >::second ( ) const
inline

Get the second value.

Returns
The second value
template<class T >
Dune::shared_ptr< T >::shared_ptr ( nullptr_t  null)
inline
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
pointerRaw 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.

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
DeleterThis class must by copyconstructable, the copy constructor must not throw an exception and it must implement void operator() (T*) const
Parameters
pointerRaw pointer to the shared data
deleterA 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.

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

Copy constructor.

Parameters
pointerThe object to copy.

References Dune::SharedCount::count_.

template<class T >
Dune::shared_ptr< T >::shared_ptr ( const shared_ptr< T > &  pointer)
inline

Copy constructor.

Parameters
pointerThe object to copy.

References Dune::SharedCount::count_.

template<class T , int N, class A >
size_t Dune::ArrayList< T, N, A >::size ( ) const
inline

Get the number of elements in the list.

Returns
The number of elements.

References size_.

template<typename T , class A >
int Dune::SLList< T, A >::size ( ) const
inline

Get the number of elements the list contains.

References size_.

Referenced by Dune::SLList< T, A >::operator!=(), and Dune::SLList< T, A >::operator==().

template<typename T , class A >
Dune::SLList< T, A >::SLList ( )

Constructor.

template<typename T , class A >
template<typename T1 , class A1 >
Dune::SLList< T, A >::SLList ( const SLList< T1, A1 > &  other)

Copy constructor with type conversion.

template<typename T, class A>
Dune::SLList< T, A >::SLList ( const SLList< T, A > &  other)

Copy constructor.

template<class T, class A>
Dune::SLListConstIterator< T, A >::SLListConstIterator ( )
inline
template<class T, class A>
Dune::SLListConstIterator< T, A >::SLListConstIterator ( typename SLList< T, A >::Element item)
inline
template<class T, class A>
Dune::SLListConstIterator< T, A >::SLListConstIterator ( const SLListIterator< T, A > &  other)
inline
template<class T, class A>
Dune::SLListConstIterator< T, A >::SLListConstIterator ( const SLListConstIterator< T, A > &  other)
inline
template<class T, class A>
Dune::SLListConstIterator< T, A >::SLListConstIterator ( const SLListModifyIterator< T, A > &  other)
inline
template<typename T, class A>
Dune::SLListIterator< T, A >::SLListIterator ( typename SLList< T, A >::Element item,
SLList< T, A > *  sllist 
)
inline
template<typename T, class A>
Dune::SLListIterator< T, A >::SLListIterator ( )
inline
template<typename T, class A>
Dune::SLListIterator< T, A >::SLListIterator ( const SLListModifyIterator< T, A > &  other)
inline
template<typename T, class A>
Dune::SLListModifyIterator< T, A >::SLListModifyIterator ( SLListIterator< T, A >  beforeIterator,
SLListIterator< T, A >  _iterator 
)
inline
template<typename T, class A>
Dune::SLListModifyIterator< T, A >::SLListModifyIterator ( const SLListModifyIterator< T, A > &  other)
inline
template<typename T, class A>
Dune::SLListModifyIterator< T, A >::SLListModifyIterator ( )
inline
template<class T >
T Dune::SQR ( t)

Compute the square of T.

*#include <dune/common/misc.hh>
Deprecated:
"Use method sqr from math.hh instead"

References t.

template<class T >
void Dune::shared_ptr< T >::swap ( shared_ptr< T > &  other)
inline

Swap content of this shared_ptr and another.

template<class T1 >
tuple<T1&> Dune::tie ( T1 &  t1)
inline
template<class T1 , class T2 >
tuple<T1&, T2&> Dune::tie ( T1 &  t1,
T2 &  t2 
)
inline
template<class T1 , class T2 , class T3 >
tuple<T1&, T2&, T3&> Dune::tie ( T1 &  t1,
T2 &  t2,
T3 &  t3 
)
inline
template<class T1 , class T2 , class T3 , class T4 >
tuple<T1&, T2&, T3&, T4&> Dune::tie ( T1 &  t1,
T2 &  t2,
T3 &  t3,
T4 &  t4 
)
inline
template<class T1 , class T2 , class T3 , class T4 , class T5 >
tuple<T1&, T2&, T3&, T4&, T5&> Dune::tie ( T1 &  t1,
T2 &  t2,
T3 &  t3,
T4 &  t4,
T5 &  t5 
)
inline
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
tuple<T1&, T2&, T3&, T4&, T5&, T6&> Dune::tie ( T1 &  t1,
T2 &  t2,
T3 &  t3,
T4 &  t4,
T5 &  t5,
T6 &  t6 
)
inline
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> Dune::tie ( T1 &  t1,
T2 &  t2,
T3 &  t3,
T4 &  t4,
T5 &  t5,
T6 &  t6,
T7 &  t7 
)
inline
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&> Dune::tie ( T1 &  t1,
T2 &  t2,
T3 &  t3,
T4 &  t4,
T5 &  t5,
T6 &  t6,
T7 &  t7,
T8 &  t8 
)
inline
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&> Dune::tie ( T1 &  t1,
T2 &  t2,
T3 &  t3,
T4 &  t4,
T5 &  t5,
T6 &  t6,
T7 &  t7,
T8 &  t8,
T9 &  t9 
)
inline
template<int k>
double Dune::bigunsignedint< k >::todouble ( ) const
inline

Convert to a double.

Warning
Subject to rounding errors!

References Dune::bigunsignedint< k >::bits, and Dune::bigunsignedint< k >::n.

template<int k>
unsigned int Dune::bigunsignedint< k >::touint ( ) const
inline

export to other types

References Dune::bigunsignedint< k >::bits.

template<typename T1 = Nil, typename T2 = Nil, typename T3 = Nil, typename T4 = Nil, typename T5 = Nil, typename T6 = Nil, typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple ( )
inline
template<typename T1 = Nil, typename T2 = Nil, typename T3 = Nil, typename T4 = Nil, typename T5 = Nil, typename T6 = Nil, typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple ( typename TupleAccessTraits< T1 >::ParameterType  t1)
inline
template<typename T1 = Nil, typename T2 = Nil, typename T3 = Nil, typename T4 = Nil, typename T5 = Nil, typename T6 = Nil, typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple ( typename TupleAccessTraits< T1 >::ParameterType  t1,
typename TupleAccessTraits< T2 >::ParameterType  t2 
)
inline
template<typename T1 = Nil, typename T2 = Nil, typename T3 = Nil, typename T4 = Nil, typename T5 = Nil, typename T6 = Nil, typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple ( typename TupleAccessTraits< T1 >::ParameterType  t1,
typename TupleAccessTraits< T2 >::ParameterType  t2,
typename TupleAccessTraits< T3 >::ParameterType  t3 
)
inline
template<typename T1 = Nil, typename T2 = Nil, typename T3 = Nil, typename T4 = Nil, typename T5 = Nil, typename T6 = Nil, typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple ( typename TupleAccessTraits< T1 >::ParameterType  t1,
typename TupleAccessTraits< T2 >::ParameterType  t2,
typename TupleAccessTraits< T3 >::ParameterType  t3,
typename TupleAccessTraits< T4 >::ParameterType  t4 
)
inline
template<typename T1 = Nil, typename T2 = Nil, typename T3 = Nil, typename T4 = Nil, typename T5 = Nil, typename T6 = Nil, typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple ( typename TupleAccessTraits< T1 >::ParameterType  t1,
typename TupleAccessTraits< T2 >::ParameterType  t2,
typename TupleAccessTraits< T3 >::ParameterType  t3,
typename TupleAccessTraits< T4 >::ParameterType  t4,
typename TupleAccessTraits< T5 >::ParameterType  t5 
)
inline
template<typename T1 = Nil, typename T2 = Nil, typename T3 = Nil, typename T4 = Nil, typename T5 = Nil, typename T6 = Nil, typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple ( typename TupleAccessTraits< T1 >::ParameterType  t1,
typename TupleAccessTraits< T2 >::ParameterType  t2,
typename TupleAccessTraits< T3 >::ParameterType  t3,
typename TupleAccessTraits< T4 >::ParameterType  t4,
typename TupleAccessTraits< T5 >::ParameterType  t5,
typename TupleAccessTraits< T6 >::ParameterType  t6 
)
inline
template<typename T1 = Nil, typename T2 = Nil, typename T3 = Nil, typename T4 = Nil, typename T5 = Nil, typename T6 = Nil, typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple ( typename TupleAccessTraits< T1 >::ParameterType  t1,
typename TupleAccessTraits< T2 >::ParameterType  t2,
typename TupleAccessTraits< T3 >::ParameterType  t3,
typename TupleAccessTraits< T4 >::ParameterType  t4,
typename TupleAccessTraits< T5 >::ParameterType  t5,
typename TupleAccessTraits< T6 >::ParameterType  t6,
typename TupleAccessTraits< T7 >::ParameterType  t7 
)
inline
template<typename T1 = Nil, typename T2 = Nil, typename T3 = Nil, typename T4 = Nil, typename T5 = Nil, typename T6 = Nil, typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple ( typename TupleAccessTraits< T1 >::ParameterType  t1,
typename TupleAccessTraits< T2 >::ParameterType  t2,
typename TupleAccessTraits< T3 >::ParameterType  t3,
typename TupleAccessTraits< T4 >::ParameterType  t4,
typename TupleAccessTraits< T5 >::ParameterType  t5,
typename TupleAccessTraits< T6 >::ParameterType  t6,
typename TupleAccessTraits< T7 >::ParameterType  t7,
typename TupleAccessTraits< T8 >::ParameterType  t8 
)
inline
template<typename T1 = Nil, typename T2 = Nil, typename T3 = Nil, typename T4 = Nil, typename T5 = Nil, typename T6 = Nil, typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::tuple ( typename TupleAccessTraits< T1 >::ParameterType  t1,
typename TupleAccessTraits< T2 >::ParameterType  t2,
typename TupleAccessTraits< T3 >::ParameterType  t3,
typename TupleAccessTraits< T4 >::ParameterType  t4,
typename TupleAccessTraits< T5 >::ParameterType  t5,
typename TupleAccessTraits< T6 >::ParameterType  t6,
typename TupleAccessTraits< T7 >::ParameterType  t7,
typename TupleAccessTraits< T8 >::ParameterType  t8,
typename TupleAccessTraits< T9 >::ParameterType  t9 
)
inline
template<class T >
int Dune::shared_ptr< T >::use_count ( ) const
inline

The number of shared_ptrs pointing to the object we point to.

zero::Zero ( int  )
explicit

References NextRow().

template<typename T , class A >
Dune::SLList< T, A >::Element::~Element ( )
template<class T, int n, int m>
Dune::fmatrix_assigner< T, n, m >::~fmatrix_assigner ( )
inline

Destructor checks for complete initialization of the matrix. The check is skipped, if this object is marked temporary.

References DUNE_THROW.

template<class T, int s>
Dune::fvector_assigner< T, s >::~fvector_assigner ( )
inline

Destructor checks for complete initialization of the vector. The check is skipped, if this object is marked temporary.

References DUNE_THROW.

Dune::ios_base_all_saver::~ios_base_all_saver ( )

Destructor that restores the flags stored by the constructor.

References Dune::ios_base_all_saver::restore().

template<class T >
Dune::shared_ptr< T >::~shared_ptr ( )
inline

Destructor.

template<typename T , class A >
Dune::SLList< T, A >::~SLList ( )

Destructor.

Deallocates all elements in the list.

Variable Documentation

template<typename T1, typename TT>
Type1 Dune::Pair< T1, TT >::first_
template<typename T1 >
Type1 Dune::Pair< T1, Nil >::first_

The value of the first field.

template<typename T, class A = std::allocator<T>>
MemberType Dune::SLList< T, A >::Element::item_

The element we hold.

template<typename T, class A = std::allocator<T>>
Element* Dune::SLList< T, A >::Element::next_

The next element in the list.

template<typename T1, typename TT>
Type2 Dune::Pair< T1, TT >::second_

The value of the second field.

Referenced by Dune::Pair< T1, TT >::operator=().

template<long m, long n>
const long Dune::Lcm< m, n >::value = (m/Gcd<m,n>::value)*n
static

The least common multiple of the template parameters m and n.

Friends

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

write indentation to a stream

template<class T>
Dune::shared_ptr< T >::shared_ptr
friend
template<typename T, class A>
friend class SLList< T, A >
friend
template<class T, class A>
friend class SLList< T, A >
friend
template<typename T, class A = std::allocator<T>>
friend class SLListConstIterator< T, A >
friend
template<typename T, class A>
friend class SLListConstIterator< T, A >
friend
template<typename T, class A>
friend class SLListConstIterator< T, A >
friend
template<typename T, class A = std::allocator<T>>
friend class SLListIterator< T, A >
friend
template<class T, class A>
friend class SLListIterator< T, A >
friend
template<typename T, class A>
friend class SLListIterator< T, A >
friend
template<typename T, class A>
friend class SLListModifyIterator< T, A >
friend