Tuple Utilities
[Utilities]

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

Classes

struct  Dune::TupleAccessTraits< T >
struct  Dune::TupleAccessTraits< T * >
struct  Dune::TupleAccessTraits< T & >
struct  Dune::NullPointerInitialiser< std::tuple< Args...> >
struct  Dune::ForEachType< TE, std::tuple< Args...> >
class  Dune::TransformTupleFunctor
struct  Dune::TransformTupleFunctor::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 & >
class  Dune::ForEachValue< Tuple >
 Helper template which implements iteration over all storage elements in a std::tuple. More...
class  Dune::ForEachValuePair< Tuple1, Tuple2 >
 Extension of ForEachValue to two std::tuple's. More...
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::FirstTypeIndex< Tuple, T, start >
 Find the first occurrence of a type in a std::tuple. More...
struct  Dune::PushBackTuple< typename std::tuple< Args...>, T >
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...

Files

file  tupleutility.hh
 

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


Typedefs

typedef T & Dune::TupleAccessTraits::NonConstType
typedef const
std::remove_const< T >::type & 
Dune::TupleAccessTraits::ParameterType
typedef T * Dune::TupleAccessTraits< T * >::NonConstType
typedef T * Dune::TupleAccessTraits< T * >::ParameterType
typedef T & Dune::TupleAccessTraits< T & >::NonConstType
typedef T & Dune::TupleAccessTraits< T & >::ParameterType
typedef std::tuple_element< N-1,
Tuple >::type 
Dune::ReduceTuple::Value
typedef F< Accumulated, Value >
::type 
Dune::ReduceTuple::type
 Result of the reduce operation.

Functions

static ResultType Dune::NullPointerInitialiser< std::tuple< Args...> >::apply ()
template<class Tuple , class Functor >
auto Dune::genericTransformTuple (Tuple &&t, Functor &&f)-> decltype(genericTransformTupleBackend(t
 Dune::TransformTupleFunctor::TransformTupleFunctor (Args &&...args)
template<class T >
auto Dune::TransformTupleFunctor::operator() (T &&t)-> decltype(this->apply(t
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
auto Dune::makeTransformTupleFunctor< TypeEvaluator > (args...)))
static Type Dune::AddRefTypeEvaluator::apply (T &t)
static Type Dune::AddPtrTypeEvaluator::apply (T &t)
static Type Dune::AddPtrTypeEvaluator< T & >::apply (T &t)
template<class Functor >
void Dune::ForEachValue::apply (Functor &f) const
 Applies a function object to each storage element of the std::tuple.
template<class Functor >
void Dune::ForEachValuePair::apply (Functor &f)
template<typename Tuple >
static TupleAccessTraits
< typename AtType< N, Tuple >
::Type >::ConstType 
Dune::At::get (const Tuple &t)

Detailed Description

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


Typedef Documentation

template<class T >
typedef T& Dune::TupleAccessTraits< T & >::NonConstType [inherited]
template<class T >
typedef T* Dune::TupleAccessTraits< T * >::NonConstType [inherited]
template<class T >
typedef T& Dune::TupleAccessTraits< T >::NonConstType [inherited]
template<class T >
typedef T& Dune::TupleAccessTraits< T & >::ParameterType [inherited]
template<class T >
typedef T* Dune::TupleAccessTraits< T * >::ParameterType [inherited]
template<class T >
typedef const std::remove_const<T>::type& Dune::TupleAccessTraits< T >::ParameterType [inherited]
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 [inherited]

Result of the reduce operation.

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 [inherited]

Function Documentation

template<class Tuple1 , class Tuple2 >
template<class Functor >
void Dune::ForEachValuePair< Tuple1, Tuple2 >::apply ( Functor &  f  )  [inline, inherited]

Applies the function object f to the pair of std::tuple's.

Parameters:
f The function object to apply on the pair of std::tuple's.
template<class Tuple >
template<class Functor >
void Dune::ForEachValue< Tuple >::apply ( Functor &  f  )  const [inline, inherited]

Applies a function object to each storage element of the std::tuple.

Parameters:
f Function object.
template<class T >
static Type Dune::AddPtrTypeEvaluator< T & >::apply ( T &  t  )  [inline, static, inherited]
template<class T >
static Type Dune::AddPtrTypeEvaluator< T >::apply ( T &  t  )  [inline, static, inherited]
template<class T >
static Type Dune::AddRefTypeEvaluator< T >::apply ( T &  t  )  [inline, static, inherited]
template<class... Args>
static ResultType Dune::NullPointerInitialiser< std::tuple< Args...> >::apply (  )  [inline, static, inherited]
template<class Tuple , class Functor >
auto Dune::genericTransformTuple ( Tuple &&  t,
Functor &&  f 
) [inline]

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:
t The std::tuple value to transform.
f The 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.

template<int N>
template<typename Tuple >
static TupleAccessTraits<typename AtType<N, Tuple>::Type>::ConstType Dune::At< N >::get ( const Tuple &  t  )  [inline, static, inherited]
template<template< class > class TE, class... Args>
TransformTupleFunctor<TE, Args...> Dune::makeTransformTupleFunctor ( Args &&...  args  )  [inline]
auto Dune::makeTransformTupleFunctor< TypeEvaluator > ( args...   ) 
template<class T >
auto Dune::TransformTupleFunctor::operator() ( T &&  t  )  [inline, inherited]
template<template< class > class TypeEvaluator, class Tuple , class... Args>
auto Dune::transformTuple ( Tuple &&  orig,
Args &&...  args 
) [inline]

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

Template Parameters:
TypeEvaluator Used as the TE template argument to TransformTupleFunctor internally.
Tuple Type of the std::tuple to transform.
Args Types of extra argument to call the transformation function with.
Parameters:
orig Tuple value to be transformed.
args Extra 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.
Dune::TransformTupleFunctor::TransformTupleFunctor ( Args &&...  args  )  [inline, inherited]
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on 25 Mar 2018 for dune-common by  doxygen 1.6.1