device_vector.hpp

/* VecMem project, part of the ACTS project (R&D line)
 *
 * (c) 2021-2026 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/containers/details/reverse_iterator.hpp"
#include "vecmem/memory/device_atomic_ref.hpp"
#include "vecmem/utils/type_traits.hpp"
#include "vecmem/utils/types.hpp"
 
// System include(s).
#include <cstddef>
#include <type_traits>
 
namespace vecmem {
 
// Forward declaration(s).
namespace edm {
template <typename T, template <typename> class I>
class device;
}
 
template <typename TYPE>
class device_vector {
 
    // Make other specializations of the class a friend of this class.
    template <typename OTHERTYPE>
    friend class device_vector;
    // Make @c vecmem::edm::device a friend of this class.
    template <typename T, template <typename> class I>
    friend class edm::device;
 
public:
 
    using value_type = TYPE;
    using size_type = unsigned int;
    using difference_type = std::ptrdiff_t;
 
    using size_pointer =
        typename std::conditional<std::is_const<TYPE>::value, const size_type*,
                                  size_type*>::type;
 
    using reference = std::add_lvalue_reference_t<value_type>;
    using const_reference =
        std::add_lvalue_reference_t<std::add_const_t<value_type>>;
    using pointer = std::add_pointer_t<value_type>;
    using const_pointer = std::add_pointer_t<std::add_const_t<value_type>>;
 
    using iterator = pointer;
    using const_iterator = const_pointer;
    using reverse_iterator = vecmem::details::reverse_iterator<iterator>;
    using const_reverse_iterator =
        vecmem::details::reverse_iterator<const_iterator>;
 
 
    VECMEM_HOST_AND_DEVICE
    explicit device_vector(const data::vector_view<value_type>& data);
    device_vector(const device_vector& parent) = default;
    template <typename OTHERTYPE,
              std::enable_if_t<details::is_same_nc<TYPE, OTHERTYPE>::value,
                               bool> = true>
    VECMEM_HOST_AND_DEVICE device_vector(
        const device_vector<OTHERTYPE>& parent);
 
    VECMEM_HOST_AND_DEVICE device_vector& operator=(const device_vector& rhs);
 
    template <typename OTHERTYPE,
              std::enable_if_t<std::is_convertible<OTHERTYPE, TYPE>::value,
                               bool> = true>
    VECMEM_HOST_AND_DEVICE device_vector& operator=(
        const device_vector<OTHERTYPE>& rhs);
 
 
    VECMEM_HOST_AND_DEVICE
    reference at(size_type pos);
    VECMEM_HOST_AND_DEVICE
    const_reference at(size_type pos) const;
 
    VECMEM_HOST_AND_DEVICE
    reference operator[](size_type pos);
    VECMEM_HOST_AND_DEVICE
    const_reference operator[](size_type pos) const;
 
    VECMEM_HOST_AND_DEVICE
    reference front();
    VECMEM_HOST_AND_DEVICE
    const_reference front() const;
 
    VECMEM_HOST_AND_DEVICE
    reference back();
    VECMEM_HOST_AND_DEVICE
    const_reference back() const;
 
    VECMEM_HOST_AND_DEVICE
    pointer data();
    VECMEM_HOST_AND_DEVICE
    const_pointer data() const;
 
 
 
    VECMEM_HOST_AND_DEVICE
    void assign(size_type count, const_reference value);
    template <
        typename InputIt,
        std::enable_if_t<details::is_iterator_of<InputIt, value_type>::value,
                         bool> = true>
    VECMEM_HOST_AND_DEVICE void assign(InputIt other_begin, InputIt other_end) {
 
        // This can only be done on a resizable vector.
        assert(m_size != nullptr);
 
        // Remove all previous elements.
        clear();
 
        // Create copies of all of the elements one-by-one. It's very
        // inefficient, but we can't make any assumptions about the type of the
        // input iterator received by this function.
        device_atomic_ref<size_type> asize(*m_size);
        for (InputIt itr = other_begin; itr != other_end; ++itr) {
            construct(asize.fetch_add(1), *itr);
        }
    }
 
    template <typename... Args>
    VECMEM_HOST_AND_DEVICE reference emplace_back(Args&&... args);
    VECMEM_HOST_AND_DEVICE
    size_type push_back(const_reference value);
 
    VECMEM_HOST_AND_DEVICE size_type bulk_append(size_type n);
 
    VECMEM_HOST_AND_DEVICE size_type bulk_append(size_type n,
                                                 const_reference v);
 
    VECMEM_HOST_AND_DEVICE size_type bulk_append_implicit(size_type n);
 
    VECMEM_HOST_AND_DEVICE size_type bulk_append_implicit_unsafe(size_type n);
 
    VECMEM_HOST_AND_DEVICE
    size_type pop_back();
 
    VECMEM_HOST_AND_DEVICE
    void clear();
    VECMEM_HOST_AND_DEVICE
    void resize(size_type new_size);
    VECMEM_HOST_AND_DEVICE
    void resize(size_type new_size, const_reference value);
 
    VECMEM_HOST_AND_DEVICE void resize_implicit(size_type new_size);
 
    VECMEM_HOST_AND_DEVICE void resize_implicit_unsafe(size_type new_size);
 
 
 
    VECMEM_HOST_AND_DEVICE
    iterator begin();
    VECMEM_HOST_AND_DEVICE
    const_iterator begin() const;
    VECMEM_HOST_AND_DEVICE
    const_iterator cbegin() const;
 
    VECMEM_HOST_AND_DEVICE
    iterator end();
    VECMEM_HOST_AND_DEVICE
    const_iterator end() const;
    VECMEM_HOST_AND_DEVICE
    const_iterator cend() const;
 
    VECMEM_HOST_AND_DEVICE
    reverse_iterator rbegin();
    VECMEM_HOST_AND_DEVICE
    const_reverse_iterator rbegin() const;
    VECMEM_HOST_AND_DEVICE
    const_reverse_iterator crbegin() const;
 
    VECMEM_HOST_AND_DEVICE
    reverse_iterator rend();
    VECMEM_HOST_AND_DEVICE
    const_reverse_iterator rend() const;
    VECMEM_HOST_AND_DEVICE
    const_reverse_iterator crend() const;
 
 
 
    VECMEM_HOST_AND_DEVICE
    bool empty() const;
    VECMEM_HOST_AND_DEVICE
    size_type size() const;
    VECMEM_HOST_AND_DEVICE
    size_type max_size() const;
    VECMEM_HOST_AND_DEVICE
    size_type capacity() const;
 
 
private:
    VECMEM_HOST_AND_DEVICE
    void construct(size_type pos, const_reference value);
    VECMEM_HOST_AND_DEVICE
    void destruct(size_type pos);
 
    size_type m_capacity;
    size_pointer m_size;
    pointer m_ptr;
 
};  // class device_vector
 
}  // namespace vecmem
 
// Include the implementation.
#include "vecmem/containers/impl/device_vector.ipp"