view.hpp

/* VecMem project, part of the ACTS project (R&D line)
 *
 * (c) 2023 CERN for the benefit of the ACTS project
 *
 * Mozilla Public License Version 2.0
 */
#pragma once
 
// Local include(s).
#include "vecmem/containers/data/vector_view.hpp"
#include "vecmem/edm/details/types.hpp"
#include "vecmem/edm/details/view_traits.hpp"
#include "vecmem/edm/schema.hpp"
#include "vecmem/utils/tuple.hpp"
#include "vecmem/utils/type_traits.hpp"
#include "vecmem/utils/types.hpp"
 
// System include(s).
#include <type_traits>
 
namespace vecmem {
 
namespace edm {
 
template <typename T>
class view;
 
template <typename... VARTYPES>
class view<schema<VARTYPES...>> {
 
    // Sanity check(s).
    static_assert(sizeof...(VARTYPES) > 0,
                  "SoA containers without variables are not supported.");
 
public:
    using schema_type = schema<VARTYPES...>;
    using size_type = details::size_type;
    using size_pointer = std::conditional_t<
        vecmem::details::disjunction_v<std::is_const<
            typename details::view_type<VARTYPES>::payload_type>...>,
        details::const_size_pointer, details::size_pointer>;
    using const_size_pointer = details::const_size_pointer;
    using tuple_type = tuple<typename details::view_type<VARTYPES>::type...>;
    using memory_view_type = std::conditional_t<
        vecmem::details::disjunction_v<std::is_const<
            typename details::view_type<VARTYPES>::payload_type>...>,
        details::const_memory_view, details::memory_view>;
 
 
    view() = default;
 
    VECMEM_HOST_AND_DEVICE
    view(size_type capacity, const memory_view_type& size = {0u, nullptr});
 
    template <
        typename... OTHERTYPES,
        std::enable_if_t<
            vecmem::details::conjunction_v<std::is_constructible<
                typename details::view_type<VARTYPES>::type,
                typename details::view_type<OTHERTYPES>::type>...> &&
                vecmem::details::disjunction_v<
                    vecmem::details::negation<std::is_same<
                        typename details::view_type<VARTYPES>::type,
                        typename details::view_type<OTHERTYPES>::type>>...>,
            bool> = true>
    VECMEM_HOST_AND_DEVICE view(const view<schema<OTHERTYPES...>>& other);
 
    template <
        typename... OTHERTYPES,
        std::enable_if_t<
            vecmem::details::conjunction_v<std::is_constructible<
                typename details::view_type<VARTYPES>::type,
                typename details::view_type<OTHERTYPES>::type>...> &&
                vecmem::details::disjunction_v<
                    vecmem::details::negation<std::is_same<
                        typename details::view_type<VARTYPES>::type,
                        typename details::view_type<OTHERTYPES>::type>>...>,
            bool> = true>
    VECMEM_HOST_AND_DEVICE view& operator=(
        const view<schema<OTHERTYPES...>>& rhs);
 
 
 
    VECMEM_HOST_AND_DEVICE
    size_type capacity() const;
 
    template <std::size_t INDEX>
    VECMEM_HOST_AND_DEVICE tuple_element_t<INDEX, tuple_type>& get();
    template <std::size_t INDEX>
    VECMEM_HOST_AND_DEVICE const tuple_element_t<INDEX, tuple_type>& get()
        const;
 
 
 
    VECMEM_HOST_AND_DEVICE
    tuple_type& variables();
    VECMEM_HOST_AND_DEVICE
    const tuple_type& variables() const;
 
    VECMEM_HOST_AND_DEVICE
    const memory_view_type& size() const;
 
    VECMEM_HOST_AND_DEVICE
    const memory_view_type& payload() const;
 
    VECMEM_HOST_AND_DEVICE
    const memory_view_type& layout() const;
    VECMEM_HOST_AND_DEVICE
    const memory_view_type& host_layout() const;
 
 
protected:
    size_type m_capacity;
    tuple_type m_views;
 
    memory_view_type m_size;
 
    memory_view_type m_payload;
 
    memory_view_type m_layout;
    memory_view_type m_host_layout;
 
};  // class view
 
}  // namespace edm
}  // namespace vecmem
 
// Include the implementation.
#include "vecmem/edm/impl/view.ipp"