dune-common  2.5.0
Classes | Functions
Dune::Hybrid::Impl Namespace Reference

Classes

class  DynamicIntegralRange
 
class  StaticIntegralRange
 

Functions

template<class T , int i>
constexpr auto size (const Dune::FieldVector< T, i > *, const PriorityTag< 5 > &) -> decltype(std::integral_constant< std::size_t, i >())
 
template<class T , T... t, class Index >
constexpr auto size (std::integer_sequence< T, t... >, PriorityTag< 4 >)
 
template<class T >
constexpr auto size (const T *, const PriorityTag< 3 > &) -> decltype(std::integral_constant< std::size_t, std::tuple_size< T >::value >())
 
template<class T >
constexpr auto size (const T *, const PriorityTag< 1 > &) -> decltype(std::integral_constant< std::size_t, T::size()>())
 
template<class T >
constexpr auto size (const T *t, const PriorityTag< 0 > &)
 
template<class Container , class Index , std::enable_if_t< IsTuple< std::decay_t< Container >>::value, int > = 0>
decltype(auto) constexpr elementAt (Container &&c, Index &&, PriorityTag< 2 >)
 
template<class T , T... t, class Index >
decltype(auto) constexpr elementAt (std::integer_sequence< T, t... > c, Index &&, PriorityTag< 1 >)
 
template<class Container , class Index >
decltype(auto) constexpr elementAt (Container &&c, Index &&i, PriorityTag< 0 >)
 
template<class Begin , class End , std::enable_if_t< IsIntegralConstant< Begin >::value and IsIntegralConstant< End >::value, int > = 0>
constexpr auto integralRange (const Begin &begin, const End &end, const PriorityTag< 1 > &)
 
template<class Begin , class End >
auto integralRange (const Begin &begin, const End &end, const PriorityTag< 0 > &)
 
template<class T >
void evaluateFoldExpression (std::initializer_list< T > &&)
 
template<class Range , class F , class Index , Index... i>
constexpr void forEachIndex (Range &&range, F &&f, std::integer_sequence< Index, i... >)
 
template<class F , class Index , Index... i>
constexpr void forEach (std::integer_sequence< Index, i... > range, F &&f, PriorityTag< 2 >)
 
template<class Range , class F , std::enable_if_t< IsIntegralConstant< decltype(Hybrid::size(std::declval< Range >()))>::value, int > = 0>
constexpr void forEach (Range &&range, F &&f, PriorityTag< 1 >)
 
template<class Range , class F >
constexpr void forEach (Range &&range, F &&f, PriorityTag< 0 >)
 
template<class IfFunc , class ElseFunc >
decltype(auto) constexpr ifElse (std::true_type, IfFunc &&ifFunc, ElseFunc &&elseFunc)
 
template<class IfFunc , class ElseFunc >
decltype(auto) constexpr ifElse (std::false_type, IfFunc &&ifFunc, ElseFunc &&elseFunc)
 
template<class IfFunc , class ElseFunc >
decltype(auto) ifElse (const bool &condition, IfFunc &&ifFunc, ElseFunc &&elseFunc)
 
template<class T1 , class T2 >
constexpr auto equals (const T1 &t1, const T2 &t2, PriorityTag< 1 >) -> decltype(T1::value, T2::value, std::integral_constant< bool, T1::value==T2::value >())
 
template<class T1 , class T2 >
constexpr auto equals (const T1 &t1, const T2 &t2, PriorityTag< 0 >)
 
template<class Result , class T , class Value , class Branches , class ElseBranch >
constexpr Result switchCases (std::integer_sequence< T >, const Value &value, Branches &&branches, ElseBranch &&elseBranch)
 
template<class Result , class T , T t0, T... tt, class Value , class Branches , class ElseBranch >
constexpr Result switchCases (std::integer_sequence< T, t0, tt... >, const Value &value, Branches &&branches, ElseBranch &&elseBranch)
 

Function Documentation

§ elementAt() [1/3]

template<class Container , class Index , std::enable_if_t< IsTuple< std::decay_t< Container >>::value, int > = 0>
decltype(auto) constexpr Dune::Hybrid::Impl::elementAt ( Container &&  c,
Index &&  ,
PriorityTag< 2 >   
)

§ elementAt() [2/3]

template<class T , T... t, class Index >
decltype(auto) constexpr Dune::Hybrid::Impl::elementAt ( std::integer_sequence< T, t... >  c,
Index &&  ,
PriorityTag< 1 >   
)

§ elementAt() [3/3]

template<class Container , class Index >
decltype(auto) constexpr Dune::Hybrid::Impl::elementAt ( Container &&  c,
Index &&  i,
PriorityTag< 0 >   
)

§ equals() [1/2]

template<class T1 , class T2 >
constexpr auto Dune::Hybrid::Impl::equals ( const T1 &  t1,
const T2 &  t2,
PriorityTag< 1 >   
) -> decltype(T1::value, T2::value, std::integral_constant<bool,T1::value == T2::value>())

§ equals() [2/2]

template<class T1 , class T2 >
constexpr auto Dune::Hybrid::Impl::equals ( const T1 &  t1,
const T2 &  t2,
PriorityTag< 0 >   
)

§ evaluateFoldExpression()

template<class T >
void Dune::Hybrid::Impl::evaluateFoldExpression ( std::initializer_list< T > &&  )

§ forEach() [1/3]

template<class F , class Index , Index... i>
constexpr void Dune::Hybrid::Impl::forEach ( std::integer_sequence< Index, i... >  range,
F &&  f,
PriorityTag< 2 >   
)

§ forEach() [2/3]

template<class Range , class F , std::enable_if_t< IsIntegralConstant< decltype(Hybrid::size(std::declval< Range >()))>::value, int > = 0>
constexpr void Dune::Hybrid::Impl::forEach ( Range &&  range,
F &&  f,
PriorityTag< 1 >   
)

§ forEach() [3/3]

template<class Range , class F >
constexpr void Dune::Hybrid::Impl::forEach ( Range &&  range,
F &&  f,
PriorityTag< 0 >   
)

§ forEachIndex()

template<class Range , class F , class Index , Index... i>
constexpr void Dune::Hybrid::Impl::forEachIndex ( Range &&  range,
F &&  f,
std::integer_sequence< Index, i... >   
)

§ ifElse() [1/3]

template<class IfFunc , class ElseFunc >
decltype(auto) constexpr Dune::Hybrid::Impl::ifElse ( std::true_type  ,
IfFunc &&  ifFunc,
ElseFunc &&  elseFunc 
)

§ ifElse() [2/3]

template<class IfFunc , class ElseFunc >
decltype(auto) constexpr Dune::Hybrid::Impl::ifElse ( std::false_type  ,
IfFunc &&  ifFunc,
ElseFunc &&  elseFunc 
)

§ ifElse() [3/3]

template<class IfFunc , class ElseFunc >
decltype(auto) Dune::Hybrid::Impl::ifElse ( const bool &  condition,
IfFunc &&  ifFunc,
ElseFunc &&  elseFunc 
)

§ integralRange() [1/2]

template<class Begin , class End , std::enable_if_t< IsIntegralConstant< Begin >::value and IsIntegralConstant< End >::value, int > = 0>
constexpr auto Dune::Hybrid::Impl::integralRange ( const Begin &  begin,
const End &  end,
const PriorityTag< 1 > &   
)

§ integralRange() [2/2]

template<class Begin , class End >
auto Dune::Hybrid::Impl::integralRange ( const Begin &  begin,
const End &  end,
const PriorityTag< 0 > &   
)

§ size() [1/5]

template<class T , int i>
constexpr auto Dune::Hybrid::Impl::size ( const Dune::FieldVector< T, i > *  ,
const PriorityTag< 5 > &   
) -> decltype(std::integral_constant<std::size_t,i>())

§ size() [2/5]

template<class T , T... t, class Index >
constexpr auto Dune::Hybrid::Impl::size ( std::integer_sequence< T, t... >  ,
PriorityTag< 4 >   
)

§ size() [3/5]

template<class T >
constexpr auto Dune::Hybrid::Impl::size ( const T *  ,
const PriorityTag< 3 > &   
) -> decltype(std::integral_constant<std::size_t,std::tuple_size<T>::value>())

§ size() [4/5]

template<class T >
constexpr auto Dune::Hybrid::Impl::size ( const T *  ,
const PriorityTag< 1 > &   
) -> decltype(std::integral_constant<std::size_t,T::size()>())

§ size() [5/5]

template<class T >
constexpr auto Dune::Hybrid::Impl::size ( const T *  t,
const PriorityTag< 0 > &   
)

§ switchCases() [1/2]

template<class Result , class T , class Value , class Branches , class ElseBranch >
constexpr Result Dune::Hybrid::Impl::switchCases ( std::integer_sequence< T >  ,
const Value &  value,
Branches &&  branches,
ElseBranch &&  elseBranch 
)

§ switchCases() [2/2]

template<class Result , class T , T t0, T... tt, class Value , class Branches , class ElseBranch >
constexpr Result Dune::Hybrid::Impl::switchCases ( std::integer_sequence< T, t0, tt... >  ,
const Value &  value,
Branches &&  branches,
ElseBranch &&  elseBranch 
)