buffer.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/containers/data/buffer_type.hpp"
#include "vecmem/edm/details/schema_traits.hpp"
#include "vecmem/edm/schema.hpp"
#include "vecmem/edm/view.hpp"
#include "vecmem/memory/memory_resource.hpp"
#include "vecmem/memory/unique_ptr.hpp"
#include "vecmem/utils/types.hpp"
 
// System include(s).
#include <type_traits>
#include <utility>
#include <vector>
 
namespace vecmem {
namespace edm {
 
template <typename T>
class buffer;
 
template <typename... VARTYPES>
class buffer<schema<VARTYPES...>> : public view<schema<VARTYPES...>> {
 
    // Make sure that all variable types are supported. It needs to be possible
    // to copy the contents of all variables with simple memory copies, and
    // it has to be possible to trivially destruct all objects.
    static_assert(
        std::conjunction_v<
            std::is_trivially_destructible<typename VARTYPES::type>...>,
        "Unsupported variable type");
    static_assert(std::conjunction_v<std::is_trivially_assignable<
                      std::add_lvalue_reference_t<typename VARTYPES::type>,
                      typename VARTYPES::type>...>,
                  "Unsupported variable type");
 
public:
    using schema_type = schema<VARTYPES...>;
    using view_type = view<schema_type>;
    using size_type = typename view_type::size_type;
    using memory_type = unique_alloc_ptr<char[]>;
 
    buffer() = default;
    buffer(buffer&&) noexcept = default;
 
    buffer& operator=(buffer&&) noexcept = default;
 
    VECMEM_HOST
    buffer(
        size_type capacity, memory_resource& mr,
        vecmem::data::buffer_type type = vecmem::data::buffer_type::fixed_size);
 
    template <typename SIZE_TYPE = std::size_t,
              typename SIZE_ALLOC = std::allocator<SIZE_TYPE>,
              std::enable_if_t<std::is_integral_v<SIZE_TYPE> &&
                                   std::is_unsigned_v<SIZE_TYPE>,
                               bool> = true>
    VECMEM_HOST buffer(
        const std::vector<SIZE_TYPE, SIZE_ALLOC>& capacities,
        memory_resource& mr, memory_resource* host_mr = nullptr,
        vecmem::data::buffer_type type = vecmem::data::buffer_type::fixed_size);
 
private:
    template <typename SIZE_TYPE = std::size_t,
              typename SIZE_ALLOC = std::allocator<SIZE_TYPE>,
              std::size_t... INDICES>
    VECMEM_HOST void setup_fixed(
        const std::vector<SIZE_TYPE, SIZE_ALLOC>& capacities,
        memory_resource& mr, memory_resource* host_mr,
        std::index_sequence<INDICES...>);
    template <typename SIZE_TYPE = std::size_t,
              typename SIZE_ALLOC = std::allocator<SIZE_TYPE>,
              std::size_t... INDICES>
    VECMEM_HOST void setup_resizable(
        const std::vector<SIZE_TYPE, SIZE_ALLOC>& capacities,
        memory_resource& mr, memory_resource* host_mr,
        std::index_sequence<INDICES...>);
 
    memory_type m_memory;
    memory_type m_host_memory;
 
};  // class buffer
 
}  // namespace edm
 
template <typename... VARTYPES>
VECMEM_HOST edm::view<edm::schema<VARTYPES...>> get_data(
    edm::buffer<edm::schema<VARTYPES...>>& buffer);
 
template <typename... VARTYPES>
VECMEM_HOST edm::view<edm::details::add_const_t<edm::schema<VARTYPES...>>>
get_data(const edm::buffer<edm::schema<VARTYPES...>>& buffer);
 
}  // namespace vecmem
 
// Include the implementation.
#include "vecmem/edm/impl/buffer.ipp"