meta.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2019 Adrian Kummerlaender
 *                2021 Adrian Kummerlaender, Nicolas Hafen, Mathias J. Krause
 *  E-mail contact: info@openlb.net
 *  The most recent release of OpenLB can be downloaded at
 *  <http://www.openlb.net/>
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public
 *  License along with this program; if not, write to the Free
 *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA  02110-1301, USA.
*/
 
#ifndef CORE_META_H
#define CORE_META_H
 
#include <type_traits>
#include <typeindex>
#include <tuple>
#include <set>
#include <utility>
#include <string>
#include <cstdint>
 
// Forward-declaration of ADf type marker
struct AD;
 
// Define operator+ to mitigate buggy unqualified name lookup in fold expressions for Clang Versions < 12
// see https://bugs.llvm.org/show_bug.cgi?id=30738
#if defined __clang__ && __clang_major__ < 12
 
namespace std {
 
template <size_t... Is, size_t... Js>
constexpr auto operator+(index_sequence<Is...>, index_sequence<Js...>)
{
  return index_sequence<Is..., Js...>();
}
 
}
 
#endif
 
namespace olb {
 
struct ExprBase { };
struct SimdBase { };
 
namespace meta {
 
// *INDENT-OFF*
 
template <typename... TYPES> struct list;
 
template <typename TYPE>
bool is_aligned(const void* ptr) {
  auto addr = reinterpret_cast<std::uintptr_t>(ptr);
  return !(addr % alignof(TYPE));
}
 
 
template <typename TYPE>
struct id {
  using type = TYPE;
 
  operator std::type_index() const {
    return typeid(TYPE);
  }
 
  TYPE get() const {
    return TYPE{};
  }
};
 
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;
 
template <typename T>
std::string name() {
  return typeid(T).name();
}
 
 
template <typename T>
using is_arithmetic = 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>
  // Pointers and enums are enabled for convenience
  // TODO: Add specific arithmetic-support checking to arithmetic Vector operators
  || std::is_pointer_v<T>
  || std::is_enum_v<T>
>;
 
template <typename T, typename U = void>
using enable_if_arithmetic_t = std::enable_if_t<is_arithmetic<T>::type::value, U>;
 
template <typename WANTED, typename... TYPES>
constexpr bool contains() {
  return (std::is_same_v<WANTED, TYPES> || ... || false);
}
 
template <typename... TYPES>
bool contains(std::type_index field) {
  return ((field == typeid(TYPES)) || ... || false);
}
 
 
//TODO: check, whether this can be generalized with "list_item_with_base"
template <
  typename BASE,
  typename HEAD = void, // Default argument in case the list is empty
  typename... TAIL
  >
struct list_item_with_base_default_base {
  using type = std::conditional_t<
    std::is_base_of<BASE, HEAD>::value,
    HEAD,
    typename list_item_with_base_default_base<BASE, TAIL...>::type
  >;
};
 
template <typename BASE, typename HEAD>
struct list_item_with_base_default_base<BASE, HEAD> {
  using type = std::conditional_t<
    std::is_base_of<BASE, HEAD>::value,
    HEAD,
    BASE
  >;
};
 
 
template <
  typename BASE,
  typename HEAD = void, // Default argument in case the list is empty
  typename... TAIL
>
struct first_type_with_base {
  using type = std::conditional_t<
    std::is_base_of<BASE, HEAD>::value,
    HEAD,
    typename first_type_with_base<BASE, TAIL...>::type
  >;
};
 
template <typename BASE, typename HEAD>
struct first_type_with_base<BASE, HEAD> {
  using type = std::conditional_t<
    std::is_base_of<BASE, HEAD>::value,
    HEAD,
    void
  >;
};
 
template <typename BASE, typename... TYPES>
using first_type_with_base_t = typename first_type_with_base<BASE, TYPES...>::type;
 
template <template<typename> typename COND, typename... TYPES>
struct index_of_first_matching;
 
template <template<typename> typename COND, typename HEAD, typename... TAIL>
struct index_of_first_matching<COND,HEAD,TAIL...> {
  static constexpr unsigned value = std::conditional_t<
    COND<HEAD>::value,
    std::integral_constant<unsigned, 0>,
    std::integral_constant<unsigned, 1 + index_of_first_matching<COND,TAIL...>::value>
  >::value;
};
 
template <template<typename> typename COND>
struct index_of_first_matching<COND> {
  static constexpr unsigned value = 0; // This way access into a list of this size fails (hacky)
};
 
template <typename... TYPES>
struct eq {
  template <typename T>
  using type = std::integral_constant<bool, (std::is_same_v<TYPES,T> || ...)>;
};
 
template <typename... TYPES>
struct neq {
  template <typename T>
  using type = std::integral_constant<bool, (!std::is_same_v<TYPES,T> && ...)>;
};
 
template <template <typename> class COND, typename HEAD=void, typename... TAIL>
struct filter {
  using type = std::conditional_t<
    COND<HEAD>::value && !std::is_void_v<HEAD>,
    typename filter<COND, TAIL...>::type::template push<HEAD>,
    typename filter<COND, TAIL...>::type
  >;
};
 
template <template <typename> class COND, typename TYPE>
struct filter<COND,TYPE> {
  using type = std::conditional_t<
    COND<TYPE>::value && !std::is_void<TYPE>::value,
    list<TYPE>,
    list<>
  >;
};
 
template <template <typename> class COND, typename... TYPES>
using filter_t = typename filter<COND,TYPES...>::type;
 
 
template <typename HEAD=void, typename... TAIL>
struct reverse {
  using type = std::conditional_t<!std::is_void_v<HEAD>,
    typename reverse<TAIL...>::type::template append<HEAD>,
    typename reverse<TAIL...>::type
  >;
};
 
template <typename TYPE>
struct reverse<TYPE> {
  using type = std::conditional_t<
    !std::is_void<TYPE>::value,
    list<TYPE>,
    list<>
  >;
};
 
template <typename... TYPES>
using reverse_t = typename reverse<TYPES...>::type;
 
struct list_base { };
 
template <typename... TYPES>
struct list : public list_base {
  static constexpr unsigned size = sizeof...(TYPES);
 
  template <unsigned INDEX>
  using get = typename std::tuple_element<INDEX, std::tuple<id<TYPES>...>>::type::type;
 
 
  template <template<typename...> class COLLECTION>
  using decompose_into = COLLECTION<TYPES...>;
 
  template <template<typename> class F>
  using map = list<F<TYPES>...>;
 
  template <typename F>
  using map_to_callable_result = list<decltype(std::declval<F&>()(meta::id<TYPES>{}))...>;
 
  template <typename TYPE>
  using push = list<TYPE, TYPES...>;
 
  template <typename... UYPES>
  using append = list<TYPES..., UYPES...>;
 
  template <typename... UYPES>
  using include = typename filter_t<neq<TYPES...>::template type, UYPES...>::template decompose_into<
    list<TYPES...>::append
  >;
 
  template <typename BASE>
  using first_with_base = first_type_with_base_t<BASE, TYPES...>;
 
 
  template <typename BASE, typename FALLBACK>
  using first_with_base_or_fallback = std::conditional_t<
    std::is_void_v<first_with_base<BASE>>,
    FALLBACK,
    first_with_base<BASE>
  >;
 
  template <typename TYPE>
  static constexpr unsigned index() {
    return index_of_first_matching<eq<TYPE>::template type, TYPES...>::value;
  }
 
  template <typename F>
  static constexpr void for_each(F f) {
    (f(id<TYPES>()), ...);
  }
 
  template <typename TYPE>
  static constexpr bool contains() {
    return olb::meta::contains<TYPE,TYPES...>();
  }
 
};
 
template <typename LIST_A, typename LIST_B>
using merge = typename LIST_A::template decompose_into<LIST_B::template include>;
 
template <typename TYPES, typename F, std::size_t... INDICES>
void list_for_each_index(F&& f, std::index_sequence<INDICES...>)
{
  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>>()), ...);
  }
}
 
template <typename TUPLE, typename F, std::size_t...INDICES>
void tuple_for_each_index(TUPLE& tuple, F&& f, std::index_sequence<INDICES...>)
{
  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)), ...);
  }
}
 
 
template <typename TUPLE, typename F>
void tuple_for_each(TUPLE& tuple, F&& f)
{
  tuple_for_each_index(tuple, std::forward<F>(f), std::make_index_sequence<std::tuple_size<TUPLE>::value> {});
}
 
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> {(INDICES, u)...};
}
 
template <typename T, unsigned D, typename U>
std::array<T,D> make_array(U&& u)
{
  return make_array<T,D,U>(std::forward<U>(u), std::make_index_sequence<D> {});
}
 
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> {f(INDICES)...};
}
 
template <typename T, unsigned D, typename F>
std::array<T,D> make_array_f(F&& f)
{
  return make_array_f<T,D,F>(std::forward<F&&>(f), std::make_index_sequence<D> {});
}
 
template <auto... VALUE, typename COND>
constexpr bool indexed_pack_contains(COND cond) {
  std::size_t i = 0;
  return (cond(i++, VALUE) || ...);
}
 
#if !defined __clang__ || __clang_major__ >= 12
 
template <std::size_t... Is, std::size_t... Js>
constexpr auto operator+(std::index_sequence<Is...>, std::index_sequence<Js...>)
{
  return std::index_sequence<Is..., Js...>();
}
 
#endif
 
template <std::size_t... Is>
constexpr auto array_from_index_sequence(std::index_sequence<Is...>)
{
  return std::array<std::size_t,sizeof...(Is)>{Is...};
}
 
template <typename PREDICATE, std::size_t... Is>
constexpr auto filter_index_sequence(PREDICATE predicate, std::index_sequence<Is...>) {
  return (
      std::conditional_t<predicate(Is),
                         std::index_sequence<Is>,
                         std::index_sequence<>>()
    + ...
    + std::index_sequence<>()
  );
}
 
template <typename TYPES, typename PREDICATE, std::size_t... Is>
constexpr auto filter_index_sequence(PREDICATE predicate, std::index_sequence<Is...>) {
  return (
      std::conditional_t<predicate(id<typename TYPES::template get<Is>>()),
                         std::index_sequence<Is>,
                         std::index_sequence<>>()
    + ...
    + std::index_sequence<>()
  );
}
 
template <typename TYPES, template<typename> class COND, std::size_t... Is>
constexpr auto filter_index_sequence(std::index_sequence<Is...>) {
  return (
      std::conditional_t<COND<typename TYPES::template get<Is>>::value,
                         std::index_sequence<Is>,
                         std::index_sequence<>>()
    + ...
    + std::index_sequence<>()
  );
}
 
template <typename TYPES, template<typename> class COND>
constexpr auto filter_index_sequence() {
  return filter_index_sequence<TYPES,COND>(std::make_index_sequence<TYPES::size>());
}
 
template <typename MAP, std::size_t... Is>
constexpr auto map_index_sequence(MAP map, std::index_sequence<Is...>) {
  return std::index_sequence<map(Is)...>();
}
 
template <std::size_t N, std::size_t I, std::size_t... Is>
constexpr auto take_n_sequence(std::index_sequence<I,Is...>) {
  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();
}
 
template <std::size_t N, std::size_t I, std::size_t... Is>
constexpr auto drop_n_sequence(std::index_sequence<I,Is...>) {
  if constexpr (N > 0) {
    return drop_n_sequence<N-1>(std::index_sequence<Is...>());
  } else {
    return std::index_sequence<I,Is...>();
  }
  __builtin_unreachable();
}
 
template <std::size_t N>
constexpr auto zero_sequence() {
  return map_index_sequence([](std::size_t) constexpr {
    return 0;
  }, std::make_index_sequence<N>());
}
 
template <std::size_t I, std::size_t O>
constexpr auto make_index_sequence_in_range() {
  return map_index_sequence([](std::size_t Is) constexpr {
    return (Is+I);
  }, std::make_index_sequence<(O-I)>());
}
 
template <std::size_t... Is>
constexpr bool is_zero_sequence(std::index_sequence<Is...>) {
  return ((Is == 0) && ... && true);
}
 
template <typename F, std::size_t... INDICES>
void call_n_times(F&& f, std::index_sequence<INDICES...>) {
  (f(INDICES), ...);
}
 
template <unsigned N, typename F>
void call_n_times(F&& f) {
  return call_n_times<F>(std::forward<F&&>(f), std::make_index_sequence<N>{});
}
 
//  index_sequence with size>1
// - This allows filtering for specific type traits, while preserving the general order
// - Intended to be used in the particleManger
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) {
  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>());
  }
}
 
//  index_sequence with size>0
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) {
  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>());
  }
}
 
//  index_sequence
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) {
  if constexpr (seq.size()>0) {
    index_sequence_for_subsequence_L1<TYPES>(fa, fb, seq );
  } else {
    fb(std::make_index_sequence<TYPES::size>());
  }
}
 
template <
  typename BASE,
  typename HEAD = void, //Default argument in case the list is empty
  typename ...TAIL
>
struct derived_type_in_nested {
  auto constexpr static evaluate_type(){
    if constexpr (!sizeof...(TAIL)) {
      if constexpr (std::is_same<HEAD,void>::value) {
        return id<BASE>{};  //Fallback
      } else {
        if constexpr(std::is_same<BASE,void>::value){
          return id<void>{};
        } else {
          using HEAD_EVAL = typename BASE::template derivedField<HEAD>;
          return id<HEAD_EVAL>{};
        }
      }
    } else {
      if constexpr(std::is_same<BASE,void>::value){
         return id<void>{};
      } else {
        using HEAD_EVAL = typename BASE::template derivedField<HEAD>;
        return id<typename derived_type_in_nested<HEAD_EVAL,TAIL...>::type>{};
      }
    }
    __builtin_unreachable();
  }
 
  using type = typename decltype(evaluate_type())::type;
 
  static constexpr bool contains() {
    return !std::is_same_v<type, void>;
  }
};
 
 
// *INDENT-ON*
 
}
 
}
 
#endif