static_array.hpp

/*
 * VecMem project, part of the ACTS project (R&D line)
 *
 * (c) 2021 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_array_traits.hpp"
#include "vecmem/utils/types.hpp"
 
// System include(s).
#include <cstddef>
#include <type_traits>
#include <utility>
 
namespace vecmem {
template <typename T, std::size_t N>
struct static_array {
 
 
    using value_type = T;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
 
    using reference = value_type &;
    using const_reference = const value_type &;
    using pointer = value_type *;
    using const_pointer = const 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
    constexpr reference at(size_type i);
 
    VECMEM_HOST
    constexpr const_reference at(size_type i) const;
 
    VECMEM_HOST_AND_DEVICE
    constexpr reference operator[](size_type i);
 
    VECMEM_HOST_AND_DEVICE
    constexpr const_reference operator[](size_type i) const;
 
    template <std::size_t I,
              std::enable_if_t<I<N, bool> = true>
                  VECMEM_HOST_AND_DEVICE constexpr reference get() noexcept;
 
    template <std::size_t I,
              std::enable_if_t<I<N, bool> = true>
                  VECMEM_HOST_AND_DEVICE constexpr const_reference get()
                      const noexcept;
 
    VECMEM_HOST_AND_DEVICE
    constexpr reference front(void);
 
    VECMEM_HOST_AND_DEVICE
    constexpr const_reference front(void) const;
 
    VECMEM_HOST_AND_DEVICE
    constexpr reference back(void);
 
    VECMEM_HOST_AND_DEVICE
    constexpr const_reference back(void) const;
 
    VECMEM_HOST_AND_DEVICE
    constexpr pointer data(void);
 
    VECMEM_HOST_AND_DEVICE
    constexpr const_pointer data(void) const;
 
 
 
    VECMEM_HOST_AND_DEVICE
    constexpr iterator begin();
    VECMEM_HOST_AND_DEVICE
    constexpr const_iterator begin() const;
    VECMEM_HOST_AND_DEVICE
    constexpr const_iterator cbegin() const;
 
    VECMEM_HOST_AND_DEVICE
    constexpr iterator end();
    VECMEM_HOST_AND_DEVICE
    constexpr const_iterator end() const;
    VECMEM_HOST_AND_DEVICE
    constexpr const_iterator cend() const;
 
    VECMEM_HOST_AND_DEVICE
    constexpr reverse_iterator rbegin();
    VECMEM_HOST_AND_DEVICE
    constexpr const_reverse_iterator rbegin() const;
    VECMEM_HOST_AND_DEVICE
    constexpr const_reverse_iterator crbegin() const;
 
    VECMEM_HOST_AND_DEVICE
    constexpr reverse_iterator rend();
    VECMEM_HOST_AND_DEVICE
    constexpr const_reverse_iterator rend() const;
    VECMEM_HOST_AND_DEVICE
    constexpr const_reverse_iterator crend() const;
 
 
 
    VECMEM_HOST_AND_DEVICE
    constexpr bool empty() const;
    VECMEM_HOST_AND_DEVICE
    constexpr size_type size() const;
    VECMEM_HOST_AND_DEVICE
    constexpr size_type max_size() const;
 
 
 
    VECMEM_HOST_AND_DEVICE
    void fill(const_reference value);
 
 
    typename details::static_array_type<T, N>::type m_array;
 
};  // struct static_array
 
template <typename T, std::size_t N>
VECMEM_HOST_AND_DEVICE bool operator==(const static_array<T, N> &lhs,
                                       const static_array<T, N> &rhs);
template <typename T, std::size_t N>
VECMEM_HOST_AND_DEVICE bool operator!=(const static_array<T, N> &lhs,
                                       const static_array<T, N> &rhs);
 
template <std::size_t I, class T, std::size_t N,
          std::enable_if_t<I<N, bool> = true> VECMEM_HOST_AND_DEVICE constexpr T
              &get(static_array<T, N> &a) noexcept;
template <std::size_t I, class T, std::size_t N,
          std::enable_if_t<I<N, bool> = true>
              VECMEM_HOST_AND_DEVICE constexpr const T &get(
                  const static_array<T, N> &a) noexcept;
 
}  // namespace vecmem
 
// Include the implementation.
#include "impl/static_array.ipp"