ConfigurablePagedPool.h

#pragma once
 
#include <vector>
 
namespace Cogs
{
  namespace Collections
  {
    struct ItemHeader
    {
      ItemHeader * next;
    };
 
    struct DefaultContext
    {
      // Context free.
    };
 
    template<typename T>
    struct DefaultPage
    {
      DefaultPage() = default;
 
      DefaultPage(DefaultContext & context, size_t pageSize)
      {
        // Unused parameter.
        (void)context;
 
        static_assert(sizeof(T) >= sizeof(intptr_t), "T must be at least of pointer size.");
 
        const size_t elementSize = sizeof(T);
 
        bytes.resize(pageSize * elementSize);
 
        auto head = reinterpret_cast<ItemHeader *>(bytes.data());
 
        // Initialize the linked list of elements chaining all elements in the page together.
        for (size_t i = 0; i < pageSize; ++i) {
          ItemHeader * block = head + i;
 
          block->next = block + 1;
        }
 
        // Terminate the free list at the end of the page.
        (head + (pageSize - 1))->next = nullptr;
      }
 
      T * getHead() { return reinterpret_cast<T *>(bytes.data()); }
 
    private:
      std::vector<uint8_t> bytes;
    };
 
    template<typename Context, typename Page, typename Item>
    class ConfigurablePagedPool
    {
    public:
      ConfigurablePagedPool() = default;
 
      ConfigurablePagedPool(Context context, size_t capacity, size_t pageSize) :
        context(context),
        pageSize(pageSize)
      {
        resize(capacity);
      }
 
      void initialize(Context context, size_t capacity, size_t pageSize)
      {
        this->context = context;
        this->pageSize = pageSize;
 
        resize(capacity);
      }
 
      Item * allocate()
      {
        if (!head) resize(capacity + pageSize);
 
        auto item = head;
        head = head->next;
 
        return reinterpret_cast<Item *>(item);
      }
 
      void deallocate(Item * item)
      {
        reinterpret_cast<ItemHeader *>(item)->next = head;
        head = reinterpret_cast<ItemHeader *>(item);
      }
 
      void resize(size_t capacity)
      {
        while (capacity > this->capacity) {
          addPage();
        }
      }
 
    private:
      void addPage()
      {
        pages.emplace_back(context, pageSize);
 
        auto & lastPage = pages.back();
 
        if (!head) {
          head = reinterpret_cast<ItemHeader *>(lastPage.getHead());
        } else {
          ItemHeader * last = head;
 
          while (last->next) {
            last = last->next;
          }
 
          last->next = reinterpret_cast<ItemHeader *>(lastPage.getHead());
        }
 
        capacity += pageSize;
      }
 
    protected:
      Context context;
      std::vector<Page> pages;
      size_t capacity = 0;
      size_t pageSize = 0;
 
      ItemHeader * head = nullptr;
    };
  }
}