array.hpp

/* VecMem project, part of the ACTS project (R&D line)
 *
 * (c) 2021-2024 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/memory_resource.hpp"
#include "vecmem/memory/unique_ptr.hpp"
#include "vecmem/utils/types.hpp"
 
// System include(s).
#include <cstddef>
#include <memory>
#include <type_traits>
 
namespace vecmem {
 
namespace details {
static constexpr std::size_t array_invalid_size = static_cast<std::size_t>(-1);
}  // namespace details
 
template <typename T, std::size_t N = details::array_invalid_size>
class array {
 
public:
 
    typedef T value_type;
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;
 
    typedef value_type& reference;
    typedef const value_type& const_reference;
 
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
 
    typedef pointer iterator;
    typedef const_pointer const_iterator;
 
    typedef vecmem::details::reverse_iterator<iterator> reverse_iterator;
    typedef vecmem::details::reverse_iterator<const_iterator>
        const_reverse_iterator;
 
 
 
    static_assert(std::is_default_constructible<value_type>::value,
                  "vecmem::array can only handle default-constructible "
                  "types");
 
 
    explicit array(memory_resource& resource);
 
    array(memory_resource& resource, size_type size);
 
    ~array() = default;
 
 
    reference at(size_type pos);
    const_reference at(size_type pos) const;
 
    reference operator[](size_type pos);
    const_reference operator[](size_type pos) const;
 
    reference front();
    const_reference front() const;
 
    reference back();
    const_reference back() const;
 
    pointer data();
    const_pointer data() const;
 
 
 
    iterator begin();
    const_iterator begin() const;
    const_iterator cbegin() const;
 
    iterator end();
    const_iterator end() const;
    const_iterator cend() const;
 
    reverse_iterator rbegin();
    const_reverse_iterator rbegin() const;
    const_reverse_iterator crbegin() const;
 
    reverse_iterator rend();
    const_reverse_iterator rend() const;
    const_reverse_iterator crend() const;
 
 
 
    bool empty() const noexcept;
    size_type size() const noexcept;
 
 
 
    void fill(const_reference value);
 
 
private:
    size_type m_size;
    vecmem::unique_obj_ptr<value_type[]> m_memory;
 
};  // class array
 
template <typename T, std::size_t N>
VECMEM_HOST data::vector_view<T> get_data(array<T, N>& a);
 
template <typename T, std::size_t N>
VECMEM_HOST data::vector_view<const T> get_data(const array<T, N>& a);
 
}  // namespace vecmem
 
// Include the implementation.
#include "vecmem/containers/impl/array.ipp"