object_pool.h

/*****************************************************/
/* lean Memory                  (c) Tobias Zirr 2011 */
/*****************************************************/

#ifndef LEAN_MEMORY_OBJECT_POOL
#define LEAN_MEMORY_OBJECT_POOL

#include "../lean.h"
#include "../tags/noncopyable.h"
#include "chunk_heap.h"
#include "default_heap.h"

namespace lean
{
namespace memory
{

template <class Element, size_t ChunkSize, class Heap = default_heap, size_t StaticChunkSize = ChunkSize, size_t Alignment = alignof(Element)>
class object_pool : public lean::noncopyable
{
public:
    typedef Element value_type;
    typedef Heap heap_type;
    typedef typename heap_type::size_type size_type;
    static const size_type chunk_size = ChunkSize;
    static const size_type alignment = Alignment;

private:
    typedef chunk_heap<0, Heap, StaticChunkSize * sizeof(Element), Alignment> chunk_heap;
    chunk_heap m_heap;

public:
    LEAN_INLINE object_pool(size_type chunkSize = ChunkSize)
        : m_heap( max(chunkSize * sizeof(Element), sizeof(Element) + (Alignment - 1)) ) { }
    LEAN_INLINE ~object_pool()
    {
        clear();
    }

    void clear()
    {
        char *chunkEnd = m_heap.currentOffset();
        char *chunkBegin = m_heap.clearCurrent();

        while (chunkBegin)
        {
            const size_t chunkSize = (chunkEnd - chunkBegin);

            char *current = align<Alignment>(chunkBegin);

            while (sizeof(Element) + static_cast<size_t>(current - chunkBegin) <= chunkSize)
            {
                reinterpret_cast<Element*>(current)->~Element();

                current = align<Alignment>(current + sizeof(Element));
            }

            char *nextChunkBegin = m_heap.clearFreeNext();

            if (nextChunkBegin != chunkBegin)
            {
                chunkBegin = nextChunkBegin;
                chunkEnd = chunkBegin
                    + ((m_heap.currentStatic()) ? StaticChunkSize * sizeof(Element) : m_heap.nextChunkSize());
            }
            else
                chunkBegin = nullptr;
        }
    }

    LEAN_INLINE void* allocate() throw()
    {
        return m_heap.allocate<Alignment>( sizeof(Element) );
    }
    LEAN_INLINE Element* place(const Element &value) throw()
    {
        return new( m_heap.allocate<Alignment>( sizeof(Element) ) ) Element(value);
    }
#ifndef LEAN0X_NO_RVALUE_REFERENCES

    LEAN_INLINE Element* place(Element &&value) throw()
    {
        return new( m_heap.allocate<Alignment>( sizeof(Element) ) ) Element( std::move(value) );
    }
#endif
};

} // namespace

using memory::object_pool;

} // namespace

#endif