.. _program_listing_file_PrismEngine_src_componentManager.h:

Program Listing for File componentManager.h
===========================================

|exhale_lsh| :ref:`Return to documentation for file <file_PrismEngine_src_componentManager.h>` (``PrismEngine/src/componentManager.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   #include "entity.h"
   #include <unordered_map>
   #include <set>
   #include <typeindex>
   #include <memory>
   #include <algorithm>
   #include <iterator>
   #include <vector>
   
   namespace prism {
       namespace scene {
           class ComponentManager
           {
           public:
               ComponentManager() = default;
   
               template<typename T>
               bool addComponent(Entity entityId, T&& component) {
                  auto& storage = getComponentStorage<std::decay_t<T>>();
                   storage.addComponent(entityId, std::forward<T>(component));
                   return true;
               }
   
               template<typename T>
               bool removeComponent(Entity entityId) {
                   ComponentStorage<T>& storage = getComponentStorage<T>();
                   return storage.removeComponent(entityId);
               }
   
               template<typename T>
               bool hasComponent(Entity entityId) const {
                   const ComponentStorage<T>* storage = getComponentStorageConst<T>();
                   return storage ? storage->hasComponent(entityId) : false;
               }
   
               template<typename T>
               T* getComponent(Entity entityId) {
                   ComponentStorage<T>& storage = getComponentStorage<T>();
                   return storage.getComponent(entityId);
               }
   
               template<typename T>
               const std::vector<Entity>& getEntitiesWith() const {
                   static const std::vector<Entity> empty;
                   const ComponentStorage<T>* storage = getComponentStorageConst<T>();
                   return storage ? storage->entities : empty;
               }
   
               template<typename T>
               struct StorageView {
                   const std::vector<T>& components; 
                   const std::vector<Entity>& entities; 
               };
   
               template<typename T>
               StorageView<T> view() const {
                   const auto* storage = getComponentStorageConst<T>();
                   if (storage) {
                       return { storage->components, storage->entities };
                   }
                   else {
                       static const std::vector<T> emptyComp;
                       static const std::vector<Entity> emptyEnt;
                       return { emptyComp, emptyEnt };
                   }
               }
   
               template<typename... ComponentTypes>
               std::vector<Entity> getEntitiesWithAll() const {
                   if constexpr (sizeof...(ComponentTypes) == 0) return {};
                   else {
                       // Собираем векторы сущностей для каждого типа
                       std::vector<const std::vector<Entity>*> entityVectors;
                       (entityVectors.push_back(&getEntitiesWith<ComponentTypes>()), ...);
   
                       // Выбираем самый маленький вектор для итерации
                       auto smallestIt = std::min_element(entityVectors.begin(), entityVectors.end(),
                           [](const auto* a, const auto* b) { return a->size() < b->size(); });
                       const auto& smallestVec = **smallestIt;
   
                       std::vector<Entity> result;
                       result.reserve(smallestVec.size());
                       for (Entity e : smallestVec) {
                           if ((hasComponent<ComponentTypes>(e) && ...)) {
                               result.push_back(e);
                           }
                       }
                       return result;
                   }
               }
   
               void removeAllComponents(Entity entityId);
   
           private:
               struct IComponentStorage {
                   virtual ~IComponentStorage() = default;
   
                   virtual void removeEntity(Entity entityId) = 0;
               };
   
               template<typename T>
               struct ComponentStorage : public IComponentStorage {
                   std::vector<T> components;
   
                   // @brief Сущности, соответствующие компонентам
                   std::vector<Entity> entities;
   
                   // @brief Позиция в массивах
                   std::unordered_map<Entity, size_t> entityToIndex;
   
                   template<typename U>
                   void addComponent(Entity entity, U&& component) {
                       auto it = entityToIndex.find(entity);
                       if (it != entityToIndex.end()) {
                           components[it->second] = std::forward<U>(component);
                           return;
                       }
                       size_t index = components.size();
                       components.push_back(std::forward<U>(component));
                       entities.push_back(entity);
                       entityToIndex[entity] = index;
                   }
   
                   bool removeComponent(Entity entity) {
                       auto it = entityToIndex.find(entity);
                       if (it == entityToIndex.end()) return false;
   
                       size_t index = it->second;
                       size_t lastIndex = components.size() - 1;
   
                       if (index != lastIndex) {
                           components[index] = std::move(components[lastIndex]);
                           entities[index] = entities[lastIndex];
                           entityToIndex[entities[index]] = index;
                       }
   
                       components.pop_back();
                       entities.pop_back();
                       entityToIndex.erase(it);
                       return true;
                   }
   
                   T* getComponent(Entity entity) {
                       auto it = entityToIndex.find(entity);
                       if (it == entityToIndex.end()) return nullptr;
                       return &components[it->second];
                   }
   
                   bool hasComponent(Entity entity) const {
                       return entityToIndex.find(entity) != entityToIndex.end();
                   }
   
                   void removeEntity(Entity entityId) override {
                       removeComponent(entityId);
                   }
               };
   
               template<typename T>
               ComponentStorage<T>& getComponentStorage() {
                   auto typeIndex = std::type_index(typeid(T));
                   auto it = componentStorages.find(typeIndex);
                   if (it == componentStorages.end()) {
                       auto storage = std::make_unique<ComponentStorage<T>>();
                       auto* ptr = storage.get();
                       componentStorages[typeIndex] = std::move(storage);
                       return *ptr;
                   }
                   return static_cast<ComponentStorage<T>&>(*it->second);
               }
   
               template<typename T>
               const ComponentStorage<T>* getComponentStorageConst() const {
                   auto typeIndex = std::type_index(typeid(T));
                   auto it = componentStorages.find(typeIndex);
                   if (it == componentStorages.end()) return nullptr;
                   return static_cast<const ComponentStorage<T>*>(it->second.get());
               }
   
               // Карта "тип -> хранилище"
               std::unordered_map<std::type_index, std::unique_ptr<IComponentStorage>> componentStorages;
           };
       }
   }