ComponentDataPool.h

#pragma once
 
#include "Component.h"
 
#include "../Memory/MemoryBuffer.h"
 
namespace Cogs
{
  namespace ComponentModel
  {
    class ComponentDataPoolBase
    {
    public:
      COGSFOUNDATION_API ComponentDataPoolBase(SizeType capacity, size_t elementSize, MemBlockType memType = MemBlockType::Bucket);
      
      COGSFOUNDATION_API void allocate(ComponentHandle handle);
 
      COGSFOUNDATION_API void deallocate(ComponentHandle handle);
 
      void * operator[](SizeType index)
      {
        debug_assert(index < capacity && "Element index out of bounds.");
        debug_assert(index * elementSize < store.size() && "Storage not allocated for specified index.");
 
        return store.data() + elementSize * index;
      }
 
      const void * operator[](SizeType index) const
      {
        debug_assert(index < capacity && "Element index out of bounds.");
        debug_assert(index * elementSize < store.size() && "Storage not allocated for specified index.");
 
        return store.data() + elementSize * index;
      }
 
    private:
      Memory::TypedBuffer<uint8_t> store;
      size_t elementSize;
      SizeType capacity;
    };
 
    template<typename DataType>
    class ComponentDataPool : private ComponentDataPoolBase
    {
    public:
      ComponentDataPool() : ComponentDataPool(1024) {}
 
      ComponentDataPool(SizeType capacity, MemBlockType memType = MemBlockType::Bucket) : ComponentDataPoolBase(capacity, sizeof(DataType), memType) {}
 
      void create(ComponentHandle handle)
      {
        allocate(handle);
 
        auto data = reinterpret_cast<DataType *>(ComponentDataPoolBase::operator[](handle.index));
 
        new (data) DataType();
      }
 
      void destroy(ComponentHandle handle)
      {
        auto data = reinterpret_cast<DataType *>(ComponentDataPoolBase::operator[](handle.index));
 
        data->~DataType();
 
        deallocate(handle);
      }
 
      DataType & operator[](SizeType index)
      {
        return *reinterpret_cast<DataType *>(ComponentDataPoolBase::operator[](index));
      }
 
      const DataType & operator[](SizeType index) const
      {
        return *reinterpret_cast<const DataType *>(ComponentDataPoolBase::operator[](index));
      }
    };
  }
}