Registry.cpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2025
** rtype
** File description:
** Registry
*/
 
#include "Registry.hpp"
 
namespace ecs {
    Registry::Registry() : _nextAddress(1) {}
 
    Registry::~Registry() {
        _signatures.clear();
        _componentMap.clear();
        _componentStorage.clear();
    }
 
    Address Registry::_generateAddress() {
        // Note: This is called with the mutex already held by newEntity()
        // Reuse a freed address if available
        if (!_freeAddresses.empty()) {
            Address addr = _freeAddresses.top();
            _freeAddresses.pop();
            return addr;
        }
 
        // Otherwise, generate a new sequential address
        return _nextAddress++;
    }
 
    Signature Registry::_registerComponent(const ComponentType componentType) {
        Signature sign = 0;
 
        if (_componentMap.contains(componentType))
            return _componentMap[componentType];
 
        if (componentType >= N_MAX_COMPONENTS) {
            return sign;
        }
        sign.set(componentType);
        _componentMap[componentType] = sign;
 
        return sign;
    }
 
    Address Registry::newEntity() {
        std::unique_lock lock(_mutex);
        const Address addr = this->_generateAddress();
        Signature signature;
 
        _signatures[addr] = signature;
        return addr;
    }
 
    void Registry::destroyEntity(Address addr) {
        std::unique_lock lock(_mutex);
        // Remove from signatures
        _signatures.erase(addr);
 
        // Remove all components for this entity
        for (auto &[componentType, storage] : _componentStorage) {
            storage.erase(addr);
        }
 
        // Add address to the pool for reuse
        _freeAddresses.push(addr);
    }
 
    Signature Registry::getSignature(Address address) {
        std::shared_lock lock(_mutex);
        Signature sign = 0u;
        if (_signatures.contains(address)) {
            sign = _signatures[address];
        }
        return sign;
    }
 
    std::vector<Address> Registry::getEntitiesWithMask(Signature requiredMask) {
        std::shared_lock lock(_mutex);
        std::vector<Address> result;
 
        if (requiredMask == 0) {
            return result;
        }
 
        for (const auto &[address, signature] : _signatures) {
            if ((signature & requiredMask) == requiredMask) {
                result.push_back(address);
            }
        }
 
        return result;
    }
}  // namespace ecs