ComponentPool.h

#pragma once
 
#include "Component.h"
 
#include "../Memory/MemoryBuffer.h"
#include "../Reflection/TypeDatabase.h"
 
namespace Cogs
{
  namespace ComponentModel
  {
    struct ComponentPoolFlags
    {
      enum EComponentPoolFlags
      {
        None = 0x0000,
        AllowGrow = 0x0001,
      };
    };
 
    class ComponentPoolBase
    {
    public:
      COGSFOUNDATION_API ComponentPoolBase(const Reflection::TypeId typeId, SizeType capacity, Memory::Allocator * allocator, MemBlockType memType);
 
      COGSFOUNDATION_API ComponentHandle allocateComponent();
 
      COGSFOUNDATION_API void deallocateComponent(ComponentHandle handle);
 
      Component & operator[](SizeType index)
      {
        return *get(roster[index]);
      }
 
      Component * get(size_t index)
      {
        return reinterpret_cast<Component *>(store.data() + (index * elementSize));
      }
 
      Component * resolve(const ComponentHandle handle)
      {
        return get(handle.index);
      }
 
      COGSFOUNDATION_API void resize(SizeType capacity);
 
      SizeType size() const { return next; }
 
      SizeType capacity() const { return static_cast<SizeType>(roster.size()); }
 
      COGSFOUNDATION_API SizeType maxSize() const;
 
      SizeType getComponentIndex(const Component * component) const { return roster[component->getIndex()]; }
 
      void setFlag(ComponentPoolFlags::EComponentPoolFlags flag) { flags |= flag; }
      
      bool isSet(const uint32_t flag) const { return (flags & flag) == flag; }
 
    private:
 
      SizeType next;
 
      Memory::TypedBuffer<SizeType> roster;
 
      Memory::TypedBuffer<uint8_t> store;
 
      size_t elementSize;
 
      Reflection::TypeId componentType;
 
      uint32_t flags;
 
    };
 
    template<typename ComponentType>
    struct ComponentPool : public ComponentPoolBase
    {
      static_assert(sizeof(Component) <= sizeof(ComponentType), "Component type incompatible.");
 
      struct ComponentIterator
      {
      public:
        typedef std::forward_iterator_tag iterator_category;
 
        typedef ComponentType value_type;
 
        typedef size_t difference_type;
 
        typedef ComponentType * pointer;
 
        typedef ComponentType & reference;
 
        ComponentIterator(ComponentPool & pool, SizeType index) : pool(pool), index(index) {}
 
        ComponentIterator(const ComponentIterator & other) : pool(other.pool), index(other.index) {}
 
        [[nodiscard]] constexpr bool operator==(const ComponentIterator & other) const { return index == other.index; }
 
        ComponentIterator operator++() { ComponentIterator t = *this; ++index; return t; }
 
        ComponentIterator & operator++(int) { ++index; return *this; }
 
        ComponentType & operator*() { return pool[index]; }
 
        const ComponentType & operator*() const { return pool[index]; }
 
        const ComponentType * operator->() const { return &pool[index]; }
 
 
        ComponentPool & pool;
 
        SizeType index;
 
      };
 
      ComponentPool(Memory::Allocator * allocator, SizeType poolSize, MemBlockType memType = MemBlockType::Bucket) :
        ComponentPoolBase(Reflection::TypeDatabase::getType<ComponentType>().getTypeId(), poolSize, allocator, memType)
      {
      }
 
      ComponentPool(SizeType poolSize = 16384) :
        ComponentPoolBase(Reflection::TypeDatabase::getType<ComponentType>().getTypeId(), poolSize, Memory::Allocator::defaultAllocator(), MemBlockType::Bucket)
      {
      }
 
      ComponentIterator begin() { return ComponentIterator(*this, 0); }
 
      ComponentIterator end() { return ComponentIterator(*this, size()); }
 
      ComponentType & operator[](SizeType index)
      {
        return *static_cast<ComponentType *>(&ComponentPoolBase::operator[](index));
      }
 
    private:
      friend struct ComponentIterator;
    };
  }
}