dune-common 2.1.1
Classes | Namespaces | Modules | Files | Defines | Typedefs | Functions | Variables | Friends
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::Gcd< a, b >
 Calculator of the greatest common divisor. More...
class  Dune::Indent
 Utility class for handling nested indentation in output. More...
class  Dune::ios_base_all_saver
 Utility class for storing and resetting stream attributes. More...
struct  Dune::Lcm< m, n >
 Calculate the least common multiple of two numbers. More...
struct  Dune::Power_m_p< m, p >
 Calculates m^p at compile time. More...
struct  Dune::Power_m_p< m, 0 >
 end of recursion via specialization More...
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::ParameterTree
 Hierarchical structure of string parameters. More...
class  Dune::ParameterTreeParser
 Parser for hierarchical configuration filesThis class parses config files into a hierarchical structure. Config files should look like this. 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::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< 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...
struct  Dune::remove_reference< T >
 Remove a reference from a type. More...
class  Dune::Conversion< From, To >
 Checks wether a type is convertible to another. More...
class  Dune::Conversion< From, void >
class  Dune::Conversion< void, To >
class  Dune::Conversion< int, double >
class  Dune::Conversion< T, T >
class  Dune::IsBaseOf< Base, Derived >
 Checks wether a type is derived from another. More...
struct  Dune::IsInteroperable< T1, T2 >
 Checks wether two types are interoperable. More...
struct  Dune::enable_if< b, T >
 Enable typedef if condition is met. More...
struct  Dune::enable_if< false, T >
struct  Dune::EnableIfInterOperable< T1, T2, Type >
 Enable typedef if two types are interoperable. More...
struct  Dune::is_same< T1, T2 >
 Compile time test for testing whether two types are the same. More...
struct  Dune::is_same< T, T >
struct  Dune::SelectType< first, T1, T2 >
 Select a type based on a condition. More...
struct  Dune::SelectType< false, T1, T2 >
struct  Dune::integral_constant< T, v >
 Generate a type for a given integral constant. More...

Namespaces

namespace  Dune
 

Dune namespace.


Modules

 GeometryType
 Parallel Communication
 Debug output
 Dense Matrix and Vector Template Library
 

Type Traits to retrieve the field and the real type of classes.


 Exception handling
 Iterator facades
 

Iterator facades for writing stl conformant iterators.


 Communication for distributed computing
 

Provides classes for syncing distributed indexed data structures.


 FloatCmp
 Filesystem Paths

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

Utility class for handling nested indentation in output.


file  ios_state.hh
 

Utility class for storing and resetting stream attributes.


file  lcm.hh
 

Statically compute the least common multiple of two integers.


file  sllist.hh
 

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
typedef integral_constant
< bool, true > 
Dune::true_type
 type for true
typedef integral_constant
< bool, false > 
Dune::false_type
 type for false

Functions

template<class T , size_t N>
bool Dune::operator< (const array< T, N > &a, const array< T, N > &b)
template<class T , size_t N>
bool Dune::operator> (const array< T, N > &a, const array< T, N > &b)
template<class T , size_t N>
bool Dune::operator<= (const array< T, N > &a, const array< T, N > &b)
template<class T , size_t N>
bool Dune::operator>= (const array< T, N > &a, const array< T, N > &b)
template<class T , size_t N>
std::ostream & Dune::operator<< (std::ostream &s, const array< T, N > &e)
 Output operator for array.
template<class T >
array< T, 10 > Dune::make_array (const T &t0, const T &t1, const T &t2, const T &t3, const T &t4, const T &t5, const T &t6, const T &t7, const T &t8, const T &t9)
 create an initialize an array
template<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 > &)
 operator double ()
 Conversion operator to double.
 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 , 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
Dune::FiniteStack::pop ()
 Dune::Indent::Indent (const std::string &basic_indent_=" ", unsigned level_=0)
 setup without parent
 Dune::Indent::Indent (unsigned level_)
 setup without parent and basic_indentation of two spaces
 Dune::Indent::Indent (const Indent *parent_, const std::string &basic_indent_=" ", unsigned level_=1)
 setup with parent
 Dune::Indent::Indent (const Indent *parent_, unsigned level_)
 setup with parent
Indent Dune::Indent::operator+ (const std::string &newindent) const
 create new indentation object with this one as parent
Indent Dune::Indent::operator+ (unsigned morelevel) const
 create a copy of this indetation object with raised level
Indent & Dune::Indent::operator++ ()
 raise indentation level
Indent & Dune::Indent::operator-- ()
 lower indentation level
std::ostream & Dune::operator<< (std::ostream &s, const Indent &indent)
 write indentation to a stream
 Dune::ios_base_all_saver::ios_base_all_saver (state_type &ios_)
 Constructor that stores the currently used flags.
 Dune::ios_base_all_saver::~ios_base_all_saver ()
 Destructor that restores the flags stored by the constructor.
void Dune::ios_base_all_saver::restore ()
 Restore flags now.
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 C >
bool Dune::hasPrefix (const C &c, const char *prefix)
 check whether a character container has a given prefix
template<typename C >
bool Dune::hasSuffix (const C &c, const char *suffix)
 check whether a character container has a given suffix
template<typename 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<class T >
static std::istream & Dune::tuple_writer::get (std::istream &is, T &t, const char *delim=",")
template<class T >
static std::istream & Dune::tuple_writer< 1 >::get (std::istream &is, T &t, const char *delim=", ")
template<class T >
static std::istream & Dune::tuple_writer< 0 >::get (std::istream &is, T &t, const char *delim=", ")
template<typename T1 , typename T2 , typename U1 , typename U2 >
bool Dune::operator== (const Pair< T1, T2 > &tuple1, const Pair< U1, U2 > &tuple2)
 Equality comparison operator for tuples.
template<typename T1 , typename T2 , typename U1 , typename U2 >
bool Dune::operator!= (const Pair< T1, T2 > &tuple1, const Pair< U1, U2 > &tuple2)
 Inequality comparison operator for tuples.
template<typename T1 , typename T2 , typename U1 , typename U2 >
bool Dune::operator< (const Pair< T1, T2 > &tuple1, const Pair< U1, U2 > &tuple2)
 Less operator for tuples.
template<typename T1 , typename U1 >
bool Dune::operator== (const Pair< T1, Nil > &tuple1, const Pair< U1, Nil > &tuple2)
 Equality comparison operator for tuples.
template<typename T1 , typename U1 >
bool Dune::operator!= (const Pair< T1, Nil > &tuple1, const Pair< U1, Nil > &tuple2)
 Inequality comparison operator for tuples.
template<typename T1 , typename U1 >
bool Dune::operator< (const Pair< T1, Nil > &tuple1, const Pair< U1, Nil > &tuple2)
 Less operator for tuples.
template<typename T1 , typename U1 , typename U2 >
bool Dune::operator== (const Pair< T1, Nil > &tuple1, const Pair< U1, U2 > &tuple2)
 Equality comparison operator for tuples.
template<typename T1 , typename U1 , typename U2 >
bool Dune::operator!= (const Pair< T1, Nil > &tuple1, const Pair< U1, U2 > &tuple2)
 Inequality comparison operator for tuples.
template<typename T1 , typename T2 , typename U1 >
bool Dune::operator== (const Pair< T1, T2 > &tuple1, const Pair< U1, Nil > &tuple2)
 Equality comparison operator for tuples.
template<typename T1 , typename T2 , typename U1 >
bool Dune::operator!= (const Pair< T1, T2 > &tuple1, const Pair< U1, Nil > &tuple2)
 Inequality comparison operator for tuples.
template<typename T1 , typename T2 >
Pair< T1, T2 > Dune::makePair (const T1 &first, const T2 &second)
 Create a tuple and initialize it.
template<typename T1 , typename T2 >
std::ostream & Dune::operator<< (std::ostream &os, const Pair< T1, T2 > &pair)
 Print a pair or tuple.
template<typename T1 >
std::ostream & Dune::operator<< (std::ostream &os, const Pair< T1, Nil > &pair)
template<typename T1 , typename T2 >
std::istream & Dune::operator>> (std::istream &is, Pair< T1, T2 > &pair)
 Read a pair or tuple.
template<typename T1 >
std::istream & Dune::operator>> (std::istream &is, Pair< T1, Nil > &pair)
template<class T1 >
tuple< T1 & > Dune::tie (T1 &t1)
template<class T1 , class T2 >
tuple< T1 &, T2 & > Dune::tie (T1 &t1, T2 &t2)
template<class T1 , class T2 , class T3 >
tuple< T1 &, T2 &, T3 & > Dune::tie (T1 &t1, T2 &t2, T3 &t3)
template<class T1 , class T2 , class T3 , class T4 >
tuple< T1 &, T2 &, T3 &, T4 & > Dune::tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4)
template<class T1 , class T2 , class T3 , class T4 , class T5 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 & > 
Dune::tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 &, T6 & > 
Dune::tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 &, T6 &, T7 & > 
Dune::tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 &, T6 &, T7 &, T8 & > 
Dune::tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 &, T6 &, T7 &, T8 &, T9 & > 
Dune::tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9)
template<class T1 >
tuple< T1 > Dune::make_tuple (const T1 &t1)
template<class T1 , class T2 >
tuple< T1, T2 > Dune::make_tuple (const T1 &t1, const T2 &t2)
template<class T1 , class T2 , class T3 >
tuple< T1, T2, T3 > Dune::make_tuple (const T1 &t1, const T2 &t2, const T3 &t3)
template<class T1 , class T2 , class T3 , class T4 >
tuple< T1, T2, T3, T4 > Dune::make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4)
template<class T1 , class T2 , class T3 , class T4 , class T5 >
tuple< T1, T2, T3, T4, T5 > Dune::make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
tuple< T1, T2, T3, T4, T5, T6 > Dune::make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
tuple< T1, T2, T3, T4, T5, T6, T7 > Dune::make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
tuple< T1, T2, T3, T4, T5, T6,
T7, T8 > 
Dune::make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
tuple< T1, T2, T3, T4, T5, T6,
T7, T8, T9 > 
Dune::make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8, const T9 &t9)
 Dune::ArrayList::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.
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
bigunsignedint< k > Dune::bigunsignedint::operator% (const bigunsignedint< k > &x) const
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 equal
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 Type &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)

Variables

Dune::FiniteStack Dune::nextRow
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 >
std::ostream & Dune::Indent::operator<< (std::ostream &s, const Indent &indent)
 write indentation to a stream

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 deprecated. If something is marked deprecated, users are advised to migrate to the new interface, since it will probably be removed in the next release of Dune.

DUNE_DEPRECATED currently works with g++ 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 {}; // 1)
    class Class {} DUNE_DEPRECATED; // 2)
    
    Both forms do not work properly with g++-4.1: no deprecation warning will be given, although the code still compiles. 1) should be preferred over 2) since 2) does not work with clang++-1.1 (again, no warning given but code still compiles)
  • Template classes
    template<class T>
    class DUNE_DEPRECATED Class {}; // 1)
    template<class T>
    class Class {} DUNE_DEPRECATED; // 2)
    
    This works works with g++-4.3, g++-4.4 and g++-4.5 only, g++-4.1 and clang++ compile the code without warning in both cases. Furthermore, the warning is only triggered when copying an object of that template class, neither making a typedef nor simply creating such an object emit the warning. It is thus recommended that some essential class member be marked deprecated as well, if possible.
  • Member constants
    template<typename T> struct Class {
      static const int c0 DUNE_DEPRECATED = 0;
      static const int DUNE_DEPRECATED c1 = 1;
    };
    
    Works with g++-4.1, g++-4.3, g++-4.4, g++-4.5. No warning but clean compile with clang++-1.1.
  • Member enumerators
    template<typename T> struct Class {
      enum enumeration { enumerator = 0 };
    };
    
    No form of deprecation is known that does not trigger an error on most compilers.
  • Member functions
    template<typename T> struct Class {
      void frob() DUNE_DEPRECATED {}
    };
    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::RemoteIndexListModifier< T, A, mode >::insert(), Dune::operator!=(), Dune::Pool< T, s >::Pool(), and Dune::put().


Typedef Documentation

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

The allocator to use.

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

The mutable iterator of the list.

typedef integral_constant<bool, false> Dune::false_type

type for false

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

The mutable iterator of the list.

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

The type we store.

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

The type of the iterator capable of deletion and insertion.

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

The size type.

typedef integral_constant<bool, true> Dune::true_type

type for true

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

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

The type of the second field.


Function Documentation

template<class T , int N, class A >
void Dune::ArrayListIterator< T, N, A >::advance ( difference_type  n) [inline]
Todo:
Please doc me!
template<class T , int N, class A >
void Dune::ConstArrayListIterator< T, N, A >::advance ( difference_type  n) [inline]
Todo:
Please doc me!
template<class T , std::size_t S>
void * Dune::Pool< T, S >::allocate ( ) [inline]

Get a new or recycled object.

Returns:
A pointer to the object memory.
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]

Allocates objects.

Parameters:
nThe number of objects to allocate. Has to be one!
hintIgnored hint.
Returns:
A pointer tp the allocated elements.
template<class T, int n, int m>
fmatrix_assigner& Dune::fmatrix_assigner< T, n, m >::append ( const T &  t) [inline]

append data to this matrix

References t.

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

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

append zeros to this matrix

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

append zeros to this matrix

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

append data to this vector

References t.

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

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

append zeros to this vector

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

Constructs an Array list with one chunk.

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

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

Returns:
An iterator pointing to the first element or the end if the list is empty.

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

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

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

Returns:
An iterator pointing to the first element or the end if the list is empty.
template<class T , int N, class A >
ArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::begin ( )

Get an iterator that is positioned at the first element.

Returns:
The iterator.
template<class T , int N, class A >
ConstArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::begin ( ) const

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

Returns:
The iterator.
template<typename T , class A >
SLListModifyIterator< T, A > Dune::SLList< T, A >::beginModify ( ) [inline]

Get an iterator capable of deleting and inserting elements.

Returns:
Modifying iterator positioned at the beginning of the list.

Referenced by Dune::IndicesSyncer< T >::Iterators::reset().

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

Construct uninitialized.

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

Construct from signed int.

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

Construct from unsigned int.

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

Remove all elements from the list.

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

Delete all entries from the list.

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]
template<class T , std::size_t s>
void Dune::PoolAllocator< T, s >::construct ( pointer  p,
const_reference  value 
) [inline]

Construct an object.

Parameters:
pPointer to the object.
valueThe value to initialize it to.
template<typename TA , int i>
bool Dune::EnumItem< TA, i >::contains ( const Type attribute) [inline, static]

Tests whether an item is in the set.

Returns:
True if item==Type.
template<typename TA , int from, int to>
bool Dune::EnumRange< TA, from, to >::contains ( const Type item) [inline, static]
template<class TI1 , class TI2 , typename TA >
bool Dune::Combine< TI1, TI2, TA >::contains ( const TA &  item) [inline, static]
template<typename TA >
bool Dune::EmptySet< TA >::contains ( const Type attribute) [inline, static]

Always returns false.

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

Always returns false.

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

Free objects.

Does not call the destructor!

Parameters:
nThe number of objects to free. Has to be one!
pPointer to the first object.
template<class T , int N, class A >
void Dune::ArrayListIterator< T, N, A >::decrement ( ) [inline]

decrement the iterator.

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

decrement the iterator.

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

Delete the entry after the current position.

Warning:
This will invalidate all iterators positioned at the delete position! Use with care!
template<typename T, class A>
T& Dune::SLListIterator< T, A >::dereference ( ) const [inline]

Dereferencing function for the iterator facade.

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

Access the element at the current position.

Returns:
The element at the current position.
template<class T , int N, class A >
ConstArrayListIterator< T, N, A >::const_reference Dune::ConstArrayListIterator< T, N, A >::dereference ( ) const [inline]

Access the element at the current position.

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

Dereferencing function for the facade.

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

Dereferencing function for the iterator facade.

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

Destroy an object without freeing memory.

Parameters:
pPointer to the object.
template<class T, int N, class A>
ArrayListIterator< T, N, A >::difference_type Dune::ArrayListIterator< T, N, A >::distanceTo ( const ArrayListIterator< T, N, A > &  other) const [inline]
Todo:
Please doc me!
template<class T, int N, class A>
ConstArrayListIterator< T, N, A >::difference_type Dune::ConstArrayListIterator< T, N, A >::distanceTo ( const ConstArrayListIterator< T, N, A > &  other) const [inline]
Todo:
Please doc me!
template<typename T , class A >
Dune::SLList< T, A >::Element::Element ( const MemberType item,
Element *  next_ = 0 
)
template<typename T , class A >
Dune::SLList< T, A >::Element::Element ( )
template<class T , int N, class A >
ArrayListIterator< T, N, A >::reference Dune::ArrayListIterator< T, N, A >::elementAt ( size_type  i) const [inline]

Get the value of the list at an arbitrary position.

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

Get the value of the list at an arbitrary position.

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

Check whether the list is empty.

Returns:
True if the list is empty;
template<typename T , class A >
SLListIterator< T, A > Dune::SLList< T, A >::end ( ) [inline]

Get an iterator pointing to the end of the list.

Returns:
An iterator pointing to the end.

Referenced by Dune::CollectiveIterator< T, A >::CollectiveIterator(), Dune::operator<<(), Dune::RemoteIndices< T, A >::operator==(), and Dune::IndicesSyncer< T >::sync().

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

Get an iterator pointing to the end of the list.

Returns:
An iterator pointing to the end.
template<class T , int N, class A >
ArrayListIterator< T, N, A > Dune::ArrayList< T, N, A >::end ( )

Get a random access iterator positioned after the last element.

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

Get a random access iterator positioned after the last element.

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

Get an iterator capable of deleting and inserting elements.

Returns:
Modifying iterator positioned after the end of the list.
template<typename T, class A>
bool Dune::SLListIterator< T, A >::equals ( const SLListIterator< T, A > &  other) const [inline]

Equality test for the iterator facade.

Parameters:
otherThe other iterator to check.
Returns:
true If the other iterator is at the same position.
template<typename T, class A>
bool Dune::SLListIterator< T, A >::equals ( const SLListModifyIterator< T, A > &  other) const [inline]

Equality test for the iterator facade.

Parameters:
otherThe other iterator to check.
Returns:
true If the other iterator is at the same position.
template<class T , int N, class A>
bool Dune::ArrayListIterator< T, N, A >::equals ( const ArrayListIterator< MemberType, N, A > &  other) const [inline]

Comares two iterators.

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

Comares two iterators.

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

Comares to iterators.

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

Equality test for the iterator facade.

Parameters:
otherThe other iterator to check.
Returns:
true If the other iterator is at the same position.
template<class T, class A>
bool Dune::SLListConstIterator< T, A >::equals ( const SLListConstIterator< T, A > &  other) const [inline]

Equality test for the iterator facade.

Parameters:
otherThe other iterator to check.
Returns:
true If the other iterator is at the same position.
template<typename T, class A>
bool Dune::SLListModifyIterator< T, A >::equals ( const SLListConstIterator< T, A > &  other) const [inline]

Test whether another iterator is equal.

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

Test whether another iterator is equal.

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

Test whether another iterator is equal.

Returns:
true if the other iterator is at the same position as this one.
template<class T , int N, class A >
void Dune::ArrayListIterator< T, N, A >::eraseToHere ( ) [inline]

Erase all entries before the current position and the one at the current position.

Afterwards the iterator will be positioned at the next unerased entry or the end if the list is empty. This does not invalidate any iterators positioned after the current position but those positioned at previous ones.

Returns:
An iterator to the first position after the deleted ones or to the end if the list is empty.
template<typename T1 , typename T2 >
TupleAccessTraits< T1 >::NonConstType Dune::Pair< T1, T2 >::first ( ) [inline]

Get the first value.

Returns:
The first value

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

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

Get the first value.

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

Get the first value.

Returns:
The first value

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

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

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

Get the first value.

Returns:
The first value

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

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

Copy Constructor.

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

Constructor from matrix and temporary flag.

Parameters:
_Amatrix which should be initialized
tbool indicating, that this is a temporary object (see ~fmatrix_assigner)
template<class T , std::size_t S>
void Dune::Pool< T, S >::free ( void *  o) [inline]

Free an object.

Parameters:
oThe pointer to memory block of the object.
template<class T, int s>
Dune::fvector_assigner< T, s >::fvector_assigner ( fvector_assigner< T, s > &  a) [inline]

Copy Constructor.

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

Constructor from vector and temporary flag.

Parameters:
_vvector which should be initialized
tbool indicating, that this is a temporary object (see ~fvector_assigner)
std::string Dune::genFilename ( const std::string &  path,
const std::string &  fn,
int  ntime,
int  precision = 6 
) [inline]

Generate filenames with timestep number in it.

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

Get the N-th element of the tuple.

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

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

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

Get the first element of the tuple.

Parameters:
tupleThe tuple whose first element we want.
Returns:
The first element of the tuple.

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

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

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

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

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

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

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

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

References t.

template<class T >
static std::istream& Dune::tuple_writer< 0 >::get ( std::istream &  is,
T &  t,
const char *  delim = ", " 
) [inline, static]
template<typename C >
bool Dune::hasPrefix ( const C &  c,
const char *  prefix 
)

check whether a character container has a given prefix

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

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

template<typename C >
bool Dune::hasSuffix ( const C &  c,
const char *  suffix 
)

check whether a character container has a given suffix

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

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

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

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

Increment function for the iterator facade.

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

Increment the iterator.

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

Increment the iterator.

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

Increment function for the iterator facade.

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

Increment function for the iterator facade.

Dune::Indent::Indent ( const std::string &  basic_indent_ = "  ",
unsigned  level_ = 0 
) [inline]

setup without parent

Note:
Initial indentation level is 0 by default for this constructor.

Referenced by Dune::Indent::operator+().

Dune::Indent::Indent ( const Indent parent_,
const std::string &  basic_indent_ = "  ",
unsigned  level_ = 1 
) [inline]

setup with parent

Note:
Initial indentation level is 1 by default for this constructor.
Dune::Indent::Indent ( unsigned  level_) [inline]

setup without parent and basic_indentation of two spaces

Dune::Indent::Indent ( const Indent parent_,
unsigned  level_ 
) [inline]

setup with parent

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

Insert an element at the current position.

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

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

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

Parameters:
vThe value to insert.
Dune::ios_base_all_saver::ios_base_all_saver ( state_type ios_)

Constructor that stores the currently used flags.

Parameters:
ios_The ios_base object whose flags are to be saved and restored. Any stream object should work here.
Note:
A reference to the ios_base object is store in this object. Thus the ios_base object must remain valid until the destructor of this object has been called.
template<class T >
array<T, 10> Dune::make_array ( const T &  t0,
const T &  t1,
const T &  t2,
const T &  t3,
const T &  t4,
const T &  t5,
const T &  t6,
const T &  t7,
const T &  t8,
const T &  t9 
)

create an initialize an array

Note:
There are overloads for this method which take fewer arguments (minimum 1). The current maximum of 10 arguments is arbitrary and can be raised on demand.
This method is Dune-specific and not part of any C++-standard.
template<class T1 >
tuple<T1> Dune::make_tuple ( const T1 &  t1) [inline]
template<class T1 , class T2 >
tuple<T1, T2> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2 
) [inline]
template<class T1 , class T2 , class T3 >
tuple<T1, T2, T3> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3 
) [inline]
template<class T1 , class T2 , class T3 , class T4 >
tuple<T1, T2, T3, T4> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4 
) [inline]
template<class T1 , class T2 , class T3 , class T4 , class T5 >
tuple<T1, T2, T3, T4, T5> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5 
) [inline]
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
tuple<T1, T2, T3, T4, T5, T6> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5,
const T6 &  t6 
) [inline]
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
tuple<T1, T2, T3, T4, T5, T6, T7> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5,
const T6 &  t6,
const T7 &  t7 
) [inline]
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
tuple<T1, T2, T3, T4, T5, T6, T7, T8> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5,
const T6 &  t6,
const T7 &  t7,
const T8 &  t8 
) [inline]
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> Dune::make_tuple ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5,
const T6 &  t6,
const T7 &  t7,
const T8 &  t8,
const T9 &  t9 
) [inline]
template<typename T1 , typename T2 >
Pair<T1,T2> Dune::makePair ( const T1 &  first,
const T2 &  second 
) [inline]

Create a tuple and initialize it.

Parameters:
firstThe value of the first field.
secondThe value of the second field.
zero::operator double ( )

Conversion operator to double.

zero::operator int ( )

Conversion operator to int.

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< 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<typename T1 , typename T2 , typename U1 , typename U2 >
bool Dune::operator!= ( const Pair< T1, T2 > &  tuple1,
const Pair< U1, U2 > &  tuple2 
) [inline]

Inequality comparison operator for tuples.

Parameters:
tuple1The first tuple.
tuple2The second tuple,

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

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

Inequality comparison operator for tuples.

Parameters:
tuple1The first tuple.
tuple2The second tuple,

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

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

Inequality comparison operator for tuples.

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

Inequality comparison operator for tuples.

Parameters:
tuple1The first tuple.
tuple2The second tuple.
Returns:
True as the type of the compared objects are different.
template<typename T , class A >
bool Dune::SLList< T, A >::operator!= ( const SLList< T, A > &  sl) const
template<int k>
bool Dune::bigunsignedint< k >::operator!= ( const bigunsignedint< k > &  x) const [inline]

not equal

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

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

modulo

Warning:
This function is very slow and its usage should be prevented if possible
template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator& ( const bigunsignedint< k > &  x) const [inline]

bitwise and

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

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

Dereference as object.

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

Dereference as const object.

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

create new indentation object with this one as parent

References Dune::Indent::Indent().

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

create a copy of this indetation object with raised level

References Dune::Indent::Indent().

template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator+ ( const bigunsignedint< k > &  x) const [inline]
Indent& Dune::Indent::operator++ ( ) [inline]

raise indentation level

template<int k>
bigunsignedint< k > & Dune::bigunsignedint< k >::operator++ ( ) [inline]
template<class T, int n, int m>
fmatrix_assigner& Dune::fmatrix_assigner< T, n, m >::operator, ( const T &  t) [inline]

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

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

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

append zeros to this matrix the overloaded comma operator is used to stop the assign of values to the matrix, all remaining entries are assigned 0.

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

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

append zeros to this matrix the overloaded comma operator is used to stop the assign of values to the matrix, all remaining entries are assigned 0.

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

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

append zeros to this vector the overloaded comma operator is used to stop the assign of values to the vector, all remaining entries are assigned 0.

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

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

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

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

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

lower indentation level

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

Dereference as pointer.

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

Dereference as const pointer.

template<int k>
bigunsignedint<k> Dune::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]

divide

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

References DUNE_THROW.

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

Less operator for tuples.

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

Less operator for tuples.

Parameters:
tuple1The first tuple.
tuple2The second tuple,

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

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

less than

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

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

Output operator for array.

template<typename TA , int from, int to>
std::ostream& Dune::operator<< ( std::ostream &  os,
const EnumRange< TA, from, to > &   
) [inline]
template<typename T1 , typename T2 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const Pair< T1, T2 > &  pair 
) [inline]

Print a pair or tuple.

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

template<typename T1 >
std::ostream& Dune::operator<< ( std::ostream &  os,
const Pair< T1, Nil > &  pair 
) [inline]
template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator<< ( int  i) const [inline]
template<int k>
std::ostream& Dune::operator<< ( std::ostream &  s,
const bigunsignedint< k > &  x 
) [inline]
std::ostream& Dune::operator<< ( std::ostream &  s,
const Indent &  indent 
) [inline]

write indentation to a stream

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

fvector assignment operator

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

References t.

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

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 
)

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 
)

fvector assignment operator

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

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

less than or equal

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

template<class T , size_t N>
bool Dune::operator<= ( const array< T, N > &  a,
const array< T, N > &  b 
) [inline]
template<typename T1 , typename T2 >
Pair< T1, T2 > & Dune::Pair< T1, T2 >::operator= ( const Pair< T1, TT > &  other) [inline]
template<typename T1 >
template<typename T2 >
Pair< T1, Nil > & Dune::Pair< T1, Nil >::operator= ( const Pair< T2, Nil > &  other)

Assignment operator for type conversion.

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

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

Assignment operator for implicit type conversion.

Parameters:
otherThe tuple to assign.

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

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

Assignment operator.

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

Assignment operator.

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

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

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]
template<class T, int N, class A>
ArrayListIterator< T, N, A > & Dune::ArrayListIterator< T, N, A >::operator= ( const ArrayListIterator< T, N, A > &  other) [inline]
Todo:
Please doc me!
template<typename T1 , typename T2 >
template<typename U1 , typename U2 >
Pair< T1, T2 > & Dune::Pair< T1, T2 >::operator= ( const Pair< U1, U2 > &  other) [inline]
template<typename T1 , 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< void, t2 > &   
)
template<typename T1 , typename U1 , typename U2 >
bool Dune::operator== ( const Pair< T1, Nil > &  tuple1,
const Pair< U1, U2 > &  tuple2 
) [inline]

Equality comparison operator for tuples.

Parameters:
tuple1The first tuple.
tuple2The second tuple.
Returns:
False as the type of the compared objects are different.
template<std::size_t t1, std::size_t t2>
bool Dune::operator== ( const PoolAllocator< void, t1 > &  ,
const PoolAllocator< void, t2 > &   
)
template<int k>
bool Dune::bigunsignedint< k >::operator== ( const bigunsignedint< k > &  x) const [inline]

equal

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

Equality comparison operator for tuples.

Parameters:
tuple1The first tuple.
tuple2The second tuple,

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

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

Equality comparison operator for tuples.

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

Equality comparison operator for tuples.

Parameters:
tuple1The first tuple.
tuple2The second tuple,

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

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

greater than

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

greater or equal

template<typename T1 >
std::istream& Dune::operator>> ( std::istream &  is,
Pair< T1, Nil > &  pair 
) [inline]
template<typename T1 , typename T2 >
std::istream& Dune::operator>> ( std::istream &  is,
Pair< T1, T2 > &  pair 
) [inline]

Read a pair or tuple.

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

template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator>> ( int  i) const [inline]
template<class T , int N, class A >
ArrayList< T, N, A >::const_reference Dune::ArrayList< T, N, A >::operator[] ( size_type  i) const [inline]

Get the element at specific position.

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

Get the element at specific position.

Parameters:
iThe index of the position.
Returns:
The element at that position.
template<int k>
bigunsignedint< k > Dune::bigunsignedint< k >::operator^ ( const bigunsignedint< k > &  x) const [inline]

bitwise exor

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

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

bitwise or

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

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

bitwise komplement

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

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

Constructor.

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

Copy Constructor for implicit type conversion.

Parameters:
otherThe tuple to copy.
template<typename T1 >
template<typename T2 >
Dune::Pair< T1, Nil >::Pair ( const Pair< T2, Nil > &  other) [inline]

Copy constructor for type conversion.

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

The number of values we hold.

Constructor

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

Constructor.

Parameters:
firstThe values for the first field.
template<typename T1 , typename TT >
Dune::Pair< T1, TT >::Pair ( typename TupleAccessTraits< Type1 >::ParameterType  t1,
TT &  t2 
) [inline]

Constructor.

Parameters:
t1The value of the first field.
t2The value of the second field.
template<typename T1 , typename T2 >
Dune::Pair< T1, T2 >::Pair ( ) [inline]
template<typename T1 >
Dune::Pair< T1, Nil >::Pair ( ) [inline]
template<class T , std::size_t S>
Dune::Pool< T, S >::Pool ( ) [inline]
template<class T , std::size_t s>
Dune::PoolAllocator< T, s >::PoolAllocator ( ) [inline]

Constructor.

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

Removes and returns the uppermost object from the stack

Warning:
This differs from the semantics of std::stack, where pop() returns void

References DUNE_THROW.

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

Remove the first item in the list.

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

Print number in hex notation.

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

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

Print elements in pool for debugging.

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

Purge the list.

If there are empty chunks at the front all nonempty chunks will be moved towards the front and the capacity increases.

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

Append an entry to the list.

Parameters:
entryThe new entry.
template<typename T , class A >
void Dune::SLList< T, A >::push_back ( const MemberType item) [inline]

Add a new entry to the end of the list.

Parameters:
itemThe item to add.

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

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

Add a new entry to the beginning of the list.

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

Delete the entry at the current position.

The iterator will be positioned at the next postion after the deletion

Warning:
This will invalidate all iterators positioned at the delete position! Use with care!
template<class T>
template<class Deleter >
void Dune::shared_ptr< T >::reset ( T *  pointer,
Deleter  deleter 
) [inline]
template<class T >
void Dune::shared_ptr< T >::reset ( ) [inline]

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

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

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

void Dune::ios_base_all_saver::restore ( )

Restore flags now.

The flags will also be restored at destruction time even if this method was used.

Referenced by Dune::ios_base_all_saver::~ios_base_all_saver().

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

Get the second value.

Returns:
The second value

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

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

Get the second value.

Returns:
The second value
template<class T>
Dune::shared_ptr< T >::shared_ptr ( T *  pointer) [inline]

Constructs a new smart pointer from a preallocated Object.

Parameters:
pointerRaw pointer to the shared data

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

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

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]

Constructs a new smart pointer from a preallocated Object.

Template Parameters:
DeleterThis class must by copyconstructable, the copy constructor must not throw an exception and it must implement void operator() (T*) const
Parameters:
pointerRaw pointer to the shared data
deleterA copy of this deleter is stored

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

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

Copy constructor.

Parameters:
pointerThe object to copy.
template<class T >
int Dune::sign ( const T &  val)

Return the sign of the value.

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

Get the number of elements in the list.

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

Get the number of elements the list contains.

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

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

Constructor.

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

Copy constructor with type conversion.

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

Copy constructor.

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

Compute the square of T.

References t.

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

Swap content of this shared_ptr and another.

template<class T1 , class T2 >
tuple<T1&, T2&> Dune::tie ( T1 &  t1,
T2 &  t2 
) [inline]
template<class T1 >
tuple<T1&> Dune::tie ( T1 &  t1) [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 >
tuple<T1&, T2&, T3&> Dune::tie ( T1 &  t1,
T2 &  t2,
T3 &  t3 
) [inline]
template<class T1 , class T2 , class T3 , class T4 >
tuple<T1&, T2&, T3&, T4&> Dune::tie ( T1 &  t1,
T2 &  t2,
T3 &  t3,
T4 &  t4 
) [inline]
template<class T1 , class T2 , class T3 , class T4 , class T5 , 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 >
tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> Dune::tie ( T1 &  t1,
T2 &  t2,
T3 &  t3,
T4 &  t4,
T5 &  t5,
T6 &  t6,
T7 &  t7 
) [inline]
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&> Dune::tie ( T1 &  t1,
T2 &  t2,
T3 &  t3,
T4 &  t4,
T5 &  t5,
T6 &  t6,
T7 &  t7,
T8 &  t8 
) [inline]
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
tuple<T1&, T2&, T3&, T4&, T5&, T6&> Dune::tie ( T1 &  t1,
T2 &  t2,
T3 &  t3,
T4 &  t4,
T5 &  t5,
T6 &  t6 
) [inline]
template<int k>
double Dune::bigunsignedint< k >::todouble ( ) const [inline]

Convert to a double.

Warning:
Subject to rounding errors!

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

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

export to other types

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

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

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

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

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

References DUNE_THROW.

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

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

References DUNE_THROW.

Dune::ios_base_all_saver::~ios_base_all_saver ( )

Destructor that restores the flags stored by the constructor.

References Dune::ios_base_all_saver::restore().

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

Destructor.

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

Destructor.

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

Destructor.

Deallocates all elements in the list.


Variable Documentation

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

The value of the first field.

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

The element we hold.

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

The value of the second field.

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

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

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


Friends

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

write indentation to a stream

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