Common

foundation classes More...

Classes

struct  Dune::AlignmentOf< T >
 Calculates the alignment requirement of a type. More...
class  Dune::ArrayList< T, N, A >
 A dynamically growing random access list. More...
class  Dune::ArrayListIterator< T, N, A >
 A random access iterator for the Dune::ArrayList class. More...
class  Dune::ConstArrayListIterator< T, N, A >
 A constant random access iterator for the Dune::ArrayList class. More...
struct  Dune::AlwaysVoid< T >
struct  Dune::IsVector< T, class >
struct  Dune::IsVector< T, typename AlwaysVoid< typename T::field_type >::type >
class  Dune::EmptySet< TA >
 An empty set. More...
class  Dune::AllSet< TA >
 A set containing everything. More...
class  Dune::EnumItem< TA, item >
 A set consisting only of one item. More...
class  Dune::EnumRange< TA, from, end >
 A set representing a range including the borders. More...
class  Dune::NegateSet< S >
 The negation of a set. An item is contained in the set if and only if it is not contained in the negated set. More...
class  Dune::Combine< TI1, TI2, TA >
 A set combining two other sets. More...
class  Dune::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...
class  Dune::ParameterTree
 Hierarchical structure of string parameters. More...
class  Dune::ParameterTreeParser
 Parsers to set up a ParameterTree from various input sources. More...
struct  Dune::StaticPower< m, p >
 Calculates m^p at compile time. More...
struct  Dune::StaticPower< m, 0 >
 end of recursion via specialization More...
struct  Dune::Power< p >
 Compute power for a run-time mantissa and a compile-time integer exponent. More...
struct  Dune::PromotionTraits< T1, T2 >
 Compute type of the result of an arithmetic operation involving two different number types. More...
struct  Dune::PromotionTraits< T1, T1 >
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::Empty
 Just an empty class. More...
struct  Dune::ConstantVolatileTraits< T >
 Determines whether a type is const or volatile and provides the unqualified types. More...
struct  Dune::IsVolatile< T >
 Tests whether a type is volatile. More...
struct  Dune::IsConst< T >
 Tests whether a type is constant. More...
struct  Dune::remove_const< T >
struct  Dune::remove_reference< T >
struct  Dune::Conversion< From, To >
 Checks whether a type is convertible to another. More...
struct  Dune::IsBaseOf< Base, Derived >
 Checks whether a type is derived from another. More...
struct  Dune::IsInteroperable< T1, T2 >
 Checks whether two types are interoperable. More...
struct  Dune::enable_if< B, T >
struct  Dune::enable_if< true, T >
struct  Dune::EnableIfInterOperable< T1, T2, Type >
 Enable typedef if two types are interoperable. More...
struct  Dune::is_same< T, U >
struct  Dune::conditional< B, T, F >
struct  Dune::integral_constant< T, v >
struct  Dune::true_type
struct  Dune::false_type
struct  Dune::is_pointer< T >
struct  Dune::is_lvalue_reference< T >
struct  Dune::remove_pointer< T >
struct  Dune::AlwaysFalse< T >
 template which always yields a false value More...
struct  Dune::AlwaysTrue< T >
 template which always yields a true value More...
struct  Dune::IsNumber< T >
struct  Dune::IsNumber< std::complex< T > >
struct  Dune::has_nan< T >
struct  Dune::has_nan< std::complex< T > >
struct  Dune::is_indexable< T, I >
struct  Dune::is_range< T, typename >
struct  Dune::IsTuple< T >
 Check if T is a std::tuple<...>. More...
struct  Dune::IsTupleOrDerived< T >
 Check if T derived from a std::tuple<...>. More...
struct  Dune::IsIntegralConstant< T >
 Check if T is an std::integral_constant<I, i>. More...
struct  Dune::SizeOf< T >
 Compute size of variadic type list. More...

Namespaces

namespace  Dune::Indices
 

Namespace with predefined compile time indices for the range [0,19].


namespace  Dune::Impl
namespace  Dune::Imp

Modules

 Allocators
 

Implementations of the STL allocator concept.


 Utilities
 

Collection of helper classes, type traits, etc.


 Numbers
 

Class implementing different number representations and helper functions.


 Debug output
 Dense Matrix and Vector Template Library
 

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


 Exception handling
 Iterator facades
 

Iterator facades for writing stl conformant iterators.


 Parallel Communication
 

Abstractions for paralle computing.


 Filesystem Paths
 

Utilities for filesystem path management.


Files

file  alignment.hh
 

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


file  function.hh
 

Simple base class templates for functions.


file  gcd.hh
 

Statically compute the greatest common divisor of two integers.


file  indent.hh
 

Utility class for handling nested indentation in output.


file  ios_state.hh
 

Utility class for storing and resetting stream attributes.


file  lcm.hh
 

Statically compute the least common multiple of two integers.


file  sllist.hh
 

Implements a singly linked list together with the necessary iterators.


file  timer.hh
 

A simple timing class.


Defines

#define DUNE_ASSERT_BOUNDS(cond)
 If `DUNE_CHECK_BOUNDS` is defined: check if condition cond holds; otherwise, do nothing.
#define DUNE_DEPRECATED
 Mark some entity as deprecated.
#define DUNE_DEPRECATED_MSG(text)   DUNE_DEPRECATED
 Mark some entity as deprecated.
#define DUNE_NO_DEPRECATED_BEGIN   ...
 Ignore deprecation warnings (start).
#define DUNE_NO_DEPRECATED_END   ...
 Ignore deprecation warnings (end).

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 constant iterator of the list.
typedef SLListModifyIterator
< T, A > 
Dune::SLList::ModifyIterator
 The type of the iterator capable of deletion and insertion.

Functions

template<typename T , std::size_t n>
std::array< T, n > Dune::fill_array (const T &t)
 Create an array and fill it with copies of the provided value.
template<class A , class B >
auto Dune::dot (const A &a, const B &b)-> typename std
 computes the dot product for fundamental data types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b
template<typename TA , int i>
std::ostream & Dune::operator<< (std::ostream &os, const EnumItem< TA, i > &)
template<typename TA , int from, int to>
std::ostream & Dune::operator<< (std::ostream &os, const EnumRange< TA, from, to > &)
template<class TI1 , class TI2 >
Combine< TI1, TI2, typename
TI1::Type > 
Dune::combine (const TI1 &set1, const TI2 &set2)
template<class TI1 , class TI2 , class T >
std::ostream & Dune::operator<< (std::ostream &os, const Combine< TI1, TI2, T > &)
 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.
 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 ()
 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 Stream , typename... Ts>
Stream & Dune::operator<< (Stream &stream, const std::tuple< Ts...> &t)
 Print a std::tuple.
template<typename Stream , typename... Ts>
Stream & Dune::operator>> (Stream &stream, std::tuple< Ts...> &t)
 Read a std::tuple.
template<typename Stream , typename T , std::size_t N>
Stream & Dune::operator<< (Stream &stream, const std::array< T, N > &a)
 Print a std::array.
 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)
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)

Variables

constexpr index_constant< 1 > Dune::Indices::_1 = {}
 Compile time index with value 1.
constexpr index_constant< 2 > Dune::Indices::_2 = {}
 Compile time index with value 2.
constexpr index_constant< 3 > Dune::Indices::_3 = {}
 Compile time index with value 3.
constexpr index_constant< 4 > Dune::Indices::_4 = {}
 Compile time index with value 4.
constexpr index_constant< 5 > Dune::Indices::_5 = {}
 Compile time index with value 5.
constexpr index_constant< 6 > Dune::Indices::_6 = {}
 Compile time index with value 6.
constexpr index_constant< 7 > Dune::Indices::_7 = {}
 Compile time index with value 7.
constexpr index_constant< 8 > Dune::Indices::_8 = {}
 Compile time index with value 8.
constexpr index_constant< 9 > Dune::Indices::_9 = {}
 Compile time index with value 9.
constexpr index_constant< 10 > Dune::Indices::_10 = {}
 Compile time index with value 10.
constexpr index_constant< 11 > Dune::Indices::_11 = {}
 Compile time index with value 11.
constexpr index_constant< 12 > Dune::Indices::_12 = {}
 Compile time index with value 12.
constexpr index_constant< 13 > Dune::Indices::_13 = {}
 Compile time index with value 13.
constexpr index_constant< 14 > Dune::Indices::_14 = {}
 Compile time index with value 14.
constexpr index_constant< 15 > Dune::Indices::_15 = {}
 Compile time index with value 15.
constexpr index_constant< 16 > Dune::Indices::_16 = {}
 Compile time index with value 16.
constexpr index_constant< 17 > Dune::Indices::_17 = {}
 Compile time index with value 17.
constexpr index_constant< 18 > Dune::Indices::_18 = {}
 Compile time index with value 18.
constexpr index_constant< 19 > Dune::Indices::_19 = {}
 Compile time index with value 19.
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.

Friends

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

Detailed Description

foundation classes


Define Documentation

#define DUNE_ASSERT_BOUNDS ( cond   ) 
Value:
do {                                                      \
    if (!(cond))                                            \
      DUNE_THROW(Dune::RangeError, "Index out of bounds."); \
  } while (false)

If `DUNE_CHECK_BOUNDS` is defined: check if condition cond holds; otherwise, do nothing.

Meant to be used for conditions that assure writes and reads do not occur outside of memory limits or pre-defined patterns and related conditions.

#define DUNE_DEPRECATED

Mark some entity as deprecated.

 *#include <dune/common/deprecated.hh>

This is a preprocessor define which can be used to mark functions, typedefs, enums and other stuff deprecated. If something is marked deprecated, users are advised to migrate to the new interface, since it will probably be removed in the next release of Dune.

DUNE_DEPRECATED currently works with g++ and clang++. For other compilers it will be defined empty. This way the user will not get any deprecation warning, but at least his code still compiles (well, until the next Dune release, that is).

Here are some examples how to mark different stuff deprecated:

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

Mark some entity as deprecated.

 *#include <dune/common/deprecated.hh>

This is a preprocessor define which can be used to mark functions, typedefs, enums and other stuff deprecated and to also specify a hint what replaces the given functionality. If something is marked deprecated, users are advised to migrate to the new interface, since it will probably be removed in the next release of Dune.

DUNE_DEPRECATED_MSG currently works only for compilers which support the attribute __attribute__((deprecated("message")). For other compilers it will be defined empty. This way the user will not get any deprecation warning, but at least his code still compiles (well, until the next Dune release, that is).

Here are some examples how to mark different stuff deprecated:

  • Classes
       class DUNE_DEPRECATED_MSG("In the future, please use 'Glass'") Class {}; // 1)
       class Class {} DUNE_DEPRECATED_MSG("In the future, please use 'Glass'"); // 2)
    
    For both forms, deprecation warnings and the additional hint "In the future, please use 'Glass'" will be printed on compilers which support it (e.g. G++ >= 4.5.0, clang++ >= 1.1). For compilers which support deprecating but do not take an additional hint (e.g. G++ < 4.5.0), only the deprecation warning is printed, and finally compilers which do not support deprecation of code won't print anything, but the code will still compile. 1) should be preferred over 2) since 2) does not work with clang++-1.1 (again, no warning will be given but code still compiles)
  • Template classes
       template<class T>
       class DUNE_DEPRECATED_MSG("In the future, please use 'Glass'") Class {}; // 1)
       template<class T>
       class Class {} DUNE_DEPRECATED_MSG("In the future, please use 'Glass'"); // 2)
    
    This works works with g++ >= 4.5, clang++ until at least version 1.1 will compile the code without warning in both cases. Furthermore, the warning is only triggered when copying an object of that template class, neither making a typedef nor simply creating such an object emit the warning. It is thus recommended that some essential class member be marked deprecated as well, if possible.
  • Member constants
       template<typename T> struct Class {
       static const int c0 DUNE_DEPRECATED_MSG("c2 is the new hype") = 0;
       static const int DUNE_DEPRECATED_MSG("c2 is the new hype") c1 = 1;
       };
    
    Works without printing the hint on g++-4.1, g++-4.3, g++-4.4 and fully on g++ >= 4.5. Works for clang++-3.1. No warning but clean compile with clang++-1.1.
  • Member enumerators
       template<typename T> struct Class {
       enum enumeration { enumerator = 0 };
       };
    
    No form of deprecation is known that does not trigger an error on most compilers.
  • Member functions
       template<typename T> struct Class {
       void frob() DUNE_DEPRECATED_MSG("use frog") {}
       }; // 1)
       template<typename T> struct Class {
       void DUNE_DEPRECATED_MSG("use frog") frob() {}
       }; // 2)
       template<typename T> struct Class {
       DUNE_DEPRECATED_MSG("use frog") void frob() {}
       }; // 3)
    
    With g++ only 2) emits a warning for templated member functions.
#define DUNE_NO_DEPRECATED_BEGIN   ...

Ignore deprecation warnings (start).

This macro can be used together with `DUNE_NO_DEPRECATED_END` to mark a block in which deprecation warnings are ignored. This can be useful for implementations of deprecated methods that call other deprecated methods or for testing deprecated methods in the testsuite.

     DUNE_NO_DEPRECATED_BEGIN
     some_deprecated_function();
     another_deprecated_function();
     DUNE_NO_DEPRECATED_END
Warning:
This macro must always be used together with `DUNE_NO_DEPRECATED_END`
#define DUNE_NO_DEPRECATED_END   ...

Ignore deprecation warnings (end).

Warning:
This macro must always be used together with `DUNE_NO_DEPRECATED_BEGIN`

Typedef Documentation

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

The allocator to use.

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

The constant iterator of the list.

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

The mutable iterator of the list.

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

The type we store.

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

The type of the iterator capable of deletion and insertion.

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

The size type.


Function Documentation

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

Constructs an Array list with one chunk.

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

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

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

Get an iterator that is positioned at the first element.

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

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

Returns:
An iterator pointing to the first element or the end if the list is empty.
template<typename T , class A >
SLListIterator< T, A > Dune::SLList< T, A >::begin (  )  [inline, inherited]

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

Returns:
An iterator pointing to the first element or the end if the list is empty.
template<typename T , class A >
SLListModifyIterator< T, A > Dune::SLList< T, A >::beginModify (  )  [inline, inherited]

Get an iterator capable of deleting and inserting elements.

Returns:
Modifying iterator positioned at the beginning of the list.
template<class T , int N, class A >
void Dune::ArrayList< T, N, A >::clear (  )  [inline, inherited]

Delete all entries from the list.

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

Remove all elements from the list.

template<class TI1 , class TI2 >
Combine<TI1,TI2,typename TI1::Type> Dune::combine ( const TI1 &  set1,
const TI2 &  set2 
) [inline]
template<class T, int N, class A>
Dune::ConstArrayListIterator< T, N, A >::ConstArrayListIterator ( const ArrayListIterator< T, N, A > &  other  )  [inline, inherited]
template<class TI1 , class TI2 , typename TA >
bool Dune::Combine< TI1, TI2, TA >::contains ( const TA &  item  )  [inline, static, inherited]
template<typename TA , int from, int to>
bool Dune::EnumRange< TA, from, to >::contains ( const Type item  )  [inline, static, inherited]
template<typename TA , int i>
bool Dune::EnumItem< TA, i >::contains ( const Type attribute  )  [inline, static, inherited]

Tests whether an item is in the set.

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

Always returns false.

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

Always returns false.

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

decrement the iterator.

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

decrement the iterator.

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

Delete the entry after the current position.

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

Access the element at the current position.

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

Access the element at the current position.

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

Dereferencing function for the iterator facade.

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

Dereferencing function for the facade.

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

Dereferencing function for the iterator facade.

Returns:
A reference to the element at the current position.
template<class T, int N, class A>
ConstArrayListIterator< T, N, A >::difference_type Dune::ConstArrayListIterator< T, N, A >::distanceTo ( const ConstArrayListIterator< T, N, A > &  other  )  const [inline, inherited]
Todo:
Please doc me!
template<class T, int N, class A>
ArrayListIterator< T, N, A >::difference_type Dune::ArrayListIterator< T, N, A >::distanceTo ( const ArrayListIterator< T, N, A > &  other  )  const [inline, inherited]
Todo:
Please doc me!
template<class A , class B >
auto Dune::dot ( const A &  a,
const B &  b 
) [inline]

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

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

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

Specialization for real first arguments which replaces conj(a) by a.

See also:
http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Vec/VecTDot.html#VecTDot
Parameters:
a 
b 
Returns:
a*b (which is the same as conj(a)*b in this case)

Specialization for real first arguments which replaces conj(a) by a.

See also:
http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Vec/VecTDot.html#VecTDot
Parameters:
a 
b 
Returns:
dot(a,b)
template<typename T , class A >
Dune::SLList< T, A >::Element::Element (  )  [inline, inherited]
template<typename T , class A >
Dune::SLList< T, A >::Element::Element ( const MemberType item,
Element *  next_ = 0 
) [inline, inherited]
template<class T , int N, class A >
ConstArrayListIterator< T, N, A >::const_reference Dune::ConstArrayListIterator< T, N, A >::elementAt ( size_type  i  )  const [inline, inherited]

Get the value of the list at an arbitrary position.

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

Get the value of the list at an arbitrary position.

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

Check whether the list is empty.

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

Get a random access iterator positioned after the last element.

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

Get a random access iterator positioned after the last element.

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

Get an iterator pointing to the end of the list.

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

Get an iterator pointing to the end of the list.

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

Get an iterator capable of deleting and inserting elements.

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

Comares to iterators.

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

Comares two iterators.

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

Comares two iterators.

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

Test whether another iterator is equal.

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

Test whether another iterator is equal.

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

Test whether another iterator is equal.

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

Equality test for the iterator facade.

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

Equality test for the iterator facade.

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

Equality test for the iterator facade.

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

Equality test for the iterator facade.

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

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

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

Returns:
An iterator to the first position after the deleted ones or to the end if the list is empty.
template<typename T , std::size_t n>
std::array<T,n> Dune::fill_array ( const T &  t  )  [inline]

Create an array and fill it with copies of the provided value.

Note:
This method is Dune-specific and not part of any C++ standard.
template<class T , int N, class A >
void Dune::ConstArrayListIterator< T, N, A >::increment (  )  [inline, inherited]

Increment the iterator.

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

Increment the iterator.

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

Increment function for the iterator facade.

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

Increment function for the iterator facade.

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

Increment function for the iterator facade.

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

setup with parent

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

setup with parent

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

setup without parent and basic_indentation of two spaces

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

setup without parent

Note:
Initial indentation level is 0 by default for this constructor.
template<typename T, class A>
void Dune::SLListModifyIterator< T, A >::insert ( const T &  v  )  [inline, inherited]

Insert an element at the current position.

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

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

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

Parameters:
v The value to insert.
Dune::ios_base_all_saver::ios_base_all_saver ( state_type ios_  )  [inherited]

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<typename T , class A >
bool Dune::SLList< T, A >::operator!= ( const SLList< T, A > &  sl  )  const [inline, inherited]
Indent Dune::Indent::operator+ ( unsigned  morelevel  )  const [inline, inherited]

create a copy of this indetation object with raised level

Indent Dune::Indent::operator+ ( const std::string &  newindent  )  const [inline, inherited]

create new indentation object with this one as parent

Indent& Dune::Indent::operator++ (  )  [inline, inherited]

raise indentation level

Indent& Dune::Indent::operator-- (  )  [inline, inherited]

lower indentation level

template<typename Stream , typename T , std::size_t N>
Stream& Dune::operator<< ( Stream &  stream,
const std::array< T, N > &  a 
) [inline]

Print a std::array.

template<typename Stream , typename... Ts>
Stream& Dune::operator<< ( Stream &  stream,
const std::tuple< Ts...> &  t 
) [inline]

Print a std::tuple.

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

write indentation to a stream

template<class TI1 , class TI2 , class T >
std::ostream& Dune::operator<< ( std::ostream &  os,
const Combine< TI1, TI2, T > &   
) [inline]
template<typename TA , int from, int to>
std::ostream& Dune::operator<< ( std::ostream &  os,
const EnumRange< TA, from, to > &   
) [inline]
template<typename TA , int i>
std::ostream& Dune::operator<< ( std::ostream &  os,
const EnumItem< TA, i > &   
) [inline]
template<class T, int N, class A>
const ConstArrayListIterator< T, N, A > & Dune::ConstArrayListIterator< T, N, A >::operator= ( const ConstArrayListIterator< T, N, A > &  other  )  [inline, inherited]
template<class T, int N, class A>
ArrayListIterator< T, N, A > & Dune::ArrayListIterator< T, N, A >::operator= ( const ArrayListIterator< T, N, A > &  other  )  [inline, inherited]
Todo:
Please doc me!
template<typename T, class A>
SLList< T, A > & Dune::SLList< T, A >::operator= ( const SLList< T, A > &  other  )  [inline, inherited]

Assignment operator.

template<typename T , class A >
bool Dune::SLList< T, A >::operator== ( const SLList< T, A > &  sl  )  const [inline, inherited]
template<typename Stream , typename... Ts>
Stream& Dune::operator>> ( Stream &  stream,
std::tuple< Ts...> &  t 
) [inline]

Read a std::tuple.

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

Get the element at specific position.

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

Get the element at specific position.

Parameters:
i The index of the position.
Returns:
The element at that position.
template<typename T , class A >
void Dune::SLList< T, A >::pop_front (  )  [inline, inherited]

Remove the first item in the list.

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

Purge the list.

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

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

Append an entry to the list.

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

Add a new entry to the end of the list.

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

Add a new entry to the beginning of the list.

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

Delete the entry at the current position.

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

Warning:
This will invalidate all iterators positioned at the delete position! Use with care!
void Dune::ios_base_all_saver::restore (  )  [inherited]

Restore flags now.

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

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

Get the number of elements in the list.

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

Get the number of elements the list contains.

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

Copy constructor with type conversion.

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

Constructor.

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

Destructor that restores the flags stored by the constructor.

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

Destructor.

Deallocates all elements in the list.


Variable Documentation

constexpr index_constant< 1> Dune::Indices::_1 = {}

Compile time index with value 1.

constexpr index_constant<10> Dune::Indices::_10 = {}

Compile time index with value 10.

constexpr index_constant<11> Dune::Indices::_11 = {}

Compile time index with value 11.

constexpr index_constant<12> Dune::Indices::_12 = {}

Compile time index with value 12.

constexpr index_constant<13> Dune::Indices::_13 = {}

Compile time index with value 13.

constexpr index_constant<14> Dune::Indices::_14 = {}

Compile time index with value 14.

constexpr index_constant<15> Dune::Indices::_15 = {}

Compile time index with value 15.

constexpr index_constant<16> Dune::Indices::_16 = {}

Compile time index with value 16.

constexpr index_constant<17> Dune::Indices::_17 = {}

Compile time index with value 17.

constexpr index_constant<18> Dune::Indices::_18 = {}

Compile time index with value 18.

constexpr index_constant<19> Dune::Indices::_19 = {}

Compile time index with value 19.

constexpr index_constant< 2> Dune::Indices::_2 = {}

Compile time index with value 2.

constexpr index_constant< 3> Dune::Indices::_3 = {}

Compile time index with value 3.

constexpr index_constant< 4> Dune::Indices::_4 = {}

Compile time index with value 4.

constexpr index_constant< 5> Dune::Indices::_5 = {}

Compile time index with value 5.

constexpr index_constant< 6> Dune::Indices::_6 = {}

Compile time index with value 6.

constexpr index_constant< 7> Dune::Indices::_7 = {}

Compile time index with value 7.

constexpr index_constant< 8> Dune::Indices::_8 = {}

Compile time index with value 8.

constexpr index_constant< 9> Dune::Indices::_9 = {}

Compile time index with value 9.

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

The element we hold.

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

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


Friends

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

write indentation to a stream

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on 25 Mar 2018 for dune-common by  doxygen 1.6.1