StackAllocator.hpp

Go to the documentation of this file.

 
 
#ifndef UTIL_STACKALLOCATOR_HPP_
#define UTIL_STACKALLOCATOR_HPP_
 
#include <cstring>
#include <memory>
#include <new>
#include <vector>
 
namespace util
{
    template <size_t size, typename Base>
    class StackAllocator {
      public:
        static constexpr size_t mem_size = size;
 
        StackAllocator()
        {
            _cursor = 0;
        }
 
        StackAllocator(StackAllocator &&other)
        {
            *this = std::move(other);
        }
 
        ~StackAllocator()
        {
            for (auto &&object : _instances)
                (*object).~Base();
        }
 
        StackAllocator &operator=(StackAllocator &&other)
        {
            // Doesn't support overlap but we shouldn't have any
            std::memcpy(_memory, other._memory, size);
            _cursor = other._cursor;
            for (Base *instance : other._instances)
                _instances.push_back(reinterpret_cast<Base *>(reinterpret_cast<char *>(_memory)
                    + (reinterpret_cast<char *>(instance) - reinterpret_cast<char *>(other._memory))));
 
            // Clear other
            other._cursor = 0;
            other._instances.clear();
            return *this;
        }
 
        template <std::derived_from<Base> T, typename... Args>
        [[nodiscard]] T &instanciate(Args &&...args)
        {
            T *newObject = new (reinterpret_cast<void *>(&_memory[_cursor])) T(std::forward<Args>(args)...);
 
            _instances.push_back(newObject);
            _cursor += sizeof(T);
            return *newObject;
        }
 
        [[nodiscard]] constexpr const std::vector<Base *> &getInstances() const noexcept
        {
            return _instances;
        }
 
      private:
        char _memory[size];
 
        size_t _cursor;
        std::vector<Base *> _instances;
    };
} // namespace util
 
#endif /* !UTIL_STACKALLOCATOR_HPP_ */