tuple_helpers.hpp

// This file is part of the ACTS project.
//
// Copyright (C) 2016 CERN for the benefit of the ACTS project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
#pragma once
 
// Project include(s)
#include "detray/definitions/detail/qualifiers.hpp"
#include "detray/utils/tuple.hpp"
#include "detray/utils/type_traits.hpp"
 
// System include(s)
#include <limits>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace detray::detail {

using std::get;
 
template <std::size_t I, typename... value_types>
DETRAY_HOST_DEVICE constexpr decltype(auto) get(
    const ::detray::dtuple<value_types...>& tuple) noexcept {
  return ::detray::get<I>(tuple);
}
 
template <std::size_t I, typename... value_types>
DETRAY_HOST_DEVICE constexpr decltype(auto) get(
    ::detray::dtuple<value_types...>& tuple) noexcept {
  return ::detray::get<I>(tuple);
}
 
template <typename query_t, typename... value_types>
DETRAY_HOST_DEVICE constexpr decltype(auto) get(
    const ::detray::dtuple<value_types...>& tuple) noexcept {
  return ::detray::get<get_type_pos_v<query_t, value_types...>>(tuple);
}
 
template <typename query_t, typename... value_types>
DETRAY_HOST_DEVICE constexpr decltype(auto) get(
    ::detray::dtuple<value_types...>& tuple) noexcept {
  return ::detray::get<get_type_pos_v<query_t, value_types...>>(tuple);
}

template <std::size_t N, class T>
struct tuple_element;
 
// std::tuple
template <std::size_t N, typename... value_types>
struct tuple_element<N, std::tuple<value_types...>>
    : std::tuple_element<N, std::tuple<value_types...>> {};
 
// detray::dtuple
template <std::size_t N, typename... value_types>
struct tuple_element<N, detray::dtuple<value_types...>> {
  using type = std::decay_t<decltype(::detray::get<N>(
      std::declval<detray::dtuple<value_types...>>()))>;
};
 
template <std::size_t N, class T>
using tuple_element_t = typename tuple_element<N, T>::type;

template <class T>
struct tuple_size;
 
// std::tuple
template <typename... value_types>
struct tuple_size<std::tuple<value_types...>>
    : std::tuple_size<std::tuple<value_types...>> {};
 
// detray::dtuple
template <typename... value_types>
struct tuple_size<::detray::dtuple<value_types...>> {
  static constexpr std::size_t value = sizeof...(value_types);
};
 
template <class T>
constexpr std::size_t tuple_size_v{tuple_size<T>::value};

template <class T>
struct unwrap_refwrapper {
  using type = T;
};
 
template <class T>
struct unwrap_refwrapper<std::reference_wrapper<T>> {
  using type = T&;
};
 
template <class T>
using unwrap_decay_t = typename unwrap_refwrapper<std::decay_t<T>>::type;
 
// make_tuple for std::tuple
template <template <typename...> class tuple_t, class... value_types>
  requires std::is_same_v<tuple_t<value_types...>, std::tuple<value_types...>>
DETRAY_HOST constexpr std::tuple<unwrap_decay_t<value_types>...> make_tuple(
    value_types&&... args) {
  return std::make_tuple(std::forward<value_types>(args)...);
}
 
// make_tuple for detray::dtuple
template <template <typename...> class tuple_t, class... value_types>
  requires std::is_same_v<tuple_t<value_types...>,
                          detray::dtuple<value_types...>>
DETRAY_HOST_DEVICE constexpr detray::dtuple<unwrap_decay_t<value_types>...>
make_tuple(value_types&&... args) {
  return detray::dtuple<unwrap_decay_t<value_types>...>{
      std::forward<value_types>(args)...};
}

template <typename T, typename tuple_t>
struct has_type;
 
// std::tuple
template <typename T>
struct has_type<T, std::tuple<>> : std::false_type {};
 
template <typename T, typename U, typename... Ts>
struct has_type<T, std::tuple<U, Ts...>> : has_type<T, std::tuple<Ts...>> {};
 
template <typename T, typename... Ts>
struct has_type<T, std::tuple<T, Ts...>> : std::true_type {};
 
// detray::dtuple
template <typename T>
struct has_type<T, detray::dtuple<>> : std::false_type {};
 
template <typename T, typename U, typename... Ts>
struct has_type<T, detray::dtuple<U, Ts...>>
    : has_type<T, detray::dtuple<Ts...>> {};
 
template <typename T, typename... Ts>
struct has_type<T, detray::dtuple<T, Ts...>> : std::true_type {};
 
template <typename T, class tuple_t>
constexpr bool has_type_v = has_type<T, tuple_t>::value;

template <typename... tuple_ts>
struct tuple_cat_type {};
 
template <typename... Args>
struct tuple_cat_type<std::tuple<Args...>> {
  using type = std::tuple<Args...>;
};
 
template <typename... Args1, typename... Args2, typename... tuple_ts>
struct tuple_cat_type<std::tuple<Args1...>, std::tuple<Args2...>, tuple_ts...> {
  using type = typename tuple_cat_type<std::tuple<Args1..., Args2...>,
                                       tuple_ts...>::type;
};

template <typename... Args>
struct tuple_cat_type<detray::dtuple<Args...>> {
  using type = detray::dtuple<Args...>;
};

template <typename... Args1, typename... Args2, typename... tuple_ts>
struct tuple_cat_type<detray::dtuple<Args1...>, detray::dtuple<Args2...>,
                      tuple_ts...> {
  using type = typename tuple_cat_type<detray::dtuple<Args1..., Args2...>,
                                       tuple_ts...>::type;
};
 
template <typename... tuple_ts>
using tuple_cat_t = typename tuple_cat_type<tuple_ts...>::type;

template <std::size_t I, typename... tuple_ts>
struct unique_types {};

template <std::size_t I>
struct unique_types<I, std::tuple<>> {
  using type = std::tuple<>;
};

template <std::size_t I, typename Arg1, typename... Args>
struct unique_types<I, std::tuple<Arg1, Args...>> {
  using type = std::conditional_t<
      has_type_v<Arg1, std::tuple<Args...>>,
      typename unique_types<I - 1u, std::tuple<Args...>>::type,
      typename unique_types<I - 1u, std::tuple<Args..., Arg1>>::type>;
};

template <typename Arg1, typename... Args>
struct unique_types<0u, std::tuple<Arg1, Args...>> {
  using type = std::tuple<Arg1, Args...>;
};

template <std::size_t I>
struct unique_types<I, detray::dtuple<>> {
  using type = detray::dtuple<>;
};

template <std::size_t I, typename Arg1, typename... Args>
struct unique_types<I, detray::dtuple<Arg1, Args...>> {
  using type = std::conditional_t<
      has_type_v<Arg1, detray::dtuple<Args...>>,
      typename unique_types<I - 1u, detray::dtuple<Args...>>::type,
      typename unique_types<I - 1u, detray::dtuple<Args..., Arg1>>::type>;
};

template <typename Arg1, typename... Args>
struct unique_types<0u, detray::dtuple<Arg1, Args...>> {
  using type = detray::dtuple<Arg1, Args...>;
};
 
template <typename tuple_t>
using unique_t =
    typename unique_types<tuple_size_v<tuple_t> - 1u, tuple_t>::type;

template <typename T1, typename T2>
struct is_permutation : public std::false_type {};
 
template <>
struct is_permutation<detray::dtuple<>, detray::dtuple<>>
    : public std::true_type {};

template <typename... Args1, typename... Args2>
struct is_permutation<detray::dtuple<Args1...>, detray::dtuple<Args2...>> {
  using T1 = detray::dtuple<Args1...>;
  using T2 = detray::dtuple<Args2...>;

  template <typename o_tuple_t, typename T, typename... U>
  static consteval bool compare() {
    if constexpr (detray::detail::has_type_v<T, o_tuple_t>) {
      if constexpr (sizeof...(U) == 0u) {
        return true;
      } else {
        return compare<o_tuple_t, U...>();
      }
    } else {
      return false;
    }
  }

  static constexpr bool value =
      ((detray::detail::tuple_size_v<T1> == detray::detail::tuple_size_v<T2>) &&
       (compare<T1, Args2...>() && compare<T2, Args1...>()));
};
 
template <typename T1, typename T2>
constexpr bool is_permutation_v = is_permutation<T1, T2>::value;

 
// Any
template <template <typename...> class trait, typename tuple_t>
struct tuple_any {};
 
template <template <typename...> class trait, typename... Args>
struct tuple_any<trait, std::tuple<Args...>> {
  static constexpr bool value = (trait<Args>::value || ...);
};
template <template <typename...> class trait, typename... Args>
struct tuple_any<trait, detray::dtuple<Args...>> {
  static constexpr bool value = (trait<Args>::value || ...);
};
 
template <template <typename...> class trait, typename tuple_t>
constexpr bool tuple_any_v = tuple_any<trait, tuple_t>::value;
 
// All
template <template <typename...> class trait, typename tuple_t>
struct tuple_all {};
 
template <template <typename...> class trait, typename... Args>
struct tuple_all<trait, std::tuple<Args...>> {
  static constexpr bool value = (trait<Args>::value && ...);
};
template <template <typename...> class trait, typename... Args>
struct tuple_all<trait, detray::dtuple<Args...>> {
  static constexpr bool value = (trait<Args>::value && ...);
};
 
template <template <typename...> class trait, typename tuple_t>
constexpr bool tuple_all_v = tuple_all<trait, tuple_t>::value;

 
}  // namespace detray::detail