Class Array

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

            throw std::bad_array_new_length();
        }
        res *= cur_d;
    }
    return res;
}
}  // namespace array_impl

template <
    typename T,
    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 {
        const size_t num_elements = size();
        if (num_elements > std::numeric_limits<size_t>::max() / sizeof(T)) {
            throw std::bad_array_new_length();
        }
        return sizeof(T) * num_elements;
    }

    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();
        }
    }