dune-common  2.4.1
Modules | Files | 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.
 
 Debug output
 
 Dense Matrix and Vector Template Library
 Type traits to retrieve the field and the real type of classes.
 
 Exception handling
 
 Iterator facades
 Iterator facades for writing stl conformant iterators.
 
 Parallel Communication
 Abstractions for paralle computing.
 
 FloatCmp
 
 Filesystem Paths
 

Files

file  alignment.hh
 This file implements a template class to determine alignment requirements of types at compile time.
 
file  function.hh
 Simple base class templates for functions.
 
file  gcd.hh
 Statically compute the greatest common divisor of two integers.
 
file  indent.hh
 Utility class for handling nested indentation in output.
 
file  ios_state.hh
 Utility class for storing and resetting stream attributes.
 
file  lcm.hh
 Statically compute the least common multiple of two integers.
 
file  sllist.hh
 Implements a singly linked list together with the necessary iterators.
 
file  timer.hh
 A simple timing class.
 
file  tuples.hh
 Fallback implementation of the std::tuple class.
 

Classes

struct  Dune::AlignmentOf< T >
 Calculates the alignment requirement of a type. More...
 
class  Dune::ArrayList< T, N, A >
 A dynamically growing random access list. More...
 
class  Dune::ArrayListIterator< T, N, A >
 A random access iterator for the Dune::ArrayList class. More...
 
class  Dune::ConstArrayListIterator< T, N, A >
 A constant random access iterator for the Dune::ArrayList class. More...
 
struct  Dune::MPITraits< T >
 A traits class describing the mapping of types onto MPI_Datatypes. More...
 
class  Dune::bigunsignedint< k >
 Portable very large unsigned integers. More...
 
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...
 
struct  Dune::Function< Domain, Range >::Traits
 Traits class containing raw types. More...
 
class  Dune::VirtualFunction< DomainType, RangeType >
 Virtual base class template for function classes. More...
 
struct  Dune::Gcd< a, b >
 Calculator of the greatest common divisor. More...
 
class  Dune::Indent
 Utility class for handling nested indentation in output. More...
 
class  Dune::ios_base_all_saver
 Utility class for storing and resetting stream attributes. More...
 
struct  Dune::Lcm< m, n >
 Calculate the least common multiple of two numbers. More...
 
class  Dune::ParameterTree
 Hierarchical structure of string parameters. More...
 
class  Dune::ParameterTreeParser
 Parsers to set up a ParameterTree from various input sources. More...
 
struct  Dune::StaticPower< m, p >
 Calculates m^p at compile time. More...
 
struct  Dune::StaticPower< m, 0 >
 end of recursion via specialization More...
 
struct  Dune::Power< p >
 Compute power for a run-time mantissa and a compile-time integer exponent. More...
 
class  Dune::SLListIterator< T, A >
 A mutable iterator for the SLList. More...
 
class  Dune::SLListConstIterator< T, A >
 A constant iterator for the SLList. More...
 
class  Dune::SLListModifyIterator< T, A >
 A mutable iterator for the SLList. More...
 
class  Dune::SLList< T, A >
 A single linked list. More...
 
class  Dune::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::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 >
 
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::EnableIfInterOperable< T1, T2, Type >
 Enable typedef if two types are interoperable. 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...
 
struct  Dune::AlwaysFalse< T >
 template which always yields a false value More...
 
struct  Dune::AlwaysTrue< T >
 template which always yields a true value More...
 
struct  Dune::is_indexable< T, I >
 

Macros

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

Typedefs

typedef std::ios_base Dune::ios_base_all_saver::state_type
 Export type of object we save the state for. More...
 
typedef A::size_type Dune::SLList< T, A >::size_type
 The size type. More...
 
typedef T Dune::SLList< T, A >::MemberType
 The type we store. More...
 
typedef A::template rebind
< Element >::other 
Dune::SLList< T, A >::Allocator
 The allocator to use. More...
 
typedef SLListIterator< T, A > Dune::SLList< T, A >::iterator
 The mutable iterator of the list. More...
 
typedef SLListConstIterator< T, A > Dune::SLList< T, A >::const_iterator
 The constant iterator of the list. More...
 
typedef SLListModifyIterator
< T, A > 
Dune::SLList< T, A >::ModifyIterator
 The type of the iterator capable of deletion and insertion. More...
 
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
 

Enumerations

enum  { Dune::AlignmentHelper< T, N >::N2 = sizeof(AlignmentStruct<T>) - sizeof(T) - N }
 
enum  {
  Dune::AlignmentTester< T, N >::a1 = ALIGNMENT_MODULO(N , sizeof(T)), Dune::AlignmentTester< T, N >::a2 = ALIGNMENT_MODULO(h::N2 , sizeof(T)), Dune::AlignmentTester< T, N >::a3 = ALIGNMENT_MODULO(sizeof(h), sizeof(T)), Dune::AlignmentTester< T, N >::a = sizeof(h) == sizeof(s) ? ALIGNMENT_MIN(a1, a2) : a3,
  Dune::AlignmentTester< T, N >::result = ALIGNMENT_MIN(a, next::result)
}
 
enum  { Dune::AlignmentTester< T, 0 >::result = ALIGNMENT_MODULO(sizeof(AlignmentStruct<T>), sizeof(T)) }
 
enum  { Dune::AlignmentOf< T >::value = std::alignment_of<T>::value }
 
enum  { Dune::ArrayList< T, N, A >::chunkSize_ = (N > 0) ? N : 1 }
 
enum  { Dune::ArrayListIterator< T, N, A >::chunkSize_ = (N > 0) ? N : 1 }
 
enum  { Dune::ConstArrayListIterator< T, N, A >::chunkSize_ = (N > 0) ? N : 1 }
 
enum  {
  Dune::bigunsignedint< k >::bits =std::numeric_limits<std::uint16_t>::digits, Dune::bigunsignedint< k >::n =k/bits+(kbits!=0), Dune::bigunsignedint< k >::hexdigits =4, Dune::bigunsignedint< k >::bitmask =0xFFFF,
  Dune::bigunsignedint< k >::compbitmask =0xFFFF0000, Dune::bigunsignedint< k >::overflowmask =0x1
}
 
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::TypeTraits< T >::PointerTraits< U >::result = false }
 
enum  { Dune::TypeTraits< T >::PointerTraits< U * >::result = true }
 
enum  { Dune::TypeTraits< T >::ReferenceTraits< U >::result = false }
 
enum  { Dune::TypeTraits< T >::ReferenceTraits< U & >::result = true }
 
enum  { Dune::TypeTraits< T >::isPointer = PointerTraits<T>::result }
 
enum  { Dune::TypeTraits< T >::isReference = ReferenceTraits<T>::result }
 
enum  { Dune::ConstantVolatileTraits< T >::isVolatile =false, Dune::ConstantVolatileTraits< T >::isConst =false }
 
enum  { Dune::ConstantVolatileTraits< const T >::isVolatile =false, Dune::ConstantVolatileTraits< const T >::isConst =true }
 
enum  { Dune::ConstantVolatileTraits< volatile T >::isVolatile =true, Dune::ConstantVolatileTraits< volatile T >::isConst =false }
 
enum  { Dune::ConstantVolatileTraits< const volatile T >::isVolatile =true, Dune::ConstantVolatileTraits< const volatile T >::isConst =true }
 
enum  { Dune::IsVolatile< T >::value =ConstantVolatileTraits<T>::isVolatile }
 
enum  { Dune::IsConst< T >::value =ConstantVolatileTraits<T>::isConst }
 
enum  { Dune::Conversion< From, To >::exists = sizeof(test(makeFrom())) == sizeof(Small), Dune::Conversion< From, To >::isTwoWay = exists && Conversion<To,From>::exists, Dune::Conversion< From, To >::sameType = false }
 
enum  { Dune::Conversion< From, void >::exists = false, Dune::Conversion< From, void >::isTwoWay = false, Dune::Conversion< From, void >::sameType = false }
 
enum  { Dune::Conversion< void, To >::exists = false, Dune::Conversion< void, To >::isTwoWay = false, Dune::Conversion< void, To >::sameType = false }
 
enum  { Dune::Conversion< int, double >::exists = true, Dune::Conversion< int, double >::isTwoWay = false, Dune::Conversion< int, double >::sameType = false }
 
enum  { Dune::Conversion< T, T >::exists =true, Dune::Conversion< T, T >::isTwoWay =true, Dune::Conversion< T, T >::sameType =true }
 
enum  { Dune::IsBaseOf< Base, Derived >::value = sizeof(test(makePtr())) == sizeof(Small) }
 
enum  { Dune::IsInteroperable< T1, T2 >::value = Conversion<T1,T2>::exists || Conversion<T2,T1>::exists }
 

Functions

template<class T , size_t N>
std::ostream & Dune::operator<< (std::ostream &s, const array< T, N > &e)
 Output operator for array. More...
 
template<class T >
array< T, 10 > Dune::make_array (const T &t0, const T &t1, const T &t2, const T &t3, const T &t4, const T &t5, const T &t6, const T &t7, const T &t8, const T &t9)
 create an initialize an array More...
 
template<typename T , std::size_t n>
array< T, n > Dune::fill_array (const T &t)
 Create an array and fill it with copies of the provided value. More...
 
template<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::uintmax_t y)
 
template<int k>
bigunsignedint< k > Dune::operator- (const bigunsignedint< k > &x, std::uintmax_t y)
 
template<int k>
bigunsignedint< k > Dune::operator* (const bigunsignedint< k > &x, std::uintmax_t y)
 
template<int k>
bigunsignedint< k > Dune::operator/ (const bigunsignedint< k > &x, std::uintmax_t y)
 
template<int k>
bigunsignedint< k > Dune::operator% (const bigunsignedint< k > &x, std::uintmax_t y)
 
template<int k>
bigunsignedint< k > Dune::operator+ (std::uintmax_t x, const bigunsignedint< k > &y)
 
template<int k>
bigunsignedint< k > Dune::operator- (std::uintmax_t x, const bigunsignedint< k > &y)
 
template<int k>
bigunsignedint< k > Dune::operator* (std::uintmax_t x, const bigunsignedint< k > &y)
 
template<int k>
bigunsignedint< k > Dune::operator/ (std::uintmax_t x, const bigunsignedint< k > &y)
 
template<int k>
bigunsignedint< k > Dune::operator% (std::uintmax_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 More...
 
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. More...
 
 operator int ()
 Conversion operator to int. More...
 
 NextRow (int)
 
 Dune::fvector_assigner< T, s >::fvector_assigner (fvector_assigner &a)
 Copy Constructor. More...
 
 Dune::fvector_assigner< T, s >::fvector_assigner (FieldVector< T, s > &_v, bool t)
 Constructor from vector and temporary flag. More...
 
 Dune::fvector_assigner< T, s >::~fvector_assigner ()
 Destructor checks for complete initialization of the vector. The check is skipped, if this object is marked temporary. More...
 
fvector_assigner & Dune::fvector_assigner< T, s >::append (const T &t)
 append data to this vector More...
 
fvector_assigner & Dune::fvector_assigner< T, s >::append (Zero z)
 append zeros to this vector More...
 
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 More...
 
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. More...
 
template<class T , class K , int s>
fvector_assigner< T, s > Dune::operator<<= (FieldVector< T, s > &v, const K &t)
 fvector assignment operator More...
 
template<class T , int s>
fvector_assigner< T, s > Dune::operator<<= (FieldVector< T, s > &v, Zero z)
 fvector assignment operator More...
 
 Dune::fmatrix_assigner< T, n, m >::fmatrix_assigner (fmatrix_assigner &a)
 Copy Constructor. More...
 
 Dune::fmatrix_assigner< T, n, m >::fmatrix_assigner (FieldMatrix< T, n, m > &_A, bool t)
 Constructor from matrix and temporary flag. More...
 
 Dune::fmatrix_assigner< T, n, m >::~fmatrix_assigner ()
 Destructor checks for complete initialization of the matrix. The check is skipped, if this object is marked temporary. More...
 
fmatrix_assigner & Dune::fmatrix_assigner< T, n, m >::append (const T &t)
 append data to this matrix More...
 
fmatrix_assigner & Dune::fmatrix_assigner< T, n, m >::append (Zero z)
 append zeros to this matrix More...
 
fmatrix_assigner & Dune::fmatrix_assigner< T, n, m >::append (NextRow nr)
 move to next row of the matrix More...
 
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 More...
 
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. More...
 
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. More...
 
template<class T , class K , int n, int m>
fmatrix_assigner< T, n, m > Dune::operator<<= (FieldMatrix< T, n, m > &v, const K &t)
 FieldMatrix assignment operator. More...
 
template<class T , int n, int m>
fmatrix_assigner< T, n, m > Dune::operator<<= (FieldMatrix< T, n, m > &v, Zero z)
 FieldMatrix assignment operator. More...
 
 Dune::Indent::Indent (const std::string &basic_indent_=" ", unsigned level_=0)
 setup without parent More...
 
 Dune::Indent::Indent (unsigned level_)
 setup without parent and basic_indentation of two spaces More...
 
 Dune::Indent::Indent (const Indent *parent_, const std::string &basic_indent_=" ", unsigned level_=1)
 setup with parent More...
 
 Dune::Indent::Indent (const Indent *parent_, unsigned level_)
 setup with parent More...
 
Indent Dune::Indent::operator+ (const std::string &newindent) const
 create new indentation object with this one as parent More...
 
Indent Dune::Indent::operator+ (unsigned morelevel) const
 create a copy of this indetation object with raised level More...
 
Indent & Dune::Indent::operator++ ()
 raise indentation level More...
 
Indent & Dune::Indent::operator-- ()
 lower indentation level More...
 
std::ostream & Dune::operator<< (std::ostream &s, const Indent &indent)
 write indentation to a stream More...
 
 Dune::ios_base_all_saver::ios_base_all_saver (state_type &ios_)
 Constructor that stores the currently used flags. More...
 
 Dune::ios_base_all_saver::~ios_base_all_saver ()
 Destructor that restores the flags stored by the constructor. More...
 
void Dune::ios_base_all_saver::restore ()
 Restore flags now. More...
 
static void Dune::Lcm< m, n >::conceptCheck ()
 
template<typename T >
static T Dune::Power< p >::eval (const T &a)
 
 Dune::SLList< T, A >::SLList ()
 Constructor. More...
 
template<typename T1 , typename A1 >
 Dune::SLList< T, A >::SLList (const SLList< T1, A1 > &other)
 Copy constructor with type conversion. More...
 
 Dune::SLList< T, A >::SLList (const SLList< T, A > &other)
 Copy constructor. More...
 
 Dune::SLList< T, A >::~SLList ()
 Destructor. More...
 
SLList< T, A > & Dune::SLList< T, A >::operator= (const SLList< T, A > &other)
 Assignment operator. More...
 
void Dune::SLList< T, A >::push_back (const MemberType &item)
 Add a new entry to the end of the list. More...
 
void Dune::SLList< T, A >::push_front (const MemberType &item)
 Add a new entry to the beginning of the list. More...
 
void Dune::SLList< T, A >::pop_front ()
 Remove the first item in the list. More...
 
void Dune::SLList< T, A >::clear ()
 Remove all elements from the list. More...
 
iterator Dune::SLList< T, A >::begin ()
 Get an iterator pointing to the first element in the list. More...
 
const_iterator Dune::SLList< T, A >::begin () const
 Get an iterator pointing to the first element in the list. More...
 
ModifyIterator Dune::SLList< T, A >::beginModify ()
 Get an iterator capable of deleting and inserting elements. More...
 
ModifyIterator Dune::SLList< T, A >::endModify ()
 Get an iterator capable of deleting and inserting elements. More...
 
iterator Dune::SLList< T, A >::end ()
 Get an iterator pointing to the end of the list. More...
 
const_iterator Dune::SLList< T, A >::end () const
 Get an iterator pointing to the end of the list. More...
 
bool Dune::SLList< T, A >::empty () const
 Check whether the list is empty. More...
 
int Dune::SLList< T, A >::size () const
 Get the number of elements the list contains. More...
 
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. More...
 
bool Dune::SLListIterator< T, A >::equals (const SLListConstIterator< T, A > &other) const
 Equality test for the iterator facade. More...
 
bool Dune::SLListIterator< T, A >::equals (const SLListIterator< T, A > &other) const
 Equality test for the iterator facade. More...
 
bool Dune::SLListIterator< T, A >::equals (const SLListModifyIterator< T, A > &other) const
 Equality test for the iterator facade. More...
 
void Dune::SLListIterator< T, A >::increment ()
 Increment function for the iterator facade. More...
 
void Dune::SLListIterator< T, A >::insertAfter (const T &v) const
 Insert an element in the underlying list after the current position. More...
 
void Dune::SLListIterator< T, A >::deleteNext () const
 Delete the entry after the current position. More...
 
 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. More...
 
bool Dune::SLListConstIterator< T, A >::equals (const SLListConstIterator< T, A > &other) const
 Equality test for the iterator facade. More...
 
void Dune::SLListConstIterator< T, A >::increment ()
 Increment function for the iterator facade. More...
 
 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. More...
 
bool Dune::SLListModifyIterator< T, A >::equals (const SLListConstIterator< T, A > &other) const
 Test whether another iterator is equal. More...
 
bool Dune::SLListModifyIterator< T, A >::equals (const SLListIterator< T, A > &other) const
 Test whether another iterator is equal. More...
 
bool Dune::SLListModifyIterator< T, A >::equals (const SLListModifyIterator< T, A > &other) const
 Test whether another iterator is equal. More...
 
void Dune::SLListModifyIterator< T, A >::increment ()
 Increment function for the iterator facade. More...
 
void Dune::SLListModifyIterator< T, A >::insert (const T &v)
 Insert an element at the current position. More...
 
void Dune::SLListModifyIterator< T, A >::remove ()
 Delete the entry at the current position. More...
 
template<typename 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. More...
 
template<typename C >
bool Dune::hasSuffix (const C &c, const char *suffix)
 Check whether a character container has a given suffix. More...
 
template<class... T>
static std::string Dune::formatString (const std::string &s, const T &...args)
 Format values according to printf format string. More...
 
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 >
std::ostream & Dune::operator<< (std::ostream &os, const tuple< T1 > &t)
 Print a tuple. More...
 
template<typename T1 , typename T2 >
std::ostream & Dune::operator<< (std::ostream &os, const tuple< T1, T2 > &t)
 
template<typename T1 , typename T2 , typename T3 >
std::ostream & Dune::operator<< (std::ostream &os, const tuple< T1, T2, T3 > &t)
 
template<typename T1 , typename T2 , typename T3 , typename T4 >
std::ostream & Dune::operator<< (std::ostream &os, const tuple< T1, T2, T3, T4 > &t)
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
std::ostream & Dune::operator<< (std::ostream &os, const tuple< T1, T2, T3, T4, T5 > &t)
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
std::ostream & Dune::operator<< (std::ostream &os, const tuple< T1, T2, T3, T4, T5, T6 > &t)
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
std::ostream & Dune::operator<< (std::ostream &os, const tuple< T1, T2, T3, T4, T5, T6, T7 > &t)
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
std::ostream & Dune::operator<< (std::ostream &os, const tuple< T1, T2, T3, T4, T5, T6, T7, T8 > &t)
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
std::ostream & Dune::operator<< (std::ostream &os, const tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > &t)
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
std::ostream & Dune::operator<< (std::ostream &os, const tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 > &t)
 
template<typename T1 >
std::istream & Dune::operator>> (std::istream &is, tuple< T1 > &t)
 Read a tuple. More...
 
template<typename T1 , typename T2 >
std::istream & Dune::operator>> (std::istream &is, tuple< T1, T2 > &t)
 
template<typename T1 , typename T2 , typename T3 >
std::istream & Dune::operator>> (std::istream &is, tuple< T1, T2, T3 > &t)
 
template<typename T1 , typename T2 , typename T3 , typename T4 >
std::istream & Dune::operator>> (std::istream &is, tuple< T1, T2, T3, T4 > &t)
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
std::istream & Dune::operator>> (std::istream &is, tuple< T1, T2, T3, T4, T5 > &t)
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
std::istream & Dune::operator>> (std::istream &is, tuple< T1, T2, T3, T4, T5, T6 > &t)
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
std::istream & Dune::operator>> (std::istream &is, tuple< T1, T2, T3, T4, T5, T6, T7 > &t)
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
std::istream & Dune::operator>> (std::istream &is, tuple< T1, T2, T3, T4, T5, T6, T7, T8 > &t)
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
std::istream & Dune::operator>> (std::istream &is, tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > &t)
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
std::istream & Dune::operator>> (std::istream &is, tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 > &t)
 
 Dune::ArrayList< T, N, A >::ArrayList ()
 Constructs an Array list with one chunk. More...
 
void Dune::ArrayList< T, N, A >::clear ()
 Delete all entries from the list. More...
 
size_type Dune::ArrayList< T, N, A >::size () const
 Get the number of elements in the list. More...
 
void Dune::ArrayList< T, N, A >::push_back (const_reference entry)
 Append an entry to the list. More...
 
reference Dune::ArrayList< T, N, A >::operator[] (size_type i)
 Get the element at specific position. More...
 
const_reference Dune::ArrayList< T, N, A >::operator[] (size_type i) const
 Get the element at specific position. More...
 
iterator Dune::ArrayList< T, N, A >::begin ()
 Get an iterator that is positioned at the first element. More...
 
const_iterator Dune::ArrayList< T, N, A >::begin () const
 Get a random access iterator that is positioned at the first element. More...
 
iterator Dune::ArrayList< T, N, A >::end ()
 Get a random access iterator positioned after the last element. More...
 
const_iterator Dune::ArrayList< T, N, A >::end () const
 Get a random access iterator positioned after the last element. More...
 
void Dune::ArrayList< T, N, A >::purge ()
 Purge the list. More...
 
void Dune::ArrayListIterator< T, N, A >::advance (difference_type n)
 
void Dune::ConstArrayListIterator< T, N, A >::advance (difference_type n)
 
bool Dune::ArrayListIterator< T, N, A >::equals (const ArrayListIterator< MemberType, N, A > &other) const
 Comares two iterators. More...
 
bool Dune::ArrayListIterator< T, N, A >::equals (const ConstArrayListIterator< MemberType, N, A > &other) const
 Comares two iterators. More...
 
bool Dune::ConstArrayListIterator< T, N, A >::equals (const ConstArrayListIterator< MemberType, N, A > &other) const
 Comares to iterators. More...
 
void Dune::ArrayListIterator< T, N, A >::increment ()
 Increment the iterator. More...
 
void Dune::ConstArrayListIterator< T, N, A >::increment ()
 Increment the iterator. More...
 
void Dune::ArrayListIterator< T, N, A >::decrement ()
 decrement the iterator. More...
 
void Dune::ConstArrayListIterator< T, N, A >::decrement ()
 decrement the iterator. More...
 
reference Dune::ArrayListIterator< T, N, A >::elementAt (size_type i) const
 Get the value of the list at an arbitrary position. More...
 
const_reference Dune::ConstArrayListIterator< T, N, A >::elementAt (size_type i) const
 Get the value of the list at an arbitrary position. More...
 
reference Dune::ArrayListIterator< T, N, A >::dereference () const
 Access the element at the current position. More...
 
const_reference Dune::ConstArrayListIterator< T, N, A >::dereference () const
 Access the element at the current position. More...
 
difference_type Dune::ArrayListIterator< T, N, A >::distanceTo (const ArrayListIterator< T, N, A > &other) const
 
difference_type Dune::ConstArrayListIterator< T, N, A >::distanceTo (const ConstArrayListIterator< T, N, A > &other) const
 
ArrayListIterator< T, N, A > & Dune::ArrayListIterator< T, N, A >::operator= (const ArrayListIterator< T, N, A > &other)
 
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. More...
 
 Dune::ConstArrayListIterator< T, N, A >::ConstArrayListIterator (const ArrayListIterator< T, N, A > &other)
 
 Dune::bigunsignedint< k >::bigunsignedint ()
 Construct uninitialized. More...
 
template<typename Signed >
 Dune::bigunsignedint< k >::bigunsignedint (Signed x, typename std::enable_if< std::is_integral< Signed >::value &&std::is_signed< Signed >::value >::type *=0)
 Construct from signed int. More...
 
 Dune::bigunsignedint< k >::bigunsignedint (std::uintmax_t x)
 Construct from unsigned int. More...
 
std::uint_least32_t Dune::bigunsignedint< k >::touint () const
 export to other types More...
 
double Dune::bigunsignedint< k >::todouble () const
 Convert to a double. More...
 
void Dune::bigunsignedint< k >::print (std::ostream &s) const
 Print number in hex notation. More...
 
bigunsignedint< k > Dune::bigunsignedint< k >::operator+ (const bigunsignedint< k > &x) const
 add More...
 
bigunsignedint< k > Dune::bigunsignedint< k >::operator- (const bigunsignedint< k > &x) const
 subtract More...
 
bigunsignedint< k > Dune::bigunsignedint< k >::operator* (const bigunsignedint< k > &x) const
 multiply More...
 
bigunsignedint< k > & Dune::bigunsignedint< k >::operator++ ()
 prefix increment More...
 
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 More...
 
bigunsignedint< k > Dune::bigunsignedint< k >::operator^ (const bigunsignedint< k > &x) const
 bitwise exor More...
 
bigunsignedint< k > Dune::bigunsignedint< k >::operator| (const bigunsignedint< k > &x) const
 bitwise or More...
 
bigunsignedint< k > Dune::bigunsignedint< k >::operator~ () const
 bitwise komplement More...
 
bigunsignedint< k > Dune::bigunsignedint< k >::operator<< (int i) const
 left shift1/ More...
 
bigunsignedint< k > Dune::bigunsignedint< k >::operator>> (int i) const
 right shift More...
 
bool Dune::bigunsignedint< k >::operator!= (const bigunsignedint< k > &x) const
 not equal More...
 
bool Dune::bigunsignedint< k >::operator== (const bigunsignedint< k > &x) const
 equal More...
 
bool Dune::bigunsignedint< k >::operator< (const bigunsignedint< k > &x) const
 less than More...
 
bool Dune::bigunsignedint< k >::operator<= (const bigunsignedint< k > &x) const
 less than or equal More...
 
bool Dune::bigunsignedint< k >::operator> (const bigunsignedint< k > &x) const
 greater than More...
 
bool Dune::bigunsignedint< k >::operator>= (const bigunsignedint< k > &x) const
 greater or equal More...
 
static bool Dune::EmptySet< TA >::contains (const Type &attribute)
 Always returns false. More...
 
static bool Dune::AllSet< TA >::contains (const Type &attribute)
 Always returns false. More...
 
static bool Dune::EnumItem< TA, item >::contains (const Type &attribute)
 Tests whether an item is in the set. More...
 
static bool Dune::EnumRange< TA, from, end >::contains (const Type &item)
 
static bool Dune::Combine< TI1, TI2, TA >::contains (const TA &item)
 

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. More...
 
Element * Dune::SLList< T, A >::Element::next_
 The next element in the list. More...
 
MemberType Dune::SLList< T, A >::Element::item_
 The element we hold. More...
 

Friends

std::ostream & Dune::Indent::operator<< (std::ostream &s, const Indent &indent)
 write indentation to a stream More...
 

Detailed Description

Macro Definition Documentation

#define DUNE_DEPRECATED

Mark some entity as deprecated.

1 #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
    1 class DUNE_DEPRECATED Class {}; // 1)
    2 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
    1 template<class T>
    2 class DUNE_DEPRECATED Class {}; // 1)
    3 template<class T>
    4 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
    1 template<typename T> struct Class {
    2 static const int c0 DUNE_DEPRECATED = 0;
    3 static const int DUNE_DEPRECATED c1 = 1;
    4 };
    Works with g++-4.1, g++ >=4.3 and clang++3.1. No warning but clean compile with clang++-1.1.
  • Member enumerators
    1 template<typename T> struct Class {
    2 enum enumeration { enumerator = 0 };
    3 };
    No form of deprecation is known that does not trigger an error on most compilers.
  • Member functions
    1 template<typename T> struct Class {
    2 void frob() DUNE_DEPRECATED {}
    3 }; // 1)
    4 template<typename T> struct Class {
    5 void DUNE_DEPRECATED frob() {}
    6 }; // 2)
    7 template<typename T> struct Class {
    8 DUNE_DEPRECATED void frob() {}
    9 }; // 3)
    With g++ only 2) emits a warning for templated member functions.
#define DUNE_DEPRECATED_MSG (   text)    DUNE_DEPRECATED

Mark some entity as deprecated.

1 #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
    1 class DUNE_DEPRECATED_MSG("In the future, please use 'Glass'") Class {}; // 1)
    2 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
    1 template<class T>
    2 class DUNE_DEPRECATED_MSG("In the future, please use 'Glass'") Class {}; // 1)
    3 template<class T>
    4 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
    1 template<typename T> struct Class {
    2 static const int c0 DUNE_DEPRECATED_MSG("c2 is the new hype") = 0;
    3 static const int DUNE_DEPRECATED_MSG("c2 is the new hype") c1 = 1;
    4 };
    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
    1 template<typename T> struct Class {
    2 enum enumeration { enumerator = 0 };
    3 };
    No form of deprecation is known that does not trigger an error on most compilers.
  • Member functions
    1 template<typename T> struct Class {
    2 void frob() DUNE_DEPRECATED_MSG("use frog") {}
    3 }; // 1)
    4 template<typename T> struct Class {
    5 void DUNE_DEPRECATED_MSG("use frog") frob() {}
    6 }; // 2)
    7 template<typename T> struct Class {
    8 DUNE_DEPRECATED_MSG("use frog") void frob() {}
    9 }; // 3)
    With g++ only 2) emits a warning for templated member functions.
#define dune_static_assert (   COND,
  MSG 
)    static_assert(COND,MSG)

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

Deprecated:
Use static_assert from C++11 instead.

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

Enumeration Type Documentation

template<class T , std::size_t N>
anonymous enum
Enumerator
N2 
template<class T , std::size_t N>
anonymous enum
Enumerator
a1 
a2 
a3 
result 
template<class T >
anonymous enum
Enumerator
result 
template<class T >
anonymous enum
Enumerator
value 

The alignment requirement.

template<int m, int p>
anonymous enum

power stores m^p

Enumerator
power 
template<int m>
anonymous enum

m^0 = 1

Enumerator
power 
template<typename T >
anonymous enum
Enumerator
isPointer 
template<typename T >
anonymous enum
Enumerator
isReference 
template<typename T >
template<class U >
anonymous enum
Enumerator
result 
template<class T, int N = 100, class A = std::allocator<T>>
anonymous enum
Enumerator
chunkSize_ 

The number of elements in one chunk of the list. This has to be at least one. The default is 100.

template<typename T >
template<class U >
anonymous enum
Enumerator
result 
template<typename T >
template<class U>
anonymous enum
Enumerator
result 
template<typename T >
template<class U >
anonymous enum
Enumerator
result 
template<typename T>
anonymous enum
Enumerator
isVolatile 

True if T has a volatile specifier.

isConst 

True if T has a const qualifier.

template<typename T >
anonymous enum
Enumerator
isVolatile 
isConst 
template<typename T >
anonymous enum
Enumerator
isVolatile 
isConst 
template<typename T >
anonymous enum
Enumerator
isVolatile 
isConst 
template<typename T >
anonymous enum
Enumerator
value 

True if The type is volatile.

template<typename T >
anonymous enum
Enumerator
value 

True if The type is constant.

template<class From, class To>
anonymous enum
Enumerator
exists 

True if the conversion exists.

isTwoWay 

Whether the conversion exists in both ways.

sameType 

True if To and From are the same type.

template<class T, int N, class A>
anonymous enum
Enumerator
chunkSize_ 

The number of elements in one chunk of the list.

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

template<class From >
anonymous enum
Enumerator
exists 
isTwoWay 
sameType 
template<class To >
anonymous enum
Enumerator
exists 
isTwoWay 
sameType 
anonymous enum
Enumerator
exists 
isTwoWay 
sameType 
template<class T >
anonymous enum
Enumerator
exists 
isTwoWay 
sameType 
template<class Base , class Derived >
anonymous enum
Enumerator
value 

True if Base is a base class of Derived.

template<class T1 , class T2 >
anonymous enum
Enumerator
value 

True if either a conversion from T1 to T2 or vice versa exists.

template<class T, int N, class A>
anonymous enum
Enumerator
chunkSize_ 

The number of elements in one chunk of the list.

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

template<int k>
anonymous enum
Enumerator
bits 
hexdigits 
bitmask 
compbitmask 
overflowmask 

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
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>
template<typename Signed >
Dune::bigunsignedint< k >::bigunsignedint ( Signed  x,
typename std::enable_if< std::is_integral< Signed >::value &&std::is_signed< Signed >::value >::type *  = 0 
)

Construct from signed int.

References DUNE_THROW.

template<int k>
Dune::bigunsignedint< k >::bigunsignedint ( std::uintmax_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
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 && !is_same<typename FieldTraits<A>::field_type,typename FieldTraits<A>::real_type>::value, typename PromotionTraits<A,B>::PromotedType>::type Dune::dot ( const A &  a,
const B &  b 
)
inline

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

See also
http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Vec/VecDot.html#VecDot
Parameters
a
b
Returns
conj(a)*b

Referenced by Dune::DenseVector< FieldVector< T, SIZE > >::dot(), 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.
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>
static std::string Dune::formatString ( const std::string &  s,
const T &...  args 
)
static

Format values according to printf format string.

Parameters
sThe format string to be used
argsThe valued to be formated

This is a wrapper to std::snprintf that provides overflow save printf functionality. For up to 1000 characters a static buffer is used. If this is not sufficient a dynamic buffer of appropriate size is allocated.

References DUNE_THROW.

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)
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 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::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.
nextRow::NextRow ( int  )
explicit
zero::operator double ( )

Conversion operator to double.

zero::operator int ( )

Conversion operator to int.

References DUNE_THROW.

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<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::uintmax_t  y 
)
inline
template<int k>
bigunsignedint<k> Dune::operator% ( std::uintmax_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<int k>
bigunsignedint<k> Dune::operator* ( const bigunsignedint< k > &  x,
std::uintmax_t  y 
)
inline
template<int k>
bigunsignedint<k> Dune::operator* ( std::uintmax_t  x,
const bigunsignedint< k > &  y 
)
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::bigunsignedint< k >::operator+ ( const bigunsignedint< k > &  x) const
inline
template<int k>
bigunsignedint<k> Dune::operator+ ( const bigunsignedint< k > &  x,
std::uintmax_t  y 
)
inline
template<int k>
bigunsignedint<k> Dune::operator+ ( std::uintmax_t  x,
const bigunsignedint< k > &  y 
)
inline
Indent& Dune::Indent::operator++ ( )
inline

raise indentation level

template<int k>
bigunsignedint< k > & Dune::bigunsignedint< k >::operator++ ( )
inline
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::uintmax_t  y 
)
inline
template<int k>
bigunsignedint<k> Dune::operator- ( std::uintmax_t  x,
const bigunsignedint< k > &  y 
)
inline
Indent& Dune::Indent::operator-- ( )
inline

lower indentation level

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::uintmax_t  y 
)
inline
template<int k>
bigunsignedint<k> Dune::operator/ ( std::uintmax_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>
std::ostream& Dune::operator<< ( std::ostream &  s,
const array< T, N > &  e 
)
inline

Output operator for array.

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

write indentation to a stream

template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator<< ( int  i) const
inline
template<typename T1 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const tuple< T1 > &  t 
)
inline

Print a tuple.

References Dune::put(), and t.

template<typename T1 , typename T2 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const tuple< T1, T2 > &  t 
)
inline

References Dune::put(), and t.

template<typename TA , int i>
std::ostream& Dune::operator<< ( std::ostream &  os,
const EnumItem< TA, i > &   
)
inline
template<typename T1 , typename T2 , typename T3 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const tuple< T1, T2, T3 > &  t 
)
inline

References Dune::put(), and t.

template<typename TA , int from, int to>
std::ostream& Dune::operator<< ( std::ostream &  os,
const EnumRange< TA, from, to > &   
)
inline
template<typename T1 , typename T2 , typename T3 , typename T4 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const tuple< T1, T2, T3, T4 > &  t 
)
inline

References Dune::put(), and t.

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const tuple< T1, T2, T3, T4, T5 > &  t 
)
inline

References Dune::put(), and t.

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const tuple< T1, T2, T3, T4, T5, T6 > &  t 
)
inline

References Dune::put(), and t.

template<class TI1 , class TI2 , class T >
std::ostream& Dune::operator<< ( std::ostream &  os,
const Combine< TI1, TI2, T > &   
)
inline
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const tuple< T1, T2, T3, T4, T5, T6, T7 > &  t 
)
inline

References Dune::put(), and t.

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const tuple< T1, T2, T3, T4, T5, T6, T7, T8 > &  t 
)
inline

References Dune::put(), and t.

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > &  t 
)
inline

References Dune::put(), and t.

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 > &  t 
)
inline

References Dune::put(), and t.

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<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<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<int k>
bool Dune::bigunsignedint< k >::operator<= ( const bigunsignedint< k > &  x) const
inline

less than or equal

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

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

Assignment operator.

template<class T, int N, class A>
ArrayListIterator< T, N, A > & Dune::ArrayListIterator< T, N, A >::operator= ( const ArrayListIterator< T, N, A > &  other)
inline
Todo:
Please doc me!

References position_.

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<int k>
bool Dune::bigunsignedint< k >::operator> ( const bigunsignedint< k > &  x) const
inline

greater than

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

greater or equal

template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator>> ( int  i) const
inline
template<typename T1 >
std::istream& Dune::operator>> ( std::istream &  is,
tuple< T1 > &  t 
)
inline

Read a tuple.

References Dune::get().

template<typename T1 , typename T2 >
std::istream& Dune::operator>> ( std::istream &  is,
tuple< T1, T2 > &  t 
)
inline

References Dune::get().

template<typename T1 , typename T2 , typename T3 >
std::istream& Dune::operator>> ( std::istream &  is,
tuple< T1, T2, T3 > &  t 
)
inline

References Dune::get().

template<typename T1 , typename T2 , typename T3 , typename T4 >
std::istream& Dune::operator>> ( std::istream &  is,
tuple< T1, T2, T3, T4 > &  t 
)
inline

References Dune::get().

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
std::istream& Dune::operator>> ( std::istream &  is,
tuple< T1, T2, T3, T4, T5 > &  t 
)
inline

References Dune::get().

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
std::istream& Dune::operator>> ( std::istream &  is,
tuple< T1, T2, T3, T4, T5, T6 > &  t 
)
inline

References Dune::get().

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
std::istream& Dune::operator>> ( std::istream &  is,
tuple< T1, T2, T3, T4, T5, T6, T7 > &  t 
)
inline

References Dune::get().

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
std::istream& Dune::operator>> ( std::istream &  is,
tuple< T1, T2, T3, T4, T5, T6, T7, T8 > &  t 
)
inline

References Dune::get().

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
std::istream& Dune::operator>> ( std::istream &  is,
tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > &  t 
)
inline

References Dune::get().

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
std::istream& Dune::operator>> ( std::istream &  is,
tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 > &  t 
)
inline

References Dune::get().

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 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!
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<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<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>
std::uint_least32_t Dune::bigunsignedint< k >::touint ( ) const
inline

export to other types

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

zero::Zero ( int  )
explicit
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<typename T , class A >
Dune::SLList< T, A >::~SLList ( )

Destructor.

Deallocates all elements in the list.

Variable Documentation

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