Common


Files

file  alignment.hh
 This file implements a template class to determine alignment requirements of types at compile time.
file  dlist.hh
file  finitestack.hh
file  gcd.hh
file  lcm.hh
file  sllist.hh
 This file implements a single linked list together with the necessary iterators.
file  stack.hh
file  timer.hh
 A simple timing class.
file  tuples.hh
 Contains classes that implement tuples.

Modules

 GeometryType
 Parallel Communication
 Debug output
 Exception handling
 Dense Matrix and Vector Template Library
 Iterator facades
 Iterator facades for writing stl conformant iterators.

Classes

struct  Dune::AlignmentOf< T >
 Calculates the alignment requirement of a type. More...
class  Dune::ArrayList< T, N, A >
 A dynamically growing random access list. More...
class  Dune::ArrayListIterator< T, N, A >
 A random access iterator for the Dune::ArrayList class. More...
class  Dune::ConstArrayListIterator< T, N, A >
 A constant random access iterator for the Dune::ArrayList class. More...
class  Dune::bigunsignedint< k >
 Portable very large unsigned integers. More...
class  Dune::BitField
 A dynamic array of booleans

This class is basically std::vector<bool>, but with a few added methods. More...

class  Dune::ConfigParser
 Parser for hierarchical configuration files

This class parses config files into a hierarchical structure. Config files should look like this. More...

class  Dune::DoubleLinkedListError
 exception thrown on illegal element access More...
class  Dune::DoubleLinkedList< T >
 (DEPRECATED) A doubly-linked list More...
class  Dune::DoubleLinkedList< T >::Iterator
 Iterator class for the doubly-linked list. More...
class  Dune::EmptySet< TA >
 An empty set. More...
class  Dune::EnumItem< TA, item >
 A set consisting only of one item. More...
class  Dune::EnumRange< T, 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::array< T, N >
 Simple fixed size array class. More...
struct  Dune::GcdHelper< a, b, bo >
 Helper for calculating the gcd. More...
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::SLList< T, A >
 A single linked list. More...
class  Dune::SLListIterator< T, A >
 A mutable iterator for the SLList. More...
class  Dune::SLListConstIterator< T, A >
 A constant iterator for the SLList. More...
class  Dune::SLListModifyIterator< T, A >
 A mutable iterator for the SLList. More...
class  Dune::SmartPointer< T >
 A reference counting smart pointer. More...
class  Dune::StackException
 Exception thrown by the stack. More...
class  Dune::Stack< T >
 (DEPRECATED) dynamic stack implemented with a double linked list More...
struct  IsTrue< condition >
 (DEPRECATED) Helper template so that compilation fails if condition is not true. More...
class  Dune::TimerError
 Exception thrown by the Timer class More...
class  Dune::Timer
 A simple stop watch. More...
struct  Dune::Nil
 An empty class. More...
struct  Dune::Pair< T1, TT >
 A tuple consisting of two objects. More...
struct  Dune::Pair< T1, Nil >
 A tuple consisting of one object. Specialization of Pair that really is a single value. More...
struct  Dune::TupleToPairs< T1, T2, T3, T4, T5, T6, T7, T8, T9 >
 Converts the Tuple to a list of pairs. More...
struct  Dune::TupleToPairs< T1, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil >
 Specialization for a tuple consisting only of one type. More...
class  Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >
 A Tuple of objects. More...
struct  Dune::tuple_element< N, Tuple >
 Get the type of the N-th element of the tuple. More...
struct  Dune::tuple_element< 0, Pair< T1, T2 > >
 Get the type of the first element of the tuple. More...
struct  Dune::Element< N >
 Get the N-th element of a tuple. More...
struct  Dune::Element< 0 >
 Get the first element of a tuple. More...
struct  Dune::tuple_size< T >
 Template meta_programm to query the size of a tuple. More...
struct  Dune::Empty
 Just an empty class. More...
class  Dune::TypeTraits< T >
 General type traits class to check whether type is reference or pointer type. More...
struct  Dune::ConstantVolatileTraits< T >
 Determines wether a type is const or volatile and provides the unqualified types. More...
struct  Dune::IsVolatile< T >
 Tests wether a type is volatile. More...
struct  Dune::IsConst< T >
 Tests wether a type is constant. More...
struct  Dune::remove_const< T >
 Removes a const qualifier while preserving others. More...
class  Dune::Conversion< From, To >
 Checks wether a type is derived from another. More...
struct  Dune::IsInteroperable< T1, T2 >
 Checks wether two types are interoperable. More...
struct  Dune::EnableIf< b, T >
 Enable typedef if condition is met. More...
struct  Dune::enable_if< b, T >
 Enable typedef if condition is met. More...
struct  Dune::EnableIfInterOperable< T1, T2, Type >
 Enable typedef if two types are interoperable. More...
struct  Dune::is_same< T1, T2 >
 Compile time test for testing whether two types are the same. More...
struct  Dune::SelectType< first, T1, T2 >
 Select a type based on a condition. More...

Defines

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

Functions

 Dune::DoubleLinkedList::Iterator::Iterator ()
 constructor
bool Dune::DoubleLinkedList::Iterator::operator!= (Iterator x) const
 comparison
bool Dune::DoubleLinkedList::Iterator::operator== (Iterator x) const
 comparison
Iterator & Dune::DoubleLinkedList::Iterator::operator++ ()
 Prefix increment.
Iterator Dune::DoubleLinkedList::Iterator::operator++ (int)
 Postfix increment.
Iterator & Dune::DoubleLinkedList::Iterator::operator-- ()
 Prefix decrement.
Iterator Dune::DoubleLinkedList::Iterator::operator-- (int)
 Postfix decrement.
T & Dune::DoubleLinkedList::Iterator::operator* () const
 dereferenciation
T * Dune::DoubleLinkedList::Iterator::operator-> () const
 dereferenciation (Stroustrup p. 289)
Iterator Dune::DoubleLinkedList::begin () const
 iterator at the lists start
Iterator Dune::DoubleLinkedList::end () const
 iterator behind last element
Iterator Dune::DoubleLinkedList::rbegin () const
 iterator at the lists end
Iterator Dune::DoubleLinkedList::rend () const
 iterator before the lists start
 Dune::DoubleLinkedList::DoubleLinkedList ()
 empty constructor
 Dune::DoubleLinkedList::DoubleLinkedList (const DoubleLinkedList< T > &)
 copy constructor
 Dune::DoubleLinkedList::~DoubleLinkedList ()
 destructor
DoubleLinkedList< T > & Dune::DoubleLinkedList::operator= (const DoubleLinkedList< T > &)
 Deep copy operator.
int Dune::DoubleLinkedList::size () const
 current list size
Iterator Dune::DoubleLinkedList::insert_after (Iterator i, T &t)
 insert after an iterators position
Iterator Dune::DoubleLinkedList::insert_before (Iterator i, T &t)
 insert before an iterators position
void Dune::DoubleLinkedList::erase (Iterator i)
 remove selected element
 Dune::@21::Zero::operator double ()
 Conversion operator to double.
 Dune::@21::Zero::operator int ()
 Conversion operator to int.
 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, int s>
fvector_assigner< T, s > Dune::operator<<= (FieldVector< T, s > &v, const T &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, int n, int m>
fmatrix_assigner< T, n, m > Dune::operator<<= (FieldMatrix< T, n, m > &v, const T &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 T, int N>
std::ostream & Dune::operator<< (std::ostream &s, array< T, N > e)
 Output operator for array.
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.
 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.
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.
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.
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.
bool Dune::Stack::full () const
 Always returns false because the stack is never full.
void Dune::Stack::push (T &t)
 Put a new object onto the stack.
Dune::Stack::pop ()
 Removes and returns the uppermost object from the stack.
Dune::Stack::top () const
 Returns the uppermost object from the stack.
int Dune::Stack::size () const
 Number of elements on the stack.
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.
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.
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.
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.
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<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.
 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.
MemberType & Dune::ArrayListIterator::elementAt (size_type i) const
 Get the value of the list at an arbitrary position.
const MemberType & Dune::ConstArrayListIterator::elementAt (size_type i) const
 Get the value of the list at an arbitrary position.
MemberType & Dune::ArrayListIterator::dereference () const
 Access the element at the current position.
const MemberType & 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)
void Dune::ArrayListIterator::eraseToHere ()
 Erase all entries before the current position and the one at the current position.
 Dune::bigunsignedint::bigunsignedint ()
 Construct uninitialized.
 Dune::bigunsignedint::bigunsignedint (int x)
 Construct from signed int.
 Dune::bigunsignedint::bigunsignedint (unsigned int x)
 Construct from unsigned int.
unsigned int Dune::bigunsignedint::touint () const
 export to other types
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::EnumItem::contains (const Type &attribute)
 Tests whether an item is in the set.
 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.
T * Dune::Pool::allocate ()
 Get a new or recycled object.
 Dune::PoolAllocator::PoolAllocator ()
 Constructor.
void Dune::PoolAllocator::deallocate (pointer p, std::size_t n)
 Free objects.
void Dune::PoolAllocator::destroy (pointer p)
 Destroy an object without freeing memory.
 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.
void Dune::SmartPointer::deallocate ()
 Deallocates the references object if no other pointers reference it.
bool Dune::Stack::empty () const
 Returns true if the stack is emptry.

Variables

struct Dune:: { ... } ::NextRow Dune::nextRow
 Marker class for next row.
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.


Define Documentation

#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

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


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>
T * Dune::Pool< T, S >::allocate (  )  [inline, inherited]

Get a new or recycled object.

Returns:
A pointer to the object memory.

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.

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

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

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

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>
const ConstArrayListIterator< T, N, A >::MemberType & 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 >::MemberType & 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]

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]

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

empty constructor

Deprecated:

template<class T, int N, class A>
const ConstArrayListIterator< T, N, A >::MemberType & 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 >::MemberType & 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<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.

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.

References Dune::ConstArrayListIterator< T, N, A >::list_, and Dune::ConstArrayListIterator< T, N, A >::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.

References Dune::ConstArrayListIterator< T, N, A >::list_, and Dune::ConstArrayListIterator< T, N, A >::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.

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

References Dune::SLListModifyIterator< T, A >::iterator_.

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.

References Dune::SLListConstIterator< T, A >::current_.

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.

References Dune::SLListModifyIterator< T, A >::iterator_.

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.

References Dune::SLListIterator< T, A >::current_.

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.

References Dune::SLListConstIterator< T, A >::current_.

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

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:
v matrix which should be initialized
t bool indicating, that this is a temporary object (see ~fmatrix_assigner)

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

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<class T>
DoubleLinkedList< T >::Iterator Dune::DoubleLinkedList< T >::insert_after ( Iterator  i,
T &  t 
) [inline, inherited]

template<class T>
DoubleLinkedList< T >::Iterator Dune::DoubleLinkedList< T >::insert_before ( Iterator  i,
T &  t 
) [inline, inherited]

insert before an iterators position

Returns:
Iterator pointing to new element

References DUNE_THROW, and Dune::DoubleLinkedList< T >::Iterator::p.

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<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<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, and Dune::Pair< T1, TT >::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 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, 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, int n, int m>
fmatrix_assigner<T,n,m> Dune::operator<<= ( FieldMatrix< T, n, m > &  v,
const T &  t 
) [inline]

FieldMatrix assignment operator.

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

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

fvector assignment operator

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

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]

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

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<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<typename T1>
Dune::Pair< T1, Nil >::Pair ( typename TupleAccessTraits< T1 >::ParameterType  first,
const Nil  
) [inline, inherited]

Constructor.

Parameters:
t1 The values for the first field.
t2 The value for the second 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:
t1 The values for the first field.
t2 The value for the second 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 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.

template<class T>
T Dune::Stack< T >::pop (  )  [inline, inherited]

Removes and returns the uppermost object from the stack.

Deprecated:

References DUNE_THROW, Dune::Stack< T >::empty(), Dune::DoubleLinkedList< T >::erase(), and Dune::DoubleLinkedList< T >::rbegin().

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>
void Dune::Stack< T >::push ( T &  t  )  [inline, inherited]

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<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, 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<class T>
Dune::SmartPointer< T >::SmartPointer ( const SmartPointer< T > &  pointer  )  [inline, inherited]

Copy constructor.

Parameters:
pointer The object to copy.

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


Variable Documentation

struct { ... } ::NextRow Dune::nextRow [static]

Marker class for next row.

overload operator <<= for FiledMatrix assignment


Generated on Sun Nov 15 22:28:15 2009 for dune-common by  doxygen 1.5.6