olb::meta Namespace Reference

Classes
struct	derived_type_in_nested
struct	eq
	Evaluates to true iff T is in TYPES. More...
struct	filter
	Return type list of all FIELDS meeting COND. More...
struct	filter< COND, TYPE >
	Return either nil type list or type list containing (single) FIELD depending on COND. More...
struct	first_type_with_base
	Get first type based on BASE contained in a given type list. More...
struct	first_type_with_base< BASE, HEAD >
struct	id
	Identity type to pass non-constructible types as value. More...
struct	index_of_first_matching
	Helper for computing indices in type lists. More...
struct	index_of_first_matching< COND >
struct	index_of_first_matching< COND, HEAD, TAIL... >
struct	list
	Plain wrapper for list of types. More...
struct	list_base
	Base of any meta::list. More...
struct	list_item_with_base_default_base
	Get first type based on BASE contained in a given type list. More...
struct	list_item_with_base_default_base< BASE, HEAD >
struct	neq
	Evaluates to true iff T is not in TYPES. More...
struct	plain_map
struct	reverse
	Return type list of all FIELDS in reversed order. More...
struct	reverse< TYPE >
	Return either nil type list or type list containing FIELD in reversed order. More...
struct	unzip_flattened_keys
struct	unzip_flattened_keys< KEY, VALUE, TAIL... >
struct	unzip_flattened_keys<>
struct	unzip_flattened_values
struct	unzip_flattened_values< KEY, VALUE, TAIL... >
struct	unzip_flattened_values<>

Typedefs
template<typename TYPE >
using	id_t = typename id<TYPE>::type
template<auto VALUE, typename TYPE = decltype(VALUE)>
using	value = typename std::integral_constant<TYPE, VALUE>::type
	Identity type to wrap non-type template arguments.
template<typename T >
using	is_arithmetic
	Checks whether T can be used as a scalar arithmetic type.
template<typename T , typename U = void>
using	enable_if_arithmetic_t = std::enable_if_t<is_arithmetic<T>::type::value, U>
template<typename BASE , typename... TYPES>
using	first_type_with_base_t = typename first_type_with_base<BASE, TYPES...>::type
template<template< typename > class COND, typename... TYPES>
using	filter_t = typename filter<COND,TYPES...>::type
	meta::list of TYPES meeting COND
template<typename... TYPES>
using	reverse_t = typename reverse<TYPES...>::type
	meta::list of TYPES in reversed order
template<typename LIST_A , typename LIST_B >
using	merge = typename LIST_A::template decompose_into<LIST_B::template include>
	Merge elements of LIST_A and LIST_B into new list.
template<typename... KVs>
using	map
	Map of types.

Functions
template<typename TYPE >
bool	is_aligned (const void *ptr)
	Returns true iff address ptr is aligned w.r.t. TYPE.
template<typename T >
std::string	name ()
	Returns distinct name on GCC, Clang and ICC but may return arbitrary garbage as per the standard.
template<typename WANTED , typename... TYPES>
constexpr bool	contains ()
	Returns true iff a given type list contains WANTED.
template<typename... TYPES>
bool	contains (std::type_index field)
	Returns true iff a given type list contains a type index.
template<typename TYPES , typename F , std::size_t... INDICES>
void	list_for_each_index (F &&f, std::index_sequence< INDICES... >)
	Apply F to each element of meta::list listed in INDICES.
template<typename TUPLE , typename F , std::size_t... INDICES>
void	tuple_for_each_index (TUPLE &tuple, F &&f, std::index_sequence< INDICES... >)
	Apply F to each element of TUPLE listed in INDICES.
template<typename TUPLE , typename F >
void	tuple_for_each (TUPLE &tuple, F &&f)
	Apply F to each element of TUPLE.
template<typename T , unsigned D, typename U , std::size_t... INDICES>
std::array< T, D >	make_array (U &&u, std::index_sequence< INDICES... >)
	Return std::array<T,D> where T is initialized with a common value (helper)
template<typename T , unsigned D, typename U >
std::array< T, D >	make_array (U &&u)
	Return std::array<T,D> where T is initialized with a common value.
template<typename T , unsigned D, typename F , std::size_t... INDICES>
std::array< T, D >	make_array_f (F &&f, std::index_sequence< INDICES... >)
	Return std::array<T,D> where T is initialized using a iDim-dependent function (helper)
template<typename T , unsigned D, typename F >
std::array< T, D >	make_array_f (F &&f)
	Return std::array<T,D> where T is initialized using a iDim-dependent function.
template<auto... VALUE, typename COND >
constexpr bool	indexed_pack_contains (COND cond)
	Returns true iff at least one VALUE satisfies COND.
template<std::size_t... Is, std::size_t... Js>
constexpr auto	operator+ (std::index_sequence< Is... >, std::index_sequence< Js... >)
	Concatenate two index sequences.
template<std::size_t... Is>
constexpr auto	array_from_index_sequence (std::index_sequence< Is... >)
	Convert index sequence into an array of its values.
template<typename PREDICATE , std::size_t... Is>
constexpr auto	filter_index_sequence (PREDICATE predicate, std::index_sequence< Is... >)
	Return index sequence of Is matching PREDICATE depending on index.
template<typename TYPES , typename PREDICATE , std::size_t... Is>
constexpr auto	filter_index_sequence (PREDICATE predicate, std::index_sequence< Is... >)
	Return index sequence of Is matching PREDICATE depending on type in TYPES.
template<typename TYPES , template< typename > class COND, std::size_t... Is>
constexpr auto	filter_index_sequence (std::index_sequence< Is... >)
	Return index sequence of Is matching COND in TYPES.
template<typename TYPES , template< typename > class COND>
constexpr auto	filter_index_sequence ()
	Return index sequence of Is matching COND using index_sequence of TYPES.
template<typename MAP , std::size_t... Is>
constexpr auto	map_index_sequence (MAP map, std::index_sequence< Is... >)
template<std::size_t N, std::size_t I, std::size_t... Is>
constexpr auto	take_n_sequence (std::index_sequence< I, Is... >)
template<std::size_t N, std::size_t I, std::size_t... Is>
constexpr auto	drop_n_sequence (std::index_sequence< I, Is... >)
template<std::size_t N>
constexpr auto	zero_sequence ()
template<std::size_t I, std::size_t O>
constexpr auto	make_index_sequence_in_range ()
template<std::size_t... Is>
constexpr bool	is_zero_sequence (std::index_sequence< Is... >)
template<typename F , std::size_t... INDICES>
void	call_n_times (F &&f, std::index_sequence< INDICES... >)
	Call F for each index (exlicitly unrolled loop)
template<unsigned N, typename F >
void	call_n_times (F &&f)
	Call F for each i in 0..N-1 (exlicitly unrolled loop)
template<typename TYPES , typename Fa , typename Fb , std::size_t Ia, std::size_t Iaa, std::size_t... Is>
void	index_sequence_for_subsequence_L2 (Fa &&fa, Fb &&fb, std::index_sequence< Ia, Iaa, Is... > seq)
	Call fa for indices in index_sequence and call fb for indices in between indices in.
template<typename TYPES , typename Fa , typename Fb , std::size_t I, std::size_t... Is>
void	index_sequence_for_subsequence_L1 (Fa &&fa, Fb &&fb, std::index_sequence< I, Is... > seq)
	Call fa for indices in index_sequence and call fb for indices in between indices in.
template<typename TYPES , typename Fa , typename Fb , std::size_t... Is>
void	index_sequence_for_subsequence (Fa &&fa, Fb &&fb, std::index_sequence< Is... > seq)
	Call fa for indices in index_sequence and call fb for indices in between indices in.

Typedef Documentation

enable_if_arithmetic_t

template<typename T , typename U = void>

using olb::meta::enable_if_arithmetic_t = std::enable_if_t<is_arithmetic<T>::type::value, U>

Definition at line 121 of file meta.h.

filter_t

template<template< typename > class COND, typename... TYPES>

using olb::meta::filter_t = typename filter<COND,TYPES...>::type

meta::list of TYPES meeting COND

Definition at line 245 of file meta.h.

first_type_with_base_t

template<typename BASE , typename... TYPES>

using olb::meta::first_type_with_base_t = typename first_type_with_base<BASE, TYPES...>::type

Definition at line 189 of file meta.h.

id_t

template<typename TYPE >

using olb::meta::id_t = typename id<TYPE>::type

Definition at line 92 of file meta.h.

is_arithmetic

template<typename T >

using olb::meta::is_arithmetic

Initial value:

 typename std::integral_constant<bool,
     std::is_base_of_v<AD,T>
  || std::is_base_of_v<SimdBase,T>
  || std::is_base_of_v<ExprBase,T>
  || std::is_arithmetic_v<T>
  
  
  || std::is_pointer_v<T>
  || std::is_enum_v<T>
>

Checks whether T can be used as a scalar arithmetic type.

Base checking for AD types to be replaced by e.g. concepts in C++20

Definition at line 109 of file meta.h.

map

template<typename... KVs>

using olb::meta::map

Initial value:

 plain_map<
  typename unzip_flattened_keys<KVs...>::type,
  typename unzip_flattened_values<KVs...>::type
>

Map of types.

Definition at line 88 of file typeMap.h.

merge

template<typename LIST_A , typename LIST_B >

using olb::meta::merge = typename LIST_A::template decompose_into<LIST_B::template include>

Merge elements of LIST_A and LIST_B into new list.

Definition at line 344 of file meta.h.

reverse_t

template<typename... TYPES>

using olb::meta::reverse_t = typename reverse<TYPES...>::type

meta::list of TYPES in reversed order

Definition at line 269 of file meta.h.

value

template<auto VALUE, typename TYPE = decltype(VALUE)>

using olb::meta::value = typename std::integral_constant<TYPE, VALUE>::type

Identity type to wrap non-type template arguments.

Definition at line 96 of file meta.h.

Function Documentation

array_from_index_sequence()

template<std::size_t... Is>

auto olb::meta::array_from_index_sequence ( std::index_sequence< Is... > )

constexpr

Convert index sequence into an array of its values.

Definition at line 426 of file meta.h.

{
  return std::array<std::size_t,sizeof...(Is)>{Is...};
}

Here is the caller graph for this function:

call_n_times() [1/2]

template<unsigned N, typename F >

void olb::meta::call_n_times

(

F &&

f

)

Call F for each i in 0..N-1 (exlicitly unrolled loop)

Definition at line 525 of file meta.h.

                         {
  return call_n_times<F>(std::forward<F&&>(f), std::make_index_sequence<N>{});
}

References call_n_times().

Here is the call graph for this function:

call_n_times() [2/2]

template<typename F , std::size_t... INDICES>

void olb::meta::call_n_times	(	F &&	f,
		std::index_sequence< INDICES... >	)

Call F for each index (exlicitly unrolled loop)

Definition at line 519 of file meta.h.

                                                        {
  (f(INDICES), ...);
}

Here is the caller graph for this function:

contains() [1/2]

template<typename WANTED , typename... TYPES>

bool olb::meta::contains ( )

constexpr

Returns true iff a given type list contains WANTED.

Definition at line 125 of file meta.h.

                          {
  return (std::is_same_v<WANTED, TYPES> || ... || false);
}

Here is the caller graph for this function:

contains() [2/2]

template<typename... TYPES>

bool olb::meta::contains

(

std::type_index

field

)

Returns true iff a given type list contains a type index.

Definition at line 131 of file meta.h.

                                   {
  return ((field == typeid(TYPES)) || ... || false);
}

drop_n_sequence()

template<std::size_t N, std::size_t I, std::size_t... Is>

auto olb::meta::drop_n_sequence ( std::index_sequence< I, Is... > )

constexpr

Definition at line 489 of file meta.h.

                                                           {
  if constexpr (N > 0) {
    return drop_n_sequence<N-1>(std::index_sequence<Is...>());
  } else {
    return std::index_sequence<I,Is...>();
  }
  __builtin_unreachable();
}

References drop_n_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

filter_index_sequence() [1/4]

template<typename TYPES , template< typename > class COND>

auto olb::meta::filter_index_sequence ( )

constexpr

Return index sequence of Is matching COND using index_sequence of TYPES.

Definition at line 469 of file meta.h.

                                       {
  return filter_index_sequence<TYPES,COND>(std::make_index_sequence<TYPES::size>());
}

References filter_index_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

filter_index_sequence() [2/4]

template<typename PREDICATE , std::size_t... Is>

auto olb::meta::filter_index_sequence ( PREDICATE predicate, std::index_sequence< Is... >  )

constexpr

Return index sequence of Is matching PREDICATE depending on index.

Definition at line 433 of file meta.h.

                                                                                    {
  return (
      std::conditional_t<predicate(Is),
                         std::index_sequence<Is>,
                         std::index_sequence<>>()
    + ...
    + std::index_sequence<>()
  );
}

filter_index_sequence() [3/4]

template<typename TYPES , typename PREDICATE , std::size_t... Is>

auto olb::meta::filter_index_sequence ( PREDICATE predicate, std::index_sequence< Is... >  )

constexpr

Return index sequence of Is matching PREDICATE depending on type in TYPES.

Definition at line 445 of file meta.h.

                                                                                    {
  return (
      std::conditional_t<predicate(id<typename TYPES::template get<Is>>()),
                         std::index_sequence<Is>,
                         std::index_sequence<>>()
    + ...
    + std::index_sequence<>()
  );
}

filter_index_sequence() [4/4]

template<typename TYPES , template< typename > class COND, std::size_t... Is>

auto olb::meta::filter_index_sequence ( std::index_sequence< Is... > )

constexpr

Return index sequence of Is matching COND in TYPES.

Definition at line 457 of file meta.h.

                                                               {
  return (
      std::conditional_t<COND<typename TYPES::template get<Is>>::value,
                         std::index_sequence<Is>,
                         std::index_sequence<>>()
    + ...
    + std::index_sequence<>()
  );
}

index_sequence_for_subsequence()

template<typename TYPES , typename Fa , typename Fb , std::size_t... Is>

void olb::meta::index_sequence_for_subsequence	(	Fa &&	fa,
		Fb &&	fb,
		std::index_sequence< Is... >	seq )

Call fa for indices in index_sequence and call fb for indices in between indices in.

Definition at line 563 of file meta.h.

                                                                                    {
  if constexpr (seq.size()>0) {
    index_sequence_for_subsequence_L1<TYPES>(fa, fb, seq );
  } else {
    fb(std::make_index_sequence<TYPES::size>());
  }
}

References index_sequence_for_subsequence_L1().

Here is the call graph for this function:

Here is the caller graph for this function:

index_sequence_for_subsequence_L1()

template<typename TYPES , typename Fa , typename Fb , std::size_t I, std::size_t... Is>

void olb::meta::index_sequence_for_subsequence_L1	(	Fa &&	fa,
		Fb &&	fb,
		std::index_sequence< I, Is... >	seq )

Call fa for indices in index_sequence and call fb for indices in between indices in.

Definition at line 550 of file meta.h.

                                                                                         {
  fb(std::make_index_sequence<I>());
  if constexpr (seq.size()>1) {
    index_sequence_for_subsequence_L2<TYPES>(fa, fb, seq );
  } else {
    fa(id<typename TYPES::template get<I>>());
    fb(make_index_sequence_in_range<I+1,TYPES::size>());
  }
}

References index_sequence_for_subsequence_L2(), and make_index_sequence_in_range().

Here is the call graph for this function:

Here is the caller graph for this function:

index_sequence_for_subsequence_L2()

template<typename TYPES , typename Fa , typename Fb , std::size_t Ia, std::size_t Iaa, std::size_t... Is>

void olb::meta::index_sequence_for_subsequence_L2	(	Fa &&	fa,
		Fb &&	fb,
		std::index_sequence< Ia, Iaa, Is... >	seq )

Call fa for indices in index_sequence and call fb for indices in between indices in.

Definition at line 534 of file meta.h.

                                                                                              {
  if constexpr (seq.size()>2) {
    fa(id<typename TYPES::template get<Ia>>());
    fb(make_index_sequence_in_range<Ia+1,Iaa>());
    index_sequence_for_subsequence_L2<TYPES>(fa,fb,std::index_sequence<Iaa,Is...>());
  } else {
    fa(id<typename TYPES::template get<Ia>>());
    fb(make_index_sequence_in_range<Ia+1,Iaa>());
    fa(id<typename TYPES::template get<Iaa>>());
    fb(make_index_sequence_in_range<Iaa+1,TYPES::size>());
  }
}

References index_sequence_for_subsequence_L2(), and make_index_sequence_in_range().

Here is the call graph for this function:

Here is the caller graph for this function:

indexed_pack_contains()

template<auto... VALUE, typename COND >

bool olb::meta::indexed_pack_contains ( COND cond )

constexpr

Returns true iff at least one VALUE satisfies COND.

Definition at line 408 of file meta.h.

                                                {
  std::size_t i = 0;
  return (cond(i++, VALUE) || ...);
}

Here is the caller graph for this function:

is_aligned()

template<typename TYPE >

bool olb::meta::is_aligned

(

const void *

ptr

)

Returns true iff address ptr is aligned w.r.t. TYPE.

Definition at line 69 of file meta.h.

                                 {
  auto addr = reinterpret_cast<std::uintptr_t>(ptr);
  return !(addr % alignof(TYPE));
}

Here is the caller graph for this function:

is_zero_sequence()

template<std::size_t... Is>

bool olb::meta::is_zero_sequence ( std::index_sequence< Is... > )

constexpr

Definition at line 513 of file meta.h.

                                                          {
  return ((Is == 0) && ... && true);
}

list_for_each_index()

template<typename TYPES , typename F , std::size_t... INDICES>

void olb::meta::list_for_each_index	(	F &&	f,
		std::index_sequence< INDICES... >	)

Apply F to each element of meta::list listed in INDICES.

Definition at line 348 of file meta.h.

{
  if constexpr (std::is_invocable_v<F, decltype(id<typename TYPES::template get<0>>()), unsigned>) {
    (f(id<typename TYPES::template get<INDICES>>(), INDICES), ...);
  } else {
    (f(id<typename TYPES::template get<INDICES>>()), ...);
  }
}

make_array() [1/2]

template<typename T , unsigned D, typename U >

std::array< T, D > olb::meta::make_array

(

U &&

u

)

Return std::array<T,D> where T is initialized with a common value.

Definition at line 387 of file meta.h.

{
  return make_array<T,D,U>(std::forward<U>(u), std::make_index_sequence<D> {});
}

References make_array().

Here is the call graph for this function:

make_array() [2/2]

template<typename T , unsigned D, typename U , std::size_t... INDICES>

std::array< T, D > olb::meta::make_array	(	U &&	u,
		std::index_sequence< INDICES... >	)

Return std::array<T,D> where T is initialized with a common value (helper)

Definition at line 380 of file meta.h.

{
  return std::array<T,D> {(INDICES, u)...};
}

Here is the caller graph for this function:

make_array_f() [1/2]

template<typename T , unsigned D, typename F >

std::array< T, D > olb::meta::make_array_f

(

F &&

f

)

Return std::array<T,D> where T is initialized using a iDim-dependent function.

Definition at line 401 of file meta.h.

{
  return make_array_f<T,D,F>(std::forward<F&&>(f), std::make_index_sequence<D> {});
}

References make_array_f().

Here is the call graph for this function:

make_array_f() [2/2]

template<typename T , unsigned D, typename F , std::size_t... INDICES>

std::array< T, D > olb::meta::make_array_f	(	F &&	f,
		std::index_sequence< INDICES... >	)

Return std::array<T,D> where T is initialized using a iDim-dependent function (helper)

Definition at line 394 of file meta.h.

{
  return std::array<T,D> {f(INDICES)...};
}

Here is the caller graph for this function:

make_index_sequence_in_range()

template<std::size_t I, std::size_t O>

auto olb::meta::make_index_sequence_in_range ( )

constexpr

Definition at line 506 of file meta.h.

                                              {
  return map_index_sequence([](std::size_t Is) constexpr {
    return (Is+I);
  }, std::make_index_sequence<(O-I)>());
}

References map_index_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

map_index_sequence()

template<typename MAP , std::size_t... Is>

auto olb::meta::map_index_sequence ( MAP map, std::index_sequence< Is... >  )

constexpr

Definition at line 474 of file meta.h.

                                                                     {
  return std::index_sequence<map(Is)...>();
}

Here is the caller graph for this function:

name()

template<typename T >

std::string olb::meta::name

(

)

Returns distinct name on GCC, Clang and ICC but may return arbitrary garbage as per the standard.

Definition at line 100 of file meta.h.

                 {
  return typeid(T).name();
}

References name().

Here is the call graph for this function:

Here is the caller graph for this function:

operator+()

template<std::size_t... Is, std::size_t... Js>

auto olb::meta::operator+ ( std::index_sequence< Is... > , std::index_sequence< Js... >  )

constexpr

Concatenate two index sequences.

Definition at line 417 of file meta.h.

{
  return std::index_sequence<Is..., Js...>();
}

take_n_sequence()

template<std::size_t N, std::size_t I, std::size_t... Is>

auto olb::meta::take_n_sequence ( std::index_sequence< I, Is... > )

constexpr

Definition at line 479 of file meta.h.

                                                           {
  if constexpr (N > 0) {
    return std::index_sequence<I>() + take_n_sequence<N-1>(std::index_sequence<Is...>());
  } else {
    return std::index_sequence<>();
  }
  __builtin_unreachable();
}

References take_n_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

tuple_for_each()

template<typename TUPLE , typename F >

void olb::meta::tuple_for_each	(	TUPLE &	tuple,
		F &&	f )

Apply F to each element of TUPLE.

Definition at line 373 of file meta.h.

{
  tuple_for_each_index(tuple, std::forward<F>(f), std::make_index_sequence<std::tuple_size<TUPLE>::value> {});
}

References tuple_for_each_index().

Here is the call graph for this function:

Here is the caller graph for this function:

tuple_for_each_index()

template<typename TUPLE , typename F , std::size_t... INDICES>

void olb::meta::tuple_for_each_index	(	TUPLE &	tuple,
		F &&	f,
		std::index_sequence< INDICES... >	)

Apply F to each element of TUPLE listed in INDICES.

Definition at line 359 of file meta.h.

{
  if constexpr (std::is_invocable_v<F, decltype(std::get<0>(tuple)), std::integral_constant<std::size_t,0>>) {
    (f(std::get<INDICES>(tuple), std::integral_constant<std::size_t,INDICES>{}), ...);
  } else if constexpr (std::is_invocable_v<F, decltype(std::get<0>(tuple)), unsigned>) {
    (f(std::get<INDICES>(tuple), INDICES), ...);
  } else {
    (f(std::get<INDICES>(tuple)), ...);
  }
}

Here is the caller graph for this function:

zero_sequence()

template<std::size_t N>

auto olb::meta::zero_sequence ( )

constexpr

Definition at line 499 of file meta.h.

                               {
  return map_index_sequence([](std::size_t) constexpr {
    return 0;
  }, std::make_index_sequence<N>());
}

References map_index_sequence().

Here is the call graph for this function: