jagged_vector_buffer.hpp

/*
 * VecMem project, part of the ACTS project (R&D line)
 *
 * (c) 2021-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/containers/data/jagged_vector_view.hpp"
#include "vecmem/memory/memory_resource.hpp"
#include "vecmem/memory/unique_ptr.hpp"
 
// System include(s).
#include <cstddef>
#include <memory>
#include <type_traits>
#include <vector>
 
namespace vecmem {
namespace data {
 
template <typename TYPE>
class jagged_vector_buffer : public jagged_vector_view<TYPE> {
 
public:
    using base_type = jagged_vector_view<TYPE>;
    using size_type = typename base_type::size_type;
    using value_type = typename base_type::value_type;
    using pointer = typename base_type::pointer;
 
 
    static_assert(std::is_trivially_destructible<TYPE>::value,
                  "vecmem::data::jagged_vector_buffer can not handle types "
                  "with custom destructors");
    static_assert(std::is_trivially_destructible<value_type>::value,
                  "vecmem::data::jagged_vector_buffer can not handle types "
                  "with custom destructors");
 
 
    jagged_vector_buffer();
 
    template <typename OTHERTYPE,
              std::enable_if_t<std::is_convertible<TYPE, OTHERTYPE>::value,
                               bool> = true>
    jagged_vector_buffer(const jagged_vector_view<OTHERTYPE>& other,
                         memory_resource& resource,
                         memory_resource* host_access_resource = nullptr,
                         buffer_type type = buffer_type::fixed_size);
 
    template <typename SIZE_TYPE = std::size_t,
              std::enable_if_t<std::is_integral<SIZE_TYPE>::value &&
                                   std::is_unsigned<SIZE_TYPE>::value,
                               bool> = true>
    jagged_vector_buffer(const std::vector<SIZE_TYPE>& capacities,
                         memory_resource& resource,
                         memory_resource* host_access_resource = nullptr,
                         buffer_type type = buffer_type::fixed_size);
 
    jagged_vector_buffer(jagged_vector_buffer&&) noexcept = default;
 
    jagged_vector_buffer& operator=(jagged_vector_buffer&&) noexcept = default;
 
private:
    vecmem::unique_alloc_ptr<value_type[]> m_outer_memory;
    vecmem::unique_alloc_ptr<value_type[]> m_outer_host_memory;
    vecmem::unique_alloc_ptr<char[]> m_inner_memory;
 
};  // class jagged_vector_buffer
 
}  // namespace data
 
template <typename TYPE>
data::jagged_vector_view<TYPE>& get_data(
    data::jagged_vector_buffer<TYPE>& data);
 
template <typename TYPE>
const data::jagged_vector_view<TYPE>& get_data(
    const data::jagged_vector_buffer<TYPE>& data);
 
}  // namespace vecmem
 
// Include the implementation.
#include "vecmem/containers/impl/jagged_vector_buffer.ipp"