proxy_traits.hpp

/* VecMem project, part of the ACTS project (R&D line)
 *
 * (c) 2024-2025 CERN for the benefit of the ACTS project
 *
 * Mozilla Public License Version 2.0
 */
#pragma once
 
// Local include(s).
#include "vecmem/containers/device_vector.hpp"
#include "vecmem/containers/jagged_device_vector.hpp"
#include "vecmem/edm/schema.hpp"
#include "vecmem/utils/tuple.hpp"
#if __cplusplus >= 201700L
#include "vecmem/containers/jagged_vector.hpp"
#include "vecmem/containers/vector.hpp"
#endif  // __cplusplus >= 201700L
 
// System include(s).
#include <tuple>
#include <type_traits>
 
namespace vecmem {
namespace edm {
namespace details {
 
enum class proxy_domain {
    host,
    device
};
 
enum class proxy_access {
    non_constant,
    constant
};
 
enum class proxy_type {
    reference,
    standalone
};
 
 
template <typename VTYPE, proxy_domain PDOMAIN, proxy_access PACCESS,
          proxy_type PTYPE>
struct proxy_var_type;
 
template <typename VTYPE, proxy_domain PDOMAIN>
struct proxy_var_type<type::scalar<VTYPE>, PDOMAIN, proxy_access::constant,
                      proxy_type::reference> {
 
    using type = std::add_lvalue_reference_t<std::add_const_t<VTYPE>>;
    using return_type = type;
    using const_return_type = return_type;
 
    template <typename ITYPE>
    VECMEM_HOST_AND_DEVICE static type make(ITYPE, return_type variable) {
        return variable;
    }
};
 
template <typename VTYPE, proxy_domain PDOMAIN>
struct proxy_var_type<type::scalar<VTYPE>, PDOMAIN, proxy_access::non_constant,
                      proxy_type::reference> {
 
    using type = std::add_lvalue_reference_t<VTYPE>;
    using return_type = type;
    using const_return_type =
        std::add_lvalue_reference_t<std::add_const_t<VTYPE>>;
 
    template <typename ITYPE>
    VECMEM_HOST_AND_DEVICE static type make(ITYPE, return_type variable) {
        return variable;
    }
};
 
template <typename VTYPE, proxy_domain PDOMAIN, proxy_access PACCESS>
struct proxy_var_type<type::scalar<VTYPE>, PDOMAIN, PACCESS,
                      proxy_type::standalone> {
 
    using type = std::remove_cv_t<VTYPE>;
    using return_type = std::add_lvalue_reference_t<type>;
    using const_return_type =
        std::add_lvalue_reference_t<std::add_const_t<type>>;
 
    template <typename ITYPE>
    VECMEM_HOST_AND_DEVICE static type make(ITYPE, const_return_type variable) {
        return variable;
    }
};
 
template <typename VTYPE, proxy_domain PDOMAIN>
struct proxy_var_type<type::vector<VTYPE>, PDOMAIN, proxy_access::constant,
                      proxy_type::reference> {
 
    using type = std::add_lvalue_reference_t<std::add_const_t<VTYPE>>;
    using return_type = type;
    using const_return_type = return_type;
 
    template <typename ITYPE, typename VECTYPE>
    VECMEM_HOST_AND_DEVICE static type make(ITYPE i, const VECTYPE& vec) {
 
        return vec.at(i);
    }
};
 
template <typename VTYPE, proxy_domain PDOMAIN>
struct proxy_var_type<type::vector<VTYPE>, PDOMAIN, proxy_access::non_constant,
                      proxy_type::reference> {
 
    using type = std::add_lvalue_reference_t<VTYPE>;
    using return_type = type;
    using const_return_type =
        std::add_lvalue_reference_t<std::add_const_t<VTYPE>>;
 
    template <typename ITYPE, typename VECTYPE>
    VECMEM_HOST_AND_DEVICE static type make(ITYPE i, VECTYPE& vec) {
 
        return vec.at(i);
    }
};
 
template <typename VTYPE, proxy_domain PDOMAIN, proxy_access PACCESS>
struct proxy_var_type<type::vector<VTYPE>, PDOMAIN, PACCESS,
                      proxy_type::standalone> {
 
    using type = std::remove_cv_t<VTYPE>;
    using return_type = std::add_lvalue_reference_t<type>;
    using const_return_type =
        std::add_lvalue_reference_t<std::add_const_t<type>>;
 
    template <typename ITYPE, typename VECTYPE>
    VECMEM_HOST_AND_DEVICE static type make(ITYPE i, const VECTYPE& vec) {
 
        return vec.at(i);
    }
};
 
template <typename VTYPE>
struct proxy_var_type<type::jagged_vector<VTYPE>, proxy_domain::device,
                      proxy_access::constant, proxy_type::reference> {
 
    using type = device_vector<std::add_const_t<VTYPE>>;
    using return_type = std::add_lvalue_reference_t<std::add_const_t<type>>;
    using const_return_type = return_type;
 
    VECMEM_HOST_AND_DEVICE
    static type make(
        typename jagged_device_vector<std::add_const_t<VTYPE>>::size_type i,
        const jagged_device_vector<std::add_const_t<VTYPE>>& vec) {
 
        return vec.at(i);
    }
};
 
template <typename VTYPE>
struct proxy_var_type<type::jagged_vector<VTYPE>, proxy_domain::device,
                      proxy_access::non_constant, proxy_type::reference> {
 
    using type = device_vector<VTYPE>;
    using return_type = std::add_lvalue_reference_t<type>;
    using const_return_type = std::add_lvalue_reference_t<
        std::add_const_t<device_vector<std::add_const_t<VTYPE>>>>;
 
    VECMEM_HOST_AND_DEVICE
    static type make(typename jagged_device_vector<VTYPE>::size_type i,
                     jagged_device_vector<VTYPE>& vec) {
 
        return vec.at(i);
    }
};
 
#if __cplusplus >= 201700L
 
template <typename VTYPE>
struct proxy_var_type<type::jagged_vector<VTYPE>, proxy_domain::host,
                      proxy_access::constant, proxy_type::reference> {
 
    using type = std::add_lvalue_reference_t<std::add_const_t<vector<VTYPE>>>;
    using return_type = type;
    using const_return_type = type;
 
    VECMEM_HOST
    static type make(typename jagged_vector<VTYPE>::size_type i,
                     const jagged_vector<VTYPE>& vec) {
 
        return vec.at(i);
    }
};
 
template <typename VTYPE>
struct proxy_var_type<type::jagged_vector<VTYPE>, proxy_domain::host,
                      proxy_access::non_constant, proxy_type::reference> {
 
    using type = std::add_lvalue_reference_t<vector<VTYPE>>;
    using return_type = type;
    using const_return_type =
        std::add_lvalue_reference_t<std::add_const_t<vector<VTYPE>>>;
 
    VECMEM_HOST
    static type make(typename jagged_vector<VTYPE>::size_type i,
                     jagged_vector<VTYPE>& vec) {
 
        return vec.at(i);
    }
};
 
template <typename VTYPE, proxy_access PACCESS>
struct proxy_var_type<type::jagged_vector<VTYPE>, proxy_domain::host, PACCESS,
                      proxy_type::standalone> {
 
    using type = vector<VTYPE>;
    using return_type = std::add_lvalue_reference_t<type>;
    using const_return_type =
        std::add_lvalue_reference_t<std::add_const_t<type>>;
 
    VECMEM_HOST
    static type make(typename jagged_vector<VTYPE>::size_type i,
                     const jagged_vector<VTYPE>& vec) {
 
        return vec.at(i);
    }
};
 
#endif  // __cplusplus >= 201700L
 
template <std::size_t INDEX, proxy_domain PDOMAIN, proxy_access PACCESS,
          proxy_type PTYPE, typename... VARTYPES>
struct proxy_var_type_at {
    using type =
        typename proxy_var_type<tuple_element_t<INDEX, tuple<VARTYPES...>>,
                                PDOMAIN, PACCESS, PTYPE>::type;
    using return_type =
        typename proxy_var_type<tuple_element_t<INDEX, tuple<VARTYPES...>>,
                                PDOMAIN, PACCESS, PTYPE>::return_type;
    using const_return_type =
        typename proxy_var_type<tuple_element_t<INDEX, tuple<VARTYPES...>>,
                                PDOMAIN, PACCESS, PTYPE>::const_return_type;
};
 
 
 
template <typename SCHEMA, proxy_domain PDOMAIN, proxy_access PACCESS,
          proxy_type PTYPE>
struct proxy_data_creator;
 
template <typename VARTYPE, proxy_domain PDOMAIN>
struct proxy_data_creator<schema<VARTYPE>, PDOMAIN, proxy_access::constant,
                          proxy_type::reference> {
 
    template <typename, proxy_domain, proxy_access, proxy_type>
    friend struct proxy_data_creator;
 
    using proxy_tuple_type =
        tuple<typename proxy_var_type<VARTYPE, PDOMAIN, proxy_access::constant,
                                      proxy_type::reference>::type>;
 
    template <typename ITYPE, typename CONTAINER>
    VECMEM_HOST_AND_DEVICE static proxy_tuple_type make(ITYPE i,
                                                        const CONTAINER& c) {
        return make_impl<0>(i, c);
    }
 
private:
    template <std::size_t INDEX, typename ITYPE, typename CONTAINER>
    VECMEM_HOST_AND_DEVICE static proxy_tuple_type make_impl(
        ITYPE i, const CONTAINER& c) {
 
        return {proxy_var_type<
            VARTYPE, PDOMAIN, proxy_access::constant,
            proxy_type::reference>::make(i, c.template get<INDEX>())};
    }
};
 
template <typename VARTYPE, proxy_domain PDOMAIN>
struct proxy_data_creator<schema<VARTYPE>, PDOMAIN, proxy_access::non_constant,
                          proxy_type::reference> {
 
    template <typename, proxy_domain, proxy_access, proxy_type>
    friend struct proxy_data_creator;
 
    using proxy_tuple_type = tuple<
        typename proxy_var_type<VARTYPE, PDOMAIN, proxy_access::non_constant,
                                proxy_type::reference>::type>;
 
    template <typename ITYPE, typename CONTAINER>
    VECMEM_HOST_AND_DEVICE static proxy_tuple_type make(ITYPE i, CONTAINER& c) {
        return make_impl<0>(i, c);
    }
 
private:
    template <std::size_t INDEX, typename ITYPE, typename CONTAINER>
    VECMEM_HOST_AND_DEVICE static proxy_tuple_type make_impl(ITYPE i,
                                                             CONTAINER& c) {
 
        return {proxy_var_type<
            VARTYPE, PDOMAIN, proxy_access::non_constant,
            proxy_type::reference>::make(i, c.template get<INDEX>())};
    }
};
 
template <typename VARTYPE, typename... VARTYPES, proxy_domain PDOMAIN>
struct proxy_data_creator<schema<VARTYPE, VARTYPES...>, PDOMAIN,
                          proxy_access::constant, proxy_type::reference> {
 
    template <typename, proxy_domain, proxy_access, proxy_type>
    friend struct proxy_data_creator;
 
    using proxy_tuple_type =
        tuple<typename proxy_var_type<VARTYPE, PDOMAIN, proxy_access::constant,
                                      proxy_type::reference>::type,
              typename proxy_var_type<VARTYPES, PDOMAIN, proxy_access::constant,
                                      proxy_type::reference>::type...>;
 
    template <typename ITYPE, typename CONTAINER>
    VECMEM_HOST_AND_DEVICE static proxy_tuple_type make(ITYPE i,
                                                        const CONTAINER& c) {
        return make_impl<0>(i, c);
    }
 
private:
    template <std::size_t INDEX, typename ITYPE, typename CONTAINER>
    VECMEM_HOST_AND_DEVICE static proxy_tuple_type make_impl(
        ITYPE i, const CONTAINER& c) {
 
        return proxy_tuple_type(
            proxy_var_type<
                VARTYPE, PDOMAIN, proxy_access::constant,
                proxy_type::reference>::make(i, c.template get<INDEX>()),
            proxy_data_creator<
                schema<VARTYPES...>, PDOMAIN, proxy_access::constant,
                proxy_type::reference>::template make_impl<INDEX + 1>(i, c));
    }
};
 
template <typename VARTYPE, typename... VARTYPES, proxy_domain PDOMAIN>
struct proxy_data_creator<schema<VARTYPE, VARTYPES...>, PDOMAIN,
                          proxy_access::non_constant, proxy_type::reference> {
 
    template <typename, proxy_domain, proxy_access, proxy_type>
    friend struct proxy_data_creator;
 
    using proxy_tuple_type = tuple<
        typename proxy_var_type<VARTYPE, PDOMAIN, proxy_access::non_constant,
                                proxy_type::reference>::type,
        typename proxy_var_type<VARTYPES, PDOMAIN, proxy_access::non_constant,
                                proxy_type::reference>::type...>;
 
    template <typename ITYPE, typename CONTAINER>
    VECMEM_HOST_AND_DEVICE static proxy_tuple_type make(ITYPE i, CONTAINER& c) {
        return make_impl<0>(i, c);
    }
 
private:
    template <std::size_t INDEX, typename ITYPE, typename CONTAINER>
    VECMEM_HOST_AND_DEVICE static proxy_tuple_type make_impl(ITYPE i,
                                                             CONTAINER& c) {
 
        return proxy_tuple_type(
            proxy_var_type<
                VARTYPE, PDOMAIN, proxy_access::non_constant,
                proxy_type::reference>::make(i, c.template get<INDEX>()),
            proxy_data_creator<
                schema<VARTYPES...>, PDOMAIN, proxy_access::non_constant,
                proxy_type::reference>::template make_impl<INDEX + 1>(i, c));
    }
};
 
 
}  // namespace details
}  // namespace edm
}  // namespace vecmem