Dune::TypeTree Namespace Reference

Namespaces
namespace	Detail
namespace	Experimental
namespace	impl
namespace	Literals
namespace	TreePathType

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

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.
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.
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.
template<typename Node >
using	NodeTag = typename std::decay_t< Node >::NodeTag
	Returns the node tag of the given Node.
template<typename T >
using	ImplementationTag = typename std::decay_t< T >::ImplementationTag
	Returns the implementation tag of the given Node.
template<typename Node >
using	StaticDegree = decltype(Node::degree())
	Returns the statically known degree of the given Node type as a std::integral_constant.
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.
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.
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.
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.
template<typename Node >
std::size_t	degree (const Node &node)
	Returns the degree of node as run time information.
template<typename Tree1 , typename Tree2 , typename Visitor >
void	applyToTreePair (Tree1 &&tree1, Tree2 &&tree2, Visitor &&visitor)
	Apply visitor to a pair of TypeTrees.
template<typename SourceNode , typename Transformation , typename Tag >
void	registerNodeTransformation (SourceNode *, Transformation *, Tag *)
	Register transformation descriptor to transform SourceNode with Transformation.
template<class Tree , TreePathType::Type pathType = TreePathType::dynamic>
constexpr auto	leafTreePathTuple ()
	Create tuple of tree paths to leafs.
template<typename Tree , typename Visitor >
void	applyToTree (Tree &&tree, Visitor &&visitor)
	Apply visitor to TypeTree.
template<class Tree , class NodeFunc >
void	forEachNode (Tree &&tree, NodeFunc &&nodeFunc)
	Traverse tree and visit each node.
template<class Tree , class LeafFunc >
void	forEachLeafNode (Tree &&tree, LeafFunc &&leafFunc)
	Traverse tree and visit each leaf node.
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.
template<class Tree , class LeafToValue >
auto	makeTreeContainer (const Tree &tree, LeafToValue &&leafToValue)
	Create container havin the same structure as the given tree.
template<class Value , class Tree >
auto	makeTreeContainer (const Tree &tree)
	Create container havin the same structure as the given tree.
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 auto	makeTreePath (const T... t)
	helper function to construct a new HybridTreePath from the given indices.
template<typename... T>
constexpr auto	hybridTreePath (const T &... t)
	Constructs a new HybridTreePath from the given indices.
template<typename... T>
constexpr auto	treePath (const T &... t)
	Constructs a new HybridTreePath from the given indices.
template<typename... T>
constexpr std::size_t	treePathSize (const HybridTreePath< T... > &)
	Returns the size (number of components) of the given HybridTreePath.
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.
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.
template<typename... T>
constexpr auto	back (const HybridTreePath< T... > &tp) -> decltype(tp.back())
	Returns a copy of the last element of the HybridTreePath.
template<typename... T>
constexpr auto	front (const HybridTreePath< T... > &tp) -> decltype(tp.front())
	Returns a copy of the first element of the HybridTreePath.
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.
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.
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.
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.
template<typename I , typename... T, std::enable_if_t<(sizeof...(T) > 0), bool > = true>
constexpr auto	accumulate_back (const HybridTreePath< T... > &tp, I i)
	Hybrid utility that accumulates to the back of a multi-index.
template<typename I , typename... T, std::enable_if_t<(sizeof...(T) > 0), bool > = true>
constexpr auto	accumulate_front (const HybridTreePath< T... > &tp, I i)
	Hybrid utility that accumulates to the front of a multi-index.
template<class... Head, class... Other>
constexpr auto	join (const HybridTreePath< Head... > &head, const Other &... tail)
	Join two tree paths into one.
template<class... T>
constexpr auto	reverse (const HybridTreePath< T... > &tp)
	Reverses the order of the elements in the path.
template<class... T, std::enable_if_t<(sizeof...(T) > 0), bool > = true>
constexpr auto	pop_front (const HybridTreePath< T... > &tp)
	Removes first index on a HybridTreePath.
template<class... T, std::enable_if_t<(sizeof...(T) > 0), bool > = true>
constexpr auto	pop_back (const HybridTreePath< T... > &tp)
	Removes last index on a HybridTreePath.
template<class... S, class... T>
constexpr bool	operator== (const HybridTreePath< S... > &lhs, const HybridTreePath< T... > &rhs)
	Compare two HybridTreePaths for value equality.
template<class S , S... lhs, class T , T... rhs>
constexpr auto	operator== (const HybridTreePath< std::integral_constant< S, lhs >... > &, const HybridTreePath< std::integral_constant< T, rhs >... > &)
	Overload for purely static HybridTreePaths.
template<class... S, class... T>
constexpr auto	operator!= (const HybridTreePath< S... > &lhs, const HybridTreePath< T... > &rhs)
	Compare two HybridTreePaths for unequality.
template<class S , S... lhs, class T , T... rhs>
constexpr auto	operator!= (const HybridTreePath< std::integral_constant< S, lhs >... > &, const HybridTreePath< std::integral_constant< T, rhs >... > &)
	Compare two static HybridTreePaths for unequality.
template<char... digits>
constexpr auto	operator""_tp ()
	Literal to create treepath.
template<typename... T>
std::ostream &	operator<< (std::ostream &os, const HybridTreePath< T... > &tp)
	Dumps a HybridTreePath to a stream.
template<typename T >
T *	declptr ()
	Helper function for generating a pointer to a value of type T in an unevaluated operand setting.
template<class T >
constexpr auto	isTreePath (const T &) -> IsTreePath< T >
	Check if given object represents a tree path.

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

T	Check if this type represents a tree path

Returns

std::true_type if argument is a tree path and std::false_type if not