ObjectPool.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Queue.hpp"
#include "Vector.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Allocator.hpp"
 
#include <memory>
 
namespace CeresEngine {
 
    template<typename T, typename RawAllocator = DefaultAllocator> class ObjectPool {
    public:
        static inline const constexpr size_t defaultChunkSize = 32;
 
    private:
        CE_NO_UNIQUE_ADDRESS
        StdAllocator<T, RawAllocator> mAllocator;
 
        size_t mChunkSize = defaultChunkSize;
 
        // The free list stores the objects that are not currently in use by
        // clients.
        Queue<T*> mFreeList;
 
        // Stores pointers to all the objects, in use or not. This vector is
        // needed in order to ensure that all objects are freed properly in the
        // destructor.
        Vector<T*> mAllObjects;
 
    public:
        explicit ObjectPool(const size_t chunkSize = defaultChunkSize) : mChunkSize(chunkSize) {
            if(chunkSize <= 0) {
                throw std::invalid_argument("chunk size must be positive");
            }
        }
 
        ObjectPool(const ObjectPool<T>& other) = delete;
        ObjectPool<T>& operator=(const ObjectPool<T>& other) = delete;
        ObjectPool(ObjectPool<T>&& other) = delete;
        ObjectPool<T>& operator=(ObjectPool<T>&& other) = delete;
 
        ~ObjectPool() {
            assert(mFreeList.size() == mAllObjects.size() * mChunkSize);
 
            // free each of the allocation chunks
            for_each(mAllObjects.begin(), mAllObjects.end(), [&](T* obj) { mAllocator.deallocate(obj, mChunkSize); });
        }
 
    public:
        template<typename... Args> T* allocate(Args&&... args) {
            if(mFreeList.empty()) {
                allocateChunk();
            }
            T* obj = mFreeList.front();
            mFreeList.pop();
 
            return new(obj) T(std::forward<Args>(args)...);
        }
 
        void release(T* obj) {
            obj->~T();
            mFreeList.push(obj);
        }
 
    protected:
        // Allocates chunkSize new objects and adds them to the freeList
        void allocateChunk() {
            T* newObjects = mAllocator.allocate(mChunkSize);
            mAllObjects.push_back(newObjects);
            for(size_t i = 0; i < mChunkSize; ++i) {
                mFreeList.push(&newObjects[i]);
            }
        }
    };
 
} // namespace CeresEngine