device.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/edm/details/device_traits.hpp"
#include "vecmem/edm/proxy.hpp"
#include "vecmem/edm/schema.hpp"
#include "vecmem/edm/view.hpp"
#include "vecmem/utils/tuple.hpp"
#include "vecmem/utils/types.hpp"
 
// System include(s).
#include <utility>
 
namespace vecmem {
namespace edm {
 
template <typename T, template <typename> class I>
class device;
 
template <typename... VARTYPES, template <typename> class INTERFACE>
class device<schema<VARTYPES...>, INTERFACE> {
 
    // Sanity check(s).
    static_assert(sizeof...(VARTYPES) > 0,
                  "SoA containers without variables are not supported.");
 
public:
    using schema_type = schema<VARTYPES...>;
    using size_type = typename view<schema_type>::size_type;
    using size_pointer = typename view<schema_type>::size_pointer;
    using tuple_type = tuple<typename details::device_type<VARTYPES>::type...>;
    template <typename T>
    using interface_type = INTERFACE<T>;
    using proxy_type =
        interface_type<proxy<schema_type, details::proxy_domain::device,
                             details::proxy_access::non_constant,
                             details::proxy_type::reference>>;
    using const_proxy_type = interface_type<
        proxy<schema_type, details::proxy_domain::device,
              details::proxy_access::constant, details::proxy_type::reference>>;
    using object_type =
        interface_type<proxy<schema_type, details::proxy_domain::device,
                             details::proxy_access::non_constant,
                             details::proxy_type::standalone>>;
 
 
    VECMEM_HOST_AND_DEVICE
    device(const view<schema_type>& view);
 
 
 
    VECMEM_HOST_AND_DEVICE
    size_type size() const;
    VECMEM_HOST_AND_DEVICE
    size_type capacity() const;
 
    VECMEM_HOST_AND_DEVICE
    size_type push_back_default();
    VECMEM_HOST_AND_DEVICE size_type push_back(const object_type& element);
 
    template <std::size_t INDEX>
    VECMEM_HOST_AND_DEVICE
        typename details::device_type_at<INDEX, VARTYPES...>::return_type
        get();
    template <std::size_t INDEX>
    VECMEM_HOST_AND_DEVICE
        typename details::device_type_at<INDEX, VARTYPES...>::const_return_type
        get() const;
 
    VECMEM_HOST_AND_DEVICE
    proxy_type at(size_type index);
    VECMEM_HOST_AND_DEVICE
    const_proxy_type at(size_type index) const;
 
    VECMEM_HOST_AND_DEVICE
    proxy_type operator[](size_type index);
    VECMEM_HOST_AND_DEVICE
    const_proxy_type operator[](size_type index) const;
 
 
 
    VECMEM_HOST_AND_DEVICE
    tuple_type& variables();
    VECMEM_HOST_AND_DEVICE
    const tuple_type& variables() const;
 
 
private:
    template <std::size_t INDEX, std::size_t... Is>
    VECMEM_HOST_AND_DEVICE void construct_default(
        size_type index, std::index_sequence<INDEX, Is...>);
    VECMEM_HOST_AND_DEVICE void construct_default(size_type index,
                                                  std::index_sequence<>);
 
    template <typename T>
    VECMEM_HOST_AND_DEVICE void construct_vector(size_type, T&);
    template <typename T>
    VECMEM_HOST_AND_DEVICE void construct_vector(size_type index,
                                                 device_vector<T>& vec);
 
    size_type m_capacity = 0;
    size_pointer m_size = nullptr;
    tuple_type m_data;
 
};  // class device
 
}  // namespace edm
}  // namespace vecmem
 
// Include the implementation.
#include "vecmem/edm/impl/device.ipp"