ComponentArray.hpp

#ifndef COMPARRAY_H
#define COMPARRAY_H
#include "Types.hpp"
#include "pch.hpp"
#include <unordered_map>
namespace Engine {
  struct IComponentDataArray {
    virtual void EntityDestroyed(EntityID entity) = 0;
  };
 
  template<typename T>
    class ComponentDataArray : public IComponentDataArray {
 
      private:
        // TODO: make this packed later, will need more maps and shit
 
        std::vector<Ref<T>> m_DataArray;
        std::unordered_map<EntityID, size_t> m_EntityMap;
 
        size_t m_nextIdx = 0;
 
      public:
        ComponentDataArray() { }
 
        Ref<T> Insert(EntityID id, Ref<T> c) {
          m_EntityMap.emplace(id, m_nextIdx);
          m_DataArray.push_back(c);
          ++m_nextIdx;
          return c;
        }
 
 
        Ref<T> Insert(EntityID id, T c) {
          // check if we have a component for this entity
          // if we have it then do nothing
          // TODO: or should we replace?
          auto itr = m_EntityMap.find(id);
          if (itr != m_EntityMap.end())
            return m_DataArray[itr->second];
 
          m_EntityMap.emplace(id, m_nextIdx);
          Ref<T> data = CreateRef<T>(c);
          m_DataArray.push_back(data);
          ++m_nextIdx;
          return data;
        }
 
        void Remove(EntityID id) {
          // does not have a component of this type
          auto itr = m_EntityMap.find(id);
          if (itr == m_EntityMap.end())
            return;
 
          size_t idx = itr->second;
          // erase the component at the right idx
          m_DataArray.erase(m_DataArray.begin() + idx);
          m_EntityMap.erase(itr);
          --m_nextIdx;
        }
 
        Ref<T> GetComp(EntityID id) {
          auto itr = m_EntityMap.find(id);
          if (itr == m_EntityMap.end())
            return nullptr;
 
          size_t idx = itr->second;
 
          return m_DataArray[idx];
        }
 
        void EntityDestroyed(EntityID id) {
          Remove(id);
        }
    };
 
}
#endif