containerdescriptors.hh File Reference

Lightweight representation of (hierarchical) size and block structure extracted from a basis to describe data structures like containers that can be accessed by multi-indices provided by the basis. More...

#include <array>
#include <cassert>
#include <functional>
#include <type_traits>
#include <vector>
#include <dune/common/filledarray.hh>
#include <dune/common/tuplevector.hh>
#include <dune/common/typeutilities.hh>
#include <dune/common/hybridutilities.hh>
#include <dune/common/rangeutilities.hh>
#include <dune/functions/common/type_traits.hh>
#include <dune/functions/functionspacebases/basistags.hh>

Go to the source code of this file.

Classes
struct	Dune::Functions::ContainerDescriptors::Unknown
	Fallback container descriptor if nothing else fits. More...
struct	Dune::Functions::ContainerDescriptors::Value
	The node in the descriptor tree representing a value placeholder. More...
struct	Dune::Functions::ContainerDescriptors::UniformArray< Child, n >
	Descriptor for arrays with all children identical and the number of children a static size. More...
struct	Dune::Functions::ContainerDescriptors::UniformVector< Child >
	Uniform descriptor with dynamic size. More...

Namespaces
namespace	Dune

Typedefs
template<class... Children>
using	Dune::Functions::ContainerDescriptors::Tuple = Dune::TupleVector< Children... >
	Descriptor with all children of possibly different type.
template<class Child , std::size_t n>
using	Dune::Functions::ContainerDescriptors::Array = std::array< Child, n >
	Descriptor for arrays with all children of the same type and static size.
template<class Child >
using	Dune::Functions::ContainerDescriptors::Vector = std::vector< Child >
	Descriptor for vectors with all children of the same type and dynamic size.
template<std::size_t n>
using	Dune::Functions::ContainerDescriptors::FlatArray = UniformArray< Value, n >
	Alias for a uniform array storing value placeholders.
using	Dune::Functions::ContainerDescriptors::FlatVector = UniformVector< Value >
	Alias for a uniform vector storing value placeholders.

Functions
template<class PreBasis >
auto	Dune::Functions::containerDescriptor (const PreBasis &preBasis)
	Return the container descriptor of the pre-basis, if defined, otherwise ContainerDescriptor::Unknown.
template<class Child0 , class... Children, std::enable_if_t<(std::is_same_v< Child0, Children > &&...), int > = 0>
auto	Dune::Functions::ContainerDescriptors::makeDescriptor (Child0 child, Children... children)
	Generate a descriptor in case the children are all of the same type.
template<class Child , std::size_t n>
auto	Dune::Functions::ContainerDescriptors::makeUniformDescriptor (std::integral_constant< std::size_t, n >, Child child)
	Generate a uniform descriptor in case the size is a static constant.
template<class Child >
auto	Dune::Functions::ContainerDescriptors::makeUniformDescriptor (std::size_t n, Child child)
	Generate a uniform descriptor in case the size is a dynamic value.

Detailed Description

Lightweight representation of (hierarchical) size and block structure extracted from a basis to describe data structures like containers that can be accessed by multi-indices provided by the basis.

The structure of a container-descriptor is a reduced container interface:

struct [Container]Descriptor
{
  template<class Index>
  [SubContainerDescriptor] operator[](Index i) const;  // return the i-th sub-container-descriptor
 
  [static constexpr] std::size_t size() [const];  // return the number of children
};

With the operator[] you can access the children. The Index type is either an integral value or an integral_constant for tuple nodes.

Size is either a static property, or a runtime value.