Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
Dune::AddPtrTypeEvaluator< T >TypeEvaluator to turn a type T into a pointer to T
Dune::AddPtrTypeEvaluator< T & >
Dune::AddRefTypeEvaluator< T >Defined(DOXYGEN)
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::array< T, N >Simple fixed size array class. This replaces std::array, if that is not available
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< 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::CommPolicy< V >::CommunicationErrorError thrown if there was a problem with the communication
Dune::ConfigParserParser for hierarchical configuration filesThis class parses config files into a hierarchical structure. Config files should look like this
Dune::const_reference< R >Get the 'const' version of a reference to amutable 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::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::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::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 >Generic iterator class for dense vector and matrix implementations
Dune::DenseMatrix< MAT >A dense n x m matrix
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_nullptr_tFallback implementation of nullptr
Dune::DynamicMatrix< K >Construct a matrix with a dynamic size
Dune::DynamicVector< K >Construct a vector with a dynamic size
Dune::Element< N >Get the N-th element of a tuple
Dune::Element< 0 >Get the first element of a tuple
Dune::ElementType< N, T >
Dune::EmptyJust 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::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
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 > >
Dune::FieldTraits< FieldMatrix< K, ROWS, COLS > >
Dune::FieldTraits< FieldVector< K, SIZE > >
Dune::FieldTraits< std::complex< T > >
Dune::FieldVector< K, SIZE >Vector space out of a tensor product of fields
Dune::FiniteStack< T, n >A stack with static memory allocation
Dune::FirstPredicateIndex< Tuple, Predicate, start, size >Finding the index of a certain in a tuple
Dune::FirstTypeIndex< Tuple, T, start >Find the first occurance of a type in a tuple
Dune::FlattenTuple< TupleTuple >Flatten a tuple of tuples
Dune::FloatCmpOps< T, cstyle_, rstyle_ >Class encapsulating a default epsilon
Dune::fmatrix_assigner< T, n, m >Fvector assignment operator
Dune::FMatrixErrorError thrown if operations of a FieldMatrix fail
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::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::fvector_assigner< T, s >Fvector assignment operator
Dune::Gcd< a, b >Calculator of the greatest common divisor
Dune::Generic_MPI_Datatype< T >
Dune::Generic_MPI_Op< Type, BinaryFunction >
Dune::GenericForLoop< Operation, Value, first, last >
Dune::GenericForLoop< Operation, Value, last, last >
Dune::GenericIterator< C, T, R, D, IteratorFacade >Generic class for stl conformant iterators for container classes with operator[]
Dune::GeometryTypeUnique label for each type of entities that can occur in DUNE grids
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::IdentityMapA property map that applies the identity function to integers
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::Singleton< T >::InstancePointerA simple smart pointer responsible for creation and deletion of the instance
Dune::Int2Type< N >Map an integer value to a type
Dune::integral_constant< T, v >Generate a type for a given integral constant
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::is_same< T1, T2 >Compile time test for testing whether two types are the same
Dune::is_same< T, T >
Dune::IsBaseOf< Base, Derived >Checks wether a type is derived from another
Dune::IsConst< T >Tests wether a type is constant
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::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::JoinTuples< Head, Tail >Join two tuples
Dune::Lcm< m, n >Calculate the least common multiple of two numbers
Dune::Length< Tuple >Helper template to calculate length of a tuple
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::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< 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::NilAn empty class
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< Tuple >A helper template that initializes a tuple consisting of pointers to NULL
std::numeric_limits< Dune::bigunsignedint< k > >
Dune::OutOfMemoryErrorDefault exception if memory allocation fails
Dune::Pair< T1, TT >A tuple consisting of two objects
Dune::Pair< T1, Nil >A tuple consisting of one object. Specialization of Pair that really is a single value
Dune::ParallelErrorDefault exception if an error in the parallel communication of the programm occured
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::ParameterTreeParserParser for hierarchical configuration filesThis class parses config files into a hierarchical structure. Config files should look like this
Dune::ParameterTree::Parser< T >
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::IsType< T >::Predicate< U >The actual predicate
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::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::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::InterfaceBuilder::RemotexIndicesStateError
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< 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::Singleton< T >An adapter to turn a class into a singleton
Dune::Size< T >
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::StreamWrap
Dune::SystemErrorDefault exception class for OS errors
Dune::TimerA simple stop watch
Dune::TimerErrorException thrown by the Timer class
Dune::ParameterTree::Parser< bool >::ToLower
Dune::Function< Domain, Range >::TraitsTraits 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< 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< T1, T2, T3, T4, T5, T6, T7, T8, T9 >A Tuple of objects
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::TransformTupleFunctor< TE, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9 >::TypeEvaluator< T >Export the TypeEvaluator template class for genericTransformTuple()
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
Dune::VariableSizeFlag for marking indexed data structures where the data at each index may be a variable multiple of another type
Dune::VirtualFunction< DomainType, RangeType >Virtual base class template for function classes
Dune::WritablePropertyMapTagTag for the category of writable property maps

Generated on Fri Apr 29 2011 with Doxygen (ver 1.7.1) [doxygen-log,error-log].