MemoryPool.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_POOL_ALLOCATOR_H
#define GRAIL_POOL_ALLOCATOR_H
 
#include "../GrailCore/consts.h"
 
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
 
namespace grail
{
namespace planner
{
 template <typename T>
 class Emplacer final
 {
 public:
 Emplacer(typename std::enable_if<std::is_trivially_destructible<T>::value>::type* = 0)
 {
 }
 
 template <typename... Arguments>
 T& operator()(void* memoryCell, Arguments&&... arguments)
 {
 return *(new(memoryCell) T{std::forward<Arguments>(arguments)...});
 }
 };
 
 template <>
 class Emplacer<std::string>
 {
 public:
 template <typename... Arguments>
 std::string& operator()(void* memoryCell, Arguments&&... arguments)
 {
 if(StringLength(std::forward<Arguments>(arguments)...) > consts::MAX_STRING_SIZE)
 {
 throw std::bad_alloc{};
 }
 return *(new(memoryCell) std::string{std::forward<Arguments>(arguments)...});
 }
 
 private:
 std::size_t StringLength(const std::string& string) const
 {
 return string.size();
 }
 };
 
 template <>
 class Emplacer<const std::string>
 {
 public:
 template <typename... Arguments>
 const std::string& operator()(void* memoryCell, Arguments&&... arguments)
 {
 if(StringLength(std::forward<Arguments>(arguments)...) > consts::MAX_STRING_SIZE)
 {
 throw std::bad_alloc{};
 }
 return *(new(memoryCell) const std::string{std::forward<Arguments>(arguments)...});
 }
 
 private:
 std::size_t StringLength(const std::string& string) const
 {
 return string.size();
 }
 };
 
 class MemoryPool final
 {
 public:
 MemoryPool(const std::size_t BYTES = 5242880u)
 : blocks{new char[BYTES]},
 currentMemoryCell{&blocks[0]},
 _size{0},
 BYTES{BYTES}
 {
 }
 
 ~MemoryPool()
 {
 delete[] blocks;
 }
 
 template <typename T, typename... ConstructorArguments>
 T& Emplace(ConstructorArguments&&... arguments)
 {
 std::size_t memoryRequired = sizeof(T);
 std::size_t alignment = alignof(T);
 std::size_t leftoverBytes = _size % alignment;
 
 if(leftoverBytes > 0)
 {
 std::size_t padding = (alignment - leftoverBytes);
 _size += padding;
 if(_size < BYTES)
 {
 currentMemoryCell = static_cast<char*>(currentMemoryCell) + padding;
 }
 }
 
 _size += memoryRequired;
 
 if(_size > BYTES)
 {
 throw std::bad_alloc{};
 }
 
 Emplacer<T> emplacer;
 T& result = emplacer(currentMemoryCell, std::forward<ConstructorArguments>(arguments)...);
 currentMemoryCell = static_cast<char*>(currentMemoryCell) + memoryRequired;
 return result;
 }
 
 std::size_t Size() const
 {
 return _size;
 }
 
 void Reset()
 {
 currentMemoryCell = &blocks[0];
 _size = 0;
 }
 
 private:
 char* const blocks;
 void* currentMemoryCell;
 std::size_t _size;
 const std::size_t BYTES;
 };
}
}
 
#endif // GRAIL_POOL_ALLOCATOR_H