proxy.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/edm/details/proxy_traits.hpp"
#include "vecmem/edm/schema.hpp"
#include "vecmem/utils/tuple.hpp"
#include "vecmem/utils/types.hpp"
 
namespace vecmem {
namespace edm {
 
template <typename T, details::proxy_domain PDOMAIN,
          details::proxy_access PACCESS, details::proxy_type PTYPE>
class proxy;
 
template <typename... VARTYPES, details::proxy_domain PDOMAIN,
          details::proxy_access PACCESS, details::proxy_type PTYPE>
class proxy<schema<VARTYPES...>, PDOMAIN, PACCESS, PTYPE> {
 
public:
    using schema_type = schema<VARTYPES...>;
    static constexpr details::proxy_domain proxy_domain = PDOMAIN;
    static constexpr details::proxy_access access_type = PACCESS;
    static constexpr details::proxy_type proxy_type = PTYPE;
    using tuple_type = tuple<typename details::proxy_var_type<
        VARTYPES, proxy_domain, access_type, proxy_type>::type...>;
 
 
    template <details::proxy_type OPTYPE = proxy_type,
              std::enable_if_t<OPTYPE == details::proxy_type::standalone,
                               bool> = true>
    VECMEM_HOST_AND_DEVICE proxy();
 
    template <typename PARENT>
    VECMEM_HOST_AND_DEVICE proxy(PARENT& parent,
                                 typename PARENT::size_type index);
 
    template <typename PARENT>
    VECMEM_HOST_AND_DEVICE proxy(const PARENT& parent,
                                 typename PARENT::size_type index);
 
    proxy(const proxy&) = default;
 
    proxy(proxy&&) noexcept = default;
 
    template <typename... OVARTYPES, details::proxy_domain OPDOMAIN,
              details::proxy_access OPACCESS, details::proxy_type OPTYPE>
    VECMEM_HOST_AND_DEVICE proxy(
        const proxy<schema<OVARTYPES...>, OPDOMAIN, OPACCESS, OPTYPE>& other);
 
    VECMEM_HOST_AND_DEVICE proxy(
        typename details::proxy_var_type<VARTYPES, proxy_domain, access_type,
                                         proxy_type>::type... data);
 
    VECMEM_HOST_AND_DEVICE
    proxy& operator=(const proxy& other);
 
    template <typename... OVARTYPES, details::proxy_domain OPDOMAIN,
              details::proxy_access OPACCESS, details::proxy_type OPTYPE>
    VECMEM_HOST_AND_DEVICE proxy<schema<VARTYPES...>, PDOMAIN, PACCESS, PTYPE>&
    operator=(
        const proxy<schema<OVARTYPES...>, OPDOMAIN, OPACCESS, OPTYPE>& other);
 
 
 
    template <std::size_t INDEX>
    VECMEM_HOST_AND_DEVICE
        typename details::proxy_var_type_at<INDEX, PDOMAIN, PACCESS, PTYPE,
                                            VARTYPES...>::return_type
        get();
    template <std::size_t INDEX>
    VECMEM_HOST_AND_DEVICE
        typename details::proxy_var_type_at<INDEX, PDOMAIN, PACCESS, PTYPE,
                                            VARTYPES...>::const_return_type
        get() const;
 
 
 
    VECMEM_HOST_AND_DEVICE
    tuple_type& variables();
    VECMEM_HOST_AND_DEVICE
    const tuple_type& variables() const;
 
 
private:
    tuple_type m_data;
 
};  // class proxy
 
}  // namespace edm
}  // namespace vecmem
 
// Include the implementation.
#include "vecmem/edm/impl/proxy.ipp"