Dune namespace. More...

Namespaces
	DenseMatrixHelp

	DynamicMatrixHelp

	FloatCmp

	FMatrixHelp

	fvmeta

	Std

Classes
struct	__is_lvalue_reference_helper

struct	__is_lvalue_reference_helper< T & >

struct	__is_pointer_helper

struct	__is_pointer_helper< T * >

struct	__remove_pointer_helper

struct	__remove_pointer_helper< _Tp * >

struct	AddPtrTypeEvaluator
	`TypeEvaluator` to turn a type `T` into a pointer to `T` More...

struct	AddPtrTypeEvaluator< T & >

struct	AddRefTypeEvaluator
	`TypeEvaluator` to turn a type `T` into a reference to `T` More...

struct	AlignmentOf
	Calculates the alignment requirement of a type. More...

class	AllSet
	A set containing everything. More...

struct	AlwaysFalse
	template which always yields a false value More...

struct	AlwaysTrue
	template which always yields a true value More...

struct	AlwaysVoid

class	ArrayList
	A dynamically growing random access list. More...

class	ArrayListIterator
	A random access iterator for the Dune::ArrayList class. More...

class	AssociativePropertyMap
	An adapter to turn an unique associative container into a property map. More...

struct	At
	Reverse element access. More...

struct	AtType
	Type for reverse element access. More...

class	BidirectionalIteratorFacade
	Facade class for stl conformant bidirectional iterators. More...

class	bigunsignedint
	Portable very large unsigned integers. More...

class	BitSetVector
	A dynamic array of blocks of booleans. More...

class	BitSetVectorConstReference
	A proxy class that acts as a const reference to a single bitset in a BitSetVector. More...

class	BitSetVectorReference
	A proxy class that acts as a mutable reference to a single bitset in a BitSetVector. More...

class	BufferedCommunicator
	A communicator that uses buffers to gather and scatter the data to be send or received. More...

struct	Cloneable
	An interface class for cloneable objects. More...

class	CollectiveCommunication
	Collective communication interface and sequential default implementation. More...

class	CollectiveCommunication< MPI_Comm >
	Specialization of CollectiveCommunication for MPI. More...

class	CollectiveIterator
	A collective iterator for moving over the remote indices for all processes collectively. More...

class	Combine
	A set combining two other sets. More...

struct	common_bits
	activate if current and mask have common bits switched on. More...

struct	CommPolicy
	Default policy used for communicating an indexed type. More...

struct	const_reference
	Get the 'const' version of a reference to a mutable object. More...

struct	const_reference< BitSetVectorConstReference< block_size, Alloc > >

struct	const_reference< BitSetVectorReference< block_size, Alloc > >

struct	const_reference< const R & >

struct	const_reference< const R >

struct	const_reference< DiagonalRowVector< K, n > >

struct	const_reference< DiagonalRowVectorConst< K, n > >

struct	const_reference< R & >

struct	ConstantVolatileTraits
	Determines wether a type is const or volatile and provides the unqualified types. More...

struct	ConstantVolatileTraits< const T >

struct	ConstantVolatileTraits< const volatile T >

struct	ConstantVolatileTraits< volatile T >

class	ConstArrayListIterator
	A constant random access iterator for the Dune::ArrayList class. More...

class	ConstAssociativePropertyMap
	An adaptor to turn an unique associative container into a property map. More...

class	ContainerWrapperIterator
	Iterator class for sparse vector-like containers. More...

class	Conversion
	Checks wether a type is convertible to another. More...

class	Conversion< From, void >

class	Conversion< int, double >

class	Conversion< T, T >

class	Conversion< void, To >

class	DebugAllocator
	Allocators implementation which performs different kind of memory checks. More...

class	DebugAllocator< void >

class	DebugStream
	Generic class to implement debug output streams. More...

class	DebugStreamError
	standard exception for the debugstream More...

class	DebugStreamState
	Intermediate class to implement tie-operation of DebugStream. More...

class	DenseIterator
	Generic iterator class for dense vector and matrix implementations. More...

class	DenseMatrix
	A dense n x m matrix. More...

struct	DenseMatrixAssigner
	you have to specialize this structure for any type that should be assignable to a DenseMatrix More...

struct	DenseMatVecTraits

struct	DenseMatVecTraits< DynamicMatrix< K > >

struct	DenseMatVecTraits< DynamicVector< K, Allocator > >

struct	DenseMatVecTraits< FieldMatrix< K, ROWS, COLS > >

struct	DenseMatVecTraits< FieldVector< K, SIZE > >

class	DenseVector
	Interface for a class of dense vectors over a given field. More...

class	DiagonalMatrix
	A diagonal matrix of static size. More...

class	DiagonalMatrixWrapper

class	DiagonalRowVector

class	DiagonalRowVectorConst

class	DynamicMatrix
	Construct a matrix with a dynamic size. More...

class	DynamicVector
	Construct a vector with a dynamic size. More...

struct	Empty
	Just an empty class. More...

class	EmptySet
	An empty set. More...

struct	EnableIfInterOperable
	Enable typedef if two types are interoperable. More...

class	EnumItem
	A set consisting only of one item. More...

class	EnumRange
	A set representing a range including the borders. More...

class	Exception
	Base class for Dune-Exceptions. More...

struct	ExceptionHook
	Base class to add a hook to the Dune::Exception. More...

struct	Factorial
	Calculates the factorial of m at compile time. More...

struct	Factorial< 0 >
	end of recursion of factorial via specialization More...

class	FakeMPIHelper
	A fake mpi helper. More...

class	FieldMatrix
	A dense n x m matrix. More...

struct	FieldTraits

struct	FieldTraits< const T >

struct	FieldTraits< DenseMatrix< M > >

struct	FieldTraits< DenseVector< V > >

struct	FieldTraits< DynamicMatrix< K > >

struct	FieldTraits< DynamicVector< K, Allocator > >

struct	FieldTraits< FieldMatrix< K, ROWS, COLS > >

struct	FieldTraits< FieldVector< K, SIZE > >

struct	FieldTraits< std::complex< T > >

class	FieldVector
	vector space out of a tensor product of fields. More...

class	FirstPredicateIndex
	Finding the index of a certain type in a tuple. More...

struct	FirstTypeIndex
	Find the first occurance of a type in a tuple. More...

struct	FlattenTuple
	Flatten a tuple of tuples. More...

class	FloatCmpOps
	Class encapsulating a default epsilon. More...

class	fmatrix_assigner
	fmatrix assignment operator More...

class	FMatrixError
	Error thrown if operations of a FieldMatrix fail. More...

class	FMatrixPrecision
	Precisions for calculations with FieldMatrix and FieldVector. More...

class	ForEachType
	Helper template to clone the type definition of a tuple with the storage types replaced by a user-defined rule. More...

class	ForEachValue
	Helper template which implements iteration over all storage elements in a tuple. More...

class	ForEachValuePair
	Extension of ForEachValue to two tuples... More...

class	ForLoop
	A static loop using TMP. More...

class	ForwardIteratorFacade
	Base class for stl conformant forward iterators. More...

class	Function
	Base class template for function classes. More...

class	fvector_assigner
	fvector assignment operator More...

struct	Gcd
	Calculator of the greatest common divisor. More...

class	Generic_MPI_Op

class	GenericIterator
	Generic class for stl-conforming iterators for container classes with operator[]. More...

class	GlobalLookupIndexSet
	Decorates an index set with the possibility to find a global index that is mapped to a specific local. More...

struct	greater_or_equal
	Greater or equal template test. More...

struct	hash
	Functor for hashing objects of type T. More...

class	HelpRequest
	exception thrown if the user wants to see help string More...

struct	IdentityMap
	A property map that applies the identity function to integers. More...

class	IdentityMatrix
	Read-only identity matrix. More...

struct	ImplementationDefined
	Dummy struct used for documentation purposes. More...

class	Indent
	Utility class for handling nested indentation in output. More...

class	IndexPair
	A pair consisting of a global and local index. More...

struct	IndexSetSortFunctor

class	IndicesSyncer
	Class for recomputing missing indices of a distributed index set. More...

class	Interface
	Communication interface between remote and local indices. More...

class	InterfaceBuilder
	Base class of all classes representing a communication interface. More...

class	InterfaceInformation
	Information describing an interface. More...

class	InvalidIndexSetState
	Exception indicating that the index set is not in the expected state. More...

class	InvalidStateException
	Default exception if a function was called while the object is not in a valid state for that function. More...

class	IOError
	Default exception class for I/O errors. More...

class	ios_base_all_saver
	Utility class for storing and resetting stream attributes. More...

struct	is_indexable

struct	is_lvalue_reference
	Determine whether a type is a lvalue reference type. More...

struct	is_pointer
	is_pointer More...

class	IsBaseOf
	Checks wether a type is derived from another. More...

struct	IsConst
	Tests wether a type is constant. More...

struct	IsFieldVectorSizeCorrect
	TMP to check the size of a DenseVectors statically, if possible. More...

struct	IsFieldVectorSizeCorrect< FieldVector< T, SIZE >, SIZE >

struct	IsFieldVectorSizeCorrect< FieldVector< T, SIZE1 >, SIZE >

struct	IsInteroperable
	Checks wether two types are interoperable. More...

struct	IsType
	Generator for predicates accepting one particular type. More...

struct	IsVector

struct	IsVector< T, typename AlwaysVoid< typename T::field_type >::type >

struct	IsVolatile
	Tests wether a type is volatile. More...

class	IteratorPropertyMap
	Adapter to turn a random access iterator into a property map. More...

class	IteratorRange
	Simple range between a begin and an end iterator. More...

struct	JoinTuples
	Join two tuples. More...

struct	Lcm
	Calculate the least common multiple of two numbers. More...

class	LocalIndex
	An index present on the local process. More...

struct	LocalIndexComparator

struct	LocalIndexComparator< ParallelLocalIndex< T > >

class	lru
	LRU Cache Container. More...

struct	LvaluePropertyMapTag
	Tag for the category of lvalue property maps. More...

class	MallocAllocator
	Allocators implementation which simply calls malloc/free. More...

struct	MathematicalConstants
	Provides commonly used mathematical constants. More...

class	MathError
	Default exception class for mathematical errors. More...

struct	Max

struct	Min

class	MPIGuard
	detects a thrown exception and communicates to all other processes More...

class	MPIGuardError
	This exception is thrown if the MPIGuard detects an error on a remote process. More...

class	MPIHelper
	A real mpi helper.This helper should be used for parallel programs. More...

struct	MPITraits
	A traits class describing the mapping of types onto MPI_Datatypes. More...

class	MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >

class	MPITraits< ParallelLocalIndex< T > >

struct	mutable_reference
	get the 'mutable' version of a reference to a const object More...

struct	mutable_reference< BitSetVectorConstReference< block_size, Alloc > >

struct	mutable_reference< BitSetVectorReference< block_size, Alloc > >

struct	mutable_reference< const R & >

struct	mutable_reference< const R >

struct	mutable_reference< DiagonalRowVector< K, n > >

struct	mutable_reference< DiagonalRowVectorConst< K, n > >

struct	mutable_reference< R & >

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

struct	No_Comm

class	NotImplemented
	Default exception for dummy implementations. More...

struct	null_deleter
	implements the Deleter concept of shared_ptr without deleting anything More...

class	NullPointerInitialiser
	A helper template that initializes a tuple consisting of pointers to NULL. More...

class	OutOfMemoryError
	Default exception if memory allocation fails. More...

class	OwnerOverlapCopyCommunication

class	ParallelError
	Default exception if an error in the parallel communication of the programm occured. More...

class	ParallelIndexSet
	Manager class for the mapping between local indices and globally unique indices. More...

class	ParallelLocalIndex
	An index present on the local process with an additional attribute flag. More...

class	ParameterTree
	Hierarchical structure of string parameters. More...

class	ParameterTreeParser
	Parsers to set up a ParameterTree from various input sources. More...

class	ParameterTreeParserError
	report parser error while reading ParameterTree More...

class	PointerPairDeletor
	Deletes all objects pointed to in a tuple of pointers. More...

class	Pool
	A memory pool of objects. More...

class	PoolAllocator
	An allocator managing a pool of objects for reuse. More...

class	PoolAllocator< void, s >

struct	Power
	Compute power for a run-time mantissa and a compile-time integer exponent. More...

struct	PropertyMapTraits

struct	PropertyMapTraits< const T * >

struct	PropertyMapTraits< T * >

struct	PropertyMapTypeSelector
	Selector for the property map type. More...

struct	PushBackTuple
	Helper template to append a type to a tuple. More...

struct	PushFrontTuple
	Helper template to prepend a type to a tuple. More...

class	RandomAccessIteratorFacade
	Base class for stl conformant forward iterators. More...

class	RangeError
	Default exception class for range errors. More...

struct	RAPropertyMapHelper

struct	ReadablePropertyMapTag
	Tag for the category of readable property maps. More...

struct	ReadWritePropertyMapTag
	Tag for the category of readable and writable property maps. More...

struct	ReduceTuple
	Apply reduce with meta binary function to template. More...

struct	ReduceTuple< F, Tuple, Seed, 0 >
	Apply reduce with meta binary function to template. More...

class	RemoteIndex
	Information about an index residing on another processor. More...

class	RemoteIndexListModifier
	Modifier for adding and/or deleting remote indices from the remote index list. More...

class	RemoteIndices
	The indices present on remote processes. More...

struct	remove_pointer
	Return the type a pointer type points to. More...

struct	RemoveConstHelper

struct	RemoveConstHelper< T, true >

class	ReservedVector
	A Vector class with statically reserved memory. More...

class	Selection
	A cached selection of indices. More...

class	SelectionIterator
	A const iterator over an uncached selection. More...

class	Singleton
	An adapter to turn a class into a singleton. More...

struct	SizeOne
	Flag for marking indexed data structures where data at each index is of the same size. More...

class	SLList
	A single linked list. More...

class	SLListConstIterator
	A constant iterator for the SLList. More...

class	SLListIterator
	A mutable iterator for the SLList. More...

class	SLListModifyIterator
	A mutable iterator for the SLList. More...

struct	StandardMathematicalConstants
	Standard implementation of MathematicalConstants. More...

struct	StaticPower
	Calculates m^p at compile time. More...

struct	StaticPower< m, 0 >
	end of recursion via specialization More...

class	StreamWrap

class	SystemError
	Default exception class for OS errors. More...

class	Timer
	A simple stop watch. More...

class	TimerError
	Exception thrown by the Timer class More...

class	TransformTupleFunctor
	helper class to implement transformTuple() More...

struct	tuple_writer

struct	tuple_writer< 0 >

struct	tuple_writer< 1 >

struct	TupleAccessTraits

struct	TupleAccessTraits< T & >

struct	TupleAccessTraits< T * >

class	TypeTraits
	General type traits class to check whether type is reference or pointer type. More...

class	UncachedSelection
	An uncached selection of indices. More...

struct	VariableSize
	Flag for marking indexed data structures where the data at each index may be a variable multiple of another type. More...

class	VariableSizeCommunicator
	A buffered communicator where the amount of data sent does not have to be known a priori. More...

class	VirtualFunction
	Virtual base class template for function classes. More...

struct	WritablePropertyMapTag
	Tag for the category of writable property maps. More...

Typedefs
typedef unsigned int	DebugLevel
	Type for debug levels. More...

typedef dune_nullptr_t	nullptr_t

typedef DebugStream< VERY_VERBOSE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DVVerbType
	Type of very verbose debug stream. More...

typedef DebugStream< VERBOSE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DVerbType
	Type of more verbose debug stream. More...

typedef DebugStream< INFO_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DInfoType
	Type of debug stream with info level. More...

typedef DebugStream< WARN_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DWarnType
	Type of debug stream with warn level. More...

typedef DebugStream< GRAVE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DGraveType
	Type of debug stream for fatal errors. More...

typedef DebugStream< 1 >	DErrType
	The type of the stream used for error messages. More...

Enumerations
enum	{ implementationDefined }

enum	ParallelIndexSetState { GROUND, RESIZE }
	The states the index set can be in. More...

enum	LocalIndexState { VALID, DELETED }
	The states avaiable for the local indices. More...

Functions
template<class T , size_t N>
std::ostream &	operator<< (std::ostream &s, const array< T, N > &e)
	Output operator for array. More...

template<class T >
array< T, 10 >	make_array (const T &t0, const T &t1, const T &t2, const T &t3, const T &t4, const T &t5, const T &t6, const T &t7, const T &t8, const T &t9)
	create an initialize an array More...

template<typename T , std::size_t n>
array< T, n >	fill_array (const T &t)
	Create an array and fill it with copies of the provided value. More...

template<int k>
std::ostream &	operator<< (std::ostream &s, const bigunsignedint< k > &x)

template<int k>
bigunsignedint< k >	operator+ (const bigunsignedint< k > &x, std::uintmax_t y)

template<int k>
bigunsignedint< k >	operator- (const bigunsignedint< k > &x, std::uintmax_t y)

template<int k>
bigunsignedint< k >	operator* (const bigunsignedint< k > &x, std::uintmax_t y)

template<int k>
bigunsignedint< k >	operator/ (const bigunsignedint< k > &x, std::uintmax_t y)

template<int k>
bigunsignedint< k >	operator% (const bigunsignedint< k > &x, std::uintmax_t y)

template<int k>
bigunsignedint< k >	operator+ (std::uintmax_t x, const bigunsignedint< k > &y)

template<int k>
bigunsignedint< k >	operator- (std::uintmax_t x, const bigunsignedint< k > &y)

template<int k>
bigunsignedint< k >	operator* (std::uintmax_t x, const bigunsignedint< k > &y)

template<int k>
bigunsignedint< k >	operator/ (std::uintmax_t x, const bigunsignedint< k > &y)

template<int k>
bigunsignedint< k >	operator% (std::uintmax_t x, const bigunsignedint< k > &y)

template<class T >
std::string	className (T &t)
	Provide the demangled class name of a given object as a string. More...

template<class T >
std::string	className ()
	Provide the demangled class name of a type T as a string. More...

template<class DenseMatrix , class K , int N, int M>
void	istl_assign_to_fmatrix (DenseMatrix &denseMatrix, const K(&values)[M][N])

template<typename MAT >
std::ostream &	operator<< (std::ostream &s, const DenseMatrix< MAT > &a)
	Sends the matrix to an output stream. More...

template<class M , class K , int n>
void	istl_assign_to_fmatrix (DenseMatrix< M > &fm, const DiagonalMatrix< K, n > &s)

template<class A , class B >
enable_if<!IsVector< A >::value &&!is_same< typename FieldTraits< A >::field_type, typename FieldTraits< A >::real_type >::value, typename PromotionTraits< A, B >::PromotedType >::type	dot (const A &a, const B &b)
	computes the dot product for fundamental data types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b More...

template<class A , class B >
enable_if<!IsVector< A >::value &&is_same< typename FieldTraits< A >::field_type, typename FieldTraits< A >::real_type >::value, typename PromotionTraits< A, B >::PromotedType >::type	dot (const A &a, const B &b)
	computes the dot product for fundamental data types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b More...

template<typename A , typename B >
enable_if< IsVector< A >::value, typename PromotionTraits< typename A::field_type, typename B::field_type >::PromotedType >::type	dot (const A &a, const B &b)
	computes the dot product for various dune vector types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b More...

template<class A , class B >
enable_if<!IsVector< A >::value &&!is_same< typename FieldTraits< A >::field_type, typename FieldTraits< A >::real_type >::value, typename PromotionTraits< A, B >::PromotedType >::type	dotT (const A &a, const B &b)
	Computes an indefinite vector dot product for fundamental data types according to Petsc's VectTDot function: dotT(a,b) := a*b. More...

template<class A , class B >
enable_if< IsVector< A >::value, typename PromotionTraits< typename A::field_type, typename B::field_type >::PromotedType >::type	dotT (const A &a, const B &b)
	Computes an indefinite vector dot product for various dune vector types according to Petsc's VectTDot function: dotT(a,b) := a*b. More...

template<typename TA , int i>
std::ostream &	operator<< (std::ostream &os, const EnumItem< TA, i > &)

template<typename TA , int from, int to>
std::ostream &	operator<< (std::ostream &os, const EnumRange< TA, from, to > &)

template<class TI1 , class TI2 >
Combine< TI1, TI2, typename TI1::Type >	combine (const TI1 &set1, const TI2 &set2)

template<class TI1 , class TI2 , class T >
std::ostream &	operator<< (std::ostream &os, const Combine< TI1, TI2, T > &)

std::ostream &	operator<< (std::ostream &stream, const Exception &e)

template<class T , class K , int s>
fvector_assigner< T, s >	operator<<= (FieldVector< T, s > &v, const K &t)
	fvector assignment operator More...

template<class T , int s>
fvector_assigner< T, s >	operator<<= (FieldVector< T, s > &v, Zero z)
	fvector assignment operator More...

template<class T , class K , int n, int m>
fmatrix_assigner< T, n, m >	operator<<= (FieldMatrix< T, n, m > &v, const K &t)
	FieldMatrix assignment operator. More...

template<class T , int n, int m>
fmatrix_assigner< T, n, m >	operator<<= (FieldMatrix< T, n, m > &v, Zero z)
	FieldMatrix assignment operator. More...

template<typename T >
void	hash_combine (std::size_t &seed, const T &arg)
	Calculates the hash value of arg and combines it in-place with seed. More...

template<typename It >
std::size_t	hash_range (It first, It last)
	Hashes all elements in the range [first,last) and returns the combined hash. More...

template<typename It >
void	hash_range (std::size_t &seed, It first, It last)
	Hashes all elements in the range [first,last) and combines the hashes in-place with seed. More...

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

template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2, bool >::type	operator== (const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
	Checks for equality. More...

template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2, bool >::type	operator!= (const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
	Checks for inequality. More...

template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
enable_if< Conversion< T2, T1 >::exists, bool >::type	operator== (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs)
	Checks for equality. More...

template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
enable_if< Conversion< T1, T2 >::exists &&!Conversion< T2, T1 >::exists, bool >::type	operator== (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs)
	Checks for equality. More...

template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2, bool >::type	operator!= (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs)
	Checks for inequality. More...

template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2, bool >::type	operator== (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
	Checks for equality. More...

template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2, bool >::type	operator!= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
	Checks for inequality. More...

template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2, bool >::type	operator< (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
	Comparison operator. More...

template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2, bool >::type	operator<= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
	Comparison operator. More...

template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2, bool >::type	operator> (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
	Comparison operator. More...

template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2, bool >::type	operator>= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
	Comparison operator. More...

template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2, D >::type	operator- (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
	Calculates the difference between two pointers. More...

template<class K >
K	conjugateComplex (const K &x)
	compute conjugate complex of x More...

template<class T >
int	sign (const T &val)
	Return the sign of the value. More...

template<class TG , class TL >
std::ostream &	operator<< (std::ostream &os, const IndexPair< TG, TL > &pair)
	Print an index pair. More...

template<class TG , class TL >
bool	operator== (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)

template<class TG , class TL >
bool	operator!= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)

template<class TG , class TL >
bool	operator< (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)

template<class TG , class TL >
bool	operator> (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)

template<class TG , class TL >
bool	operator<= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)

template<class TG , class TL >
bool	operator>= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)

template<class TG , class TL >
bool	operator== (const IndexPair< TG, TL > &, const TG &)

template<class TG , class TL >
bool	operator!= (const IndexPair< TG, TL > &, const TG &)

template<class TG , class TL >
bool	operator< (const IndexPair< TG, TL > &, const TG &)

template<class TG , class TL >
bool	operator> (const IndexPair< TG, TL > &, const TG &)

template<class TG , class TL >
bool	operator<= (const IndexPair< TG, TL > &, const TG &)

template<class TG , class TL >
bool	operator>= (const IndexPair< TG, TL > &, const TG &)

template<class TG , class TL , int N>
std::ostream &	operator<< (std::ostream &os, const ParallelIndexSet< TG, TL, N > &indexSet)
	Print an index set. More...

template<typename TG , typename TA >
bool	operator< (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)

template<typename TG , typename TA >
bool	operator< (const std::pair< TG, TA > &i1, const IndexPair< TG, ParallelLocalIndex< TA > > &i2)

template<typename TG , typename TA >
bool	operator== (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)

template<typename TG , typename TA >
bool	operator!= (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)

template<typename TG , typename TA >
bool	operator== (const std::pair< TG, TA > &i2, const IndexPair< TG, ParallelLocalIndex< TA > > &i1)

template<typename TG , typename TA >
bool	operator!= (const std::pair< TG, TA > &i2, const IndexPair< TG, ParallelLocalIndex< TA > > &i1)

template<typename T , typename A , typename A1 >
void	storeGlobalIndicesOfRemoteIndices (std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > &globalMap, const RemoteIndices< T, A1 > &remoteIndices)
	Stores the corresponding global indices of the remote index information. More...

template<typename T , typename A , typename A1 >
void	repairLocalIndexPointers (std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > &globalMap, RemoteIndices< T, A1 > &remoteIndices, const T &indexSet)
	Repair the pointers to the local indices in the remote indices. More...

	ComposeMPIOp (char, std::plus, MPI_SUM)

	ComposeMPIOp (unsigned char, std::plus, MPI_SUM)

	ComposeMPIOp (short, std::plus, MPI_SUM)

	ComposeMPIOp (int, std::plus, MPI_SUM)

	ComposeMPIOp (long, std::plus, MPI_SUM)

	ComposeMPIOp (float, std::plus, MPI_SUM)

	ComposeMPIOp (double, std::plus, MPI_SUM)

	ComposeMPIOp (char, std::multiplies, MPI_PROD)

	ComposeMPIOp (unsigned char, std::multiplies, MPI_PROD)

	ComposeMPIOp (short, std::multiplies, MPI_PROD)

	ComposeMPIOp (int, std::multiplies, MPI_PROD)

	ComposeMPIOp (long, std::multiplies, MPI_PROD)

	ComposeMPIOp (float, std::multiplies, MPI_PROD)

	ComposeMPIOp (double, std::multiplies, MPI_PROD)

	ComposeMPIOp (char, Min, MPI_MIN)

	ComposeMPIOp (unsigned char, Min, MPI_MIN)

	ComposeMPIOp (short, Min, MPI_MIN)

	ComposeMPIOp (int, Min, MPI_MIN)

	ComposeMPIOp (long, Min, MPI_MIN)

	ComposeMPIOp (float, Min, MPI_MIN)

	ComposeMPIOp (double, Min, MPI_MIN)

	ComposeMPIOp (char, Max, MPI_MAX)

	ComposeMPIOp (unsigned char, Max, MPI_MAX)

	ComposeMPIOp (short, Max, MPI_MAX)

	ComposeMPIOp (int, Max, MPI_MAX)

	ComposeMPIOp (long, Max, MPI_MAX)

	ComposeMPIOp (float, Max, MPI_MAX)

	ComposeMPIOp (double, Max, MPI_MAX)

template<class T >
std::ostream &	operator<< (std::ostream &os, const ParallelLocalIndex< T > &index)
	Print the local index to a stream. More...

template<typename T >
bool	operator== (const ParallelLocalIndex< T > &p1, const ParallelLocalIndex< T > &p2)

template<typename T >
bool	operator!= (const ParallelLocalIndex< T > &p1, const ParallelLocalIndex< T > &p2)

template<typename T1 , typename T2 >
std::ostream &	operator<< (std::ostream &os, const RemoteIndex< T1, T2 > &index)

template<class T , class A >
std::ostream &	operator<< (std::ostream &os, const RemoteIndices< T, A > &indices)

template<typename TG , typename TA >
std::ostream &	operator<< (std::ostream &os, const RemoteIndex< TG, TA > &index)

std::string	concatPaths (const std::string &base, const std::string &p)
	concatenate two paths More...

std::string	processPath (const std::string &p)
	sanitize a path for further processing More...

bool	pathIndicatesDirectory (const std::string &p)
	check whether the given path indicates that it is a directory More...

std::string	prettyPath (const std::string &p, bool isDirectory)
	pretty print path More...

std::string	prettyPath (const std::string &p)
	pretty print path More...

std::string	relativePath (const std::string &newbase, const std::string &p)
	compute a relative path between two paths More...

template<typename T1 , std::size_t t1, typename T2 , std::size_t t2>
bool	operator== (const PoolAllocator< T1, t1 > &, const PoolAllocator< T2, t2 > &)

template<typename T1 , std::size_t t1, typename T2 , std::size_t t2>
bool	operator!= (const PoolAllocator< T1, t1 > &, const PoolAllocator< T2, t2 > &)

template<typename T , std::size_t t1, std::size_t t2>
bool	operator== (const PoolAllocator< T, t1 > &p1, const PoolAllocator< T, t2 > &p2)

template<typename T , std::size_t t1, std::size_t t2>
bool	operator!= (const PoolAllocator< T, t1 > &p1, const PoolAllocator< T, t2 > &p2)

template<typename T , std::size_t t1, std::size_t t2>
bool	operator== (const PoolAllocator< void, t1 > &, const PoolAllocator< T, t2 > &)

template<typename T , std::size_t t1, std::size_t t2>
bool	operator!= (const PoolAllocator< void, t1 > &, const PoolAllocator< T, t2 > &)

template<std::size_t t1, std::size_t t2>
bool	operator== (const PoolAllocator< void, t1 > &p1, const PoolAllocator< void, t2 > &p2)

template<std::size_t t1, std::size_t t2>
bool	operator!= (const PoolAllocator< void, t1 > &p1, const PoolAllocator< void, t2 > &p2)

template<class Reference , class PropertyMap , class Key >
Reference	get (const RAPropertyMapHelper< Reference, PropertyMap > &pmap, const Key &key)

template<class Reference , class PropertyMap , class Key , class Value >
void	put (const RAPropertyMapHelper< Reference, PropertyMap > &pmap, const Key &key, const Value &value)

template<typename T >
pointer_or_proxy_holder	handle_proxy_member_access (T &&t)
	Transparent support for providing member access to both lvalues and rvalues (temporary proxies). More...

template<typename T >
shared_ptr< T >	stackobject_to_shared_ptr (T &t)
	Create a shared_ptr for a stack-allocated object. More...

template<typename T , typename T2 >
shared_ptr< T2 >	stackobject_to_shared_ptr (T &t)
	Create a shared_ptr to a base class for a stack-allocated object. More...

void	doAssertCallOnce (const char file, int line, const char function)

void	assertCallOnce (const char file=nullptr, int line=-1, const char function=nullptr)
	Make sure call_once() works and provide a helpful error message otherwise. More...

template<typename C >
bool	hasPrefix (const C &c, const char *prefix)
	Check whether a character container has a given prefix. More...

template<typename C >
bool	hasSuffix (const C &c, const char *suffix)
	Check whether a character container has a given suffix. More...

template<class... T>
static std::string	formatString (const std::string &s, const T &...args)
	Format values according to printf format string. More...

template<typename T1 >
std::ostream &	operator<< (std::ostream &os, const tuple< T1 > &t)
	Print a tuple. More...

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

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

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

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

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

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

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

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

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

template<typename T1 >
std::istream &	operator>> (std::istream &is, tuple< T1 > &t)
	Read a tuple. More...

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

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

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

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

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

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

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

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

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


template<class Tuple , class Functor >
ForEachType< Functor::template TypeEvaluator, Tuple >::Type	genericTransformTuple (Tuple &t, Functor &f)
	transform a tuple object into another tuple object More...

template<template< class > class TE, class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 >
TransformTupleFunctor< TE, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9 >	makeTransformTupleFunctor (A0 &a0, A1 &a1, A2 &a2, A3 &a3, A4 &a4, A5 &a5, A6 &a6, A7 &a7, A8 &a8, A9 &a9)
	syntactic sugar for creation of TransformTupleFunctor objects More...

template<template< class > class TypeEvaluator, class Tuple , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 >
remove_const< typename ForEachType< TypeEvaluator, Tuple >::Type >::type	transformTuple (Tuple &orig, A0 &a0, A1 &a1, A2 &a2, A3 &a3, A4 &a4, A5 &a5, A6 &a6, A7 &a7, A8 &a8, A9 &a9)
	transform a tuple's value according to a user-supplied policy More...

Variables
DVVerbType	dvverb (std::cout)
	stream for very verbose output. More...

DVerbType	dverb (std::cout)
	Singleton of verbose debug stream. More...

DInfoType	dinfo (std::cout)
	Stream for informative output. More...

DWarnType	dwarn (std::cerr)
	Stream for warnings indicating problems. More...

DGraveType	dgrave (std::cerr)
	Stream for warnings indicating fatal errors. More...

DErrType	derr (std::cerr)
	Stream for error messages. More...

static const DebugLevel	MINIMAL_DEBUG_LEVEL = DUNE_MINIMAL_DEBUG_LEVEL

static const DebugLevel	VERY_VERBOSE_DEBUG_LEVEL = 1
	The level of the very verbose debug stream. More...

static const DebugLevel	VERBOSE_DEBUG_LEVEL = 2
	The level of the verbose debug stream. More...

static const DebugLevel	INFO_DEBUG_LEVEL = 3
	The level of the informative debug stream. More...

static const DebugLevel	WARN_DEBUG_LEVEL = 4
	The level of the debug stream for warnings. More...

static const DebugLevel	GRAVE_DEBUG_LEVEL = 5
	The level of the debug stream for fatal errors. More...

Detailed Description

Dune namespace.

Typedef Documentation

typedef dune_nullptr_t Dune::nullptr_t

Enumeration Type Documentation

anonymous enum

Enumerator

implementationDefined

Dummy integral value used for documentation purposes.

#include <dune/common/documentation.hh>

See also: ImplementationDefined

Function Documentation

void Dune::assertCallOnce	(	const char *	file = `nullptr`,
		int	line = `-1`,
		const char *	function = `nullptr`
	)

inline

Make sure call_once() works and provide a helpful error message otherwise.

For call_once() to work, certain versions of libstdc++ need to be linked with -pthread or similar flags. If that is not the case, call_once() will throw an exception. This function checks that call_once() can indeed be used, i.e. that it does not throw an exception when it should not, and that the code does indeed get executed. If call_once() cannot be used, assertCallOnce() aborts the program with a helpful error message.

The check is only actually executed the first time assertCallOnce() is called.

The arguments file and line specify the filename and line number that should appear in the error message. They are ignored if file is 0. The argument function specifies the name of the function to appear in the error message. It is ignored if function is 0.

References doAssertCallOnce(), and DUNE_UNUSED.

template<class T >

std::string Dune::className ( T & t )

Provide the demangled class name of a given object as a string.

References t.

Referenced by className().

template<class T >

std::string Dune::className ( )

Provide the demangled class name of a type T as a string.

References className().

Dune::ComposeMPIOp	(	char	,
		std::plus	,
		MPI_SUM
	)

Dune::ComposeMPIOp	(	unsigned	char,
		std::plus	,
		MPI_SUM
	)

Dune::ComposeMPIOp	(	short	,
		std::plus	,
		MPI_SUM
	)

Dune::ComposeMPIOp	(	int	,
		std::plus	,
		MPI_SUM
	)

Dune::ComposeMPIOp	(	long	,
		std::plus	,
		MPI_SUM
	)

Dune::ComposeMPIOp	(	float	,
		std::plus	,
		MPI_SUM
	)

Dune::ComposeMPIOp	(	double	,
		std::plus	,
		MPI_SUM
	)

Dune::ComposeMPIOp	(	char	,
		std::multiplies	,
		MPI_PROD
	)

Dune::ComposeMPIOp	(	unsigned	char,
		std::multiplies	,
		MPI_PROD
	)

Dune::ComposeMPIOp	(	short	,
		std::multiplies	,
		MPI_PROD
	)

Dune::ComposeMPIOp	(	int	,
		std::multiplies	,
		MPI_PROD
	)

Dune::ComposeMPIOp	(	long	,
		std::multiplies	,
		MPI_PROD
	)

Dune::ComposeMPIOp	(	float	,
		std::multiplies	,
		MPI_PROD
	)

Dune::ComposeMPIOp	(	double	,
		std::multiplies	,
		MPI_PROD
	)

Dune::ComposeMPIOp	(	char	,
		Min	,
		MPI_MIN
	)

Dune::ComposeMPIOp	(	unsigned	char,
		Min	,
		MPI_MIN
	)

Dune::ComposeMPIOp	(	short	,
		Min	,
		MPI_MIN
	)

Dune::ComposeMPIOp	(	int	,
		Min	,
		MPI_MIN
	)

Dune::ComposeMPIOp	(	long	,
		Min	,
		MPI_MIN
	)

Dune::ComposeMPIOp	(	float	,
		Min	,
		MPI_MIN
	)

Dune::ComposeMPIOp	(	double	,
		Min	,
		MPI_MIN
	)

Dune::ComposeMPIOp	(	char	,
		Max	,
		MPI_MAX
	)

Dune::ComposeMPIOp	(	unsigned	char,
		Max	,
		MPI_MAX
	)

Dune::ComposeMPIOp	(	short	,
		Max	,
		MPI_MAX
	)

Dune::ComposeMPIOp	(	int	,
		Max	,
		MPI_MAX
	)

Dune::ComposeMPIOp	(	long	,
		Max	,
		MPI_MAX
	)

Dune::ComposeMPIOp	(	float	,
		Max	,
		MPI_MAX
	)

Dune::ComposeMPIOp	(	double	,
		Max	,
		MPI_MAX
	)

template<class K >

K Dune::conjugateComplex ( const K & x )

inline

compute conjugate complex of x

References c.

Referenced by Dune::DiagonalMatrix< K, n >::mmhv(), Dune::DenseMatrix< FieldMatrix< T, ROWS, COLS > >::mmhv(), Dune::DiagonalMatrix< K, n >::umhv(), Dune::DenseMatrix< FieldMatrix< T, ROWS, COLS > >::umhv(), Dune::DiagonalMatrix< K, n >::usmhv(), and Dune::DenseMatrix< FieldMatrix< T, ROWS, COLS > >::usmhv().

void Dune::doAssertCallOnce	(	const char *	file,
		int	line,
		const char *	function
	)

Referenced by assertCallOnce().

template<class A , class B >

enable_if<!IsVector<A>::value && is_same<typename FieldTraits<A>::field_type,typename FieldTraits<A>::real_type>::value, typename PromotionTraits<A,B>::PromotedType>::type Dune::dot	(	const A &	a,
		const B &	b
	)

inline

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

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)

template<typename A , typename B >

enable_if<IsVector<A>::value, typename PromotionTraits<typename A::field_type, typename B::field_type >::PromotedType>::type Dune::dot	(	const A &	a,
		const B &	b
	)

inline

computes the dot product for various dune vector types according to Petsc's VectDot function: dot(a,b) := std::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: dot(a,b)

template<class A , class B >

enable_if<!IsVector<A>::value && !is_same<typename FieldTraits<A>::field_type,typename FieldTraits<A>::real_type>::value, typename PromotionTraits<A,B>::PromotedType>::type Dune::dotT	(	const A &	a,
		const B &	b
	)

inline

Computes an indefinite vector dot product for fundamental data types according to Petsc's VectTDot function: dotT(a,b) := a*b.

See also: http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Vec/VecTDot.html#VecTDot

Parameters

a
b

Returns: a*b

template<class A , class B >

enable_if<IsVector<A>::value, typename PromotionTraits<typename A::field_type, typename B::field_type >::PromotedType>::type Dune::dotT	(	const A &	a,
		const B &	b
	)

inline

Computes an indefinite vector dot product for various dune vector types according to Petsc's VectTDot function: dotT(a,b) := a*b.

See also: http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Vec/VecTDot.html#VecTDot

Parameters

a
b

Returns: a*b

template<class Tuple , class Functor >

ForEachType<Functor::template TypeEvaluator, Tuple>::Type Dune::genericTransformTuple	(	Tuple &	t,
		Functor &	f
	)

transform a tuple object into another tuple object

#include <dune/common/utility.hh>

This function does for the value of a tuple what ForEachType does for the type of a tuple: it transforms the value using a user-provided policy functor.

Parameters

t	The tuple value to transform.
f	The functor to use to transform the values.

The functor should have the following form:

struct Functor {
  template<class> struct TypeEvaluator {
    typedef user-defined Type;
  };
  template<class T>
  typename TypeEvaluator<T>::Type operator()(T& val);
  template<class T>
  typename TypeEvaluator<T>::Type operator()(T& val) const;
  template<class T>
  typename TypeEvaluator<T>::Type operator()(const T& val);
  template<class T>
  typename TypeEvaluator<T>::Type operator()(const T& val) const;
};

The member class template TypeEvaluator should be a class template suitable as the TypeEvaluator template parameter for ForEachType. The function call operator operator() is used to transform the value; only the signatures of operator() which are actually used must be present.

There are overloaded definitions of genericTransformTuple() wich take constant tuple and functor arguments so rvalues are permissible as arguments here. These overloaded definitions are not documented separately.

Referenced by transformTuple().

template<class Reference , class PropertyMap , class Key >

Reference Dune::get	(	const RAPropertyMapHelper< Reference, PropertyMap > &	pmap,
		const Key &	key
	)

inline

Referenced by Dune::tuple_writer< i >::get(), operator>>(), and Dune::tuple_writer< i >::put().

template<typename T >

pointer_or_proxy_holder Dune::handle_proxy_member_access ( T && t )

Transparent support for providing member access to both lvalues and rvalues (temporary proxies).

If an iterator facade (like entity iterators) wants to allow the embedded implementation to return either an (internally stored) reference or a temporary object and expose these two behaviors to enable performance optimizations, operator->() needs special handling: If the implementation returns a reference, operator->() in the facade can simply return the address of the referenced object, but if the returned object is a temporary, we need to capture and store it in a helper object to make sure it outlives the member access. This function transparently supports both variants. It should be used like this:

class iterator
{
  ...
  decltype(handle_proxy_member_access(implementation.dereference()))
  operator->() const
  {
    return handle_proxy_member_access(implementation.dereference());
  }
  ...
};

Note: This function exploits the special type deduction rules for unqualified rvalue references to distinguish between lvalues and rvalues and thus needs to be passed the object returned by the implementation.

template<typename T >

void Dune::hash_combine	(	std::size_t &	seed,
		const T &	arg
	)

inline

Calculates the hash value of arg and combines it in-place with seed.

Note: This function is only available if the macro HAVE_DUNE_HASH is defined.

Parameters

seed	The hash value that will be combined with the hash of arg.
arg	The object for which to calculate a hash value and combine it with seed.

Referenced by hash_range().

template<typename It >

std::size_t Dune::hash_range	(	It	first,
		It	last
	)

inline

Hashes all elements in the range [first,last) and returns the combined hash.

Note: This function is only available if the macro HAVE_DUNE_HASH is defined.

Parameters

first	Iterator pointing to the first object to hash.
last	Iterator pointing one past the last object to hash.

Returns: The result of hashing all objects in the range and combining them using hash_combine() in sequential fashion, starting with seed 0.

References hash_combine().

template<typename It >

void Dune::hash_range	(	std::size_t &	seed,
		It	first,
		It	last
	)

inline

Hashes all elements in the range [first,last) and combines the hashes in-place with seed.

Note: This function is only available if the macro HAVE_DUNE_HASH is defined.

Parameters

seed	Start value that will be combined with the hash values of all objects in the range using hash_combine() in sequential fashion.
first	Iterator pointing to the first ojbect to hash.
last	Iterator pointing one past the last object to hash.

References hash_combine().

template<template< class > class TE, class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 >

TransformTupleFunctor<TE, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> Dune::makeTransformTupleFunctor	(	A0 &	a0,
		A1 &	a1,
		A2 &	a2,
		A3 &	a3,
		A4 &	a4,
		A5 &	a5,
		A6 &	a6,
		A7 &	a7,
		A8 &	a8,
		A9 &	a9
	)

syntactic sugar for creation of TransformTupleFunctor objects

#include <dune/common/utility.hh>

Template Parameters

TE	TypeEvaluator class template.
A0	Type of extra arguments to pass to `TE<T>::apply()`. It should not be necessary to specify these template parameters explicitly since they can be deduced.
A1	Type of extra arguments to pass to `TE<T>::apply()`. It should not be necessary to specify these template parameters explicitly since they can be deduced.
A2	Type of extra arguments to pass to `TE<T>::apply()`. It should not be necessary to specify these template parameters explicitly since they can be deduced.
A3	Type of extra arguments to pass to `TE<T>::apply()`. It should not be necessary to specify these template parameters explicitly since they can be deduced.
A4	Type of extra arguments to pass to `TE<T>::apply()`. It should not be necessary to specify these template parameters explicitly since they can be deduced.
A5	Type of extra arguments to pass to `TE<T>::apply()`. It should not be necessary to specify these template parameters explicitly since they can be deduced.
A6	Type of extra arguments to pass to `TE<T>::apply()`. It should not be necessary to specify these template parameters explicitly since they can be deduced.
A7	Type of extra arguments to pass to `TE<T>::apply()`. It should not be necessary to specify these template parameters explicitly since they can be deduced.
A8	Type of extra arguments to pass to `TE<T>::apply()`. It should not be necessary to specify these template parameters explicitly since they can be deduced.
A9	Type of extra arguments to pass to `TE<T>::apply()`. It should not be necessary to specify these template parameters explicitly since they can be deduced.

Parameters

a0	Arguments to save references to in the TransformTupleFunctor.
a1	Arguments to save references to in the TransformTupleFunctor.
a2	Arguments to save references to in the TransformTupleFunctor.
a3	Arguments to save references to in the TransformTupleFunctor.
a4	Arguments to save references to in the TransformTupleFunctor.
a5	Arguments to save references to in the TransformTupleFunctor.
a6	Arguments to save references to in the TransformTupleFunctor.
a7	Arguments to save references to in the TransformTupleFunctor.
a8	Arguments to save references to in the TransformTupleFunctor.
a9	Arguments to save references to in the TransformTupleFunctor.

There are overloads of this function (not documented separately) for any number of arguments, up to an implementation-defined arbitrary limit. The number of arguments given determines the number of non-void template arguments in the type of the returned TransformTupleFunctor.

template<typename TG , typename TA >

std::ostream& Dune::operator<<	(	std::ostream &	os,
		const RemoteIndex< TG, TA > &	index
	)

inline

template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >

enable_if<Conversion<T1,T2>::exists && !Conversion<T2,T1>::exists, bool>::type Dune::operator==	(	const BidirectionalIteratorFacade< T1, V1, R1, D > &	lhs,
		const BidirectionalIteratorFacade< T2, V2, R2, D > &	rhs
	)

inline

Checks for equality.

This operation is only defined if either T1 is convertible to T2, and T2 is not convetible to T1. Otherwise the operator is removed from the overload set since the enable_if for the return type yield an invalid type expression.

template<class Reference , class PropertyMap , class Key , class Value >

void Dune::put	(	const RAPropertyMapHelper< Reference, PropertyMap > &	pmap,
		const Key &	key,
		const Value &	value
	)

inline

Referenced by operator<<().

template<class T >

int Dune::sign ( const T & val )

Return the sign of the value.

Referenced by Dune::DenseMatrix< FieldMatrix< T, ROWS, COLS > >::exists().

template<typename T >

shared_ptr< T > stackobject_to_shared_ptr ( T & t )

inline

Create a shared_ptr for a stack-allocated object.

#include <dune/common/shared_ptr.hh>

Usage:

int i = 10;

shared_ptr<int> pi = stackobject_to_shared_ptr(i);

The shared_ptr points to the object on the stack, but its deleter is set to an instance of null_deleter so that nothing happens when the shared_ptr is destroyed.

See also: shared_ptr, null_deleter

References t.

template<typename T , typename T2 >

shared_ptr< T2 > stackobject_to_shared_ptr ( T & t )

inline

Create a shared_ptr to a base class for a stack-allocated object.

#include <dune/common/shared_ptr.hh>

Usage:

class A {};
class B : public A {};
...
B b;
shared_ptr<A> pa = stackobject_to_shared_ptr<A>(b);

The shared_ptr points to the object on the stack, but its deleter is set to an instance of null_deleter so that nothing happens when the shared_ptr is destroyed.

See also: shared_ptr, null_deleter

References t.

template<template< class > class TypeEvaluator, class Tuple , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 >

remove_const<typename ForEachType<TypeEvaluator, Tuple>::Type>::type Dune::transformTuple	(	Tuple &	orig,
		A0 &	a0,
		A1 &	a1,
		A2 &	a2,
		A3 &	a3,
		A4 &	a4,
		A5 &	a5,
		A6 &	a6,
		A7 &	a7,
		A8 &	a8,
		A9 &	a9
	)

transform a tuple's value according to a user-supplied policy

#include <dune/common/utility.hh>

This function provides functionality similar to genericTransformTuple(), although less general and closer in spirit to ForEachType.

Template Parameters

TypeEvaluator	Used as the `TE` template argument to TransformTupleFunctor internally.
Tuple	Type of the tuple to transform.
A0	Types of extra argument to call the transformation function with.
A1	Types of extra argument to call the transformation function with.
A2	Types of extra argument to call the transformation function with.
A3	Types of extra argument to call the transformation function with.
A4	Types of extra argument to call the transformation function with.
A5	Types of extra argument to call the transformation function with.
A6	Types of extra argument to call the transformation function with.
A7	Types of extra argument to call the transformation function with.
A8	Types of extra argument to call the transformation function with.
A9	Types of extra argument to call the transformation function with.

Note: The Tuple and An template arguments can be deduced from the function arguments, so they can usually be omitted.

Parameters

orig	Tuple value to be transformed.
a0	Extra argument values to provide to the transformation function.
a1	Extra argument values to provide to the transformation function.
a2	Extra argument values to provide to the transformation function.
a3	Extra argument values to provide to the transformation function.
a4	Extra argument values to provide to the transformation function.
a5	Extra argument values to provide to the transformation function.
a6	Extra argument values to provide to the transformation function.
a7	Extra argument values to provide to the transformation function.
a8	Extra argument values to provide to the transformation function.
a9	Extra argument values to provide to the transformation function.

This function is overloaded for any number of extra arguments, up to an implementation-defined arbitrary limit. The overloads are not documented separately.

The TypeEvaluator class template should be suitable as the TE template argument for TransformTupleFunctor. It has the following form (an extension of the TypeEvaluator template argument of ForEachType):

template <class T>
struct TypeEvaluator {
  typedef UserDefined Type;
  template<class A0, class A1, class A2, class A3, class A4, class A5,
           class A6, class A7, class A8, class A9>
  static Type apply(T& t, A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5,
                    A6& a6, A7& a7, A8& a8, A9& a9);
};

For any given element type T of the tuple, the TypeEvaluator template class should provide a member typedef Type which determines the type of the transformed value and a static function apply(), taking the value of the tuple element t and the extra arguments given to transformTuple(). The signature of apply() does not have to match the one given above exactly, as long as it can be called that way.

Note: Since transformTuple() takes non-const references to the extra arguments, it will only bind to lvalue extra arguments, unless you specify the corresponding template parameter as const SomeType. Specifically this means that you cannot simply use literals or function return values as extra arguments. Providing overloads for all possible combinations of rvalue and lvalue extra arguments would result in $2^{n+1}-1$ overloads where is the implementation defined limit in the number of extra arguments.

See also: genericTransforTuple(), ForEachType, AddRefTypeEvaluator, and AddPtrTypeEvaluator.

References genericTransformTuple().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation