DUNE-ACFEM (unstable)

SequenceElementAccess

Random access to sequence elements. More...

Classes

struct  Dune::ACFem::Get< N, Seq >
 Gets the type of the n-th element of a tuple-like or the std::integral_constant corresponding to the n-th element of a sequence. More...
 

Typedefs

template<std::size_t N, class TupleLike >
using Dune::ACFem::TupleElement = std::tuple_element_t< N, std::decay_t< TupleLike > >
 Forward to std::tuple_element<N, std::decay_t<T> >
 
template<std::size_t Skip, std::size_t Cnt, class Seq >
using Dune::ACFem::GetPart = typename GetHeadPartHelper< Cnt, typename GetTailPartHelper< Skip, Seq >::Type >::Type
 Extract Cnt many consecutive elements from Seq starting at position N.
 
template<std::size_t Cnt, class Seq >
using Dune::ACFem::HeadPart = typename GetHeadPartHelper< Cnt, Seq >::Type
 Extract Cnt many consecutive elements from the front of Seq.
 
template<std::size_t Cnt, class Seq >
using Dune::ACFem::TailPart = typename GetTailPartHelper< Seq::size() -Cnt, Seq >::Type
 Extract Cnt many consecutive elements from the end of Seq.
 
template<class Seq , typename Seq::value_type V>
using Dune::ACFem::IndexIn = IndexConstant< IndexInHelper< 0, typename Seq::value_type, V, Seq >::value >
 Find the index of a given value in a sequence.
 
template<std::ptrdiff_t V, class Seq >
using Dune::ACFem::PushFront = decltype(pushFront< V >(Seq{}))
 Add value to start of integer-sequence.
 
template<std::ptrdiff_t V, class Seq >
using Dune::ACFem::PushBack = decltype(pushBack< V >(Seq{}))
 Add value to end of integer-sequence.
 
template<std::size_t V, std::size_t N, class Input >
using Dune::ACFem::Put = typename PutHelper< V, N, IndexSequence<>, Input >::Type
 Replace value at position N with V.
 

Functions

template<std::size_t I, class T , std::enable_if_t< IsTupleLike< T >::value, int > = 0>
constexpr decltype(auto) Dune::ACFem::get (T &&t, IndexConstant< I >=IndexConstant< I >{})
 Access to the i-the element.
 
template<std::size_t I, class T , std::size_t N, std::enable_if_t< std::is_integral< T >::value, int > = 0>
constexpr decltype(auto) Dune::ACFem::get (const T(&t)[N], IndexConstant< I >=IndexConstant< I >{})
 Access to the i-the element.
 
template<std::size_t I, class T , T... V>
constexpr auto Dune::ACFem::get (Sequence< T, V... >, IndexConstant< I >=IndexConstant< I >{})
 Access to the i-the element.
 
template<std::size_t I, class T , T V>
constexpr auto Dune::ACFem::get (Constant< T, V >, IndexConstant< I >=IndexConstant< I >{})
 Access to the i-the element.
 
template<std::ptrdiff_t V, class T , T... I>
constexpr auto Dune::ACFem::pushFront (Sequence< T, I... >, IntConstant< V >=IntConstant< V >{})
 Add V at the front of the sequence.
 
template<std::ptrdiff_t V, class T , T... I>
constexpr auto Dune::ACFem::pushBack (Sequence< T, I... >, IntConstant< V >=IntConstant< V >{})
 Add V at the end of the sequece.
 
template<class T1 , class T2 , std::enable_if_t<(IsTupleLike< T1 >::value &&IsTupleLike< T2 >::value &&size< T1 >()==size< T2 >()), int > = 0>
auto & Dune::ACFem::assign (T1 &t1, T2 &&t2)
 Assign one tuple-alike to another by looping over the elements.
 

ListSize

Getting the size of sequences and tuple-likes.

template<class T >
using Dune::ACFem::Size = IndexConstant< SizeV< std::decay_t< T > > >
 Gives the number of elements in tuple-likes and std::integer_sequence.
 
template<class T >
constexpr std::size_t Dune::ACFem::SizeV = std::numeric_limits<std::size_t>::max()
 Gives the number of elements in tuple-likes and std::integer_sequence.
 
template<class T , T V>
constexpr std::size_t Dune::ACFem::SizeV< Constant< T, V > > = 1UL
 Gives the number of elements in tuple-likes and std::integer_sequence.
 
template<class T , T... V>
constexpr std::size_t Dune::ACFem::SizeV< Sequence< T, V... > > = sizeof...(V)
 Gives the number of elements in tuple-likes and std::integer_sequence.
 
template<class T >
constexpr std::size_t Dune::ACFem::SizeV< T && > = SizeV<std::decay_t<T> >
 Gives the number of elements in tuple-likes and std::integer_sequence.
 
template<class T >
constexpr std::size_t Dune::ACFem::SizeV< T & > = SizeV<std::decay_t<T> >
 Gives the number of elements in tuple-likes and std::integer_sequence.
 
template<class T >
constexpr std::size_t Dune::ACFem::size ()
 Gives the number of elements in tuple-likes and std::integer_sequence.
 
template<class T , std::enable_if_t<(SizeV< T > !=SizeV< void >), int > = 0>
constexpr std::size_t Dune::ACFem::size (T &&t)
 Gives the number of elements in tuple-likes and std::integer_sequence. More...
 

Detailed Description

Random access to sequence elements.

Function Documentation

◆ size()

template<class T , std::enable_if_t<(SizeV< T > !=SizeV< void >), int > = 0>
constexpr std::size_t Dune::ACFem::size ( T &&  t)
constexpr

Gives the number of elements in tuple-likes and std::integer_sequence.

Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.80.0 (Mar 27, 23:31, 2024)