objectpool.h

Go to the documentation of this file.

#ifndef OBJECTPOOL_H
#define OBJECTPOOL_H

#include <queue>
#include <memory>
#include <stdexcept>
#include <thread>


template<typename T>
class ObjectPool{
public:
    ObjectPool(size_t chunkSize = kDefaultChunkSize)
        throw(std::invalid_argument, std::bad_alloc);
    std::shared_ptr<T> AcquireObject();
    void ReturnObject(std::shared_ptr<T> obj);

protected:
    void AllocateChunk();

protected:
    std::queue<std::shared_ptr<T>> mFreeList;
    size_t mChunkSize;
    static const size_t kDefaultChunkSize = 10;

private:
    ObjectPool(const ObjectPool<T> &src);
    ObjectPool<T>& operator=(const ObjectPool<T> &rhs);
};
template<typename T> const size_t ObjectPool<T>::kDefaultChunkSize;

template<typename T> ObjectPool<T>::ObjectPool(size_t chunkSize)
        throw(std::invalid_argument, std::bad_alloc)
{
    if (chunkSize <= 0)
        throw std::invalid_argument("Chunk size cannot be <= 0");
    mChunkSize = chunkSize;
    //allocate an initial chunk of objects
    AllocateChunk();
}
template<typename T> std::shared_ptr<T> ObjectPool<T>::AcquireObject(){
    //if free list is empty, create more
    if (mFreeList.empty())
        AllocateChunk();
    auto obj = mFreeList.front();
    mFreeList.pop();
    return obj;
}
template<typename T> void ObjectPool<T>::ReturnObject(std::shared_ptr<T> obj){
    mFreeList.push(obj);
}
template<typename T> void ObjectPool<T>::AllocateChunk(){
    for (size_t i = 0; i < mChunkSize; ++i)
        mFreeList.push(std::make_shared<T>());
}

//Trying an idea
typedef ObjectPool<std::thread> ThreadPool;

#endif