TreePath

Collaboration diagram for TreePath:

Namespaces
namespace	Dune::TypeTree::TreePathType

Classes
class	Dune::TypeTree::FixedCapacityStackView< T >
class	Dune::TypeTree::FixedCapacityStack< T, capacity >
struct	Dune::TypeTree::TreePathSize< typename >
struct	Dune::TypeTree::TreePathPushBack< typename, size_t >
struct	Dune::TypeTree::TreePathPushFront< typename, size_t >
struct	Dune::TypeTree::TreePathBack< typename >
struct	Dune::TypeTree::TreePathFront< typename >
struct	Dune::TypeTree::TreePathPopBack< typename,... >
struct	Dune::TypeTree::TreePathPopFront< typename >
struct	Dune::TypeTree::TreePathConcat< typename, typename >
class	Dune::TypeTree::HybridTreePath< T >
	A hybrid version of TreePath that supports both compile time and run time indices. More...
struct	Dune::TypeTree::TreePathSize< HybridTreePath< index_constant< i >... > >
struct	Dune::TypeTree::TreePathPushBack< HybridTreePath< index_constant< i >... >, k >
struct	Dune::TypeTree::TreePathPushFront< HybridTreePath< index_constant< i >... >, k >
struct	Dune::TypeTree::TreePathBack< HybridTreePath< index_constant< k > > >
struct	Dune::TypeTree::TreePathBack< HybridTreePath< index_constant< j >, index_constant< k >, index_constant< l >... > >
struct	Dune::TypeTree::TreePathFront< HybridTreePath< index_constant< k >, index_constant< i >... > >
struct	Dune::TypeTree::TreePathPopBack< HybridTreePath< index_constant< k > >, i... >
struct	Dune::TypeTree::TreePathPopBack< HybridTreePath< index_constant< j >, index_constant< k >, index_constant< l >... >, i... >
struct	Dune::TypeTree::TreePathPopFront< HybridTreePath< index_constant< k >, index_constant< i >... > >
struct	Dune::TypeTree::TreePathConcat< HybridTreePath< index_constant< i >... >, HybridTreePath< index_constant< k >... > >

Typedefs
template<std::size_t... i>
using	Dune::TypeTree::TreePath = HybridTreePath< Dune::index_constant< i >... >
template<std::size_t... i>
using	Dune::TypeTree::StaticTreePath = HybridTreePath< Dune::index_constant< i >... >

Functions
template<std::size_t... i>
void	Dune::TypeTree::print_tree_path (std::ostream &os)
template<std::size_t k, std::size_t... i>
void	Dune::TypeTree::print_tree_path (std::ostream &os)
template<typename... T>
constexpr HybridTreePath< T... >	Dune::TypeTree::hybridTreePath (const T &... t)
	Constructs a new HybridTreePath from the given indices.
template<typename... T>
constexpr HybridTreePath< T... >	Dune::TypeTree::treePath (const T &... t)
	Constructs a new HybridTreePath from the given indices.
template<typename... T>
constexpr std::size_t	Dune::TypeTree::treePathSize (const HybridTreePath< T... > &)
	Returns the size (number of components) of the given HybridTreePath.
template<std::size_t i, typename... T>
constexpr auto	Dune::TypeTree::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	Dune::TypeTree::treePathIndex (const HybridTreePath< T... > &tp, index_constant< i >={})
	Returns the index value of the i-th element of the HybridTreePath.
template<typename... T, typename std::enable_if<(sizeof...(T) > 0), bool >::type = true>
constexpr auto	Dune::TypeTree::back (const HybridTreePath< T... > &tp) -> decltype(treePathEntry< sizeof...(T) -1 >(tp))
	Returns a copy of the last element of the HybridTreePath.
template<typename... T>
constexpr auto	Dune::TypeTree::front (const HybridTreePath< T... > &tp) -> decltype(treePathEntry< 0 >(tp))
	Returns a copy of the first element of the HybridTreePath.
template<typename... T>
constexpr HybridTreePath< T..., std::size_t >	Dune::TypeTree::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 > >	Dune::TypeTree::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... >	Dune::TypeTree::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... >	Dune::TypeTree::push_front (const HybridTreePath< T... > &tp, index_constant< i > _i={})
	Prepends a compile time index to a HybridTreePath.
template<typename... T>
std::ostream &	Dune::TypeTree::operator<< (std::ostream &os, const HybridTreePath< T... > &tp)
	Dumps a HybridTreePath to a stream.

Detailed Description

Typedef Documentation

StaticTreePath

template<std::size_t... i>

using Dune::TypeTree::StaticTreePath = typedef HybridTreePath<Dune::index_constant<i>...>

TreePath

template<std::size_t... i>

using Dune::TypeTree::TreePath = typedef HybridTreePath<Dune::index_constant<i>...>

Function Documentation

back()

template<typename... T, typename std::enable_if<(sizeof...(T) > 0), bool >::type = true>

constexpr auto Dune::TypeTree::back ( const HybridTreePath< T... > &  tp ) -> decltype(treePathEntry<sizeof...(T)-1>(tp))

constexpr

Returns a copy of the last element of the HybridTreePath.

As HybridTreePath instances should not be mutated after their creation, this function returns a copy of the value. As values are either std::integral_constant or std::size_t, that's just as cheap as returning a reference.

front()

template<typename... T>

constexpr auto Dune::TypeTree::front ( const HybridTreePath< T... > &  tp ) -> decltype(treePathEntry<0>(tp))

constexpr

Returns a copy of the first element of the HybridTreePath.

As HybridTreePath instances should not be mutated after their creation, this function returns a copy of the value. As values are either std::integral_constant or std::size_t, that's just as cheap as returning a reference.

hybridTreePath()

template<typename... T>

constexpr HybridTreePath< T... > Dune::TypeTree::hybridTreePath ( const T &...  t )

constexpr

Constructs a new HybridTreePath from the given indices.

This function returns a new HybridTreePath with the given index values. It exists mainly to avoid having to manually specify the exact type of the new object.

operator<<()

template<typename... T>

std::ostream & Dune::TypeTree::operator<<	(	std::ostream &	os,
		const HybridTreePath< T... > &	tp
	)

Dumps a HybridTreePath to a stream.

print_tree_path() [1/2]

template<std::size_t... i>

void Dune::TypeTree::print_tree_path

(

std::ostream &

os

)

print_tree_path() [2/2]

template<std::size_t k, std::size_t... i>

void Dune::TypeTree::print_tree_path

(

std::ostream &

os

)

push_back() [1/2]

template<std::size_t i, typename... T>

constexpr HybridTreePath< T..., index_constant< i > > Dune::TypeTree::push_back ( const HybridTreePath< T... > &  tp, index_constant< i >  i_ = {}  )

constexpr

Appends a compile time index to a HybridTreePath.

This function returns a new HybridTreePath with the compile time index i appended.

The value for the new entry can be passed either as a template parameter or as an index_constant:

auto tp = hybridTreePath(1,2,3,4);
using namespace Dune::TypeTree::Indices;
// the following two lines are equivalent
auto tp_a = push_back<1>(tp);
auto tp_b = push_back(tp,_1);

push_back() [2/2]

template<typename... T>

constexpr HybridTreePath< T..., std::size_t > Dune::TypeTree::push_back ( const HybridTreePath< T... > &  tp, std::size_t  i  )

constexpr

Appends a run time index to a HybridTreePath.

This function returns a new HybridTreePath with the run time index i appended.

push_front() [1/2]

template<std::size_t i, typename... T>

constexpr HybridTreePath< index_constant< i >, T... > Dune::TypeTree::push_front ( const HybridTreePath< T... > &  tp, index_constant< i >  _i = {}  )

constexpr

Prepends a compile time index to a HybridTreePath.

This function returns a new HybridTreePath with the compile time index i prepended.

The value for the new entry can be passed either as a template parameter or as an index_constant:

auto tp = hybridTreePath(1,2,3,4);
using namespace Dune::TypeTree::Indices;
// the following two lines are equivalent
auto tp_a = push_front<1>(tp);
auto tp_b = push_front(tp,_1);

push_front() [2/2]

template<typename... T>

constexpr HybridTreePath< std::size_t, T... > Dune::TypeTree::push_front ( const HybridTreePath< T... > &  tp, std::size_t  element  )

constexpr

Prepends a run time index to a HybridTreePath.

This function returns a new HybridTreePath with the run time index i prepended.

treePath()

template<typename... T>

constexpr HybridTreePath< T... > Dune::TypeTree::treePath ( const T &...  t )

constexpr

Constructs a new HybridTreePath from the given indices.

This function returns a new HybridTreePath with the given index values. It exists mainly to avoid having to manually specify the exact type of the new object.

treePathEntry()

template<std::size_t i, typename... T>

constexpr auto Dune::TypeTree::treePathEntry ( const HybridTreePath< T... > &  tp, index_constant< i >  = {}  ) -> typename std::decay<decltype(std::get<i>(tp._data))>::type

constexpr

Returns a copy of the i-th element of the HybridTreePath.

As HybridTreePath instances should not be mutated after their creation, this function returns a copy of the value. As values are either std::integral_constant or std::size_t, that's just as cheap as returning a reference.

The index for the entry can be passed either as a template parameter or as an index_constant:

auto tp = hybridTreePath(1,2,3,4);
using namespace Dune::TypeTree::Indices;
// the following two lines are equivalent
std::cout << treePathEntry<2>(tp) << std::endl;
std::cout << treePathEntry(tp,_2) << std::endl;

treePathIndex()

template<std::size_t i, typename... T>

constexpr std::size_t Dune::TypeTree::treePathIndex ( const HybridTreePath< T... > &  tp, index_constant< i >  = {}  )

constexpr

Returns the index value of the i-th element of the HybridTreePath.

This function always returns the actual index value, irrespective of whether the entry is a compile time index or a run time index.

The index for the entry can be passed either as a template parameter or as an index_constant:

auto tp = hybridTreePath(1,2,3,4);
using namespace Dune::TypeTree::Indices;
// the following two lines are equivalent
std::cout << treePathIndex<2>(tp) << std::endl;
std::cout << treePathIndex(tp,_2) << std::endl;

treePathSize()

template<typename... T>

constexpr std::size_t Dune::TypeTree::treePathSize ( const HybridTreePath< T... > &  )

constexpr

Returns the size (number of components) of the given HybridTreePath.