static_vector.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/details/reverse_iterator.hpp"
#include "vecmem/containers/details/static_vector_traits.hpp"
#include "vecmem/utils/type_traits.hpp"
#include "vecmem/utils/types.hpp"
 
// System include(s).
#include <cstddef>
#include <type_traits>
 
namespace vecmem {
 
template <typename TYPE, std::size_t MAX_SIZE>
class static_vector {
 
public:
 
    static_assert(std::is_trivially_copyable<TYPE>::value,
                  "The type of the static vector needs to be trivially "
                  "copyable.");
    static_assert(std::is_trivially_destructible<TYPE>::value,
                  "The type of the static vector needs to be trivially "
                  "destructible.");
 
 
 
    using value_type = TYPE;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
 
    static constexpr size_type array_max_size = MAX_SIZE;
    static constexpr size_type value_size = sizeof(value_type);
    using array_type =
        typename details::static_vector_type<char,
                                             array_max_size * value_size>::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
    static_vector();
    VECMEM_HOST_AND_DEVICE
    explicit static_vector(size_type size,
                           const_reference value = value_type());
    template <
        typename InputIt,
        std::enable_if_t<details::is_iterator_of<InputIt, value_type>::value,
                         bool> = true>
    VECMEM_HOST_AND_DEVICE static_vector(InputIt other_begin, InputIt other_end)
        : m_size(0), m_elements() {
 
        assign<InputIt>(other_begin, other_end);
    }
    static_vector(const static_vector&) = default;
    static_vector(static_vector&&) noexcept = default;
 
    ~static_vector() = default;
 
    static_vector& operator=(const static_vector&) = default;
    static_vector& operator=(static_vector&&) noexcept = default;
 
 
 
    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) {
 
        // 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
        for (InputIt itr = other_begin; itr != other_end; ++itr) {
            construct(m_size, *itr);
            ++m_size;
        }
    }
 
    VECMEM_HOST_AND_DEVICE
    iterator insert(const_iterator pos, const_reference value);
    VECMEM_HOST_AND_DEVICE
    iterator insert(const_iterator pos, size_type count, const_reference value);
    template <
        typename InputIt,
        std::enable_if_t<details::is_iterator_of<InputIt, value_type>::value,
                         bool> = true>
    iterator insert(const_iterator pos, InputIt other_begin,
                    InputIt other_end) {
 
        // Find the index of this iterator inside of the vector.
        auto id = element_id(pos);
 
        // Insert 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.
        const_iterator self_itr = pos;
        for (InputIt other_itr = other_begin; other_itr != other_end;
             ++other_itr, ++self_itr) {
            insert(self_itr, *other_itr);
        }
 
        // Return an iterator to the first inserted element.
        return id.m_ptr;
    }
 
    template <typename... Args>
    VECMEM_HOST_AND_DEVICE iterator emplace(const_iterator pos, Args&&... args);
    template <typename... Args>
    VECMEM_HOST_AND_DEVICE reference emplace_back(Args&&... args);
 
    VECMEM_HOST_AND_DEVICE
    void push_back(const_reference value);
 
    VECMEM_HOST_AND_DEVICE
    iterator erase(const_iterator pos);
    VECMEM_HOST_AND_DEVICE
    iterator erase(const_iterator first, const_iterator last);
    VECMEM_HOST_AND_DEVICE
    void pop_back();
 
    VECMEM_HOST_AND_DEVICE
    void clear();
    VECMEM_HOST_AND_DEVICE
    void resize(std::size_t new_size);
    VECMEM_HOST_AND_DEVICE
    void resize(std::size_t new_size, const_reference value);
 
 
 
    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;
    VECMEM_HOST_AND_DEVICE
    void reserve(size_type new_cap);
 
 
private:
    VECMEM_HOST_AND_DEVICE
    void construct(size_type pos, const_reference value);
 
    struct ElementId {
        size_type m_index;
        pointer m_ptr;
    };  // struct ElementId
    VECMEM_HOST_AND_DEVICE
    ElementId element_id(const_iterator pos);
 
    size_type m_size;
    array_type m_elements;
 
};  // class static_vector
 
}  // namespace vecmem
 
// Include the implementation.
#include "vecmem/containers/impl/static_vector.ipp"