ComponentStorage.hpp

#pragma once
#include <vector>
#include <functional>
#include <cassert>
#include <cstddef>
#include "Types.hpp"
 
namespace vex {

template <typename T>
class ComponentStorage : public IComponentStorage {
private:
    std::vector<T> m_components;
    std::vector<Entity> m_indexToEntity;
    std::vector<size_t> m_entityToIndex;

    std::vector<std::function<void(Entity, T&)>> m_onCreate;
    std::vector<std::function<void(Entity, T&)>> m_onDestroy;
 
public:
    bool has(Entity entity) const {
        return entity < m_entityToIndex.size() && m_entityToIndex[entity] != static_cast<size_t>(-1);
    }

    template<typename... Args>
    T& add_or_replace(Entity entity, Args&&... args) {
        if (entity >= m_entityToIndex.size()) {
            m_entityToIndex.resize(entity + 1, static_cast<size_t>(-1));
        }
 
        if (has(entity)) {
            m_components[m_entityToIndex[entity]] = T{std::forward<Args>(args)...};
            return m_components[m_entityToIndex[entity]];
        }
 
        size_t newIndex = m_components.size();
        m_entityToIndex[entity] = newIndex;
        m_indexToEntity.push_back(entity);
        m_components.emplace_back(std::forward<Args>(args)...);
 
        T& component = m_components.back();
        for (auto& cb : m_onCreate) cb(entity, component);
 
        return component;
    }

    void remove(Entity entity) {
        if (!has(entity)) return;
 
        size_t indexOfRemoved = m_entityToIndex[entity];
        size_t indexOfLast = m_components.size() - 1;
 
        for (auto& cb : m_onDestroy) cb(entity, m_components[indexOfRemoved]);
 
        if (indexOfRemoved != indexOfLast) {
            Entity entityOfLast = m_indexToEntity[indexOfLast];
            m_components[indexOfRemoved] = std::move(m_components[indexOfLast]);
            m_indexToEntity[indexOfRemoved] = entityOfLast;
            m_entityToIndex[entityOfLast] = indexOfRemoved;
        }
 
        m_components.pop_back();
        m_indexToEntity.pop_back();
        m_entityToIndex[entity] = static_cast<size_t>(-1);
    }

    T& get(Entity entity) {
        assert(has(entity) && "Retrieving non-existent component.");
        return m_components[m_entityToIndex[entity]];
    }

    void entity_destroyed(Entity entity) override {
        remove(entity);
    }

    void on_create(std::function<void(Entity, T&)> cb) { m_onCreate.push_back(cb); }

    void on_destroy(std::function<void(Entity, T&)> cb) { m_onDestroy.push_back(cb); }

    const std::vector<Entity>& get_entities() const { return m_indexToEntity; }
};
 
}