Loading...
Searching...
No Matches
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
namespace | Dune::Functions
namespace | Dune::Functions::ContainerDescriptors

## 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.