dune-common 2.9.0
Loading...
Searching...
No Matches
Files | Classes | Typedefs | Functions
Tuple Utilities

Utility classes which can be used with std::tuple. More...

Collaboration diagram for Tuple Utilities:

Files

file  tupleutility.hh
 Contains utility classes which can be used with std::tuple.
 

Classes

struct  Dune::TupleAccessTraits< T >
 
struct  Dune::TupleAccessTraits< T * >
 
struct  Dune::TupleAccessTraits< T & >
 
struct  Dune::NullPointerInitialiser< T >
 A helper template that initializes a std::tuple consisting of pointers to nullptr. More...
 
struct  Dune::NullPointerInitialiser< std::tuple< Args... > >
 
struct  Dune::ForEachType< TE, T >
 Helper template to clone the type definition of a std::tuple with the storage types replaced by a user-defined rule. More...
 
struct  Dune::ForEachType< TE, std::tuple< Args... > >
 
class  Dune::TransformTupleFunctor< TE, Args >
 
struct  Dune::TransformTupleFunctor< TE, Args >::TypeEvaluator< T >
 
struct  Dune::AddRefTypeEvaluator< T >
 TypeEvaluator to turn a type T into a reference to T More...
 
struct  Dune::AddPtrTypeEvaluator< T >
 TypeEvaluator to turn a type T into a pointer to T More...
 
struct  Dune::AddPtrTypeEvaluator< T & >
 
struct  Dune::AtType< N, Tuple >
 Type for reverse element access. More...
 
struct  Dune::At< N >
 Reverse element access. More...
 
struct  Dune::PointerPairDeletor< Tuple >
 Deletes all objects pointed to in a std::tuple of pointers. More...
 
class  Dune::FirstPredicateIndex< Tuple, Predicate, start, size >
 Finding the index of a certain type in a std::tuple. More...
 
struct  Dune::IsType< T >
 Generator for predicates accepting one particular type. More...
 
struct  Dune::IsType< T >::Predicate< U >
 The actual predicate. More...
 
struct  Dune::FirstTypeIndex< Tuple, T, start >
 Find the first occurrence of a type in a std::tuple. More...
 
struct  Dune::PushBackTuple< Tuple, T >
 Helper template to append a type to a std::tuple. More...
 
struct  Dune::PushBackTuple< typename std::tuple< Args... >, T >
 
struct  Dune::PushFrontTuple< Tuple, T >
 Helper template to prepend a type to a std::tuple. More...
 
struct  Dune::PushFrontTuple< typename std::tuple< Args... >, T >
 
struct  Dune::ReduceTuple< F, Tuple, Seed, N >
 Apply reduce with meta binary function to template. More...
 
struct  Dune::ReduceTuple< F, Tuple, Seed, 0 >
 Apply reduce with meta binary function to template. More...
 
struct  Dune::JoinTuples< Head, Tail >
 Join two std::tuple's. More...
 
struct  Dune::FlattenTuple< Tuple >
 Flatten a std::tuple of std::tuple's. More...
 

Typedefs

typedef std::add_const< T >::type & Dune::TupleAccessTraits< T >::ConstType
 
typedef T & Dune::TupleAccessTraits< T >::NonConstType
 
typedef const std::remove_const< T >::type & Dune::TupleAccessTraits< T >::ParameterType
 
typedef std::add_const< T >::type * Dune::TupleAccessTraits< T * >::ConstType
 
typedef T * Dune::TupleAccessTraits< T * >::NonConstType
 
typedef T * Dune::TupleAccessTraits< T * >::ParameterType
 
typedef T & Dune::TupleAccessTraits< T & >::ConstType
 
typedef T & Dune::TupleAccessTraits< T & >::NonConstType
 
typedef T & Dune::TupleAccessTraits< T & >::ParameterType
 
typedef std::tuple< Args... > Dune::NullPointerInitialiser< std::tuple< Args... > >::ResultType
 
typedef std::tuple< typename TE< Args >::Type... > Dune::ForEachType< TE, std::tuple< Args... > >::Type
 
typedef T & Dune::AddRefTypeEvaluator< T >::Type
 
typedef std::remove_reference< T >::type * Dune::AddPtrTypeEvaluator< T >::Type
 
typedef std::remove_reference< T >::type * Dune::AddPtrTypeEvaluator< T & >::Type
 
typedef std::tuple_element< std::tuple_size< Tuple >::value-N-1, Tuple >::type Dune::AtType< N, Tuple >::Type
 
typedef std::tuple< Args..., T > Dune::PushBackTuple< typename std::tuple< Args... >, T >::type
 
typedef std::tuple< T, Args... > Dune::PushFrontTuple< typename std::tuple< Args... >, T >::type
 
typedef ReduceTuple< F, Tuple, Seed, N-1 >::type Dune::ReduceTuple< F, Tuple, Seed, N >::Accumulated
 
typedef std::tuple_element< N-1, Tuple >::type Dune::ReduceTuple< F, Tuple, Seed, N >::Value
 
typedef F< Accumulated, Value >::type Dune::ReduceTuple< F, Tuple, Seed, N >::type
 Result of the reduce operation.
 
typedef Seed Dune::ReduceTuple< F, Tuple, Seed, 0 >::type
 Result of the reduce operation.
 
typedef ReduceTuple< PushBackTuple, Tail, Head >::type Dune::JoinTuples< Head, Tail >::type
 Result of the join operation.
 
typedef ReduceTuple< JoinTuples, Tuple >::type Dune::FlattenTuple< Tuple >::type
 Result of the flatten operation.
 

Functions

template<class F , class ArgTuple , class I , I... i>
decltype(auto) Dune::applyPartial (F &&f, ArgTuple &&args, std::integer_sequence< I, i... >)
 Apply function with arguments from a given tuple.
 
static ResultType Dune::NullPointerInitialiser< std::tuple< Args... > >::apply ()
 
template<class Tuple , class Functor >
auto Dune::genericTransformTuple (Tuple &&t, Functor &&f) -> decltype(genericTransformTupleBackend(t, f))
 
 Dune::TransformTupleFunctor< TE, Args >::TransformTupleFunctor (Args &&... args)
 
template<class T >
auto Dune::TransformTupleFunctor< TE, Args >::operator() (T &&t) -> decltype(this->apply(t, std::index_sequence_for< Args... >{})) const
 
template<template< class > class TE, class... Args>
TransformTupleFunctor< TE, Args... > Dune::makeTransformTupleFunctor (Args &&... args)
 
template<template< class > class TypeEvaluator, class Tuple , class... Args>
auto Dune::transformTuple (Tuple &&orig, Args &&... args) -> decltype(genericTransformTuple(orig, makeTransformTupleFunctor< TypeEvaluator >(args...)))
 
static Type Dune::AddRefTypeEvaluator< T >::apply (T &t)
 
static Type Dune::AddPtrTypeEvaluator< T >::apply (T &t)
 
static Type Dune::AddPtrTypeEvaluator< T & >::apply (T &t)
 
template<typename Tuple >
static TupleAccessTraits< typenameAtType< N, Tuple >::Type >::NonConstType Dune::At< N >::get (Tuple &t)
 
template<typename Tuple >
static TupleAccessTraits< typenameAtType< N, Tuple >::Type >::ConstType Dune::At< N >::get (const Tuple &t)
 
template<typename... Ts>
static void Dune::PointerPairDeletor< Tuple >::apply (std::tuple< Ts... > &t)
 

Detailed Description

Utility classes which can be used with std::tuple.

Typedef Documentation

◆ Accumulated

template<template< class, class > class F, class Tuple , class Seed = std::tuple<>, int N = std::tuple_size<Tuple>::value>
typedef ReduceTuple<F,Tuple,Seed,N-1>::type Dune::ReduceTuple< F, Tuple, Seed, N >::Accumulated

◆ ConstType [1/3]

template<class T >
typedef std::add_const<T>::type& Dune::TupleAccessTraits< T >::ConstType

◆ ConstType [2/3]

template<class T >
typedef std::add_const<T>::type* Dune::TupleAccessTraits< T * >::ConstType

◆ ConstType [3/3]

template<class T >
typedef T& Dune::TupleAccessTraits< T & >::ConstType

◆ NonConstType [1/3]

template<class T >
typedef T& Dune::TupleAccessTraits< T >::NonConstType

◆ NonConstType [2/3]

template<class T >
typedef T* Dune::TupleAccessTraits< T * >::NonConstType

◆ NonConstType [3/3]

template<class T >
typedef T& Dune::TupleAccessTraits< T & >::NonConstType

◆ ParameterType [1/3]

template<class T >
typedef const std::remove_const<T>::type& Dune::TupleAccessTraits< T >::ParameterType

◆ ParameterType [2/3]

template<class T >
typedef T* Dune::TupleAccessTraits< T * >::ParameterType

◆ ParameterType [3/3]

template<class T >
typedef T& Dune::TupleAccessTraits< T & >::ParameterType

◆ ResultType

template<class... Args>
typedef std::tuple<Args...> Dune::NullPointerInitialiser< std::tuple< Args... > >::ResultType

◆ Type [1/5]

template<template< class > class TE, class... Args>
typedef std::tuple<typename TE<Args>::Type...> Dune::ForEachType< TE, std::tuple< Args... > >::Type

◆ Type [2/5]

template<class T >
typedef T& Dune::AddRefTypeEvaluator< T >::Type

◆ Type [3/5]

template<class T >
typedef std::remove_reference<T>::type* Dune::AddPtrTypeEvaluator< T >::Type

◆ Type [4/5]

template<class T >
typedef std::remove_reference<T>::type* Dune::AddPtrTypeEvaluator< T & >::Type

◆ Type [5/5]

template<int N, class Tuple >
typedef std::tuple_element<std::tuple_size<Tuple>::value-N-1,Tuple>::type Dune::AtType< N, Tuple >::Type

◆ type [1/6]

template<class... Args, class T >
typedef std::tuple<Args..., T> Dune::PushBackTuple< typename std::tuple< Args... >, T >::type

◆ type [2/6]

template<class... Args, class T >
typedef std::tuple<T, Args...> Dune::PushFrontTuple< typename std::tuple< Args... >, T >::type

◆ type [3/6]

template<template< class, class > class F, class Tuple , class Seed = std::tuple<>, int N = std::tuple_size<Tuple>::value>
typedef F<Accumulated,Value>::type Dune::ReduceTuple< F, Tuple, Seed, N >::type

Result of the reduce operation.

◆ type [4/6]

template<template< class, class > class F, class Tuple , class Seed >
typedef Seed Dune::ReduceTuple< F, Tuple, Seed, 0 >::type

Result of the reduce operation.

◆ type [5/6]

template<class Head , class Tail >
typedef ReduceTuple<PushBackTuple,Tail,Head>::type Dune::JoinTuples< Head, Tail >::type

Result of the join operation.

◆ type [6/6]

template<class Tuple >
typedef ReduceTuple<JoinTuples,Tuple>::type Dune::FlattenTuple< Tuple >::type

Result of the flatten operation.

◆ Value

template<template< class, class > class F, class Tuple , class Seed = std::tuple<>, int N = std::tuple_size<Tuple>::value>
typedef std::tuple_element<N-1,Tuple>::type Dune::ReduceTuple< F, Tuple, Seed, N >::Value

Function Documentation

◆ apply() [1/5]

template<class... Args>
static ResultType Dune::NullPointerInitialiser< std::tuple< Args... > >::apply ( )
inlinestatic

◆ apply() [2/5]

template<class Tuple >
template<typename... Ts>
static void Dune::PointerPairDeletor< Tuple >::apply ( std::tuple< Ts... > &  t)
inlinestatic

◆ apply() [3/5]

template<class T >
static Type Dune::AddRefTypeEvaluator< T >::apply ( T &  t)
inlinestatic

◆ apply() [4/5]

template<class T >
static Type Dune::AddPtrTypeEvaluator< T >::apply ( T &  t)
inlinestatic

◆ apply() [5/5]

template<class T >
static Type Dune::AddPtrTypeEvaluator< T & >::apply ( T &  t)
inlinestatic

◆ applyPartial()

template<class F , class ArgTuple , class I , I... i>
decltype(auto) Dune::applyPartial ( F &&  f,
ArgTuple &&  args,
std::integer_sequence< I, i... >   
)

Apply function with arguments from a given tuple.

Parameters
fA callable object
argsTuple containing the arguments
indicesIndices to arguments in tuple as std::integer_sequence

This will call the function with arguments generated by unpacking those entries of the tuple that show up given integer_sequence.

◆ genericTransformTuple()

template<class Tuple , class Functor >
auto Dune::genericTransformTuple ( Tuple &&  t,
Functor &&  f 
) -> decltype(genericTransformTupleBackend(t, f))

This function does for the value of a std::tuple what ForEachType does for the type of a std::tuple: it transforms the value using a user-provided policy functor.

Parameters
tThe std::tuple value to transform.
fThe functor to use to transform the values.

The functor should have the following form:

struct Functor
{
template<class>
struct TypeEvaluator
{
typedef user-defined Type;
};
template<class T>
typename TypeEvaluator<T>::Type operator()(T& val);
template<class T>
typename TypeEvaluator<T>::Type operator()(T& val) const;
template<class T>
typename TypeEvaluator<T>::Type operator()(const T& val);
template<class T>
typename TypeEvaluator<T>::Type operator()(const T& val) const;
};

The member class template TypeEvaluator should be a class template suitable as the TypeEvaluator template parameter for ForEachType. The function call operator operator() is used to transform the value; only the signatures of operator() which are actually used must be present.

◆ get() [1/2]

template<int N>
template<typename Tuple >
static TupleAccessTraits< typenameAtType< N, Tuple >::Type >::ConstType Dune::At< N >::get ( const Tuple &  t)
inlinestatic

◆ get() [2/2]

template<int N>
template<typename Tuple >
static TupleAccessTraits< typenameAtType< N, Tuple >::Type >::NonConstType Dune::At< N >::get ( Tuple &  t)
inlinestatic

◆ makeTransformTupleFunctor()

template<template< class > class TE, class... Args>
TransformTupleFunctor< TE, Args... > Dune::makeTransformTupleFunctor ( Args &&...  args)

◆ operator()()

template<template< class > class TE, class... Args>
template<class T >
auto Dune::TransformTupleFunctor< TE, Args >::operator() ( T &&  t) -> decltype(this->apply(t,std::index_sequence_for<Args...>{})) const
inline

◆ transformTuple()

template<template< class > class TypeEvaluator, class Tuple , class... Args>
auto Dune::transformTuple ( Tuple &&  orig,
Args &&...  args 
) -> decltype(genericTransformTuple(orig, makeTransformTupleFunctor<TypeEvaluator>(args...)))

This function provides functionality similar to genericTransformTuple(), although less general and closer in spirit to ForEachType.

Template Parameters
TypeEvaluatorUsed as the TE template argument to TransformTupleFunctor internally.
TupleType of the std::tuple to transform.
ArgsTypes of extra argument to call the transformation function with.
Parameters
origTuple value to be transformed.
argsExtra arguments values to provide to the transformation function.

The TypeEvaluator class template should be suitable as the TE template argument for TransformTupleFunctor. It has the following form (an extension of the TypeEvaluator template argument of ForEachType):

template <class T>
struct TypeEvaluator
{
typedef UserDefined Type;
template<class... Args>
static Type apply(T& t, Args&... args);
};
See also
genericTransforTuple(), ForEachType, AddRefTypeEvaluator, and AddPtrTypeEvaluator.

◆ TransformTupleFunctor()

template<template< class > class TE, class... Args>
Dune::TransformTupleFunctor< TE, Args >::TransformTupleFunctor ( Args &&...  args)
inline