ComponentPool.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <cstddef>
#include <vector>
 
#include "Core/Diagnostics/Assert.h"
#include "Core/Ecs/Entity.h"

 
namespace core {

class IComponentPool {
public:
    virtual ~IComponentPool() = default;

    virtual bool removeIfPresent(Entity entity) = 0;
};

template <typename T>
class ComponentPool : public IComponentPool {
public:
    static constexpr std::size_t INVALID_POSITION = ~std::size_t{0};

    void add(Entity entity, const T& component) {
        JADG_ASSERT(!has(entity), "L'entite possede deja ce composant.");
 
        ensureSparseSize(entity.index);
        _sparse[entity.index] = _components.size();
        _components.push_back(component);
        _entities.push_back(entity);
    }

    void remove(Entity entity) {
        JADG_ASSERT(has(entity), "L'entite ne possede pas ce composant.");
 
        const std::size_t removed = _sparse[entity.index];
        const std::size_t last = _components.size() - 1;
 
        // Swap-and-pop : on remonte le dernier élément à la place du supprimé
        // pour garder le tableau dense contigu, puis on met à jour le creux de
        // l'entité déplacée pour qu'il pointe vers sa nouvelle position.
        _components[removed] = _components[last];
        _entities[removed] = _entities[last];
        _sparse[_entities[removed].index] = removed;
 
        _components.pop_back();
        _entities.pop_back();
        _sparse[entity.index] = INVALID_POSITION;
    }

    bool removeIfPresent(Entity entity) override {
        if (!has(entity)) {
            return false;
        }
        remove(entity);
        return true;
    }

    [[nodiscard]] bool has(Entity entity) const {
        if (entity.index >= _sparse.size()) {
            return false;
        }
        const std::size_t position = _sparse[entity.index];
        // Position valide et pointant une entrée dont l'entité correspond
        // exactement (l'égalité inclut la génération : un handle périmé échoue).
        return position != INVALID_POSITION && _entities[position] == entity;
    }

    [[nodiscard]] T& get(Entity entity) {
        JADG_ASSERT(has(entity), "L'entite ne possede pas ce composant.");
        return _components[_sparse[entity.index]];
    }

    [[nodiscard]] const T& get(Entity entity) const {
        JADG_ASSERT(has(entity), "L'entite ne possede pas ce composant.");
        return _components[_sparse[entity.index]];
    }

    [[nodiscard]] std::size_t size() const {
        return _components.size();
    }

    [[nodiscard]] bool empty() const {
        return _components.empty();
    }

    [[nodiscard]] const std::vector<Entity>& entities() const {
        return _entities;
    }

    [[nodiscard]] const std::vector<T>& components() const {
        return _components;
    }
 
private:
    void ensureSparseSize(Entity::Index index) {
        if (index >= _sparse.size()) {
            _sparse.resize(static_cast<std::size_t>(index) + 1, INVALID_POSITION);
        }
    }

    std::vector<T> _components;
    std::vector<Entity> _entities;
    std::vector<std::size_t> _sparse;
};
 
}  // namespace core