PoolImpl.h

// Copyright eeGeo Ltd (2012-2014), All Rights Reserved

#pragma once

#include "Pool.h"

namespace Eegeo
{
    namespace DataStructures
    {
        template <typename T>
        Pool<T>::Pool(int totalCapacity, PoolItemFactory<T> *pInstanceFactory)
        :m_pInstanceFactory(pInstanceFactory),
        m_count(0)
        {
            if(totalCapacity > 0)
            {
                PoolEntry<T>* pCurrent = NULL;
                
                m_entries.reserve(totalCapacity);

                for (int i = 0; i < totalCapacity; ++i)
                {
                    PoolEntry<T> entry;
                    m_entries.push_back(entry);
                    pCurrent = &(m_entries[i]);
                    
                    pCurrent->allocated = false;
                    pCurrent->counter = 1;
                    pCurrent->instance = m_pInstanceFactory->CreateItem();

                    m_freeIndices.push(i);
                }
            }
        }
        
        template <typename T>
        Pool<T>::~Pool()
        {
            for (size_t i = 0; i < m_entries.size(); ++i)
            {
                PoolEntry<T>* pCurrent = &(m_entries[i]);
                Eegeo_DELETE pCurrent->instance;
            }
            
            m_entries.clear();
        }
        
        
        template <typename T>
        PoolHandle Pool<T>::Allocate()
        {
            PoolEntry<T>* pCurrent = NULL;

            u16 index = 0;

            if (m_freeIndices.empty())
            {
                PoolEntry<T> entry;
                m_entries.push_back(entry);
                
                pCurrent = &m_entries.back();
                pCurrent->counter = 0;
                pCurrent->instance = m_pInstanceFactory->CreateItem();

                index = m_entries.size() - 1;
            }
            else
            {
                index = m_freeIndices.top();
                m_freeIndices.pop();

                pCurrent = &m_entries[index];
            }

            ++pCurrent->counter;
            ++m_count;

            pCurrent->allocated = true;

            return PoolHandle(pCurrent->counter, index);
        }

    
        template <typename T>
        void Pool<T>::Release(PoolHandle handle)
        {
            u32 index = handle.GetIndex();
            
            PoolEntry<T>* pCurrent = &(m_entries[index]);
            pCurrent->allocated = false;
            ++pCurrent->counter;

            m_freeIndices.push(index);
            
            --m_count;
        }
        
        template <typename T>
        T Pool<T>::Resolve(PoolHandle handle)
        {
            u32 index = handle.GetIndex();

            Eegeo_ASSERT(m_entries[index].counter == handle.GetCounter(), "Failed to resolve handle");
            
            T pInstance = m_entries[index].instance;
            return pInstance;
        }
    }
}