Common (foundation classes)

Collaboration diagram for Common (foundation classes):

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...
class  Dune::ConfigParser
 Parser for hierarchical configuration filesThis class parses config files into a hierarchical structure. Config files should look like this. More...
class  Dune::EmptySet< TA >
 An empty set. More...
class  Dune::AllSet< TA >
 An 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 >
 fvector assignment operator More...
class  Dune::FiniteStack< T, n >
 A stack with static memory allocation. 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::GcdHelper< a, b, bo >
 Helper for calculating the gcd. More...
struct  Dune::GcdHelper< a, b, true >
struct  Dune::GcdHelper< a, b, false >
struct  Dune::GcdHelper< a, 0, true >
struct  Dune::Gcd< a, b >
 Calculator of the greatest common divisor. 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...
struct  Dune::Factorial< m >
 Calculates the factorial of m at compile time. More...
struct  Dune::Factorial< 0 >
 end of recursion of factorial via specialization More...
class  Dune::Pool< T, s >
 A memory pool of objects. More...
class  Dune::PoolAllocator< T, s >
 An allocator managing a pool of objects for reuse. More...
class  Dune::PoolAllocator< void, s >
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::SmartPointer< T >
 A reference counting smart pointer. More...
struct  IsTrue< condition >
 (DEPRECATED) Helper template so that compilation fails if condition is not true. More...
struct  IsTrue< true >
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::ElementType< N, T >
struct  Dune::Element< N >
 Get the N-th element of a tuple. More...
struct  Dune::Element< 0 >
 Get the first element of a tuple. More...
struct  Dune::tuple_size< T >
 Template meta_programm to query the size of a tuple. More...
struct  Dune::tuple_size< Pair< T1, T2 > >
struct  Dune::tuple_size< Pair< T1, Nil > >
struct  Dune::tuple_size< Pair< Nil, Nil > >
struct  Dune::Size< 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 >
struct  Dune::remove_const< T >
 Removes a const qualifier while preserving others. 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 >

Namespaces

namespace  Dune
 

Dune namespace.


Modules

 GeometryType
 Parallel Communication
 Debug output
 Exception handling
 Dense Matrix and Vector Template Library
 Iterator facades
 

Iterator facades for writing stl conformant iterators.


 FloatCmp

Files

file  alignment.hh
 

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


file  finitestack.hh
file  function.hh
 

Simple base class templates for functions.


file  gcd.hh
file  lcm.hh
file  sllist.hh
 

This file implements a single linked list together with the necessary iterators.


file  timer.hh
 

A simple timing class.


file  tuples.hh
 

Contains classes that implement tuples.


Defines

#define 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 A::size_type Dune::SLList::size_type
 The size type.
typedef T Dune::SLList::MemberType
 The type we store.
typedef A::template rebind
< Element >::other 
Dune::SLList::Allocator
 The allocator to use.
typedef SLListIterator< T, A > Dune::SLList::iterator
 The mutable iterator of the list.
typedef SLListConstIterator< T, A > Dune::SLList::const_iterator
 The mutable iterator of the list.
typedef SLListModifyIterator
< T, A > 
Dune::SLList::ModifyIterator
 The type of the iterator capable of deletion and insertion.
typedef T & Dune::TupleAccessTraits::NonConstType
typedef const
ConstantVolatileTraits< T >
::UnqualifiedType & 
Dune::TupleAccessTraits::ParameterType
typedef T * Dune::TupleAccessTraits< T * >::NonConstType
typedef T * Dune::TupleAccessTraits< T * >::ParameterType
typedef T & Dune::TupleAccessTraits< T & >::NonConstType
typedef T & Dune::TupleAccessTraits< T & >::ParameterType
typedef TT Dune::Pair::Type2
 The type of the second 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 tuple_element< N,
typename Tuple::FirstPair >
::type 
Dune::tuple_element::Type
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

Functions

template<class T , int N>
bool Dune::operator< (const array< T, N > &a, const array< T, N > &b)
template<class T , int N>
bool Dune::operator> (const array< T, N > &a, const array< T, N > &b)
template<class T , int N>
bool Dune::operator<= (const array< T, N > &a, const array< T, N > &b)
template<class T , int N>
bool Dune::operator>= (const array< T, N > &a, const array< T, N > &b)
template<class T , int N>
std::ostream & Dune::operator<< (std::ostream &s, array< T, N > e)
 Output operator for array.
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<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 > &)
 Dune::fvector_assigner::fvector_assigner (fvector_assigner &a)
 Copy Constructor.
 Dune::fvector_assigner::fvector_assigner (FieldVector< T, s > &_v, bool t)
 Constructor from vector and temporary flag.
 Dune::fvector_assigner::~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::append (const T &t)
 append data to this vector
fvector_assigner & Dune::fvector_assigner::append (Zero z)
 append zeros to this vector
fvector_assigner & Dune::fvector_assigner::operator, (const T &t)
 append data to this vector the overloaded comma operator is used to assign a comma seperated list of values to the vector
fvector_assigner & Dune::fvector_assigner::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::fmatrix_assigner (fmatrix_assigner &a)
 Copy Constructor.
 Dune::fmatrix_assigner::fmatrix_assigner (FieldMatrix< T, n, m > &_A, bool t)
 Constructor from matrix and temporary flag.
 Dune::fmatrix_assigner::~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::append (const T &t)
 append data to this matrix
fmatrix_assigner & Dune::fmatrix_assigner::append (Zero z)
 append zeros to this matrix
fmatrix_assigner & Dune::fmatrix_assigner::append (NextRow nr)
 append zeros to this matrix
fmatrix_assigner & Dune::fmatrix_assigner::operator, (const T &t)
 append data to this matrix the overloaded comma operator is used to assign a comma seperated list of values to the matrix
fmatrix_assigner & Dune::fmatrix_assigner::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::operator, (NextRow nr)
 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.
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)
 fFileMatrix assignment operator
bool Dune::FiniteStack::full () const
 Returns true if the stack is full.
void Dune::FiniteStack::push (const T &t)
 Puts a new object onto the stack.
Dune::FiniteStack::pop ()
 Removes and returns the uppermost object from the stack.
Dune::FiniteStack::top () const
 Returns the uppermost object on the stack.
int Dune::FiniteStack::size () const
 Dynamic stacksize.
 Dune::FiniteStack::FiniteStack ()
 Makes empty stack.
template<class K >
Dune::conjugateComplex (const K &x)
 compute conjugate complex of x
template<class T >
int Dune::sign (const T &val)
 Return the sign of the value.
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 T1 , std::size_t t1, typename T2 , std::size_t t2>
bool Dune::operator== (const PoolAllocator< T1, t1 > &, const PoolAllocator< T2, t2 > &)
template<typename T1 , std::size_t t1, typename T2 , std::size_t t2>
bool Dune::operator!= (const PoolAllocator< T1, t1 > &, const PoolAllocator< T2, t2 > &)
template<typename T , std::size_t t1, std::size_t t2>
bool Dune::operator== (const PoolAllocator< T, t1 > &, const PoolAllocator< T, t2 > &)
template<typename T , std::size_t t1, std::size_t t2>
bool Dune::operator!= (const PoolAllocator< T, t1 > &, const PoolAllocator< T, t2 > &)
template<typename T , std::size_t t1, std::size_t t2>
bool Dune::operator== (const PoolAllocator< T, t1 > &, const PoolAllocator< void, t2 > &)
template<typename T , std::size_t t1, std::size_t t2>
bool Dune::operator!= (const PoolAllocator< T, t1 > &, const PoolAllocator< void, t2 > &)
template<typename T , std::size_t t1, std::size_t t2>
bool Dune::operator== (const PoolAllocator< void, t1 > &, const PoolAllocator< T, t2 > &)
template<typename T , std::size_t t1, std::size_t t2>
bool Dune::operator!= (const PoolAllocator< void, t1 > &, const PoolAllocator< T, t2 > &)
template<std::size_t t1, std::size_t t2>
bool Dune::operator== (const PoolAllocator< void, t1 > &, const PoolAllocator< void, t2 > &)
template<std::size_t t1, std::size_t t2>
bool Dune::operator!= (const PoolAllocator< void, t1 > &, const PoolAllocator< void, t2 > &)
 Dune::SLList::SLList ()
 Constructor.
template<typename T1 , typename A1 >
 Dune::SLList::SLList (const SLList< T1, A1 > &other)
 Copy constructor with type conversion.
 Dune::SLList::SLList (const SLList< T, A > &other)
 Copy constructor.
 Dune::SLList::~SLList ()
 Destructor.
SLList< T, A > & Dune::SLList::operator= (const SLList< T, A > &other)
 Assignment operator.
void Dune::SLList::push_back (const MemberType &item)
 Add a new entry to the end of the list.
void Dune::SLList::push_front (const MemberType &item)
 Add a new entry to the beginning of the list.
void Dune::SLList::pop_front ()
 Remove the first item in the list.
void Dune::SLList::clear ()
 Remove all elements from the list.
iterator Dune::SLList::begin ()
 Get an iterator pointing to the first element in the list.
const_iterator Dune::SLList::begin () const
 Get an iterator pointing to the first element in the list.
ModifyIterator Dune::SLList::beginModify ()
 Get an iterator capable of deleting and inserting elements.
ModifyIterator Dune::SLList::endModify ()
 Get an iterator capable of deleting and inserting elements.
iterator Dune::SLList::end ()
 Get an iterator pointing to the end of the list.
const_iterator Dune::SLList::end () const
 Get an iterator pointing to the end of the list.
bool Dune::SLList::empty () const
 Check whether the list is empty.
int Dune::SLList::size () const
 Get the number of elements the list contains.
bool Dune::SLList::operator== (const SLList &sl) const
bool Dune::SLList::operator!= (const SLList &sl) const
 Dune::SLList::Element::Element (const MemberType &item, Element *next_=0)
 Dune::SLList::Element::Element ()
 Dune::SLList::Element::~Element ()
 Dune::SLListIterator::SLListIterator (typename SLList< T, A >::Element *item, SLList< T, A > *sllist)
 Dune::SLListIterator::SLListIterator ()
 Dune::SLListIterator::SLListIterator (const SLListModifyIterator< T, A > &other)
T & Dune::SLListIterator::dereference () const
 Dereferencing function for the iterator facade.
bool Dune::SLListIterator::equals (const SLListConstIterator< T, A > &other) const
 Equality test for the iterator facade.
bool Dune::SLListIterator::equals (const SLListIterator< T, A > &other) const
 Equality test for the iterator facade.
bool Dune::SLListIterator::equals (const SLListModifyIterator< T, A > &other) const
 Equality test for the iterator facade.
void Dune::SLListIterator::increment ()
 Increment function for the iterator facade.
void Dune::SLListIterator::insertAfter (const T &v) const
 Insert an element in the underlying list after the current position.
void Dune::SLListIterator::deleteNext () const
 Delete the entry after the current position.
 Dune::SLListConstIterator::SLListConstIterator ()
 Dune::SLListConstIterator::SLListConstIterator (typename SLList< T, A >::Element *item)
 Dune::SLListConstIterator::SLListConstIterator (const SLListIterator< T, A > &other)
 Dune::SLListConstIterator::SLListConstIterator (const SLListConstIterator< T, A > &other)
 Dune::SLListConstIterator::SLListConstIterator (const SLListModifyIterator< T, A > &other)
const T & Dune::SLListConstIterator::dereference () const
 Dereferencing function for the facade.
bool Dune::SLListConstIterator::equals (const SLListConstIterator< T, A > &other) const
 Equality test for the iterator facade.
void Dune::SLListConstIterator::increment ()
 Increment function for the iterator facade.
 Dune::SLListModifyIterator::SLListModifyIterator (SLListIterator< T, A > beforeIterator, SLListIterator< T, A > _iterator)
 Dune::SLListModifyIterator::SLListModifyIterator (const SLListModifyIterator< T, A > &other)
 Dune::SLListModifyIterator::SLListModifyIterator ()
T & Dune::SLListModifyIterator::dereference () const
 Dereferencing function for the iterator facade.
bool Dune::SLListModifyIterator::equals (const SLListConstIterator< T, A > &other) const
 Test whether another iterator is equal.
bool Dune::SLListModifyIterator::equals (const SLListIterator< T, A > &other) const
 Test whether another iterator is equal.
bool Dune::SLListModifyIterator::equals (const SLListModifyIterator< T, A > &other) const
 Test whether another iterator is equal.
void Dune::SLListModifyIterator::increment ()
 Increment function for the iterator facade.
void Dune::SLListModifyIterator::insert (const T &v)
 Insert an element at the current position.
void Dune::SLListModifyIterator::remove ()
 Delete the entry at the current position.
template<typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
 Dune::Pair::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::Pair (typename TupleAccessTraits< Type1 >::ParameterType t1, TT &t2)
 Constructor.
 Dune::Pair::Pair ()
template<typename U1 , typename U2 >
 Dune::Pair::Pair (const Pair< U1, U2 > &other)
 Copy Constructor for implicit type conversion.
template<typename U1 , typename U2 >
Pair & Dune::Pair::operator= (const Pair< U1, U2 > &other)
 Assignment operator for implicit type conversion.
Pair & Dune::Pair::operator= (const Pair &other)
TupleAccessTraits< Type1 >
::NonConstType 
Dune::Pair::first ()
 Get the first value.
TupleAccessTraits< Type1 >
::ConstType 
Dune::Pair::first () const
 Get the first value.
TupleAccessTraits< Type2 >
::NonConstType 
Dune::Pair::second ()
 Get the second value.
TupleAccessTraits< Type2 >
::ConstType 
Dune::Pair::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::tuple ()
 Dune::tuple::tuple (typename TupleAccessTraits< T1 >::ParameterType t1)
 Dune::tuple::tuple (typename TupleAccessTraits< T1 >::ParameterType t1, typename TupleAccessTraits< T2 >::ParameterType t2)
 Dune::tuple::tuple (typename TupleAccessTraits< T1 >::ParameterType t1, typename TupleAccessTraits< T2 >::ParameterType t2, typename TupleAccessTraits< T3 >::ParameterType t3)
 Dune::tuple::tuple (typename TupleAccessTraits< T1 >::ParameterType t1, typename TupleAccessTraits< T2 >::ParameterType t2, typename TupleAccessTraits< T3 >::ParameterType t3, typename TupleAccessTraits< T4 >::ParameterType t4)
 Dune::tuple::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::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::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::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::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::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 >
::ConstType 
Dune::Element::get (const Pair< T1, T2 > &tuple)
 Get the N-th 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<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 aa pair or tuple.
template<typename T1 >
std::ostream & Dune::operator<< (std::ostream &os, const 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::ArrayList ()
 Constructs an Array list with one chunk.
void Dune::ArrayList::clear ()
 Delete all entries from the list.
size_type Dune::ArrayList::size () const
 Get the number of elements in the list.
size_type Dune::ArrayList::capacity () const
 Get the current capacity of the list.
void Dune::ArrayList::push_back (const_reference entry)
 Append an entry to the list.
reference Dune::ArrayList::operator[] (size_type i)
 Get the element at specific position.
const_reference Dune::ArrayList::operator[] (size_type i) const
 Get the element at specific position.
iterator Dune::ArrayList::begin ()
 Get an iterator that is positioned at the first element.
const_iterator Dune::ArrayList::begin () const
 Get a random access iterator that is positioned at the first element.
iterator Dune::ArrayList::end ()
 Get a random access iterator positioned after the last element.
const_iterator Dune::ArrayList::end () const
 Get a random access iterator positioned after the last element.
void Dune::ArrayList::purge ()
 Purge the list.
void Dune::ArrayListIterator::advance (difference_type n)
void Dune::ConstArrayListIterator::advance (difference_type n)
bool Dune::ArrayListIterator::equals (const ArrayListIterator< MemberType, N, A > &other) const
 Comares two iterators.
bool Dune::ArrayListIterator::equals (const ConstArrayListIterator< MemberType, N, A > &other) const
 Comares two iterators.
bool Dune::ConstArrayListIterator::equals (const ConstArrayListIterator< MemberType, N, A > &other) const
 Comares to iterators.
void Dune::ArrayListIterator::increment ()
 Increment the iterator.
void Dune::ConstArrayListIterator::increment ()
 Increment the iterator.
void Dune::ArrayListIterator::decrement ()
 decrement the iterator.
void Dune::ConstArrayListIterator::decrement ()
 decrement the iterator.
reference Dune::ArrayListIterator::elementAt (size_type i) const
 Get the value of the list at an arbitrary position.
const_reference Dune::ConstArrayListIterator::elementAt (size_type i) const
 Get the value of the list at an arbitrary position.
reference Dune::ArrayListIterator::dereference () const
 Access the element at the current position.
const_reference Dune::ConstArrayListIterator::dereference () const
 Access the element at the current position.
difference_type Dune::ArrayListIterator::distanceTo (const ArrayListIterator< T, N, A > &other) const
difference_type Dune::ConstArrayListIterator::distanceTo (const ConstArrayListIterator< T, N, A > &other) const
ArrayListIterator< T, N, A > & Dune::ArrayListIterator::operator= (const ArrayListIterator< T, N, A > &other)
const ConstArrayListIterator
< T, N, A > & 
Dune::ConstArrayListIterator::operator= (const ConstArrayListIterator< T, N, A > &other)
void Dune::ArrayListIterator::eraseToHere ()
 Erase all entries before the current position and the one at the current position.
 Dune::ConstArrayListIterator::ConstArrayListIterator (const ArrayListIterator< T, N, A > &other)
 Dune::bigunsignedint::bigunsignedint ()
 Construct uninitialized.
 Dune::bigunsignedint::bigunsignedint (int x)
 Construct from signed int.
 Dune::bigunsignedint::bigunsignedint (std::size_t x)
 Construct from unsigned int.
unsigned int Dune::bigunsignedint::touint () const
 export to other types
double Dune::bigunsignedint::todouble () const
 Convert to a double.
void Dune::bigunsignedint::print (std::ostream &s) const
 Print number in hex notation.
bigunsignedint< k > Dune::bigunsignedint::operator+ (const bigunsignedint< k > &x) const
 add
bigunsignedint< k > Dune::bigunsignedint::operator- (const bigunsignedint< k > &x) const
 subtract
bigunsignedint< k > Dune::bigunsignedint::operator* (const bigunsignedint< k > &x) const
 multiply
bigunsignedint< k > & Dune::bigunsignedint::operator++ ()
 prefix increment
bigunsignedint< k > Dune::bigunsignedint::operator/ (const bigunsignedint< k > &x) const
 divide
bigunsignedint< k > Dune::bigunsignedint::operator% (const bigunsignedint< k > &x) const
 modulo
bigunsignedint< k > Dune::bigunsignedint::operator& (const bigunsignedint< k > &x) const
 bitwise and
bigunsignedint< k > Dune::bigunsignedint::operator^ (const bigunsignedint< k > &x) const
 bitwise exor
bigunsignedint< k > Dune::bigunsignedint::operator| (const bigunsignedint< k > &x) const
 bitwise or
bigunsignedint< k > Dune::bigunsignedint::operator~ () const
 bitwise komplement
bigunsignedint< k > Dune::bigunsignedint::operator<< (int i) const
 left shift1/
bigunsignedint< k > Dune::bigunsignedint::operator>> (int i) const
 right shift
bool Dune::bigunsignedint::operator!= (const bigunsignedint< k > &x) const
 not equal
bool Dune::bigunsignedint::operator== (const bigunsignedint< k > &x) const
 equal
bool Dune::bigunsignedint::operator< (const bigunsignedint< k > &x) const
 less than
bool Dune::bigunsignedint::operator<= (const bigunsignedint< k > &x) const
 less than or equal
bool Dune::bigunsignedint::operator> (const bigunsignedint< k > &x) const
 greater than
bool Dune::bigunsignedint::operator>= (const bigunsignedint< k > &x) const
 greater or equalt
static bool Dune::EmptySet::contains (const Type &attribute)
 Always returns false.
static bool Dune::AllSet::contains (const Type &attribute)
 Always returns false.
static bool Dune::EnumItem::contains (const Type &attribute)
 Tests whether an item is in the set.
static bool Dune::EnumRange::contains (const TA &item)
static bool Dune::Combine::contains (const TA &item)
 Dune::Pool::Pool ()
 Constructor.
 Dune::Pool::~Pool ()
 Destructor.
void Dune::Pool::print (std::ostream &os)
 Print elements in pool for debugging.
void Dune::Pool::free (void *o)
 Free an object.
void * Dune::Pool::allocate ()
 Get a new or recycled object.
 Dune::PoolAllocator::PoolAllocator ()
 Constructor.
pointer Dune::PoolAllocator::allocate (std::size_t n, const_pointer hint=0)
 Allocates objects.
void Dune::PoolAllocator::deallocate (pointer p, std::size_t n)
 Free objects.
void Dune::PoolAllocator::construct (pointer p, const_reference value)
 Construct an object.
void Dune::PoolAllocator::destroy (pointer p)
 Destroy an object without freeing memory.
 Dune::shared_ptr::shared_ptr (T *pointer)
 Constructs a new smart pointer from a preallocated Object.
template<class Deleter >
 Dune::shared_ptr::shared_ptr (T *pointer, Deleter deleter)
 Constructs a new smart pointer from a preallocated Object.
 Dune::shared_ptr::shared_ptr ()
 Constructs a new smart pointer and allocates the referenced Object.
 Dune::shared_ptr::shared_ptr (const shared_ptr< T > &pointer)
 Copy constructor.
shared_ptr & Dune::shared_ptr::operator= (const shared_ptr< T > &pointer)
 Assignment operator.
 Dune::shared_ptr::~shared_ptr ()
 Destructor.
element_type & Dune::shared_ptr::operator* ()
 Dereference as object.
element_type * Dune::shared_ptr::operator-> ()
 Dereference as pointer.
const element_type & Dune::shared_ptr::operator* () const
 Dereference as const object.
const element_type * Dune::shared_ptr::operator-> () const
 Dereference as const pointer.
int Dune::shared_ptr::use_count () const
 The number of shared_ptrs pointing to the object we point to.
void Dune::shared_ptr::swap (shared_ptr &other)
 Swap content of this shared_ptr and another.
void Dune::shared_ptr::reset ()
 Decrease the reference count by one and free the memory if the reference count has reached 0.
void Dune::shared_ptr::reset (T *pointer)
 Detach shared pointer and set it anew for the given pointer.
template<class Deleter >
void Dune::shared_ptr::reset (T *pointer, Deleter deleter)
 Dune::SmartPointer::SmartPointer (T *pointer)
 Constructs a new smart pointer from a preallocated Object.
 Dune::SmartPointer::SmartPointer ()
 Constructs a new smart pointer and allocates the referenced Object.
 Dune::SmartPointer::SmartPointer (const SmartPointer< T > &pointer)
 Copy constructor.
SmartPointer & Dune::SmartPointer::operator= (const SmartPointer< T > &pointer)
 Assignment operator.
 Dune::SmartPointer::~SmartPointer ()
 Destructor.
MemberType & Dune::SmartPointer::operator* ()
 Dereference as object.
MemberType * Dune::SmartPointer::operator-> ()
 Dereference as pointer.
const MemberType & Dune::SmartPointer::operator* () const
 Dereference as const object.
const MemberType * Dune::SmartPointer::operator-> () const
 Dereference as const pointer.
int Dune::SmartPointer::count () const
void Dune::SmartPointer::deallocate ()
 Deallocates the references object if no other pointers reference it.

Variables

static const long Dune::Lcm::value = (m/Gcd<m,n>::value)*n
 The least common multiple of the template parameters m and n.
MemberType Dune::SLList::Element::item_
 The element we hold.
Type1 Dune::Pair::first_
 The value of the first field.
Type2 Dune::Pair::second_
 The value of the second field.
Type1 Dune::Pair< T1, Nil >::first_
 The value of the first field.

Friends

class Dune::SLList::SLListIterator< T, A >
class Dune::SLList::SLListConstIterator< T, A >
class Dune::SLListIterator::SLListModifyIterator< T, A >
class Dune::SLListIterator::SLList< T, A >
class Dune::SLListConstIterator::SLList< T, A >
class Dune::SLListModifyIterator::SLListIterator< T, A >

Define Documentation

#define DUNE_DEPRECATED

Mark some entity as deprecated.

This is a preprocessor define which can be used to mark functions, typedefs, enums and other stuff depretcated. 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++ only. 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 {};
    class Class {} DUNE_DEPRECATED;
    
    This does not seem to work for template classes. If the class template has some essential member, maybe you can get away by marking that as deprecated instead.
  • Member functions
    template<typename T> struct Class {
      void frob() DUNE_DEPRECATED {}
    };
    template<typename T> struct Class {
      void DUNE_DEPRECATED frob() {}
    };
    template<typename T> struct Class {
      DUNE_DEPRECATED void frob() {}
    };
    
#define dune_static_assert ( COND,
MSG   ) 
Value:
typedef static_assert_test<                         \
      sizeof(static_assert_failure< (bool)( COND )>)\
      > CPPMAGIC_JOIN(dune_static_assert_typedef_, __LINE__)

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

    #include <dune/common/static_assert.hh>
    dune_static_assert(CONDITION, ERRORMSG);

If CONDITION is not true, dune_static_assert fails.

If the C++0x language feature static_assert is available, dune_static_assert should break down static_assert. Otherwise dune_static_assert implements a test that trigger a compile time error if 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::GcdHelper< a, b, true >::conceptCheck(), 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 [inherited]

The allocator to use.

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

The mutable iterator of the list.

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

The mutable iterator of the list.

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

The type we store.

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

The type of the iterator capable of deletion and insertion.

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

The size type.

template<typename T1 , typename T2 >
typedef T1 Dune::tuple_element< 0, Pair< T1, T2 > >::Type [inherited]
template<int N, typename T1 , typename T2 >
typedef tuple_element<N-1,T2>::Type Dune::tuple_element< N, Pair< T1, T2 > >::Type [inherited]
template<int N, class Tuple>
typedef tuple_element<N,typename Tuple::FirstPair>::type Dune::tuple_element< N, Tuple >::Type [inherited]
template<typename T1 >
typedef Nil Dune::Pair< T1, Nil >::Type2 [inherited]

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>

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

The type of the second field.


Function Documentation

template<class T , int N, class A >
void Dune::ConstArrayListIterator< T, N, A >::advance ( difference_type  n  )  [inline, inherited]
Todo:
Please doc me!
template<class T , int N, class A >
void Dune::ArrayListIterator< T, N, A >::advance ( difference_type  n  )  [inline, inherited]
Todo:
Please doc me!
template<class T , std::size_t s>
PoolAllocator< T, s >::pointer Dune::PoolAllocator< T, s >::allocate ( std::size_t  n,
const_pointer  hint = 0 
) [inline, inherited]

Allocates objects.

Parameters:
n The number of objects to allocate. Has to be one!
hint Ignored hint.
Returns:
A pointer tp the allocated elements.

References Dune::Pool< T, s >::allocate().

template<class T , std::size_t S>
void * Dune::Pool< T, S >::allocate (  )  [inline, inherited]

Get a new or recycled object.

Returns:
A pointer to the object memory.

Referenced by Dune::PoolAllocator< T, s >::allocate().

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

append zeros to this matrix

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

append zeros to this matrix

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

append data to this matrix

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

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

append zeros to this vector

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

append data to this vector

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

template<class T , int N, class A >
Dune::ArrayList< T, N, A >::ArrayList (  )  [inline, inherited]

Constructs an Array list with one chunk.

template<class T , int N, class A >
ConstArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::begin (  )  const [inline, inherited]

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

Returns:
The iterator.
template<class T , int N, class A >
ArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::begin (  )  [inline, inherited]

Get an iterator that is positioned at the first element.

Returns:
The iterator.
template<typename T , class A >
SLListConstIterator< T, A > Dune::SLList< T, A >::begin (  )  const [inline, inherited]

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 >
SLListIterator< T, A > Dune::SLList< T, A >::begin (  )  [inline, inherited]

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

template<typename T , class A >
SLListModifyIterator< T, A > Dune::SLList< T, A >::beginModify (  )  [inline, inherited]

Get an iterator capable of deleting and inserting elements.

Returns:
Modifying iterator positioned at the beginning of the list.
template<int k>
Dune::bigunsignedint< k >::bigunsignedint ( std::size_t  x  )  [inline, inherited]

Construct from unsigned int.

template<int k>
Dune::bigunsignedint< k >::bigunsignedint ( int  x  )  [inline, inherited]

Construct from signed int.

template<int k>
Dune::bigunsignedint< k >::bigunsignedint (  )  [inline, inherited]

Construct uninitialized.

template<class T , int N, class A >
size_t Dune::ArrayList< T, N, A >::capacity (  )  const [inline, inherited]

Get the current capacity of the list.

Returns:
The capacity.
template<class T , int N, class A >
void Dune::ArrayList< T, N, A >::clear (  )  [inline, inherited]

Delete all entries from the list.

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

Remove all elements from the list.

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

template<class TI1 , class TI2 >
Combine<TI1,TI2,typename TI1::Type> Dune::combine ( const TI1 &  set1,
const TI2 &  set2 
) [inline]
template<class K >
K Dune::conjugateComplex ( const K &  x  )  [inline]
template<class T, int N, class A>
Dune::ConstArrayListIterator< T, N, A >::ConstArrayListIterator ( const ArrayListIterator< T, N, A > &  other  )  [inline, inherited]
template<class T , std::size_t s>
void Dune::PoolAllocator< T, s >::construct ( pointer  p,
const_reference  value 
) [inline, inherited]

Construct an object.

Parameters:
p Pointer to the object.
value The value to initialize it to.
template<class TI1 , class TI2 , typename TA >
bool Dune::Combine< TI1, TI2, TA >::contains ( const TA &  item  )  [inline, static, inherited]
template<typename TA , int from, int to>
bool Dune::EnumRange< TA, from, to >::contains ( const TA &  item  )  [inline, static, inherited]
template<typename TA , int i>
bool Dune::EnumItem< TA, i >::contains ( const Type attribute  )  [inline, static, inherited]

Tests whether an item is in the set.

Returns:
True if item==Type.
template<typename TA >
bool Dune::AllSet< TA >::contains ( const Type attribute  )  [inline, static, inherited]

Always returns false.

template<typename TA >
bool Dune::EmptySet< TA >::contains ( const Type attribute  )  [inline, static, inherited]

Always returns false.

template<class T >
int Dune::SmartPointer< T >::count (  )  const [inline, inherited]
template<class T >
void Dune::SmartPointer< T >::deallocate (  )  [inline, inherited]

Deallocates the references object if no other pointers reference it.

template<class T , std::size_t s>
void Dune::PoolAllocator< T, s >::deallocate ( pointer  p,
std::size_t  n 
) [inline, inherited]

Free objects.

Does not call the destructor!

Parameters:
n The number of objects to free. Has to be one!
p Pointer to the first object.

References Dune::Pool< T, s >::free().

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

decrement the iterator.

template<class T , int N, class A >
void Dune::ArrayListIterator< T, N, A >::decrement (  )  [inline, inherited]

decrement the iterator.

template<typename T, class A>
void Dune::SLListIterator< T, A >::deleteNext (  )  const [inline, inherited]

Delete the entry after the current position.

Warning:
This will invalidate all iterators positioned at the delete position! Use with care!
template<class T , int N, class A >
ConstArrayListIterator< T, N, A >::const_reference Dune::ConstArrayListIterator< T, N, A >::dereference (  )  const [inline, inherited]

Access the element at the current position.

Returns:
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, inherited]

Access the element at the current position.

Returns:
The element at the current position.
template<typename T, class A>
T& Dune::SLListModifyIterator< T, A >::dereference (  )  const [inline, inherited]

Dereferencing function for the iterator facade.

Returns:
A reference to the element at the current position.
template<class T, class A>
const T& Dune::SLListConstIterator< T, A >::dereference (  )  const [inline, inherited]

Dereferencing function for the facade.

Returns:
A reference to the element at the current position.
template<typename T, class A>
T& Dune::SLListIterator< T, A >::dereference (  )  const [inline, inherited]

Dereferencing function for the iterator facade.

Returns:
A reference to the element at the current position.
template<class T , std::size_t s>
void Dune::PoolAllocator< T, s >::destroy ( pointer  p  )  [inline, inherited]

Destroy an object without freeing memory.

Parameters:
p Pointer to the object.
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, inherited]
Todo:
Please doc me!
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, inherited]
Todo:
Please doc me!
template<typename T , class A >
Dune::SLList< T, A >::Element::Element (  )  [inline, inherited]
template<typename T , class A >
Dune::SLList< T, A >::Element::Element ( const MemberType item,
Element *  next_ = 0 
) [inline, inherited]
template<class T , int N, class A >
ConstArrayListIterator< T, N, A >::const_reference Dune::ConstArrayListIterator< T, N, A >::elementAt ( size_type  i  )  const [inline, inherited]

Get the value of the list at an arbitrary position.

Returns:
The value at that postion.
template<class T , int N, class A >
ArrayListIterator< T, N, A >::reference Dune::ArrayListIterator< T, N, A >::elementAt ( size_type  i  )  const [inline, inherited]

Get the value of the list at an arbitrary position.

Returns:
The value at that postion.
template<typename T , class A >
bool Dune::SLList< T, A >::empty (  )  const [inline, inherited]

Check whether the list is empty.

Returns:
True if the list is empty;
template<class T , int N, class A >
ConstArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::end (  )  const [inline, inherited]

Get a random access iterator positioned after the last element.

template<class T , int N, class A >
ArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::end (  )  [inline, inherited]

Get a random access iterator positioned after the last element.

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

Get an iterator pointing to the end of the list.

Returns:
An iterator pointing to the end.
template<typename T , class A >
SLListIterator< T, A > Dune::SLList< T, A >::end (  )  [inline, inherited]

Get an iterator pointing to the end of the list.

Returns:
An iterator pointing to the end.

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

template<typename T , class A >
SLListModifyIterator< T, A > Dune::SLList< T, A >::endModify (  )  [inline, inherited]

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::ConstArrayListIterator< T, N, A >::equals ( const ConstArrayListIterator< MemberType, N, A > &  other  )  const [inline, inherited]

Comares to iterators.

Returns:
true if the iterators are for the same list and at the position.
template<class T , int N, class A>
bool Dune::ArrayListIterator< T, N, A >::equals ( const ConstArrayListIterator< MemberType, N, A > &  other  )  const [inline, inherited]

Comares two iterators.

Returns:
True if the iterators are for the same list and at the position.
template<class T , int N, class A>
bool Dune::ArrayListIterator< T, N, A >::equals ( const ArrayListIterator< MemberType, N, A > &  other  )  const [inline, inherited]

Comares two iterators.

Returns:
True if the iterators are for the same list and at the position.
template<typename T, class A>
bool Dune::SLListModifyIterator< T, A >::equals ( const SLListModifyIterator< T, A > &  other  )  const [inline, inherited]

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, inherited]

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 SLListConstIterator< T, A > &  other  )  const [inline, inherited]

Test whether another iterator is equal.

Returns:
true if the other iterator is at the same position as this one.
template<class T, class A>
bool Dune::SLListConstIterator< T, A >::equals ( const SLListConstIterator< T, A > &  other  )  const [inline, inherited]

Equality test for the iterator facade.

Parameters:
other The 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, inherited]

Equality test for the iterator facade.

Parameters:
other The 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, inherited]

Equality test for the iterator facade.

Parameters:
other The 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 SLListConstIterator< T, A > &  other  )  const [inline, inherited]

Equality test for the iterator facade.

Parameters:
other The other iterator to check.
Returns:
true If the other iterator is at the same position.
template<class T , int N, class A >
void Dune::ArrayListIterator< T, N, A >::eraseToHere (  )  [inline, inherited]

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 Dune::ArrayListIterator< T, N, A >::chunkSize_.

template<class T , int n>
Dune::FiniteStack< T, n >::FiniteStack (  )  [inline, inherited]

Makes empty stack.

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

Get the first value.

Returns:
The first value

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

template<typename T1 >
TupleAccessTraits< T1 >::NonConstType Dune::Pair< T1, Nil >::first (  )  [inline, inherited]

Get the first value.

Returns:
The first value

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

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

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

Get the first value.

Returns:
The first value

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

template<typename T1 , typename T2 >
TupleAccessTraits< T1 >::NonConstType Dune::Pair< T1, T2 >::first (  )  [inline, inherited]

Get the first value.

Returns:
The first value

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

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

template<class T, int n, int m>
Dune::fmatrix_assigner< T, n, m >::fmatrix_assigner ( FieldMatrix< T, n, m > &  _A,
bool  t 
) [inline, inherited]

Constructor from matrix and temporary flag.

Parameters:
_A matrix which should be initialized
t bool indicating, that this is a temporary object (see ~fmatrix_assigner)
template<class T, int n, int m>
Dune::fmatrix_assigner< T, n, m >::fmatrix_assigner ( fmatrix_assigner< T, n, m > &  a  )  [inline, inherited]

Copy Constructor.

template<class T , std::size_t S>
void Dune::Pool< T, S >::free ( void *  o  )  [inline, inherited]

Free an object.

Parameters:
o The pointer to memory block of the object.

Referenced by Dune::PoolAllocator< T, s >::deallocate().

template<class T , int n>
bool Dune::FiniteStack< T, n >::full (  )  const [inline, inherited]

Returns true if the stack is full.

Referenced by Dune::FiniteStack< T, n >::push().

template<class T, int s>
Dune::fvector_assigner< T, s >::fvector_assigner ( FieldVector< T, s > &  _v,
bool  t 
) [inline, inherited]

Constructor from vector and temporary flag.

Parameters:
_v vector which should be initialized
t bool indicating, that this is a temporary object (see ~fvector_assigner)
template<class T, int s>
Dune::fvector_assigner< T, s >::fvector_assigner ( fvector_assigner< T, s > &  a  )  [inline, inherited]

Copy Constructor.

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 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  )  [inline]

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>::NonConstType Dune::get ( tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > &  t  )  [inline]

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

template<typename T1 , typename T2 >
static TupleAccessTraits<T1>::ConstType Dune::Element< 0 >::get ( const Pair< T1, T2 > &  tuple  )  [inline, static, inherited]

Get the first element of the tuple.

Parameters:
tuple The tuple whose first element we want.
Returns:
The first element of the tuple.
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  )  [inline, static, inherited]

Get the N-th element of the tuple.

Parameters:
tuple The tuple whose N-th element we want.
Returns:
The N-th element of the tuple.

References Dune::Element< N >::get().

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

Increment the iterator.

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

Increment the iterator.

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

Increment function for the iterator facade.

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

Increment function for the iterator facade.

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

Increment function for the iterator facade.

template<typename T, class A>
void Dune::SLListModifyIterator< T, A >::insert ( const T &  v  )  [inline, inherited]

Insert an element at the current position.

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

Parameters:
v The value to insert.
template<typename T, class A>
void Dune::SLListIterator< T, A >::insertAfter ( const T &  v  )  const [inline, inherited]

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

Parameters:
v The value to insert.
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<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 >
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 >
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 >
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 >
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 >
tuple<T1, T2, T3> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3 
) [inline]
template<class T1 , class T2 >
tuple<T1, T2> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2 
) [inline]
template<class T1 >
tuple<T1> Dune::make_tuple ( const T1 &  t1  )  [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:
first The value of the first field.
second The value of the second field.
template<int k>
bool Dune::bigunsignedint< k >::operator!= ( const bigunsignedint< k > &  x  )  const [inline, inherited]

not equal

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

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

Inequality comparison operator for tuples.

Parameters:
tuple1 The first tuple.
tuple2 The second tuple.
Returns:
True as the type of the compared objects are different.
template<typename T1 , typename U1 , typename U2 >
bool Dune::operator!= ( const Pair< T1, Nil > &  tuple1,
const Pair< U1, U2 > &  tuple2 
) [inline]

Inequality comparison operator for tuples.

Parameters:
tuple1 The first tuple.
tuple2 The second tuple.
Returns:
True as the type of the compared objects are different.
template<typename T1 , typename U1 >
bool Dune::operator!= ( const Pair< T1, Nil > &  tuple1,
const Pair< U1, Nil > &  tuple2 
) [inline]

Inequality comparison operator for tuples.

Parameters:
tuple1 The first tuple.
tuple2 The second tuple,

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

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

Inequality comparison operator for tuples.

Parameters:
tuple1 The first tuple.
tuple2 The second tuple,

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

template<typename T , class A >
bool Dune::SLList< T, A >::operator!= ( const SLList< T, A > &  sl  )  const [inline, inherited]
template<std::size_t t1, std::size_t t2>
bool Dune::operator!= ( const PoolAllocator< void, t1 > &  ,
const PoolAllocator< void, t2 > &   
) [inline]
template<typename T , std::size_t t1, std::size_t t2>
bool Dune::operator!= ( const PoolAllocator< void, t1 > &  ,
const PoolAllocator< T, t2 > &   
) [inline]
template<typename T , std::size_t t1, std::size_t t2>
bool Dune::operator!= ( const PoolAllocator< T, t1 > &  ,
const PoolAllocator< void, t2 > &   
) [inline]
template<typename T , std::size_t t1, std::size_t t2>
bool Dune::operator!= ( const PoolAllocator< T, t1 > &  ,
const PoolAllocator< T, t2 > &   
) [inline]
template<typename T1 , std::size_t t1, typename T2 , std::size_t t2>
bool Dune::operator!= ( const PoolAllocator< T1, t1 > &  ,
const PoolAllocator< T2, t2 > &   
) [inline]
template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator% ( const bigunsignedint< k > &  x  )  const [inline, inherited]

modulo

template<int k>
bigunsignedint<k> Dune::operator% ( std::size_t  x,
const bigunsignedint< k > &  y 
) [inline]
template<int k>
bigunsignedint<k> Dune::operator% ( const bigunsignedint< k > &  x,
std::size_t  y 
) [inline]
template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator& ( const bigunsignedint< k > &  x  )  const [inline, inherited]

bitwise and

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

template<class T >
const T & Dune::SmartPointer< T >::operator* (  )  const [inline, inherited]

Dereference as const object.

template<class T >
T & Dune::SmartPointer< T >::operator* (  )  [inline, inherited]

Dereference as object.

template<class T >
const T & Dune::shared_ptr< T >::operator* (  )  const [inline, inherited]

Dereference as const object.

template<class T >
T & Dune::shared_ptr< T >::operator* (  )  [inline, inherited]

Dereference as object.

template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator* ( const bigunsignedint< k > &  x  )  const [inline, inherited]
template<int k>
bigunsignedint<k> Dune::operator* ( std::size_t  x,
const bigunsignedint< k > &  y 
) [inline]
template<int k>
bigunsignedint<k> Dune::operator* ( const bigunsignedint< k > &  x,
std::size_t  y 
) [inline]
template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator+ ( const bigunsignedint< k > &  x  )  const [inline, inherited]
template<int k>
bigunsignedint<k> Dune::operator+ ( std::size_t  x,
const bigunsignedint< k > &  y 
) [inline]
template<int k>
bigunsignedint<k> Dune::operator+ ( const bigunsignedint< k > &  x,
std::size_t  y 
) [inline]
template<int k>
bigunsignedint< k > & Dune::bigunsignedint< k >::operator++ (  )  [inline, inherited]
template<class T, int n, int m>
fmatrix_assigner& Dune::fmatrix_assigner< T, n, m >::operator, ( NextRow  nr  )  [inline, inherited]

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, ( Zero  z  )  [inline, inherited]

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, ( const T &  t  )  [inline, inherited]

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

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

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

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 s>
fvector_assigner& Dune::fvector_assigner< T, s >::operator, ( const T &  t  )  [inline, inherited]

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

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

template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator- ( const bigunsignedint< k > &  x  )  const [inline, inherited]
template<int k>
bigunsignedint<k> Dune::operator- ( std::size_t  x,
const bigunsignedint< k > &  y 
) [inline]
template<int k>
bigunsignedint<k> Dune::operator- ( const bigunsignedint< k > &  x,
std::size_t  y 
) [inline]
template<class T >
const T * Dune::SmartPointer< T >::operator-> (  )  const [inline, inherited]

Dereference as const pointer.

template<class T >
T * Dune::SmartPointer< T >::operator-> (  )  [inline, inherited]

Dereference as pointer.

template<class T >
const T * Dune::shared_ptr< T >::operator-> (  )  const [inline, inherited]

Dereference as const pointer.

template<class T >
T * Dune::shared_ptr< T >::operator-> (  )  [inline, inherited]

Dereference as pointer.

template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator/ ( const bigunsignedint< k > &  x  )  const [inline, inherited]

divide

References DUNE_THROW.

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

less than

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

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

Less operator for tuples.

Parameters:
tuple1 The first tuple.
tuple2 The second tuple,
template<typename T1 , typename T2 , typename U1 , typename U2 >
bool Dune::operator< ( const Pair< T1, T2 > &  tuple1,
const Pair< U1, U2 > &  tuple2 
) [inline]

Less operator for tuples.

Parameters:
tuple1 The first tuple.
tuple2 The second tuple,
template<class T , int 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, inherited]
template<typename T1 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const Pair< T1, Nil > &  pair 
) [inline]
template<typename T1 , typename T2 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const Pair< T1, T2 > &  pair 
) [inline]

Print aa pair or tuple.

template<class TI1 , class TI2 , class T >
std::ostream& Dune::operator<< ( std::ostream &  os,
const Combine< TI1, TI2, T > &   
) [inline]
template<typename TA , int from, int to>
std::ostream& Dune::operator<< ( std::ostream &  os,
const EnumRange< TA, from, to > &   
) [inline]
template<typename TA , int i>
std::ostream& Dune::operator<< ( std::ostream &  os,
const EnumItem< TA, i > &   
) [inline]
template<int k>
std::ostream& Dune::operator<< ( std::ostream &  s,
const bigunsignedint< k > &  x 
) [inline]
template<class T , int N>
std::ostream& Dune::operator<< ( std::ostream &  s,
array< T, N >  e 
) [inline]

Output operator for array.

template<class T , int n, int m>
fmatrix_assigner<T,n,m> Dune::operator<<= ( FieldMatrix< T, n, m > &  v,
Zero  z 
) [inline]

fFileMatrix assignment operator

overload operator <<= for FieldMatrix row 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 
) [inline]

FieldMatrix assignment operator.

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

References t.

template<class T , int s>
fvector_assigner<T,s> Dune::operator<<= ( FieldVector< T, s > &  v,
Zero  z 
) [inline]

fvector assignment operator

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

template<class T , class K , int s>
fvector_assigner<T,s> Dune::operator<<= ( FieldVector< T, s > &  v,
const K &  t 
) [inline]

fvector assignment operator

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

References t.

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

less than or equal

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

template<class T , int N>
bool Dune::operator<= ( const array< T, N > &  a,
const array< T, N > &  b 
) [inline]
template<class T >
SmartPointer< T > & Dune::SmartPointer< T >::operator= ( const SmartPointer< T > &  pointer  )  [inline, inherited]

Assignment operator.

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

Assignment operator.

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, inherited]
template<class T, int N, class A>
ArrayListIterator< T, N, A > & Dune::ArrayListIterator< T, N, A >::operator= ( const ArrayListIterator< T, N, A > &  other  )  [inline, inherited]
Todo:
Please doc me!
template<typename T1, 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, inherited]

Assignment operator for implicit type conversion.

Parameters:
other The tuple to assign.

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

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

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

Assignment operator.

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

template<typename T1 >
template<typename T2 >
Pair< T1, Nil > & Dune::Pair< T1, Nil >::operator= ( const Pair< T2, Nil > &  other  )  [inline, inherited]

Assignment operator for type conversion.

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

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

Assignment operator for implicit type conversion.

Parameters:
other The tuple to assign.

Reimplemented in Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >.

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

Referenced by Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >::operator=().

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

Assignment operator.

References Dune::SLList< T, A >::clear().

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

equal

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

Equality comparison operator for tuples.

Parameters:
tuple1 The first tuple.
tuple2 The second tuple.
Returns:
False as the type of the compared objects are different.
template<typename T1 , typename U1 , typename U2 >
bool Dune::operator== ( const Pair< T1, Nil > &  tuple1,
const Pair< U1, U2 > &  tuple2 
) [inline]

Equality comparison operator for tuples.

Parameters:
tuple1 The first tuple.
tuple2 The second tuple.
Returns:
False as the type of the compared objects are different.
template<typename T1 , typename U1 >
bool Dune::operator== ( const Pair< T1, Nil > &  tuple1,
const Pair< U1, Nil > &  tuple2 
) [inline]

Equality comparison operator for tuples.

Parameters:
tuple1 The first tuple.
tuple2 The second tuple,

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

template<typename T1 , typename T2 , typename U1 , typename U2 >
bool Dune::operator== ( const Pair< T1, T2 > &  tuple1,
const Pair< U1, U2 > &  tuple2 
) [inline]

Equality comparison operator for tuples.

Parameters:
tuple1 The first tuple.
tuple2 The second tuple,

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

template<typename T , class A >
bool Dune::SLList< T, A >::operator== ( const SLList< T, A > &  sl  )  const [inline, inherited]
template<std::size_t t1, std::size_t t2>
bool Dune::operator== ( const PoolAllocator< void, t1 > &  ,
const PoolAllocator< void, t2 > &   
) [inline]
template<typename T , std::size_t t1, std::size_t t2>
bool Dune::operator== ( const PoolAllocator< void, t1 > &  ,
const PoolAllocator< T, t2 > &   
) [inline]
template<typename T , std::size_t t1, std::size_t t2>
bool Dune::operator== ( const PoolAllocator< T, t1 > &  ,
const PoolAllocator< void, t2 > &   
) [inline]
template<typename T , std::size_t t1, std::size_t t2>
bool Dune::operator== ( const PoolAllocator< T, t1 > &  ,
const PoolAllocator< T, t2 > &   
) [inline]
template<typename T1 , std::size_t t1, typename T2 , std::size_t t2>
bool Dune::operator== ( const PoolAllocator< T1, t1 > &  ,
const PoolAllocator< T2, t2 > &   
) [inline]
template<int k>
bool Dune::bigunsignedint< k >::operator> ( const bigunsignedint< k > &  x  )  const [inline, inherited]

greater than

template<class T , int 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, inherited]

greater or equalt

template<class T , int 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, inherited]
template<class T , int N, class A >
ArrayList< T, N, A >::const_reference Dune::ArrayList< T, N, A >::operator[] ( size_type  i  )  const [inline, inherited]

Get the element at specific position.

Parameters:
i The index of the position.
Returns:
The element at that position.
template<class T , int N, class A >
ArrayList< T, N, A >::reference Dune::ArrayList< T, N, A >::operator[] ( size_type  i  )  [inline, inherited]

Get the element at specific position.

Parameters:
i The 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, inherited]

bitwise exor

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

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

bitwise or

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

template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator~ (  )  const [inline, inherited]

bitwise komplement

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

template<typename T1 >
template<typename T2 >
Dune::Pair< T1, Nil >::Pair ( const Pair< T2, Nil > &  other  )  [inline, inherited]

Copy constructor for type conversion.

template<typename T1 >
Dune::Pair< T1, Nil >::Pair (  )  [inline, inherited]
template<typename T1 >
Dune::Pair< T1, Nil >::Pair ( typename TupleAccessTraits< T1 >::ParameterType  first,
const Nil  
) [inline, inherited]

Constructor.

Parameters:
first The values for the first field.
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, inherited]

Constructor.

Parameters:
first The values for the first field.
template<typename T1 , typename T2 >
template<typename U1 , typename U2 >
Dune::Pair< T1, T2 >::Pair ( const Pair< U1, U2 > &  other  )  [inline, inherited]

Copy Constructor for implicit type conversion.

Parameters:
other The tuple to copy.
template<typename T1 , typename T2 >
Dune::Pair< T1, T2 >::Pair (  )  [inline, inherited]
template<typename T1 , typename TT >
Dune::Pair< T1, TT >::Pair ( typename TupleAccessTraits< Type1 >::ParameterType  t1,
TT &  t2 
) [inline, inherited]

Constructor.

Parameters:
t1 The value of the first field.
t2 The value of the second field.
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, inherited]

The number of values we hold.

Constructor

Parameters:
t1 The value of the first field.
t2 The value of the second field.
t3 The value of the third field.
t4 The value of the 4th field.
t5 The value of the 5th field.
t6 The value of the 6th field.
t7 The value of the 7th field.
t8 The value of the 8th field.
t9 The value of the 9th field.
template<class T , std::size_t S>
Dune::Pool< T, S >::Pool (  )  [inline, inherited]
template<class T , std::size_t s>
Dune::PoolAllocator< T, s >::PoolAllocator (  )  [inline, inherited]

Constructor.

template<class T , int n>
T Dune::FiniteStack< T, n >::pop (  )  [inline, inherited]

Removes and returns the uppermost object from the stack.

References DUNE_THROW, and Dune::FiniteStack< T, n >::empty().

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

Remove the first item in the list.

template<class T , std::size_t S>
void Dune::Pool< T, S >::print ( std::ostream &  os  )  [inline, inherited]

Print elements in pool for debugging.

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

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, inherited]

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 Dune::ArrayList< T, N, A >::chunkSize_.

template<class T , int n>
void Dune::FiniteStack< T, n >::push ( const T &  t  )  [inline, inherited]

Puts a new object onto the stack.

References DUNE_THROW, and Dune::FiniteStack< T, n >::full().

template<class T , int N, class A >
void Dune::ArrayList< T, N, A >::push_back ( const_reference  entry  )  [inline, inherited]

Append an entry to the list.

Parameters:
entry The new entry.

References Dune::ArrayList< T, N, A >::chunkSize_.

template<typename T , class A >
void Dune::SLList< T, A >::push_back ( const MemberType item  )  [inline, inherited]

Add a new entry to the end of the list.

Parameters:
item The item to add.
template<typename T , class A >
void Dune::SLList< T, A >::push_front ( const MemberType item  )  [inline, inherited]

Add a new entry to the beginning of the list.

Parameters:
item The item to add.
template<typename T, class A>
void Dune::SLListModifyIterator< T, A >::remove (  )  [inline, inherited]

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

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

References Dune::shared_ptr< T >::swap().

template<class T >
void Dune::shared_ptr< T >::reset (  )  [inline, inherited]

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

References Dune::shared_ptr< T >::swap().

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

Get the second value.

Returns:
The second value

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

template<typename T1 , typename T2 >
TupleAccessTraits< T2 >::NonConstType Dune::Pair< T1, T2 >::second (  )  [inline, inherited]

Get the second value.

Returns:
The second value

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

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

template<class T>
Dune::shared_ptr< T >::shared_ptr ( const shared_ptr< T > &  pointer  )  [inline, inherited]

Copy constructor.

Parameters:
pointer The object to copy.
template<class T >
Dune::shared_ptr< T >::shared_ptr (  )  [inline, inherited]

Constructs a new smart pointer and allocates the referenced Object.

template<class T>
template<class Deleter >
Dune::shared_ptr< T >::shared_ptr ( T *  pointer,
Deleter  deleter 
) [inline, inherited]

Constructs a new smart pointer from a preallocated Object.

Template Parameters:
Deleter This class must by copyconstructable, the copy constructor must not throw an exception and it must implement void operator() (T*) const
Parameters:
deleter A copy of this deleter is stored

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

template<class T>
Dune::shared_ptr< T >::shared_ptr ( T *  pointer  )  [inline, inherited]

Constructs a new smart pointer from a preallocated Object.

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 >
int Dune::sign ( const T &  val  )  [inline]

Return the sign of the value.

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

Get the number of elements in the list.

Returns:
The number of elements.
template<typename T , class A >
int Dune::SLList< T, A >::size (  )  const [inline, inherited]

Get the number of elements the list contains.

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

template<class T , int n>
int Dune::FiniteStack< T, n >::size (  )  const [inline, inherited]

Dynamic stacksize.

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

Copy constructor.

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

Copy constructor with type conversion.

template<typename T , class A >
Dune::SLList< T, A >::SLList (  )  [inline, inherited]

Constructor.

template<class T, class A>
Dune::SLListConstIterator< T, A >::SLListConstIterator ( const SLListModifyIterator< T, A > &  other  )  [inline, inherited]
template<class T, class A>
Dune::SLListConstIterator< T, A >::SLListConstIterator ( const SLListConstIterator< T, A > &  other  )  [inline, inherited]
template<class T, class A>
Dune::SLListConstIterator< T, A >::SLListConstIterator ( const SLListIterator< T, A > &  other  )  [inline, inherited]
template<class T, class A>
Dune::SLListConstIterator< T, A >::SLListConstIterator ( typename SLList< T, A >::Element item  )  [inline, inherited]
template<class T, class A>
Dune::SLListConstIterator< T, A >::SLListConstIterator (  )  [inline, inherited]
template<typename T, class A>
Dune::SLListIterator< T, A >::SLListIterator ( const SLListModifyIterator< T, A > &  other  )  [inline, inherited]
template<typename T, class A>
Dune::SLListIterator< T, A >::SLListIterator (  )  [inline, inherited]
template<typename T, class A>
Dune::SLListIterator< T, A >::SLListIterator ( typename SLList< T, A >::Element item,
SLList< T, A > *  sllist 
) [inline, inherited]
template<typename T, class A>
Dune::SLListModifyIterator< T, A >::SLListModifyIterator (  )  [inline, inherited]
template<typename T, class A>
Dune::SLListModifyIterator< T, A >::SLListModifyIterator ( const SLListModifyIterator< T, A > &  other  )  [inline, inherited]
template<typename T, class A>
Dune::SLListModifyIterator< T, A >::SLListModifyIterator ( SLListIterator< T, A >  beforeIterator,
SLListIterator< T, A >  _iterator 
) [inline, inherited]
template<class T >
Dune::SmartPointer< T >::SmartPointer ( const SmartPointer< T > &  pointer  )  [inline, inherited]

Copy constructor.

Parameters:
pointer The object to copy.
template<class T >
Dune::SmartPointer< T >::SmartPointer (  )  [inline, inherited]

Constructs a new smart pointer and allocates the referenced Object.

template<class T >
Dune::SmartPointer< T >::SmartPointer ( T *  pointer  )  [inline, inherited]

Constructs a new smart pointer from a preallocated Object.

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

template<class T >
T Dune::SQR ( t  )  [inline]

Compute the square of T.

template<class T >
void Dune::shared_ptr< T >::swap ( shared_ptr< T > &  other  )  [inline, inherited]

Swap content of this shared_ptr and another.

Referenced by Dune::shared_ptr< T >::reset().

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<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 >
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 >
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 >
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 >
tuple<T1&, T2&, T3&, T4&> Dune::tie ( T1 &  t1,
T2 &  t2,
T3 &  t3,
T4 &  t4 
) [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 >
tuple<T1&, T2&> Dune::tie ( T1 &  t1,
T2 &  t2 
) [inline]
template<class T1 >
tuple<T1&> Dune::tie ( T1 &  t1  )  [inline]
template<int k>
double Dune::bigunsignedint< k >::todouble (  )  const [inline, inherited]

Convert to a double.

Warning:
Subject to rounding errors!

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

template<class T , int n>
T Dune::FiniteStack< T, n >::top (  )  const [inline, inherited]

Returns the uppermost object on the stack.

References DUNE_THROW, and Dune::FiniteStack< T, n >::empty().

template<int k>
unsigned int Dune::bigunsignedint< k >::touint (  )  const [inline, inherited]

export to other types

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

template<typename T1, 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, inherited]
template<typename T1, 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, inherited]
template<typename T1, 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, inherited]
template<typename T1, 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, inherited]
template<typename T1, 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, inherited]
template<typename T1, 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, inherited]
template<typename T1, 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, inherited]
template<typename T1, 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, inherited]
template<typename T1, 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, inherited]
template<typename T1, 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, inherited]
template<class T >
int Dune::shared_ptr< T >::use_count (  )  const [inline, inherited]

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

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

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, inherited]

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

References DUNE_THROW.

template<class T , std::size_t S>
Dune::Pool< T, S >::~Pool (  )  [inline, inherited]

Destructor.

template<class T >
Dune::shared_ptr< T >::~shared_ptr (  )  [inline, inherited]

Destructor.

template<typename T , class A >
Dune::SLList< T, A >::~SLList (  )  [inline, inherited]

Destructor.

Deallocates all elements in the list.

References Dune::SLList< T, A >::clear().

template<class T >
Dune::SmartPointer< T >::~SmartPointer (  )  [inline, inherited]

Destructor.


Variable Documentation

template<typename T1 >
Type1 Dune::Pair< T1, Nil >::first_ [inherited]

The value of the first field.

template<typename T1, typename TT>
Type1 Dune::Pair< T1, TT >::first_ [inherited]
template<typename T, class A = std::allocator<T>>
MemberType Dune::SLList< T, A >::Element::item_ [inherited]

The element we hold.

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

The value of the second field.

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

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

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


Friends

template<class T, class A>
friend class SLList< T, A > [friend, inherited]
template<typename T, class A>
friend class SLList< T, A > [friend, inherited]
template<typename T, class A = std::allocator<T>>
friend class SLListConstIterator< T, A > [friend, inherited]
template<typename T, class A>
friend class SLListIterator< T, A > [friend, inherited]
template<typename T, class A = std::allocator<T>>
friend class SLListIterator< T, A > [friend, inherited]
template<typename T, class A>
friend class SLListModifyIterator< T, A > [friend, inherited]
Generated on Mon Apr 26 10:45:22 2010 for dune-common by  doxygen 1.6.3