traits.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2024 The Ikarus Developers mueller@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
#include <optional>
#include <tuple>
#include <type_traits>
 
#include <dune/common/hybridutilities.hh>
namespace Ikarus::traits {
 
  template <typename T>
  concept Pointer = std::is_pointer_v<T> || std::is_same_v<T, std::nullptr_t>;
 
#ifndef DOXYGEN
  template <typename>
  struct is_tuple : std::false_type {};
#endif
  template <typename... T>
  struct is_tuple<std::tuple<T...>> : std::true_type {};
 
  template <class Tuple, class Type>
  requires is_tuple<Tuple>::value consteval int countType() {
    int count = 0;
    Dune::Hybrid::forEach(Dune::Hybrid::integralRange(Dune::index_constant<std::tuple_size_v<Tuple>>()), [&](auto i) {
      using currentType = std::remove_cvref_t<std::tuple_element_t<i, Tuple>>;
      if constexpr (std::is_same_v<currentType, Type>) ++count;
    });
    return count;
  }
 
  template <typename Fun, typename... Args>
  using ReturnType = std::invoke_result_t<Fun, Args...>;
 
  template <typename T, typename Tuple>
  struct hasType : std::false_type {};
 
#ifndef DOXYGEN
  template <typename T>
  struct hasType<T, std::tuple<>> : std::false_type {};
 
  template <typename T>
  struct hasType<T, T> : std::true_type {};
 
  template <typename T, typename U, typename... Ts>
  struct hasType<T, std::tuple<U, Ts...>> : hasType<T, std::tuple<Ts...>> {};
 
  template <typename T, typename... Ts>
  struct hasType<T, std::tuple<T, Ts...>> : std::true_type {};
#endif
 
#ifndef DOXYGEN
  template <template <typename...> class, typename...>
  struct isSpecialization : std::false_type {};
#endif
 
  template <template <typename...> class U, typename... T>
  struct isSpecialization<U, U<T...>> : std::true_type {};
 
#ifndef DOXYGEN
  template <template <typename, auto...> class Type, typename>
  struct isSpecializationTypeAndNonTypes : std::false_type {};
 
  template <template <typename, auto...> class Type, typename T, auto... N>
  struct isSpecializationTypeAndNonTypes<Type, Type<T, N...>> : std::true_type {};
 
  template <template <auto, typename...> class Type, typename>
  struct isSpecializationNonTypeAndTypes : std::false_type {};
#endif
 
  template <template <auto, typename...> class Type, auto T, typename... N>
  struct isSpecializationNonTypeAndTypes<Type, Type<T, N...>> : std::true_type {};
 
#ifndef DOXYGEN
  template <template <typename, auto, typename> class Type, typename>
  struct isSpecializationTypeNonTypeAndType : std::false_type {};
#endif
  template <template <typename, auto, typename> class Type, typename T, auto M, typename N>
  struct isSpecializationTypeNonTypeAndType<Type, Type<T, M, N>> : std::true_type {};
 
#ifndef DOXYGEN
  template <template <auto...> class Type, typename>
  struct isSpecializationNonTypes : std::false_type {};
#endif
 
  template <template <auto...> class Type, auto... N>
  struct isSpecializationNonTypes<Type, Type<N...>> : std::true_type {};
 
  template <class T, class Tuple>
  struct Index;
#ifndef DOXYGEN
  template <class T>
  struct Index<T, std::tuple<>> {
    static const std::size_t value = 0;
  };
 
  template <class T, class... Types>
  struct Index<T, std::tuple<T, Types...>> {
    static constexpr std::size_t value = 0;
  };
 
  template <class T, class U, class... Types>
  struct Index<T, std::tuple<U, Types...>> {
    static const std::size_t value = 1 + Index<T, std::tuple<Types...>>::value;
  };
#endif
 
  template <class Container, class NewType>
  struct Rebind;
 
#ifndef DOXYGEN
  /*
   * Specialization for types like std::vector<...> and nested std::vector<std::vector>
   */
  template <class OldType, class... Args, template <class...> class Container, class NewType>
  struct Rebind<Container<OldType, Args...>, NewType> {
    using other = Container<NewType, typename Rebind<Args, NewType>::other...>;
  };
 
  /*
   * Specialization for types like std::array<...,N>
   */
  template <class OldType, std::size_t N, template <class, std::size_t> class Container, class NewType>
  struct Rebind<Container<OldType, N>, NewType> {
    using other = Container<NewType, N>;
  };
 
#endif
 
  template <typename T, typename = void>
  struct FunctionTraits;
 
#ifndef DOXYGEN
  template <typename R, typename... Args>
  struct FunctionTraits<R (*)(Args...)> {
    using return_type = R;
    template <int i>
    using args_type                        = typename std::tuple_element<i, std::tuple<Args...>>::type;
    static constexpr int numberOfArguments = sizeof...(Args);
  };
 
  template <typename R, typename C, typename... Args>
  struct FunctionTraits<R (C::*)(Args...) const> {
    using return_type = R;
    template <int i>
    using args_type                        = typename std::tuple_element<i, std::tuple<Args...>>::type;
    static constexpr int numberOfArguments = sizeof...(Args);
  };
 
  template <typename R, typename C, typename... Args>
  struct FunctionTraits<R (C::*)(Args...)> {
    using return_type = R;
    template <int i>
    using args_type                        = typename std::tuple_element<i, std::tuple<Args...>>::type;
    static constexpr int numberOfArguments = sizeof...(Args);
  };
 
  template <typename T>
  struct FunctionTraits<T, Dune::void_t<decltype(&T::operator())>> : public FunctionTraits<decltype(&T::operator())> {};
#endif
 
}  // namespace Ikarus::traits