Pool.h

#pragma once
 
#include "PoolBase.h"
 
namespace Cogs
{
  namespace Collections
  {
    template<typename ElementType>
    struct Pool
    {
      Pool(MemBlockType memType = MemBlockType::Bucket) : Pool(1024, 1024, memType) {}
 
      Pool(ElementOffset capacity, ElementOffset pageSize = 128, MemBlockType memType = MemBlockType::Bucket) : Pool(capacity, pageSize, Memory::Allocator::defaultAllocator(), memType) {}
 
      Pool(ElementOffset capacity, ElementOffset pageSize, Memory::Allocator * allocator, MemBlockType memType = MemBlockType::Bucket) : base(sizeof(ElementType), capacity, pageSize, allocator, memType) {}
 
      Pool(Pool &&) noexcept = default;
 
      Pool & operator=(Pool &&) noexcept = default;
 
      Pool(const Pool &) = delete;
 
      Pool & operator=(const Pool &) = delete;
 
      void resize(size_t capacity) { base.resize(capacity); }
 
      template<typename... ARGS>
      ElementType* create(ARGS&&... args)
      {
        return new (base.allocate()) ElementType(std::forward<ARGS>(args)...);
      }
 
      void destroy(ElementType * element)
      {
        element->~ElementType();
 
        base.deallocate(element);
      }
 
      size_t size() const { return base.size(); }
 
      size_t getCapacity() const { return base.getCapacity(); }
 
      size_t getPageSize() const { return base.getPageSize(); }
 
      ElementHandle getHandle(ElementType * element) const { return base.getHandle(element); }
 
      ElementType * operator[](ElementHandle handle)
      {
        return static_cast<ElementType *>(base.getElement(handle));
      }
 
      bool isValid(ElementHandle handle) const { return base.isValid(handle); }
 
      bool isAllocated(ElementHandle handle) const { return base.isAllocated(handle); }
 
    private:
      PoolBase base;
    };
  }
}