26 template<
class T,
int i>
28 ->
decltype(std::integral_constant<std::size_t,i>())
36 ->
decltype(std::integral_constant<std::size_t,std::tuple_size<T>::value>())
44 ->
decltype(std::integral_constant<std::size_t,T::size()>())
82constexpr auto size(
const T& t)
91 template<
class Container,
class Index,
92 std::enable_if_t<IsTuple<std::decay_t<Container>>::value,
int> = 0>
93 constexpr decltype(
auto) elementAt(Container&& c, Index&&,
PriorityTag<2>)
95 return std::get<std::decay_t<Index>::value>(c);
98 template<
class T, T... t,
class Index>
99 constexpr decltype(
auto) elementAt(std::integer_sequence<T, t...> c, Index, PriorityTag<1>)
104 template<
class Container,
class Index>
105 constexpr decltype(
auto) elementAt(Container&& c, Index&& i, PriorityTag<0>)
134template<
class Container,
class Index>
135constexpr decltype(
auto)
elementAt(Container&& c, Index&& i)
137 return Impl::elementAt(std::forward<Container>(c), std::forward<Index>(i),
PriorityTag<42>());
144 template<
class Begin,
class End,
146 constexpr auto integralRange(
const Begin& ,
const End& ,
const PriorityTag<1>&)
148 static_assert(Begin::value <= End::value,
"You cannot create an integralRange where end<begin");
156 template<
class Begin,
class End>
157 constexpr auto integralRange(
const Begin& begin,
const End& end,
const PriorityTag<0>&)
183template<
class Begin,
class End>
213 constexpr void evaluateFoldExpression(std::initializer_list<T>&&)
216 template<
class Range,
class F,
class Index, Index... i>
217 constexpr void forEachIndex(Range&&
range, F&& f, std::integer_sequence<Index, i...>)
222 template<
class F,
class Index, Index... i>
223 constexpr void forEach(std::integer_sequence<Index, i...> , F&& f, PriorityTag<2>)
225 evaluateFoldExpression<int>({(f(std::integral_constant<Index,i>()), 0)...});
229 template<
class Range,
class F,
230 std::enable_if_t<IsIntegralConstant<decltype(Hybrid::size(std::declval<Range>()))>::value,
int> = 0>
231 constexpr void forEach(Range&&
range, F&& f, PriorityTag<1>)
234 auto indices = std::make_index_sequence<size>();
235 (forEachIndex)(std::forward<Range>(
range), std::forward<F>(f), indices);
238 template<
class Range,
class F>
239 constexpr void forEach(Range&&
range, F&& f, PriorityTag<0>)
241 for(
auto&& e :
range)
267template<
class Range,
class F>
290template<
class Range,
class T,
class F>
294 value = f(value, entry);
305 constexpr T operator()(T&& x)
const {
306 return std::forward<T>(x);
310 template<
class IfFunc,
class ElseFunc>
311 constexpr decltype(
auto) ifElse(std::true_type, IfFunc&& ifFunc, ElseFunc&& )
316 template<
class IfFunc,
class ElseFunc>
317 constexpr decltype(
auto) ifElse(std::false_type, IfFunc&& , ElseFunc&& elseFunc)
319 return elseFunc(Id{});
322 template<
class IfFunc,
class ElseFunc>
323 decltype(
auto) ifElse(
const bool& condition, IfFunc&& ifFunc, ElseFunc&& elseFunc)
328 return elseFunc(Id{});
355template<
class Condition,
class IfFunc,
class ElseFunc>
356decltype(
auto)
ifElse(
const Condition& condition, IfFunc&& ifFunc, ElseFunc&& elseFunc)
358 return Impl::ifElse(condition, std::forward<IfFunc>(ifFunc), std::forward<ElseFunc>(elseFunc));
368template<
class Condition,
class IfFunc>
369void ifElse(
const Condition& condition, IfFunc&& ifFunc)
371 ifElse(condition, std::forward<IfFunc>(ifFunc), [](
auto&&) {});
378 template<
class T1,
class T2>
379 constexpr auto equals(
const T1& ,
const T2& ,
PriorityTag<1>) ->
decltype(T1::value, T2::value, std::integral_constant<bool,T1::value == T2::value>())
382 template<
class T1,
class T2>
383 constexpr auto equals(
const T1& t1,
const T2& t2, PriorityTag<0>)
401template<
class T1,
class T2>
404 return Impl::equals(std::forward<T1>(t1), std::forward<T2>(t2),
PriorityTag<1>());
411 template<
class Result,
class T,
class Value,
class Branches,
class ElseBranch>
412 constexpr Result switchCases(std::integer_sequence<T>,
const Value& , Branches&& , ElseBranch&& elseBranch)
417 template<
class Result,
class T, T t0, T... tt,
class Value,
class Branches,
class ElseBranch>
418 constexpr Result switchCases(std::integer_sequence<T, t0, tt...>,
const Value& value, Branches&& branches, ElseBranch&& elseBranch)
422 [&](
auto id) ->
decltype(
auto) {
423 return id(branches)(std::integral_constant<T, t0>());
424 }, [&](
auto id) ->
decltype(
auto) {
425 return Impl::switchCases<Result>(
id(std::integer_sequence<T, tt...>()), value, branches, elseBranch);
460template<
class Cases,
class Value,
class Branches,
class ElseBranch>
461constexpr decltype(
auto)
switchCases(
const Cases& cases,
const Value& value, Branches&& branches, ElseBranch&& elseBranch)
463 return Impl::switchCases<decltype(elseBranch())>(cases, value, std::forward<Branches>(branches), std::forward<ElseBranch>(elseBranch));
486template<
class Cases,
class Value,
class Branches>
487constexpr void switchCases(
const Cases& cases,
const Value& value, Branches&& branches)
489 Impl::switchCases<void>(cases, value, std::forward<Branches>(branches), []() {});
static StaticIntegralRange< T, to, from > range(std::integral_constant< T, from >, std::integral_constant< T, to >) noexcept
Definition rangeutilities.hh:300
constexpr auto integerSequenceEntry(std::integer_sequence< T, t... >, std::integral_constant< std::size_t, index > i)
Get entry of std::integer_sequence.
Definition typetraits.hh:462