Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
Dune::Concept::Imp::TupleEntriesModelHelper< C, Tuple >::AccumulateFunctor< Accumulated, T >
Dune::AddPtrTypeEvaluator< T >TypeEvaluator to turn a type T into a pointer to T
Dune::AddPtrTypeEvaluator< T & >
Dune::AddRefTypeEvaluator< T >TypeEvaluator to turn a type T into a reference to T
Dune::AlignmentOf< T >Calculates the alignment requirement of a type
Dune::AllSet< TA >A set containing everything
Dune::AlwaysFalse< T >Template which always yields a false value
Dune::AlwaysTrue< T >Template which always yields a true value
Dune::AlwaysVoid< T >
Dune::ArrayList< T, N, A >A dynamically growing random access list
Dune::ArrayListIterator< T, N, A >A random access iterator for the Dune::ArrayList class
Dune::AssociativePropertyMap< T >An adapter to turn an unique associative container into a property map
Dune::At< N >Reverse element access
Dune::AtType< N, Tuple >Type for reverse element access
Dune::BidirectionalIteratorFacade< T, V, R, D >Facade class for stl conformant bidirectional iterators
Dune::bigunsignedint< k >Portable very large unsigned integers
Dune::BitSetVector< block_size, Allocator >A dynamic array of blocks of booleans
Dune::BitSetVectorConstReference< block_size, Alloc >A proxy class that acts as a const reference to a single bitset in a BitSetVector
Dune::BitSetVectorReference< block_size, Alloc >A proxy class that acts as a mutable reference to a single bitset in a BitSetVector
Dune::BufferedCommunicatorA communicator that uses buffers to gather and scatter the data to be send or received
Dune::CloneableAn interface class for cloneable objects
Dune::CollectiveCommunication< Communicator >Collective communication interface and sequential default implementation
Dune::CollectiveCommunication< MPI_Comm >Specialization of CollectiveCommunication for MPI
Dune::CollectiveIterator< T, A >A collective iterator for moving over the remote indices for all processes collectively
Dune::Combine< TI1, TI2, TA >A set combining two other sets
Dune::common_bits< current, mask >Activate if current and mask have common bits switched on
Dune::CommPolicy< V >Default policy used for communicating an indexed type
Dune::CommPolicy< V >::CommPolicy< VariableBlockVector< FieldVector< K, n >, A > >
Dune::CommPolicy< V >::CommunicationErrorError thrown if there was a problem with the communication
Dune::conditional< B, T, F >
Dune::const_reference< R >Get the 'const' version of a reference to a mutable object
Dune::const_reference< BitSetVectorConstReference< block_size, Alloc > >
Dune::const_reference< BitSetVectorReference< block_size, Alloc > >
Dune::const_reference< const R & >
Dune::const_reference< const R >
Dune::const_reference< DiagonalRowVector< K, n > >
Dune::const_reference< DiagonalRowVectorConst< K, n > >
Dune::const_reference< R & >
Dune::ConstantVolatileTraits< T >Determines whether a type is const or volatile and provides the unqualified types
Dune::ConstArrayListIterator< T, N, A >A constant random access iterator for the Dune::ArrayList class
Dune::ConstAssociativePropertyMap< T >An adaptor to turn an unique associative container into a property map
Dune::ContainerWrapperIterator< CW, T, R >Iterator class for sparse vector-like containers
Dune::Conversion< From, To >Checks whether a type is convertible to another
Dune::CommPolicy< V >::CopyGatherScatter< T >GatherScatter default implementation that just copies data
Dune::DebugAllocator< T >Allocators implementation which performs different kind of memory checks
Dune::DebugAllocator< void >
Dune::DebugStream< thislevel, dlevel, alevel, activator >Generic class to implement debug output streams
Dune::DebugStreamErrorStandard exception for the debugstream
Dune::DebugStreamStateIntermediate class to implement tie-operation of DebugStream
Dune::FloatCmp::DefaultEpsilon< T, style >Mapping from a value type and a compare style to a default epsilon
Dune::FloatCmp::DefaultEpsilon< T, absolute >
Dune::FloatCmp::DefaultEpsilon< T, relativeStrong >
Dune::FloatCmp::DefaultEpsilon< T, relativeWeak >
Dune::DenseIterator< C, T, R >Generic iterator class for dense vector and matrix implementations
Dune::DenseMatrix< MAT >A dense n x m matrix
Dune::DenseMatrixAssigner< DenseMatrix, DiagonalMatrix< field, N > >
Dune::DenseMatrixAssigner< DenseMatrix, IdentityMatrix< field, N > >
Dune::DenseMatVecTraits< T >
Dune::DenseMatVecTraits< DynamicMatrix< K > >
Dune::DenseMatVecTraits< DynamicVector< K, Allocator > >
Dune::DenseMatVecTraits< FieldMatrix< K, ROWS, COLS > >
Dune::DenseMatVecTraits< FieldVector< K, SIZE > >
Dune::DenseVector< V >Interface for a class of dense vectors over a given field
Dune::DiagonalMatrix< K, n >A diagonal matrix of static size
Dune::DiagonalMatrixWrapper< DiagonalMatrixType >
Dune::DiagonalRowVector< K, n >
Dune::DiagonalRowVectorConst< K, n >
Dune::DynamicMatrix< K >Construct a matrix with a dynamic size
Dune::DynamicVector< K, Allocator >Construct a vector with a dynamic size
Dune::EmptyJust an empty class
Dune::EmptySet< TA >An empty set
Dune::enable_if< B, T >
Dune::enable_if< true, T >
Dune::EnableIfInterOperable< T1, T2, Type >Enable typedef if two types are interoperable
Dune::EnumItem< TA, item >A set consisting only of one item
Dune::EnumRange< TA, from, end >A set representing a range including the borders
Dune::FloatCmp::EpsilonType< T >Mapping of value type to epsilon type
Dune::FloatCmp::EpsilonType< FieldVector< T, n > >Specialization of EpsilonType for Dune::FieldVector
Dune::FloatCmp::EpsilonType< std::vector< T, A > >Specialization of EpsilonType for std::vector
Dune::FloatCmp::Detail::eq_t< Dune::FieldVector< T, n >, cstyle >
Dune::FloatCmp::Detail::eq_t< std::vector< T >, cstyle >
Dune::FloatCmp::Detail::eq_t< T, absolute >
Dune::FloatCmp::Detail::eq_t< T, relativeStrong >
Dune::FloatCmp::Detail::eq_t< T, relativeWeak >
Dune::ExceptionBase class for Dune-Exceptions
Dune::ExceptionHookBase class to add a hook to the Dune::Exception
Dune::Factorial< m >Calculates the factorial of m at compile time
Dune::Factorial< 0 >End of recursion of factorial via specialization
Dune::FakeMPIHelperA fake mpi helper
false_type
Dune::false_type
Dune::FieldMatrix< K, ROWS, COLS >A dense n x m matrix
Dune::FieldTraits< T >
Dune::FieldTraits< const T >
Dune::FieldTraits< DenseMatrix< M > >
Dune::FieldTraits< DenseVector< V > >
Dune::FieldTraits< DynamicMatrix< K > >
Dune::FieldTraits< DynamicVector< K, Allocator > >
Dune::FieldTraits< FieldMatrix< K, ROWS, COLS > >
Dune::FieldTraits< FieldVector< K, SIZE > >
Dune::FieldTraits< std::complex< T > >
Dune::FieldTraits< std::vector< T > >
Dune::FieldTraits< T[N] >
Dune::FieldVector< K, SIZE >Vector space out of a tensor product of fields
Dune::FirstPredicateIndex< Tuple, Predicate, start, size >Finding the index of a certain type in a std::tuple
Dune::FirstTypeIndex< Tuple, T, start >Find the first occurrence of a type in a std::tuple
Dune::FlattenTuple< Tuple >Flatten a std::tuple of std::tuple's
Dune::FloatCmpOps< T, cstyle_, rstyle_ >Class encapsulating a default epsilon
Dune::FMatrixErrorError thrown if operations of a FieldMatrix fail
Dune::FMatrixPrecision< ctype >Precisions for calculations with FieldMatrix and FieldVector
Dune::ForEachType< TE, std::tuple< Args...> >
Dune::ForEachValue< Tuple >Helper template which implements iteration over all storage elements in a std::tuple
Dune::ForEachValuePair< Tuple1, Tuple2 >Extension of ForEachValue to two std::tuple's
Dune::ForLoop< Operation, first, last >A static loop using TMP
Dune::ForwardIteratorFacade< T, V, R, D >Base class for stl conformant forward iterators
Dune::Function< Domain, Range >Base class template for function classes
Dune::Gcd< a, b >Calculator of the greatest common divisor
Dune::Generic_MPI_Op< Type, BinaryFunction >
Dune::GenericIterator< C, T, R, D, IteratorFacade >Generic class for stl-conforming iterators for container classes with operator[]
Dune::GlobalLookupIndexSet< I >Decorates an index set with the possibility to find a global index that is mapped to a specific local
Dune::GMPField< precision >Number class for high precision floating point number using the GMP library mpf_class implementation
Dune::greater_or_equal< current, threshold >Greater or equal template test
Dune::has_nan< T >
Dune::has_nan< std::complex< T > >
Dune::hash< T >Functor for hashing objects of type T
Dune::HelpRequestException thrown if the user wants to see help string
Dune::IdentityMapA property map that applies the identity function to integers
Dune::IdentityMatrix< K, N >Read-only identity matrix
Dune::ImplementationDefinedDummy struct used for documentation purposes
Dune::IndentUtility class for handling nested indentation in output
Dune::IndexPair< TG, TL >A pair consisting of a global and local index
Dune::IndexSetSortFunctor< TG, TL >
Dune::IndicesSyncer< T >Class for recomputing missing indices of a distributed index set
Dune::integral_constant< T, v >
Dune::InterfaceCommunication interface between remote and local indices
Dune::InterfaceBuilderBase class of all classes representing a communication interface
Dune::InterfaceInformationInformation describing an interface
Dune::InvalidIndexSetStateException indicating that the index set is not in the expected state
Dune::RemoteIndexListModifier< T, A, mode >::InvalidPosition
Dune::InvalidStateExceptionDefault exception if a function was called while the object is not in a valid state for that function
Dune::IOErrorDefault exception class for I/O errors
Dune::ios_base_all_saverUtility class for storing and resetting stream attributes
Dune::Std::is_callable< F(Args...), R >Traits class to check if function is callable
Dune::is_indexable< T, I >
Dune::is_lvalue_reference< T >
Dune::is_pointer< T >
Dune::is_range< T, typename >
Dune::is_same< T, U >
Dune::IsBaseOf< Base, Derived >Checks whether a type is derived from another
Dune::IsConst< T >Tests whether a type is constant
Dune::IsEmptyTypeList< T >Check if given type is an empty TypeList
Dune::IsFieldVectorSizeCorrect< C, SIZE >TMP to check the size of a DenseVectors statically, if possible
Dune::IsFieldVectorSizeCorrect< FieldVector< T, SIZE >, SIZE >
Dune::IsFieldVectorSizeCorrect< FieldVector< T, SIZE1 >, SIZE >
Dune::Imp::IsIntegralConstant< T >
Dune::IsIntegralConstant< T >Check if T is an std::integral_constant<I, i>
Dune::Imp::IsIntegralConstant< std::integral_constant< T, t > >
Dune::IsInteroperable< T1, T2 >Checks whether two types are interoperable
Dune::IsNumber< T >
Dune::IsNumber< GMPField< precision > >
Dune::IsNumber< std::complex< T > >
Dune::Imp::IsTuple< T >
Dune::IsTuple< T >Check if T is a std::tuple<...>
Dune::Imp::IsTuple< std::tuple< T...> >
Dune::IsTupleOrDerived< T >Check if T derived from a std::tuple<...>
Dune::IsType< T >Generator for predicates accepting one particular type
Dune::IsTypeList< T >Check if given type is a TypeList
Dune::IsTypeList< TypeList< T...> >
Dune::IsVector< T, class >
Dune::IsVector< T, typename AlwaysVoid< typename T::field_type >::type >
Dune::IsVolatile< T >Tests whether a type is volatile
iterator
Dune::ParallelIndexSet< TG, TL, N >::iteratorThe iterator over the pairs
Dune::CollectiveIterator< T, A >::iteratorIterator over the valid underlying iterators
Dune::IteratorPropertyMap< RAI, IM, T, R >Adapter to turn a random access iterator into a property map
Dune::IteratorRange< Iterator >Simple range between a begin and an end iterator
Dune::JoinTuples< Head, Tail >Join two std::tuple's
Dune::Lcm< m, n >Calculate the least common multiple of two numbers
Dune::LocalIndexAn index present on the local process
Dune::LocalIndexComparator< T >
Dune::LocalIndexComparator< ParallelLocalIndex< T > >
Dune::lru< _Key, _Tp, _Traits >LRU Cache Container
Dune::LvaluePropertyMapTagTag for the category of lvalue property maps
Dune::Std::MakeUniqueHelper< T >
Dune::Std::MakeUniqueHelper< T[]>
Dune::Std::MakeUniqueHelper< T[N]>
Dune::MallocAllocator< T >Allocators implementation which simply calls malloc/free
Dune::MathErrorDefault exception class for mathematical errors
Dune::Max< Type >
Dune::Min< Type >
Dune::MPIGuardDetects a thrown exception and communicates to all other processes
Dune::MPIGuardErrorThis exception is thrown if the MPIGuard detects an error on a remote process
Dune::MPIHelperA real mpi helper.This helper should be used for parallel programs
Dune::MPITraits< T >A traits class describing the mapping of types onto MPI_Datatypes
Dune::MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >
Dune::MPITraits< ParallelLocalIndex< T > >
Dune::mutable_reference< R >Get the 'mutable' version of a reference to a const object
Dune::mutable_reference< BitSetVectorConstReference< block_size, Alloc > >
Dune::mutable_reference< BitSetVectorReference< block_size, Alloc > >
Dune::mutable_reference< const R & >
Dune::mutable_reference< const R >
Dune::mutable_reference< DiagonalRowVector< K, n > >
Dune::mutable_reference< DiagonalRowVectorConst< K, n > >
Dune::mutable_reference< R & >
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
Dune::No_Comm
Dune::NotImplementedDefault exception for dummy implementations
Dune::null_deleter< T >Implements the Deleter concept of shared_ptr without deleting anything
Dune::NullPointerInitialiser< std::tuple< Args...> >
std::numeric_limits< Dune::bigunsignedint< k > >
Dune::Impl::OrderedOverloadSet< F0, F >
Dune::Impl::OrderedOverloadSet< F0 >
Dune::OutOfMemoryErrorDefault exception if memory allocation fails
Dune::Impl::OverloadSet< F0, F >
Dune::Impl::OverloadSet< F0 >
Dune::ParallelErrorDefault exception if an error in the parallel communication of the programm occurred
Dune::ParallelIndexSet< TG, TL, N >Manager class for the mapping between local indices and globally unique indices
Dune::ParallelLocalIndex< T >An index present on the local process with an additional attribute flag
Dune::ParameterTreeHierarchical structure of string parameters
Dune::ParameterTreeParserParsers to set up a ParameterTree from various input sources
Dune::ParameterTreeParserErrorReport parser error while reading ParameterTree
Dune::ParameterTree::Parser< T >
Dune::ParameterTree::Parser< bool >
Dune::ParameterTree::Parser< FieldVector< T, n > >
Dune::ParameterTree::Parser< std::array< T, n > >
Dune::ParameterTree::Parser< std::basic_string< char, traits, Allocator > >
Dune::ParameterTree::Parser< std::bitset< n > >
Dune::ParameterTree::Parser< std::vector< T, A > >
Dune::PointerPairDeletor< Tuple >Deletes all objects pointed to in a std::tuple of pointers
Dune::Pool< T, s >A memory pool of objects
Dune::PoolAllocator< T, s >An allocator managing a pool of objects for reuse
Dune::PoolAllocator< void, s >
Dune::Power< p >Compute power for a run-time mantissa and a compile-time integer exponent
Dune::IsType< T >::Predicate< U >The actual predicate
Dune::PriorityTag< priority >Helper class for tagging priorities
Dune::PriorityTag< 0 >Helper class for tagging priorities
Dune::PromotionTraits< T1, T2 >Compute type of the result of an arithmetic operation involving two different number types
Dune::PromotionTraits< T1, T1 >
Dune::PropertyMapTraits< PM >
Dune::PropertyMapTraits< const T * >
Dune::PropertyMapTraits< T * >
Dune::PropertyMapTypeSelector< T, C >Selector for the property map type
Dune::PushBackTuple< typename std::tuple< Args...>, T >
Dune::PushFrontTuple< typename std::tuple< Args...>, T >
Dune::RandomAccessIteratorFacade< T, V, R, D >Base class for stl conformant forward iterators
Dune::RangeErrorDefault exception class for range errors
Dune::RAPropertyMapHelper< Reference, PropertyMap >
Dune::ReadablePropertyMapTagTag for the category of readable property maps
Dune::ReadWritePropertyMapTagTag for the category of readable and writable property maps
Dune::MallocAllocator< T >::rebind< U >
Dune::PoolAllocator< void, s >::rebind< U >
Dune::DebugAllocator< void >::rebind< U >
Dune::DebugAllocator< T >::rebind< U >
Dune::PoolAllocator< T, s >::rebind< U >Rebind the allocator to another type
Dune::ReduceTuple< F, Tuple, Seed, N >Apply reduce with meta binary function to template
Dune::ReduceTuple< F, Tuple, Seed, 0 >Apply reduce with meta binary function to template
Dune::Concept::Refines< BaseConcepts >Base class for refined concepts
Dune::RemoteIndex< T1, T2 >Information about an index residing on another processor
Dune::RemoteIndexListModifier< T, A, mode >Modifier for adding and/or deleting remote indices from the remote index list
Dune::RemoteIndices< T, A >The indices present on remote processes
Dune::InterfaceBuilder::RemoteIndicesStateError
Dune::remove_const< T >
Dune::remove_pointer< T >
Dune::remove_reference< T >
Dune::ReservedVector< T, n >A Vector class with statically reserved memory
Dune::FloatCmp::Detail::round_t< Dune::FieldVector< I, n >, Dune::FieldVector< T, n >, cstyle, rstyle >
Dune::FloatCmp::Detail::round_t< I, T, cstyle, downward >
Dune::FloatCmp::Detail::round_t< I, T, cstyle, towardInf >
Dune::FloatCmp::Detail::round_t< I, T, cstyle, towardZero >
Dune::FloatCmp::Detail::round_t< I, T, cstyle, upward >
Dune::FloatCmp::Detail::round_t< std::vector< I >, std::vector< T >, cstyle, rstyle >
Dune::Selection< TS, TG, TL, N >A cached selection of indices
Dune::SelectionIterator< TS, TG, TL, N >A const iterator over an uncached selection
Dune::SimdScalarTypeTraits< T >
Dune::Singleton< T >An adapter to turn a class into a singleton
Dune::SizeOf< T >Compute size of variadic type list
Dune::SizeOneFlag for marking indexed data structures where data at each index is of the same size
Dune::SLList< T, A >A single linked list
Dune::SLListConstIterator< T, A >A constant iterator for the SLList
Dune::SLListIterator< T, A >A mutable iterator for the SLList
Dune::SLListModifyIterator< T, A >A mutable iterator for the SLList
Dune::StandardMathematicalConstants< T >Standard implementation of MathematicalConstants
Dune::StaticPower< m, p >Calculates m^p at compile time
Dune::StaticPower< m, 0 >End of recursion via specialization
Dune::StreamWrap
Dune::SystemErrorDefault exception class for OS errors
Dune::TimerA simple stop watch
Dune::TimerErrorException thrown by the Timer class
Dune::Std::to_false_type< T >Template mapping a type to std::false_type
Dune::Std::to_true_type< T >Template mapping a type to std::true_type
Dune::ParameterTree::Parser< bool >::ToLower
Dune::Function< Domain, Range >::TraitsTraits class containing raw types
Dune::TransformTupleFunctor
Dune::true_type
Dune::FloatCmp::Detail::trunc_t< Dune::FieldVector< I, n >, Dune::FieldVector< T, n >, cstyle, rstyle >
Dune::FloatCmp::Detail::trunc_t< I, T, cstyle, downward >
Dune::FloatCmp::Detail::trunc_t< I, T, cstyle, towardInf >
Dune::FloatCmp::Detail::trunc_t< I, T, cstyle, towardZero >
Dune::FloatCmp::Detail::trunc_t< I, T, cstyle, upward >
Dune::FloatCmp::Detail::trunc_t< std::vector< I >, std::vector< T >, cstyle, rstyle >
Dune::TupleAccessTraits< T >
Dune::TupleAccessTraits< T & >
Dune::TupleAccessTraits< T * >
Dune::Concept::Imp::TupleEntriesModelHelper< C, Tuple >
Dune::TupleVector< T >A class augmenting std::tuple by element access via operator[]
type
Dune::TransformTupleFunctor::TypeEvaluator< T >
Dune::TypeList< T >A simple type list
Dune::TypeListElement< i, T >
Dune::TypeListElement< i, TypeList< T...> >Get element of TypeList
Dune::TypeListSize< T >
Dune::TypeListSize< TypeList< T...> >Get size of TypeList
Dune::UncachedSelection< TS, TG, TL, N >An uncached selection of indices
Dune::VariableSizeFlag for marking indexed data structures where the data at each index may be a variable multiple of another type
Dune::VariableSizeCommunicator< Allocator >A buffered communicator where the amount of data sent does not have to be known a priori
Dune::VirtualFunction< DomainType, RangeType >Virtual base class template for function classes
Dune::detail::voider<>
Dune::WritablePropertyMapTagTag for the category of writable property maps
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

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