DenseArray.hpp

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <optional>
#include <memory>
#include <cassert>
#include <algorithm>
 
template <typename Component, typename Allocator = std::allocator<Component>>
class DenseArray {
public:
    using value_type = Component; 
    using optional_t = std::optional<Component>; 
    using reference_type = optional_t&; 
    using const_reference_type = const optional_t&; 
    using id_type = std::size_t; 
    using id_container_t = std::vector<id_type>; 
    using component_container_t = std::vector<optional_t, Allocator>; 
    using size_type = typename component_container_t::size_type; 
    using iterator = typename component_container_t::iterator; 
    using const_iterator = typename component_container_t::const_iterator; 
    DenseArray() = default;
 
    DenseArray(const DenseArray& other) = default;
 
    DenseArray(DenseArray&& other) noexcept = default;
 
    ~DenseArray() = default;
 
    DenseArray& operator=(const DenseArray& other) = default;
 
    DenseArray& operator=(DenseArray&& other) noexcept = default;
 
    reference_type operator[](size_type idx) {
        assert(idx < _components.size() && "Index out of bounds");
        return _components[idx];
    }
 
    const_reference_type operator[](size_type idx) const {
        return _components[idx];
    }
 
    iterator begin() {
        return _components.begin();
    }
 
    const_iterator begin() const {
        return _components.begin();
    }
 
    const_iterator cbegin() const {
        return _components.cbegin();
    }
 
    iterator end() {
        return _components.end();
    }
 
    const_iterator end() const {
        return _components.end();
    }
 
    const_iterator cend() const {
        return _components.cend();
    }
 
    size_type size() const {
        return _components.size();
    }
 
    void insert_at(size_type id, const Component& component) {
        ensure_size(id);
        _ids.push_back(id);
        _components.push_back(component);
    }
 
    void insert_at(size_type id, Component&& component) {
        ensure_size(id);
        _ids.push_back(id);
        _components[id] = std::move(component);
    }
 
    template <typename... Params>
    void emplace_at(size_type id, Params&&... params) {
        ensure_size(id);
        _ids.push_back(id);
        _components.emplace_back(std::forward<Params>(params)...);
    }
 
    void erase(size_type id) {
        _ids.erase(_ids.begin() + id);
        _components.erase(_components.begin() + id);
    }
 
private:
    void ensure_size(size_type pos) {
        if (pos >= _components.size()) {
            _ids.resize(pos + 1);
            _components.resize(pos + 1);
        }
    }
 
    id_container_t _ids; 
    component_container_t _components; 
    Allocator _allocator; 
};