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 <functional>
#include <tuple>
#include <type_traits>
 
namespace std {
template <class T>
class shared_ptr;
}
 
#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 <typename T>
struct isSharedPtr : std::false_type
{
};
 
#ifndef DOXYGEN
template <typename T>
struct isSharedPtr<std::shared_ptr<T>> : std::true_type
{
};
#endif
 
template <typename T>
class remove_pointer
{
  template <typename U = T>
  static auto test(int) -> std::remove_reference<decltype(*std::declval<U>())>;
  static auto test(...) -> std::remove_cv<T>;
 
public:
  using type = typename decltype(test(0))::type;
};
 
template <typename T>
using remove_pointer_t = typename remove_pointer<T>::type;
 
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;
  using ArgsTuple   = std::tuple<Args...>;
 
  template <int i>
  using args_type                        = typename std::tuple_element<i, ArgsTuple>::type;
  static constexpr int numberOfArguments = sizeof...(Args);
};
 
template <typename R, typename C, typename... Args>
struct FunctionTraits<R (C::*)(Args...) const>
{
  using return_type = R;
  using ArgsTuple   = std::tuple<Args...>;
 
  template <int i>
  using args_type                        = typename std::tuple_element<i, ArgsTuple>::type;
  static constexpr int numberOfArguments = sizeof...(Args);
};
 
template <typename R, typename C, typename... Args>
struct FunctionTraits<R (C::*)(Args...)>
{
  using return_type = R;
  using ArgsTuple   = std::tuple<Args...>;
 
  template <int i>
  using args_type                        = typename std::tuple_element<i, ArgsTuple>::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
 
template <typename Tuple, std::size_t Pos, typename NewType>
struct ReplaceTypeAtPos;
 
#ifndef DOXYGEN
template <typename NewType, std::size_t Pos, typename... Args>
struct ReplaceTypeAtPos<std::tuple<Args...>, Pos, NewType>
{
private:
  template <std::size_t... Is>
  static auto replace_impl(std::index_sequence<Is...>) -> std::tuple<std::conditional_t<Is == Pos, NewType, Args>...>;
 
public:
  using type = decltype(replace_impl(std::index_sequence_for<Args...>{}));
};
#endif
 
template <typename Tuple, std::size_t Pos, typename NewType>
using ReplaceTypeAtPos_t = typename ReplaceTypeAtPos<Tuple, Pos, NewType>::type;
 
template <typename R, typename Tuple>
struct TupleToFunctionType;
 
#ifndef DOXYGEN
template <typename R, typename... Args>
struct TupleToFunctionType<R, std::tuple<Args...>>
{
  using type = std::function<R(Args...)>;
};
#endif
 
template <typename R, typename Tuple>
using TupleToFunctionType_t = typename TupleToFunctionType<R, Tuple>::type;
 
template <typename Func, std::size_t Pos, typename NewType>
struct ChangeArgTypeAtPos;
 
#ifndef DOXYGEN
template <typename R, typename... Args, std::size_t Pos, typename NewType>
struct ChangeArgTypeAtPos<std::function<R(Args...)>, Pos, NewType>
{
  using OriginalFunction = std::function<R(Args...)>;
  using Traits           = FunctionTraits<OriginalFunction>;
  using NewArgsTuple     = ReplaceTypeAtPos_t<typename Traits::ArgsTuple, Pos, NewType>;
  using NewFunctionType  = TupleToFunctionType_t<R, NewArgsTuple>;
};
#endif
 
} // namespace Ikarus::traits