dune-typetree  2.8.0
Namespaces | Classes | Typedefs | Functions
Dune::TypeTree Namespace Reference

Namespaces

 apply_to_tuple_policy
 Policies for the function apply_to_tuple().
 
 Detail
 
 Experimental
 
 impl
 
 TreePathType
 

Classes

struct  or_
 Statically combine two values of type result_type using ||. More...
 
struct  and_
 Statically combine two values of type result_type using &&. More...
 
struct  plus
 Statically combine two values of type result_type using +. More...
 
struct  minus
 Statically combine two values of type result_type using -. More...
 
struct  multiply
 Statically combine two values of type result_type using *. More...
 
struct  min
 Statically combine two values of type result_type by returning their minimum. More...
 
struct  max
 Statically combine two values of type result_type by returning their maximum. More...
 
struct  AccumulateValue
 Statically accumulate a value over the nodes of a TypeTree. More...
 
struct  TypeAccumulationPolicy
 
struct  AccumulateType
 Statically accumulate a type over the nodes of a TypeTree. More...
 
class  CompositeNode
 Base class for composite nodes based on variadic templates. More...
 
class  DynamicPowerNode
 Collect multiple instances of type T within a dune-typetree. More...
 
class  Exception
 Base class for all TypeTree exceptions. More...
 
class  FilteredCompositeNode
 Base class for composite nodes representing a filtered view on an underlying composite node. More...
 
struct  FilterEntry
 A filter entry describing the mapping of one child in the filtered node. More...
 
struct  FilterResult
 The result of a filter. More...
 
struct  SimpleFilterTag
 Tag describing a simple filter that can only decide whether or not to include a single given child. More...
 
struct  AdvancedFilterTag
 Tag describing an advanced filter that has full control over the construction of the list of FilterEntries. More...
 
struct  AdvancedFilter
 Base class for advanced filters. More...
 
struct  SimpleFilter
 Default simple filter that accepts any node and leaves its child structure unchanged. More...
 
struct  IndexFilter
 Filter class for FilteredCompositeNode that selects the children with the given indices. More...
 
struct  filter
 Adapter class that takes a SimpleFilter, validated it and turns it into an AdvancedFilter. More...
 
class  FixedCapacityStackView
 
class  FixedCapacityStack
 
struct  GenericLeafNodeTransformation
 
struct  TemplatizedGenericPowerNodeTransformation
 
struct  GenericPowerNodeTransformation
 
struct  TemplatizedGenericDynamicPowerNodeTransformation
 
struct  GenericDynamicPowerNodeTransformation
 
struct  TemplatizedGenericCompositeNodeTransformation
 
struct  GenericCompositeNodeTransformation
 
class  LeafNode
 Base class for leaf nodes in a dune-typetree. More...
 
struct  NodeInterface
 Interface for nodes in a dune-typetree. More...
 
struct  LeafNodeTag
 Tag designating a leaf node. More...
 
struct  PowerNodeTag
 Tag designating a power node. More...
 
struct  DynamicPowerNodeTag
 Tag designating a power node with runtime degree. More...
 
struct  CompositeNodeTag
 Tag designating a composite node. More...
 
struct  GenericPowerNodeTransformationTemplate
 
struct  GenericDynamicPowerNodeTransformationTemplate
 
struct  GenericCompositeNodeTransformationTemplate
 
class  PowerNode
 Collect k instances of type T within a dune-typetree. More...
 
class  ProxyNode
 Base class for nodes acting as a proxy for an existing node. More...
 
class  StaticChildAccessors
 Mixin class providing methods for child access with compile-time parameter. More...
 
class  DynamicChildAccessors
 Mixin class providing methods for child access with run-time parameter. More...
 
struct  ProxyNodeBase
 Tag-based dispatch to appropriate base class that provides necessary functionality. More...
 
struct  ProxyNodeBase< Node, LeafNodeTag >
 ProxyNode base class for LeafNode. More...
 
struct  ProxyNodeBase< Node, CompositeNodeTag >
 ProxyNode base class for CompositeNode. More...
 
struct  ProxyNodeBase< Node, PowerNodeTag >
 ProxyNode base class for PowerNode. More...
 
struct  SimpleLeafNodeTransformation
 
struct  SimplePowerNodeTransformation
 
struct  SimpleDynamicPowerNodeTransformation
 
struct  SimpleCompositeNodeTransformation
 
struct  TransformTree
 Transform a TypeTree. More...
 
class  HybridTreePath
 A hybrid version of TreePath that supports both compile time and run time indices. More...
 
struct  TreePathSize
 
struct  TreePathPushBack
 
struct  TreePathPushFront
 
struct  TreePathBack
 
struct  TreePathFront
 
struct  TreePathPopBack
 
struct  TreePathPopFront
 
struct  TreePathConcat
 
struct  TreePathSize< HybridTreePath< index_constant< i >... > >
 
struct  TreePathPushBack< HybridTreePath< index_constant< i >... >, k >
 
struct  TreePathPushFront< HybridTreePath< index_constant< i >... >, k >
 
struct  TreePathBack< HybridTreePath< index_constant< k > > >
 
struct  TreePathBack< HybridTreePath< index_constant< j >, index_constant< k >, index_constant< l >... > >
 
struct  TreePathFront< HybridTreePath< index_constant< k >, index_constant< i >... > >
 
struct  TreePathPopBack< HybridTreePath< index_constant< k > >, i... >
 
struct  TreePathPopBack< HybridTreePath< index_constant< j >, index_constant< k >, index_constant< l >... >, i... >
 
struct  TreePathPopFront< HybridTreePath< index_constant< k >, index_constant< i >... > >
 
struct  TreePathConcat< HybridTreePath< index_constant< i >... >, HybridTreePath< index_constant< k >... > >
 
struct  has_node_tag
 
struct  has_node_tag_value
 
struct  has_implementation_tag
 
struct  has_implementation_tag_value
 
struct  AlwaysVoid
 
struct  meta_function
 Marker tag declaring a meta function. More...
 
struct  lazy_evaluate
 Helper meta function to delay evaluation of F. More...
 
struct  lazy_identity
 Identity function. More...
 
struct  evaluate_if_meta_function
 Meta function that evaluates its argument iff it inherits from meta_function. More...
 
struct  IsTreePath
 Check if type represents a tree path. More...
 
struct  TreeInfo
 Struct for obtaining some basic structural information about a TypeTree. More...
 
struct  DefaultVisitor
 Visitor interface and base class for TypeTree visitors. More...
 
struct  DefaultPairVisitor
 Visitor interface and base class for visitors of pairs of TypeTrees. More...
 
struct  VisitDirectChildren
 Mixin base class for visitors that only want to visit the direct children of a node. More...
 
struct  VisitTree
 Mixin base class for visitors that want to visit the complete tree. More...
 
struct  StaticTraversal
 Mixin base class for visitors that require a static TreePath during traversal. More...
 
struct  DynamicTraversal
 Mixin base class for visitors that only need a dynamic TreePath during traversal. More...
 
struct  TreeVisitor
 Convenience base class for visiting the entire tree. More...
 
struct  DirectChildrenVisitor
 Convenience base class for visiting the direct children of a node. More...
 
struct  TreePairVisitor
 Convenience base class for visiting an entire tree pair. More...
 
struct  DirectChildrenPairVisitor
 Convenience base class for visiting the direct children of a node pair. More...
 

Typedefs

template<typename Node , std::size_t... indices>
using Child = typename impl::_Child< Node, indices... >::type
 Template alias for the type of a child node given by a list of child indices. More...
 
template<typename Node , typename TreePath >
using ChildForTreePath = typename impl::_ChildForTreePath< Node, TreePath >::type
 Template alias for the type of a child node given by a TreePath or a HybridTreePath type. More...
 
template<typename T >
using is_flat_index = typename impl::_is_flat_index< std::decay_t< T > >::type
 Type trait that determines whether T is a flat index in the context of child extraction. More...
 
template<typename Node >
using NodeTag = typename std::decay_t< Node >::NodeTag
 Returns the node tag of the given Node. More...
 
template<typename T >
using ImplementationTag = typename std::decay_t< T >::ImplementationTag
 Returns the implementation tag of the given Node. More...
 
template<typename Node >
using StaticDegree = decltype(Node::degree())
 Returns the statically known degree of the given Node type as a std::integral_constant. More...
 
template<class Value , class Tree >
using UniformTreeContainer = std::decay_t< decltype(makeTreeContainer< Value >(std::declval< const Tree & >()))>
 Alias to container type generated by makeTreeContainer for given tree type and uniform value type. More...
 
template<template< class Node > class LeafToValue, class Tree >
using TreeContainer = std::decay_t< decltype(makeTreeContainer(std::declval< const Tree & >(), std::declval< Detail::LeafToDefaultConstructibleValue< LeafToValue > >()))>
 Alias to container type generated by makeTreeContainer for give tree type and when using LeafToValue to create values. More...
 
template<std::size_t... i>
using TreePath = HybridTreePath< Dune::index_constant< i >... >
 
template<std::size_t... i>
using StaticTreePath = HybridTreePath< Dune::index_constant< i >... >
 

Functions

template<typename Node , typename... Indices>
ImplementationDefined child (Node &&node, Indices... indices)
 Extracts the child of a node given by a sequence of compile-time and run-time indices. More...
 
template<typename Node , typename... Indices>
ImplementationDefined childStorage (Node &&node, Indices... indices)
 
template<typename Node , typename... Indices>
ImplementationDefined child (Node &&node, HybridTreePath< Indices... > treePath)
 Extracts the child of a node given by a HybridTreePath object. More...
 
template<typename Node >
std::size_t degree (const Node &node)
 Returns the degree of node as run time information. More...
 
template<typename Tree1 , typename Tree2 , typename Visitor >
void applyToTreePair (Tree1 &&tree1, Tree2 &&tree2, Visitor &&visitor)
 Apply visitor to a pair of TypeTrees. More...
 
template<typename SourceNode , typename Transformation , typename Tag >
void registerNodeTransformation (SourceNode *, Transformation *, Tag *)
 Register transformation descriptor to transform SourceNode with Transformation. More...
 
template<class Tree , TreePathType::Type pathType = TreePathType::dynamic>
constexpr auto leafTreePathTuple ()
 Create tuple of tree paths to leafs. More...
 
template<typename Tree , typename Visitor >
void applyToTree (Tree &&tree, Visitor &&visitor)
 Apply visitor to TypeTree. More...
 
template<class Tree , class PreFunc , class LeafFunc , class PostFunc >
void forEachNode (Tree &&tree, PreFunc &&preFunc, LeafFunc &&leafFunc, PostFunc &&postFunc)
 Traverse tree and visit each node. More...
 
template<class Tree , class InnerFunc , class LeafFunc >
void forEachNode (Tree &&tree, InnerFunc &&innerFunc, LeafFunc &&leafFunc)
 Traverse tree and visit each node. More...
 
template<class Tree , class NodeFunc >
void forEachNode (Tree &&tree, NodeFunc &&nodeFunc)
 Traverse tree and visit each node. More...
 
template<class Tree , class LeafFunc >
void forEachLeafNode (Tree &&tree, LeafFunc &&leafFunc)
 Traverse tree and visit each leaf node. More...
 
template<typename ResultType , typename Tree , typename F , typename R >
ResultType reduceOverLeafs (const Tree &tree, F functor, R reduction, ResultType startValue)
 Calculate a quantity as a reduction over the leaf nodes of a TypeTree. More...
 
template<class Tree , class LeafToValue >
auto makeTreeContainer (const Tree &tree, LeafToValue &&leafToValue)
 Create container havin the same structure as the given tree. More...
 
template<class Value , class Tree >
auto makeTreeContainer (const Tree &tree)
 Create container havin the same structure as the given tree. More...
 
template<std::size_t... i>
void print_tree_path (std::ostream &os)
 
template<std::size_t k, std::size_t... i>
void print_tree_path (std::ostream &os)
 
template<typename... T>
constexpr HybridTreePath< T... > hybridTreePath (const T &... t)
 Constructs a new HybridTreePath from the given indices. More...
 
template<typename... T>
constexpr HybridTreePath< T... > treePath (const T &... t)
 Constructs a new HybridTreePath from the given indices. More...
 
template<typename... T>
constexpr std::size_t treePathSize (const HybridTreePath< T... > &)
 Returns the size (number of components) of the given HybridTreePath. More...
 
template<std::size_t i, typename... T>
constexpr auto treePathEntry (const HybridTreePath< T... > &tp, index_constant< i >={}) -> typename std::decay< decltype(std::get< i >(tp._data))>::type
 Returns a copy of the i-th element of the HybridTreePath. More...
 
template<std::size_t i, typename... T>
constexpr std::size_t treePathIndex (const HybridTreePath< T... > &tp, index_constant< i >={})
 Returns the index value of the i-th element of the HybridTreePath. More...
 
template<typename... T, typename std::enable_if<(sizeof...(T) > 0), bool >::type = true>
constexpr auto back (const HybridTreePath< T... > &tp) -> decltype(treePathEntry< sizeof...(T) -1 >(tp))
 Returns a copy of the last element of the HybridTreePath. More...
 
template<typename... T>
constexpr auto front (const HybridTreePath< T... > &tp) -> decltype(treePathEntry< 0 >(tp))
 Returns a copy of the first element of the HybridTreePath. More...
 
template<typename... T>
constexpr HybridTreePath< T..., std::size_t > push_back (const HybridTreePath< T... > &tp, std::size_t i)
 Appends a run time index to a HybridTreePath. More...
 
template<std::size_t i, typename... T>
constexpr HybridTreePath< T..., index_constant< i > > push_back (const HybridTreePath< T... > &tp, index_constant< i > i_={})
 Appends a compile time index to a HybridTreePath. More...
 
template<typename... T>
constexpr HybridTreePath< std::size_t, T... > push_front (const HybridTreePath< T... > &tp, std::size_t element)
 Prepends a run time index to a HybridTreePath. More...
 
template<std::size_t i, typename... T>
constexpr HybridTreePath< index_constant< i >, T... > push_front (const HybridTreePath< T... > &tp, index_constant< i > _i={})
 Prepends a compile time index to a HybridTreePath. More...
 
template<typename... T>
std::ostream & operator<< (std::ostream &os, const HybridTreePath< T... > &tp)
 Dumps a HybridTreePath to a stream. More...
 
template<typename T >
T * declptr ()
 Helper function for generating a pointer to a value of type T in an unevaluated operand setting. More...
 
template<class T >
constexpr auto isTreePath (const T &) -> IsTreePath< T >
 Check if given object represents a tree path. More...
 
template<typename... Args>
void discard (Args &&... args)
 No-op function to make calling a function on a variadic template argument pack legal C++. More...
 
template<typename T , typename F , typename Policy >
void apply_to_tuple (T &&t, F &&f, Policy=apply_to_tuple_policy::default_policy())
 Apply a functor to each element of a std::tuple. More...
 

Function Documentation

◆ declptr()

template<typename T >
T* Dune::TypeTree::declptr ( )

Helper function for generating a pointer to a value of type T in an unevaluated operand setting.

◆ isTreePath()

template<class T >
constexpr auto Dune::TypeTree::isTreePath ( const T &  ) -> IsTreePath<T>
constexpr

Check if given object represents a tree path.

Template Parameters
TCheck if this type represents a tree path
Returns
std::true_type if argument is a tree path and std::false_type if not