dune-common 2.10
Loading...
Searching...
No Matches
Namespaces | Functions
integersequence.hh File Reference
#include <algorithm>
#include <array>
#include <cassert>
#include <functional>
#include <type_traits>
#include <utility>
#include <dune/common/indices.hh>

Go to the source code of this file.

Namespaces

namespace  Dune
 Dune namespace.
 

Functions

template<std::size_t pos, class T , T... II, std::enable_if_t<(!(pos >=sizeof...(II))), int > = 0>
constexpr auto Dune::get (std::integer_sequence< T, II... >, std::integral_constant< std::size_t, pos >={})
 Return the entry at position pos of the given sequence.
 
template<class T , T... II>
constexpr T Dune::get (std::integer_sequence< T, II... >, std::size_t pos)
 Return the entry at position pos of the given sequence.
 
template<class T , T I0, T... II>
constexpr std::integral_constant< T, I0 > Dune::front (std::integer_sequence< T, I0, II... >)
 Return the first entry of the sequence.
 
template<class T , T... II, std::enable_if_t<(sizeof...(II) > 0), int > = 0>
constexpr auto Dune::back (std::integer_sequence< T, II... > seq)
 Return the last entry of the sequence.
 
template<class T , T I0, T... II>
constexpr std::integral_constant< T, I0 > Dune::head (std::integer_sequence< T, I0, II... >)
 For a sequence [head,tail...) return the single head element.
 
template<class T , T I0, T... II>
constexpr std::integer_sequence< T, II... > Dune::tail (std::integer_sequence< T, I0, II... >)
 For a sequence [head,tail...) return the tail sequence.
 
template<auto I0, class T , T... II>
constexpr std::integer_sequence< T, T(I0), II... > Dune::push_front (std::integer_sequence< T, II... >, std::integral_constant< T, I0 >={})
 Append an index I0 to the front of the sequence.
 
template<auto IN, class T , T... II>
constexpr std::integer_sequence< T, II..., T(IN)> Dune::push_back (std::integer_sequence< T, II... >, std::integral_constant< T, IN >={})
 Append an index IN to the back of the sequence.
 
template<class T , T... II>
constexpr std::integral_constant< std::size_t, sizeof...(II)> Dune::size (std::integer_sequence< T, II... >)
 Return the size of the sequence.
 
template<class T , T... II>
constexpr std::bool_constant<(sizeof...(II)==0)> Dune::empty (std::integer_sequence< T, II... >)
 Checks whether the sequence is empty.
 
template<class T , T... II, class Compare >
constexpr auto Dune::sorted (std::integer_sequence< T, II... > seq, Compare comp)
 Sort a given sequence by the comparator comp.
 
template<class T , T... II>
constexpr auto Dune::sorted (std::integer_sequence< T, II... > seq)
 Sort a given sequence by less-than comparison.
 
template<class T , T... II, T value>
constexpr std::bool_constant<((II==value)||...)> Dune::contains (std::integer_sequence< T, II... >, std::integral_constant< T, value >)
 Checks whether or not a given sequence contains a value.
 
template<class T , T... II, T... JJ>
constexpr auto Dune::difference (std::integer_sequence< T, II... > iSeq, std::integer_sequence< T, JJ... > jSeq)
 Return the elements from the sequence [II...) which are not found in the sequence [JJ...).
 
template<std::size_t N, class T , T... JJ, std::enable_if_t<(N >=sizeof...(JJ)), int > = 0>
constexpr auto Dune::difference (std::integer_sequence< T, JJ... > jSeq)
 Return the elements from the sequence [0,1,...N) which are not found in the sequence [JJ...).
 
template<class S , S... II, class T , T... JJ, std::enable_if_t<(sizeof...(II)==sizeof...(JJ)), int > = 0, class ST = std::common_type_t<S,T>>
constexpr std::is_same< std::integer_sequence< bool, true,(ST(II)==ST(JJ))... >, std::integer_sequence< bool,(ST(II)==ST(JJ))..., true > > Dune::equal (std::integer_sequence< S, II... >, std::integer_sequence< T, JJ... >)
 Checks whether two sequences are identical.
 
template<class S , S... II, class T , T... JJ, std::enable_if_t<(sizeof...(II) !=sizeof...(JJ)), int > = 0>
constexpr std::bool_constant< false > Dune::equal (std::integer_sequence< S, II... >, std::integer_sequence< T, JJ... >)
 Sequences are unequal if not of the same length.
 
template<template< auto > class Filter, class T >
constexpr auto Dune::filter (std::integer_sequence< T > jSeq)
 
template<template< auto > class Filter, class T , T J0, T... JJ>
constexpr auto Dune::filter (std::integer_sequence< T, J0, JJ... > jSeq)
 
template<class Filter , class T >
constexpr auto Dune::filter (Filter, std::integer_sequence< T > jSeq)
 
template<class Filter , class T , T J0, T... JJ>
constexpr auto Dune::filter (Filter f, std::integer_sequence< T, J0, JJ... > jSeq)