ObjectFactoryStack.h

#pragma once
 
#include <atomic>
#include <iostream>
#include <list>
#include <mutex>
#include <thread>
 
namespace CoRiBoDynamics
{
 
template <class _ObjectType_>   class ObjectFactoryStack{
public:
    ObjectFactoryStack(){setBufferSize(1);}
    explicit ObjectFactoryStack(unsigned int bufferSize){setBufferSize(bufferSize);}
 
    void setBufferSize(unsigned int BufferSize){
        destroyAllBuffers();
        m_BufferSize = BufferSize;
        m_sizeConvergenceCounter = BufferSize;
        m_ObjectCounter = 0;
        createNewBuffer();
    }
 
    unsigned int getObjectCounter(){
        return m_ObjectCounter;
    }
 
    ~ObjectFactoryStack(){
        destroyAllBuffers();
    }
 
    void restart(){
        m_sizeConvergenceCounter = m_ObjectCounter >= m_sizeConvergenceCounter ? m_ObjectCounter : (m_sizeConvergenceCounter+m_ObjectCounter)/2;
        if(m_sizeConvergenceCounter < (m_buffers.size()-1)*m_BufferSize){
            destroyBuffer();
        }
        m_currentBuffer = m_buffers.begin();
        m_ObjectCounter = 0;
        m_currentBufferIndex = 0;
    }
 
    _ObjectType_* getNewObject(){
        m_ObjectCounter++;
        if(m_currentBufferIndex >= m_BufferSize){ // if current buffer is full
            m_currentBufferIndex = 0;
            if(++m_currentBuffer == m_buffers.end()) // if current buffer is last
                createNewBuffer();
        }
        return static_cast<_ObjectType_*>(*m_currentBuffer) + (m_currentBufferIndex++);
    }
 
    _ObjectType_* getNewObjectThreadSafe(){
        std::scoped_lock lock(m_Lock);
        return getNewObject();
    }
 
private:
    ObjectFactoryStack( const ObjectFactoryStack& );
    ObjectFactoryStack& operator=( const ObjectFactoryStack& );
 
    void createNewBuffer(){
        m_currentBufferIndex = 0;
        try
        {
            _ObjectType_* buffer = new _ObjectType_[m_BufferSize];
            m_buffers.push_back(buffer);
            m_currentBuffer = m_buffers.end();
            --m_currentBuffer;
        }
        catch (const std::bad_alloc& error)
        {
            std::cerr << "ERROR: Bad memory allocation in ObjectFactoryStack<" << typeid(_ObjectType_).name() << ">" << std::endl;
            std::cerr << error.what() << std::endl;
            throw error;
        }
    }
 
    void destroyBuffer(){
        delete [] static_cast<_ObjectType_*>(m_buffers.back());
        m_buffers.pop_back();
    }
 
    void destroyAllBuffers(){
        for(std::list<void*>::iterator i = m_buffers.begin(); i != m_buffers.end(); ++i){
            delete [] static_cast<_ObjectType_*>(*i);
        }
        m_buffers.clear();
        m_ObjectCounter = 0;
    }
 
    unsigned int m_ObjectCounter;
    unsigned int m_sizeConvergenceCounter;
 
    unsigned int m_BufferSize;
    std::list<void*>::iterator m_currentBuffer;
    unsigned int m_currentBufferIndex;
    std::list<void*> m_buffers;
 
    std::mutex m_Lock;
};
}