Class Array

include/rabitqlib/utils/array.hpp:47–129

    typename Dims = std::vector<size_t>,
    typename Alloc = memory::Allocator<T>>
class Array {
   private:
    static_assert(std::is_trivial_v<T>);  // only handle trivial types

    /// @brief num of data objects
    [[nodiscard]] constexpr auto size() const -> size_t { return array_impl::size(dims_); }

    /// @brief num of bytes for all data objects
    [[nodiscard]] constexpr auto bytes() const -> size_t { return sizeof(T) * size(); }

    void destroy() {
        size_t num_elements = size();
        atraits::deallocate(allocator_, pointer_, num_elements);
        pointer_ = nullptr;
    }

   public:
    using allocator_type = Alloc;
    using atraits = std::allocator_traits<allocator_type>;
    using pointer = typename atraits::pointer;
    using const_pointer = typename atraits::const_pointer;

    using value_type = T;
    using reference = T&;
    using const_reference = const T&;

    Array() = default;

    explicit Array(Dims dims, const Alloc& allocator)
        : dims_(std::move(dims)), allocator_(allocator) {
        size_t num_elements = size();
        pointer_ = atraits::allocate(allocator_, num_elements);
    }

    explicit Array(Dims dims) : Array(std::move(dims), Alloc()) {}

    ~Array() noexcept {
        if (pointer_ != nullptr) {
            destroy();
        }
    }

    /// @brief move constructor
    Array(Array&& other) noexcept
        : pointer_{std::exchange(other.pointer_, nullptr)}
        , dims_{std::move(other.dims_)}
        , allocator_{std::move(other.allocator_)} {}

    Array& operator=(Array&& other) noexcept {
        if (pointer_ != nullptr) {
            destroy();
        }

        if constexpr (atraits::propagate_on_container_move_assignment::value) {
            allocator_ = std::move(other.allocator_);
        }
        dims_ = std::exchange(other.dims_, Dims());
        pointer_ = std::exchange(other.pointer_, nullptr);