ComponentContainer.hpp

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <optional>
#include <variant>
#include <memory>
#include <cassert>
#include <algorithm>
 
#include "DenseArray.hpp"
#include "SparseArray.hpp"
 
template <typename Component, typename Allocator = std::allocator<Component>>
class ComponentContainer {
public:
    using value_type = Component; 
    using optional_t = std::optional<Component>; 
    using sparse_storage_t = SparseArray<Component, Allocator>; 
    using dense_storage_t = DenseArray<Component, Allocator>; 
    using size_type = typename sparse_storage_t::size_type; 
    using reference = optional_t&; 
    using const_reference = const optional_t&; 
    using iterator = typename std::vector<optional_t, Allocator>::iterator; 
    using const_iterator = typename std::vector<optional_t, Allocator>::const_iterator; 
    ComponentContainer() : _storage(sparse_storage_t()) {}
 
    reference operator[](size_t idx) {
        return std::visit([&](auto& storage) -> reference { return storage[idx]; }, _storage);
    }
 
    const_reference operator[](size_t idx) const {
        return std::visit([&](auto const& storage) -> const_reference { return storage[idx]; }, _storage);
    }
 
    iterator begin() {
        if (std::holds_alternative<sparse_storage_t>(_storage)) {
            auto& sparse = std::get<sparse_storage_t>(_storage);
            return sparse.begin();
        } else {
            auto& dense = std::get<dense_storage_t>(_storage);
            return dense.begin();
        }
    }
 
    const_iterator begin() const {
        if (std::holds_alternative<sparse_storage_t>(_storage)) {
            auto& sparse = std::get<sparse_storage_t>(_storage);
            return sparse.begin();
        } else {
            auto& dense = std::get<dense_storage_t>(_storage);
            return dense.begin();
        }
    }
 
    const_iterator cbegin() const {
        if (std::holds_alternative<sparse_storage_t>(_storage)) {
            auto& sparse = std::get<sparse_storage_t>(_storage);
            return sparse.cbegin();
        } else {
            auto& dense = std::get<dense_storage_t>(_storage);
            return dense.cbegin();
        }
    }
 
    iterator end() {
        if (std::holds_alternative<sparse_storage_t>(_storage)) {
            auto& sparse = std::get<sparse_storage_t>(_storage);
            return sparse.end();
        } else {
            auto& dense = std::get<dense_storage_t>(_storage);
            return dense.end();
        }
    }
 
    const_iterator end() const {
        if (std::holds_alternative<sparse_storage_t>(_storage)) {
            auto& sparse = std::get<sparse_storage_t>(_storage);
            return sparse.end();
        } else {
            auto& dense = std::get<dense_storage_t>(_storage);
            return dense.end();
        }
    }
 
    const_iterator cend() const {
        if (std::holds_alternative<sparse_storage_t>(_storage)) {
            auto& sparse = std::get<sparse_storage_t>(_storage);
            return sparse.cend();
        } else {
            auto& dense = std::get<dense_storage_t>(_storage);
            return dense.cend();
        }
    }
 
    size_type size() const {
        if (std::holds_alternative<sparse_storage_t>(_storage)) {
            auto& sparse = std::get<sparse_storage_t>(_storage);
            return sparse.size();
        } else {
            auto& dense = std::get<dense_storage_t>(_storage);
            return dense.size();
        }
    }
 
    void insert_at(size_type id, const Component& component) {
        if (std::holds_alternative<sparse_storage_t>(_storage)) {
            auto& sparse = std::get<sparse_storage_t>(_storage);
            sparse.insert_at(id, component);
        } else {
            auto& dense = std::get<dense_storage_t>(_storage);
            dense.insert_at(id, component);
        }
    }
 
    void insert_at(size_type id, Component&& component) {
        if (std::holds_alternative<sparse_storage_t>(_storage)) {
            auto& sparse = std::get<sparse_storage_t>(_storage);
            sparse.insert_at(id, std::forward<Component>(component));
        } else {
            auto& dense = std::get<dense_storage_t>(_storage);
            dense.insert_at(id, std::forward<Component>(component));
        }
    }
 
    template <typename... Params>
    void emplace_at(size_type id, Params&&... params) {
        if (std::holds_alternative<sparse_storage_t>(_storage)) {
            auto& sparse = std::get<sparse_storage_t>(_storage);
            if (id >= sparse.size()) {
                sparse.resize(id + 1);
            }
 
            sparse[id].emplace(std::forward<Params>(params)...);
        } else {
            auto& dense = std::get<dense_storage_t>(_storage);
            
            dense.emplace_at(id, std::forward<Params>(params)...);
        }
    }
 
    std::optional<Component> get(const value_type& id) const {
        if (std::holds_alternative<sparse_storage_t>(_storage)) {
            const auto& sparse = std::get<sparse_storage_t>(_storage);
            if (id < sparse.size()) {
                return sparse[id];
            }
        } else {
            const auto& dense = std::get<dense_storage_t>(_storage);
             if (id < dense.size()) {
                return dense[id];
            }
        }
        return std::nullopt;
    }
 
    void erase(size_type id) {
        if (std::holds_alternative<sparse_storage_t>(_storage)) {
            auto& sparse = std::get<sparse_storage_t>(_storage);
            if (id < sparse.size()) {
                sparse[id].reset();
            }
        } else {
            auto& dense = std::get<dense_storage_t>(_storage);
            if (id < dense.size()) {
                dense.erase(id);
            }
        }
    }
 
    void resize(size_type new_size) {
        if (std::holds_alternative<sparse_storage_t>(_storage)) {
            auto& sparse = std::get<sparse_storage_t>(_storage);
            sparse.resize(new_size);
        }
    }
 
    void optimize_storage(size_type sparse_threshold, size_type dense_threshold) {
        if (std::holds_alternative<sparse_storage_t>(_storage)) {
            auto& sparse = std::get<sparse_storage_t>(_storage);
            size_type filled = std::count_if(sparse.begin(), sparse.end(), [](const auto& opt) { return opt.has_value(); });
            if (filled >= dense_threshold) {
                dense_storage_t dense;
                migrate_storage(dense);
                _storage = std::move(dense);
            }
        } else {
            auto& dense = std::get<dense_storage_t>(_storage);
            if (dense.size() <= sparse_threshold) {
                sparse_storage_t sparse;
                migrate_storage(sparse);
                _storage = std::move(sparse);
            }
        }
    }
 
private:
    using ComponentStorage = std::variant<sparse_storage_t, dense_storage_t>;
    ComponentStorage _storage; 
    template <typename NewContainer>
    void migrate_storage(NewContainer& new_storage) {
         if (std::holds_alternative<sparse_storage_t>(_storage)) {
            const auto& sparse = std::get<sparse_storage_t>(_storage);
            for (size_type i = 0; i < sparse.size(); ++i) {
                if (sparse[i]) {
                    new_storage.insert_at(i, *sparse[i]);
                }
            }
        } else {
            const auto& dense = std::get<dense_storage_t>(_storage);
            size_type max_id = *std::max_element(dense.begin(), dense.end());
            new_storage.resize(max_id + 1);
            for (size_type i = 0; i < dense.size(); ++i) {
                new_storage[i] = dense[i];
            }
        }
    }
};