PoolBase.h

#pragma once
 
#include "../Memory/MemoryBuffer.h"
 
#include <OsoMemoryProfiler/CogsMemoryProfile.h>
 
namespace Cogs
{
  namespace Collections
  {
    typedef uint16_t ElementOffset;
 
    typedef uint32_t ElementHandle;
 
    struct COGSFOUNDATION_API PoolBase
    {
      PoolBase(size_t elementSize, size_t initialCapacity, size_t pageSize, Memory::Allocator * allocator = Memory::Allocator::defaultAllocator(), MemBlockType memType=MemBlockType::Bucket);
 
      PoolBase(PoolBase &&) = default;
 
      // Defaulted move assignment operator.
      PoolBase & operator=(PoolBase &&) = default;
 
      PoolBase(const PoolBase &) = delete;
 
      PoolBase & operator=(const PoolBase &) = delete;
 
      void resize(size_t capacity);
 
      void * allocate();
 
      void deallocate(void * element);
 
      size_t size() const { return numAllocated; }
 
      size_t getCapacity() const { return capacity; }
 
      size_t getPageSize() const { return pageSize; }
 
      ElementHandle getHandle(void * element) const;
 
      void * getElement(ElementHandle handle);
 
      bool isValid(ElementHandle handle) const {
        const auto pageIndex = getPageIndex(handle);
        const auto elementIndex = getElementOffset(handle);
        return (pageIndex < pages.size()) && (elementIndex < pageSize);
      }
 
      bool isAllocated(ElementHandle handle) const;
 
    protected:
      constexpr uint32_t getPageIndex(ElementHandle handle) const { return handle >> 16; }
 
      constexpr ElementOffset getElementOffset(ElementHandle handle) const { return static_cast<ElementOffset>(handle & 0x0000FFFF); }
 
    protected:
      void addPage(size_t pageSize);
 
      std::vector<Memory::MemoryBuffer> pages;
 
      void * freeHead = nullptr;
 
      size_t numAllocated = 0;
      size_t elementSize = 0;
      size_t capacity = 0;
      size_t pageSize = 0;
 
      Memory::Allocator * allocator = nullptr;
      MemBlockType memType = MemBlockType::Bucket;
    };
  }
}