SparseArray.hpp

Go to the documentation of this file.

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