 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 > | An set containing everything |
 Dune::AlwaysFalse< T > | Template which always yields a false value |
 Dune::AlwaysTrue< T > | Template which always yields a true value |
 Dune::ForLoopHelper::Apply< A, B > | |
 Dune::ForLoopHelper::Apply< Operation< first >, GenericForLoop< ForLoopHelper::Apply, Operation, first+1, last > > | |
  Dune::GenericForLoop< ForLoopHelper::Apply, Operation, first, last > | |
   Dune::ForLoop< Operation, first, last > | A static loop using TMP |
 Dune::array< T, N > | Simple fixed size array class. This replaces std::array, if that is not available |
 Dune::array< Dune::FieldVector< K, COLS >, ROWS > | |
 Dune::array< Dune::FieldVector< T, COLS >, ROWS > | |
 Dune::array< K, SIZE > | |
 Dune::array< MemberType, chunkSize_ > | |
 Dune::array< T, SIZE > | |
 Dune::ArrayList< T, N, A > | A dynamically growing random access list |
 Dune::ArrayList< Dune::IndexPair, N > | |
 Dune::ArrayList< IndexPair< TG, TL >, N, std::allocator< Dune::IndexPair< TG, TL > > > | |
 Dune::At< N > | Reverse element access |
 Dune::AtType< N, Tuple > | Type for reverse element access |
 Dune::bigunsignedint< k > | Portable very large unsigned integers |
 binary_function | |
  Dune::Max< Type > | |
  Dune::Min< Type > | |
 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::BufferedCommunicator | A communicator that uses buffers to gather and scatter the data to be send or received |
 Dune::Cloneable | An interface class for cloneable objects |
 Dune::CollectiveCommunication< C > | 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::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< R & > | |
 Dune::ConstantVolatileTraits< T > | Determines wether a type is const or volatile and provides the unqualified types |
 Dune::ConstantVolatileTraits< const T > | |
 Dune::ConstantVolatileTraits< const volatile T > | |
 Dune::ConstantVolatileTraits< volatile T > | |
 Dune::Conversion< From, To > | Checks wether a type is convertible to another |
 Dune::Conversion< From, void > | |
 Dune::Conversion< int, double > | |
 Dune::Conversion< T, T > | |
 Dune::Conversion< void, To > | |
 Dune::CommPolicy< V >::CopyGatherScatter< T > | GatherScatter default implementation that just copies data |
 Dune::DebugStreamState | Intermediate class to implement tie-operation of DebugStream |
  Dune::DebugStream< thislevel, dlevel, alevel, activator > | Generic class to implement debug output streams |
 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::DenseMatrix< M > | A dense n x m matrix |
  Dune::FieldMatrix< T, n, m > | |
 Dune::DenseMatrix< DynamicMatrix< K > > | |
  Dune::DynamicMatrix< K > | Construct a matrix with a dynamic size |
 Dune::DenseMatrix< FieldMatrix< K, ROWS, COLS > > | |
  Dune::FieldMatrix< K, N, M > | A dense n x m matrix |
 Dune::DenseMatrix< FieldMatrix< T, ROWS, COLS > > | |
 Dune::DenseMatVecTraits< T > | |
 Dune::DenseMatVecTraits< DynamicMatrix< K > > | |
 Dune::DenseMatVecTraits< DynamicVector< K > > | |
 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::FieldVector< T, COLS > | |
  Dune::FieldVector< T, s > | |
 Dune::DenseVector< DynamicVector< K > > | |
  Dune::DynamicVector< K > | Construct a vector with a dynamic size |
 Dune::DenseVector< FieldVector< K, SIZE > > | |
  Dune::FieldVector< K, N > | Vector space out of a tensor product of fields |
  Dune::FieldVector< K, COLS > | |
 Dune::DenseVector< FieldVector< T, SIZE > > | |
 dune_nullptr_t | Fallback implementation of nullptr |
 Dune::Element< N > | Get the N-th element of a tuple |
 Dune::Element< 0 > | Get the first element of a tuple |
 Dune::Empty | Just an empty class |
 Dune::EmptySet< TA > | An empty set |
 Dune::enable_if< b, T > | Enable typedef if condition is met |
 Dune::enable_if< false, T > | |
 Dune::enable_if< IsInteroperable< T1, T2 >::value, Type > | |
  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< T, style > | |
 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::Exception | Base class for Dune-Exceptions |
  Dune::FMatrixError | Error thrown if operations of a FieldMatrix fail |
  Dune::InterfaceBuilder::RemotexIndicesStateError | |
  Dune::InvalidIndexSetState | Exception indicating that the index set is not in the expected state |
  Dune::InvalidStateException | Default exception if a function was called while the object is not in a valid state for that function |
  Dune::IOError | Default exception class for I/O errors |
   Dune::CommPolicy< V >::CommunicationError | Error thrown if there was a problem with the communication |
   Dune::DebugStreamError | Standard exception for the debugstream |
  Dune::MathError | Default exception class for mathematical errors |
  Dune::NotImplemented | Default exception for dummy implementations |
  Dune::ParallelError | Default exception if an error in the parallel communication of the programm occured |
   Dune::MPIGuardError | This exception is thrown if the MPIGuard detects an error on a remote process |
  Dune::RangeError | Default exception class for range errors |
   Dune::RemoteIndexListModifier< T, A, mode >::InvalidPosition | |
  Dune::SystemError | Default exception class for OS errors |
   Dune::OutOfMemoryError | Default exception if memory allocation fails |
   Dune::TimerError | Exception thrown by the Timer class |
 Dune::ExceptionHook | Base 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::FakeMPIHelper | A fake mpi helper |
 Dune::FieldTraits< T > | |
 Dune::FieldTraits< const T > | |
 Dune::FieldTraits< DenseMatrix< M > > | |
 Dune::FieldTraits< DenseVector< V > > | |
 Dune::FieldTraits< DynamicMatrix< K > > | |
 Dune::FieldTraits< DynamicVector< K > > | |
 Dune::FieldTraits< FieldMatrix< K, ROWS, COLS > > | |
 Dune::FieldTraits< FieldVector< K, SIZE > > | |
 Dune::FieldTraits< std::complex< T > > | |
 Dune::CommPolicy< V >::FieldVector< K, n > | |
 Dune::FlattenTuple< TupleTuple > | Flatten a tuple of tuples |
 Dune::FloatCmpOps< T, cstyle_, rstyle_ > | Class encapsulating a default epsilon |
 Dune::fmatrix_assigner< T, n, m > | Fmatrix assignment operator |
 Dune::FMatrixPrecision< ctype > | Precisions for calculations with FieldMatrix and FieldVector |
 Dune::ForEachType< TypeEvaluator, TupleType > | Helper template to clone the type definition of a tuple with the storage types replaced by a user-defined rule |
 Dune::ForEachValue< TupleType > | Helper template which implements iteration over all storage elements in a tuple |
 Dune::ForEachValuePair< TupleType1, TupleType2 > | Extension of ForEachValue to two tuples.. |
 Dune::Function< Domain, Range > | Base class template for function classes |
 Dune::Function< const DomainType &, RangeType & > | |
  Dune::VirtualFunction< DomainType, RangeType > | Virtual base class template for function classes |
 Dune::fvector_assigner< T, s > | Fvector assignment operator |
 Dune::Gcd< a, b > | Calculator of the greatest common divisor |
 Dune::Generic_MPI_Op< Type, BinaryFunction > | |
 Dune::GeometryType | Unique label for each type of entities that can occur in DUNE grids |
 Dune::GlobalGeometryTypeIndex | Compute indices for geometry types, taking the dimension into account |
 Dune::GlobalLookupIndexSet< I > | Decorates an index set with the possibility to find a global index that is mapped to a specific local |
 Dune::greater_or_equal< current, threshold > | Greater or equal template test |
 Dune::ImplementationDefined | Dummy struct used for documentation purposes |
 Dune::Indent | Utility 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 > | Generate a type for a given integral constant |
  Dune::FirstPredicateIndex< Tuple, Predicate, start, size > | Finding the index of a certain type in a tuple |
  Dune::FirstPredicateIndex< Tuple, IsType< T >::template Predicate, start > | |
   Dune::FirstTypeIndex< Tuple, T, start > | Find the first occurance of a type in a tuple |
 Dune::InterfaceBuilder | Base class of all classes representing a communication interface |
  Dune::Interface | Communication interface between remote and local indices |
 Dune::InterfaceInformation | Information describing an interface |
 Dune::ios_base_all_saver | Utility class for storing and resetting stream attributes |
 Dune::is_same< T1, T2 > | Compile time test for testing whether two types are the same |
 Dune::is_same< T, T > | |
 Dune::is_same< T, U > | |
  Dune::IsType< T >::Predicate< U > | The actual predicate |
 Dune::IsBaseOf< Base, Derived > | Checks wether a type is derived from another |
 Dune::IsConst< T > | Tests wether a type is constant |
 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::IsInteroperable< T1, T2 > | Checks wether two types are interoperable |
 Dune::IsType< T > | Generator for predicates accepting one particular type |
 Dune::IsVolatile< T > | Tests wether a type is volatile |
 iterator | |
  Dune::BidirectionalIteratorFacade< T, V, R, D > | Facade class for stl conformant bidirectional iterators |
  Dune::ForwardIteratorFacade< T, V, R, D > | Base class for stl conformant forward iterators |
   Dune::SLListIterator< RemoteIndex, Allocator > | |
   Dune::SLListModifyIterator< RemoteIndex, Allocator > | |
  Dune::RandomAccessIteratorFacade< T, V, R, D > | Base class for stl conformant forward iterators |
   Dune::ConstArrayListIterator< IndexPair< TG, TL >, N, std::allocator< Dune::IndexPair< TG, TL > > > | |
  Dune::ForwardIteratorFacade< SLListConstIterator< T, A >, const T, const T &, std::size_t > | |
   Dune::SLListConstIterator< T, A > | A constant iterator for the SLList |
  Dune::ForwardIteratorFacade< SLListIterator< RemoteIndex, Allocator >, RemoteIndex, RemoteIndex &, std::size_t > | |
  Dune::ForwardIteratorFacade< SLListIterator< T, A >, T, T &, std::size_t > | |
   Dune::SLListIterator< T, A > | A mutable iterator for the SLList |
  Dune::ForwardIteratorFacade< SLListModifyIterator< RemoteIndex, Allocator >, RemoteIndex, RemoteIndex &, std::size_t > | |
  Dune::ForwardIteratorFacade< SLListModifyIterator< T, A >, T, T &, std::size_t > | |
   Dune::SLListModifyIterator< T, A > | A mutable iterator for the SLList |
  Dune::RandomAccessIteratorFacade< ArrayListIterator< T, N, A >, A::value_type, A::reference, A::difference_type > | |
   Dune::ArrayListIterator< T, N, A > | A random access iterator for the Dune::ArrayList class |
    Dune::ParallelIndexSet< TG, TL, N >::iterator | The iterator over the pairs |
  Dune::RandomAccessIteratorFacade< ConstArrayListIterator< IndexPair< TG, TL >, N, std::allocator< Dune::IndexPair< TG, TL > > >, const std::allocator< Dune::IndexPair< TG, TL > >::value_type, std::allocator< Dune::IndexPair< TG, TL > >::const_reference, std::allocator< Dune::IndexPair< TG, TL > >::difference_type > | |
  Dune::RandomAccessIteratorFacade< ConstArrayListIterator< T, N, A >, const A::value_type, A::const_reference, A::difference_type > | |
   Dune::ConstArrayListIterator< T, N, A > | A constant random access iterator for the Dune::ArrayList class |
  Dune::RandomAccessIteratorFacade< DenseIterator< C, T >, T, T &, std::ptrdiff_t > | |
   Dune::DenseIterator< C, T > | Generic iterator class for dense vector and matrix implementations |
 Dune::CollectiveIterator< T, A >::iterator | Iterator over the valid underlying iterators |
 IteratorFacade | |
  Dune::GenericIterator< C, T, R, D, IteratorFacade > | Generic class for stl-conforming iterators for container classes with operator[] |
 Dune::JoinTuples< Head, Tail > | Join two tuples |
 Dune::Lcm< m, n > | Calculate the least common multiple of two numbers |
 Dune::LocalGeometryTypeIndex | Compute per-dimension indices for geometry types |
 Dune::LocalIndex | An index present on the local process |
 Dune::LocalIndexComparator< T > | |
 Dune::LocalIndexComparator< ParallelLocalIndex< T > > | |
 Dune::lru< _Key, _Tp, _Traits > | LRU Cache Container |
 Dune::MathematicalConstants< Field > | Provides commonly used mathematical constants |
 Dune::MPIGuard | Detects a thrown exception and communicates to all other processes |
 Dune::MPIHelper | A real mpi helper.This helper should be used for parallel programs |
 Dune::MPITraits< K > | 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< 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::Nil | An empty class |
 Dune::No_Comm | |
 Dune::null_deleter< T > | Implements the Deleter concept of shared_ptr without deleting anything |
 Dune::NullPointerInitialiser< Tuple > | A helper template that initializes a tuple consisting of pointers to NULL |
 std::numeric_limits< Dune::bigunsignedint< k > > | |
 Operation | |
  Dune::GenericForLoop< Operation, Value, first, last > | |
 Dune::OwnerOverlapCopyCommunication< T1, T2 > | |
 Dune::Pair< T1, TT > | A tuple consisting of two objects |
  Dune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > | A Tuple of objects |
  Dune::tuple< RemoteIndexModifier, GlobalIndexModifier, BoolListModifier, const ConstRemoteIndexIterator > | |
 Dune::Pair< T1, Nil > | A tuple consisting of one object. Specialization of Pair that really is a single value |
 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::ParameterTree | Hierarchical structure of string parameters |
 Dune::ParameterTreeParser | Parsers to set up a ParameterTree from various input sources |
 Dune::ParameterTree::Parser< array< T, n > > | |
 Dune::ParameterTree::Parser< bool > | |
 Dune::ParameterTree::Parser< FieldVector< T, n > > | |
 Dune::ParameterTree::Parser< std::basic_string< char, traits, Allocator > > | |
 Dune::ParameterTree::Parser< std::vector< T, A > > | |
 Dune::PointerPairDeletor< Tuple > | Deletes all objects pointed to in a 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_m_p< m, p > | Calculates m^p at compile time |
 Dune::Power_m_p< m, 0 > | End of recursion via specialization |
 Dune::PropertyMapTraits< PM > | |
 Dune::PropertyMapTraits< const T * > | |
 Dune::PropertyMapTraits< T * > | |
 Dune::PropertyMapTypeSelector< T, C > | Selector for the property map type |
 Dune::PushBackTuple< Tuple, T > | Helper template to append a type to a tuple |
 Dune::PushFrontTuple< Tuple, T > | Helper template to prepend a type to a tuple |
 Dune::RAPropertyMapHelper< Reference, PropertyMap > | |
 Dune::RAPropertyMapHelper< const T::value_type::second_type &, ConstAssociativePropertyMap< T > > | |
  Dune::ConstAssociativePropertyMap< T > | An adaptor to turn an unique associative container into a property map |
 Dune::RAPropertyMapHelper< R, IteratorPropertyMap< RAI, IM, T, R > > | |
  Dune::IteratorPropertyMap< RAI, IM, T, R > | Adapter to turn a random access iterator into a property map |
 Dune::RAPropertyMapHelper< std::size_t, IdentityMap > | |
  Dune::IdentityMap | A property map that applies the identity function to integers |
 Dune::RAPropertyMapHelper< T::value_type::second_type &, AssociativePropertyMap< T > > | |
  Dune::AssociativePropertyMap< T > | An adapter to turn an unique associative container into a property map |
 Dune::ReadablePropertyMapTag | Tag for the category of readable property maps |
  Dune::ReadWritePropertyMapTag | Tag for the category of readable and writable property maps |
   Dune::LvaluePropertyMapTag | Tag for the category of lvalue property maps |
 Dune::PoolAllocator< T, s >::rebind< U > | Rebind the allocator to another type |
 Dune::PoolAllocator< void, s >::rebind< U > | |
 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::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::RemoteIndices< ParallelIndexSet > | |
 Dune::remove_const< T > | Removes a const qualifier while preserving others |
 Dune::remove_reference< T > | Remove a reference from a type |
 Dune::RemoveConstHelper< T, isVolatile > | |
 Dune::RemoveConstHelper< T, true > | |
 Dune::ReservedVector< T, n > | A Vector class with statically reserved memory |
 Dune::FloatCmp::Detail::round_t< I, T, cstyle, rstyle > | |
 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 > | An cached selection of indices |
 Dune::SelectionIterator< TS, TG, TL, N > | A const iterator over an uncached selection |
 Dune::SelectType< first, T1, T2 > | Select a type based on a condition |
 Dune::SelectType< false, T1, T2 > | |
 Dune::shared_ptr< T > | A reference counting smart pointer |
 Dune::shared_ptr< Dune::array< MemberType, chunkSize_ > > | |
 Dune::shared_ptr< MPI_Op > | |
 Dune::SharedCount | The object we reference |
 Dune::Singleton< T > | An adapter to turn a class into a singleton |
 Dune::SizeOne | Flag for marking indexed data structures where data at each index is of the same size |
 Dune::SLList< T, A > | A single linked list |
 Dune::SLList< RemoteIndex, Allocator > | |
 std::stack< T > | STL class |
  Dune::FiniteStack< T, n > | A stack with static memory allocation |
 Dune::StandardMathematicalConstants< T > | Standard implementation of MathematicalConstants |
 Dune::StreamWrap | |
 TE | |
  Dune::TransformTupleFunctor< TE, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9 >::TypeEvaluator< T > | Export the TypeEvaluator template class for genericTransformTuple() |
 testPoolMain< size, T > | |
 Dune::Timer | A simple stop watch |
 Dune::ParameterTree::Parser< bool >::ToLower | |
 Dune::Function< Domain, Range >::Traits | Traits class containing raw types |
 Dune::TransformTupleFunctor< TE, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9 > | Helper class to implement transformTuple() |
 Dune::FloatCmp::Detail::trunc_t< I, T, cstyle, rstyle > | |
 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::tuple_element< N, Tuple > | Get the type of the N-th element of the tuple |
 Dune::tuple_element< 0, Pair< T1, T2 > > | Get the type of the first element of the tuple |
 Dune::tuple_element< N, Pair< T1, T2 > > | |
 Dune::tuple_size< T > | Template meta_programm to query the size of a tuple |
 Dune::tuple_size< Pair< Nil, Nil > > | |
 Dune::tuple_size< Pair< T1, Nil > > | |
 Dune::tuple_size< Pair< T1, T2 > > | |
 Dune::tuple_writer< i > | |
 Dune::tuple_writer< 0 > | |
 Dune::tuple_writer< 1 > | |
 Dune::TupleAccessTraits< T > | |
 Dune::TupleAccessTraits< T & > | |
 Dune::TupleAccessTraits< T * > | |
 Dune::TupleToPairs< T1, T2, T3, T4, T5, T6, T7, T8, T9 > | Converts the Tuple to a list of pairs |
 Dune::TupleToPairs< T1, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil > | Specialization for a tuple consisting only of one type |
 Dune::TypeTraits< T > | General type traits class to check whether type is reference or pointer type |
 Dune::UncachedSelection< TS, TG, TL, N > | An uncached selection of indices |
 Value | |
  Dune::GenericForLoop< Operation, Value, last, last > | |
 Dune::CommPolicy< V >::VariableBlockVector< B, A > | |
 Dune::VariableSize | Flag for marking indexed data structures where the data at each index may be a variable multiple of another type |
 std::vector< T > | STL class |
  Dune::BitSetVector< block_size, Alloc > | A dynamic array of blocks of booleans |
 Dune::WritablePropertyMapTag | Tag for the category of writable property maps |
  Dune::ReadWritePropertyMapTag | Tag for the category of readable and writable property maps |