MaterialIdGenerator.h

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

#pragma once

#include "Types.h"
#include "IdTypes.h"
#include "MaterialId.h"
#include "ICallback.h"
#include "SortKey.h"
#include <set>

namespace Eegeo
{
    namespace Rendering
    {
        namespace Materials
        {
            class MaterialIdGenerator : protected Eegeo::NonCopyable
            {
            public:
                MaterialIdGenerator()
                : m_nextIdentifier(0)
                , m_allocatedIdentifierCount(0)
                , m_releaseCallback(this, &MaterialIdGenerator::ReleaseIdentifier)
                {
                }
                
                TMaterialId GetNextId()
                {
                    return TMaterialId(Eegeo_NEW(TMaterialIdWrapper)(AllocateNextIdentifier(), m_releaseCallback));
                }
                
            private:
                void ReleaseIdentifier(const TMaterialIdWrapper::TValueType& identifier)
                {
                    Eegeo_ASSERT(m_allocatedIdentifierCount > 0,
                                 "Releasing material but no materials allocated. Indicates possible double release of identifier.\n");
                    
                    --m_allocatedIdentifierCount;
                    size_t valuesErased(m_identifiersUsed.erase(identifier));
                    
                    Eegeo_ASSERT(valuesErased == 1,
                                 "Error: Consistency error in tracking material identifiers. Untracked identifier released.\n");
                }
                
                TMaterialIdWrapper::TValueType AllocateNextIdentifier()
                {
                    Eegeo_ASSERT(m_allocatedIdentifierCount < SortKey::MaxMaterialValue,
                                 "Too many materials allocated, out of space to identify. Indicates possible identifier leak.\n");
                    
                    ++m_allocatedIdentifierCount;
                    TMaterialIdWrapper::TValueType identifierToUse(m_nextIdentifier);
                    std::pair<TIdentifiersUsed::iterator, bool> insertionResult(m_identifiersUsed.insert(identifierToUse));
                    Eegeo_ASSERT(insertionResult.second, "Error: reused material identifier in MaterialIdGenerator.\n");
                    m_nextIdentifier = FindNextUnusedIdentifierAfter(identifierToUse);
                    
                    return identifierToUse;
                }
                
                TMaterialIdWrapper::TValueType FindNextUnusedIdentifierAfter(TMaterialIdWrapper::TValueType identifier)
                {
                    do
                    {
                        identifier = (identifier + 1) % SortKey::MaxMaterialValue;
                    }
                    while(m_identifiersUsed.find(identifier) != m_identifiersUsed.end());
                    
                    return identifier;
                }
                
                TMaterialIdWrapper::TValueType m_nextIdentifier;
                int m_allocatedIdentifierCount;
                Helpers::TCallback1<MaterialIdGenerator, const TMaterialIdWrapper::TValueType> m_releaseCallback;
                
                typedef std::set<TMaterialIdWrapper::TValueType> TIdentifiersUsed;
                TIdentifiersUsed m_identifiersUsed;
            };
        }
    }
}