tuple.hpp

/* VecMem project, part of the ACTS project (R&D line)
 *
 * (c) 2023-2025 CERN for the benefit of the ACTS project
 *
 * Mozilla Public License Version 2.0
 */
#pragma once
 
// Local include(s).
#include "vecmem/utils/type_traits.hpp"
#include "vecmem/utils/types.hpp"
 
// System include(s).
#include <type_traits>
 
namespace vecmem {
 
template <typename... Ts>
struct tuple {
 
    // As long as we did everything correctly, this should only get instantiated
    // with an empty parameter list, for the implementation to work correctly.
    static_assert(sizeof...(Ts) == 0,
                  "There's a coding error in vecmem::tuple!");
 
    constexpr tuple() = default;
 
};  // struct tuple
 
template <typename T, typename... Ts>
struct tuple<T, Ts...> {
 
    constexpr tuple() = default;
    constexpr tuple(const tuple &) = default;
    constexpr tuple(tuple &&) noexcept = default;
 
    template <typename U, typename... Us,
              std::enable_if_t<
                  vecmem::details::conjunction<
                      std::is_constructible<T, std::decay_t<U>>,
                      std::is_constructible<Ts, std::decay_t<Us>>...>::value,
                  bool> = true>
    VECMEM_HOST_AND_DEVICE constexpr tuple(const tuple<U, Us...> &parent)
        : m_head(parent.m_head), m_tail(parent.m_tail) {}
 
    template <
        typename U, typename... Us,
        std::enable_if_t<
            vecmem::details::conjunction<
                vecmem::details::negation<std::is_same<tuple<T, Ts...>, U>>,
                std::is_constructible<T, U &&>,
                std::is_constructible<Ts, Us &&>...>::value,
            bool> = true>
    VECMEM_HOST_AND_DEVICE constexpr tuple(U &&head, Us &&... tail)
        : m_head(std::forward<U>(head)), m_tail(std::forward<Us>(tail)...) {}
 
    template <typename U, typename... Us,
              std::enable_if_t<vecmem::details::conjunction<
                                   std::is_constructible<T, U &&>,
                                   std::is_constructible<Ts, Us &&>...>::value,
                               bool> = true>
    VECMEM_HOST_AND_DEVICE constexpr tuple(U &&head, tuple<Us...> &&tail)
        : m_head(std::forward<U>(head)), m_tail(std::move(tail)) {}
 
    VECMEM_HOST_AND_DEVICE constexpr tuple &operator=(const tuple &parent) {
        m_head = parent.m_head;
        m_tail = parent.m_tail;
        return *this;
    }
 
    template <typename U, typename... Us,
              std::enable_if_t<(sizeof...(Ts) == sizeof...(Us)) &&
                                   vecmem::details::conjunction<
                                       std::is_assignable<T, U &&>,
                                       std::is_assignable<Ts, Us &&>...>::value,
                               bool> = true>
    VECMEM_HOST_AND_DEVICE constexpr tuple &operator=(
        const tuple<U, Us...> &parent) {
        m_head = parent.m_head;
        m_tail = parent.m_tail;
        return *this;
    }
 
    T m_head;
    tuple<Ts...> m_tail;
 
};  // struct tuple
 
 
template <std::size_t I, typename... Ts>
VECMEM_HOST_AND_DEVICE inline constexpr const auto &get(
    const tuple<Ts...> &t) noexcept;
 
template <std::size_t I, typename... Ts>
VECMEM_HOST_AND_DEVICE inline constexpr auto &get(tuple<Ts...> &t) noexcept;
 
template <typename... Ts>
VECMEM_HOST_AND_DEVICE inline constexpr tuple<Ts &...> tie(Ts &... args);
 
template <class... Ts>
VECMEM_HOST_AND_DEVICE inline constexpr tuple<typename std::decay<Ts>::type...>
make_tuple(Ts &&... args);
 
template <std::size_t I, class T>
struct tuple_element;
 
template <std::size_t I, typename... Ts>
struct tuple_element<I, tuple<Ts...>> {
 
    using type = std::decay_t<decltype(get<I>(std::declval<tuple<Ts...>>()))>;
};
 
template <std::size_t I, class T>
using tuple_element_t = typename tuple_element<I, T>::type;
 
 
}  // namespace vecmem
 
// Include the implementation.
#include "vecmem/utils/impl/tuple.ipp"