host.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/data.hpp"
#include "vecmem/edm/details/host_traits.hpp"
#include "vecmem/edm/details/schema_traits.hpp"
#include "vecmem/edm/proxy.hpp"
#include "vecmem/edm/schema.hpp"
#include "vecmem/memory/memory_resource.hpp"
#include "vecmem/utils/types.hpp"
 
// System include(s).
#include <cstddef>
#include <functional>
#include <tuple>
 
namespace vecmem {
namespace edm {
 
template <typename T, template <typename> class I>
class host;
 
template <typename... VARTYPES, template <typename> class INTERFACE>
class host<schema<VARTYPES...>, INTERFACE> {
 
public:
    using schema_type = schema<VARTYPES...>;
    using size_type = std::size_t;
    using tuple_type =
        std::tuple<typename details::host_type<VARTYPES>::type...>;
    template <typename T>
    using interface_type = INTERFACE<T>;
    using proxy_type =
        interface_type<proxy<schema_type, details::proxy_domain::host,
                             details::proxy_access::non_constant,
                             details::proxy_type::reference>>;
    using const_proxy_type = interface_type<
        proxy<schema_type, details::proxy_domain::host,
              details::proxy_access::constant, details::proxy_type::reference>>;
    using object_type =
        interface_type<proxy<schema_type, details::proxy_domain::host,
                             details::proxy_access::non_constant,
                             details::proxy_type::standalone>>;
 
 
    VECMEM_HOST
    explicit host(memory_resource& resource);
 
 
 
    VECMEM_HOST
    size_type size() const;
    VECMEM_HOST
    size_type capacity() const;
    VECMEM_HOST
    void resize(size_type size);
    VECMEM_HOST
    void reserve(size_type size);
    VECMEM_HOST void push_back(const object_type& element);
 
    template <std::size_t INDEX>
    VECMEM_HOST typename details::host_type_at<INDEX, VARTYPES...>::return_type
    get();
    template <std::size_t INDEX>
    VECMEM_HOST
        typename details::host_type_at<INDEX, VARTYPES...>::const_return_type
        get() const;
 
    VECMEM_HOST
    proxy_type at(size_type index);
    VECMEM_HOST
    const_proxy_type at(size_type index) const;
 
    VECMEM_HOST
    proxy_type operator[](size_type index);
    VECMEM_HOST
    const_proxy_type operator[](size_type index) const;
 
 
 
    VECMEM_HOST
    tuple_type& variables();
    VECMEM_HOST
    const tuple_type& variables() const;
 
    VECMEM_HOST
    memory_resource& resource() const;
 
 
private:
    tuple_type m_data;
    std::reference_wrapper<memory_resource> m_resource;
 
};  // class host
 
}  // namespace edm
 
template <typename... VARTYPES, template <typename> class INTERFACE>
VECMEM_HOST edm::data<edm::schema<VARTYPES...>> get_data(
    edm::host<edm::schema<VARTYPES...>, INTERFACE>& host,
    memory_resource* resource = nullptr);
 
template <typename... VARTYPES, template <typename> class INTERFACE>
VECMEM_HOST edm::data<edm::details::add_const_t<edm::schema<VARTYPES...>>>
get_data(const edm::host<edm::schema<VARTYPES...>, INTERFACE>& host,
         memory_resource* resource = nullptr);
 
}  // namespace vecmem
 
// Include the implementation.
#include "vecmem/edm/impl/host.ipp"