Variations.impl.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
namespace Atoms
{
    bool Variations::removeAgentTypeVariation(const std::string &agentTypeName)
    {
        std::map<std::string, AgentTypeVariation>::iterator it = m_agentTypeVariations.find(agentTypeName);
        if (it != m_agentTypeVariations.end())
        {
            m_agentTypeVariations.erase(it);
            return true;
        }
        return false;
    }
 
    std::vector<std::string> Variations::getAgentTypeNames() const
    {
        std::vector<std::string> names;
        names.reserve(m_agentTypeVariations.size());
        for (auto it = m_agentTypeVariations.cbegin(); it != m_agentTypeVariations.cend(); it++)
            names.push_back(it->first);
        return names;
    }
 
    AgentTypeVariationCPtr Variations::getAgentTypeVariationPtr(const std::string &agentTypeName) const
    {
        std::map<std::string, AgentTypeVariation>::const_iterator it = m_agentTypeVariations.find(agentTypeName);
        if (it != m_agentTypeVariations.cend())
            return &it->second;
        return nullptr;
    }
 
    inline VariationGeometryCPtr AgentTypeVariation::getGeometryPtr(const std::string &name) const
    {
        std::map<std::string, VariationGeometry>::const_iterator it = m_geos.find(name);
        if (it != m_geos.cend())
            return &it->second;
        return nullptr;
    }
 
    inline VariationMaterialCPtr AgentTypeVariation::getMaterialPtr(const std::string &name) const
    {
        std::map<std::string, VariationMaterial>::const_iterator it = m_mats.find(name);
        if (it != m_mats.cend())
            return &it->second;
        return nullptr;
    }
 
    inline VariationGroupCPtr AgentTypeVariation::getGroupPtr(const std::string &name) const
    {
        std::map<std::string, VariationGroup>::const_iterator it = m_groups.find(name);
        if (it != m_groups.cend())
            return &it->second;
        return nullptr;
    }
 
    void AgentTypeVariation::clear()
    {
        m_geos.clear();
        m_mats.clear();
        m_groups.clear();
    }
 
    std::vector<std::string> AgentTypeVariation::getGeometryNames()  const
    {
        std::vector<std::string> names;
        names.reserve(m_geos.size());
        for (auto it = m_geos.cbegin(); it != m_geos.cend(); it++)
            names.push_back(it->first);
        return names;
    }
 
    std::vector<std::string> AgentTypeVariation::getMaterialNames()  const
    {
        std::vector<std::string> names;
        names.reserve(m_mats.size());
        for (auto it = m_mats.cbegin(); it != m_mats.cend(); it++)
            names.push_back(it->first);
        return names;
    }
 
    std::vector<std::string> AgentTypeVariation::getGroupNames()  const
    {
        std::vector<std::string> names;
        names.reserve(m_groups.size());
        for (auto it = m_groups.cbegin(); it != m_groups.cend(); it++)
            names.push_back(it->first);
        return names;
    }
 
    bool AgentTypeVariation::removeGeometry(const std::string &name)
    {
        std::map<std::string, VariationGeometry>::iterator it = m_geos.find(name);
        if (it != m_geos.end())
        {
            m_geos.erase(it);
            return true;
        }
        return false;
    }
 
    bool AgentTypeVariation::removeMaterial(const std::string &name)
    {
        std::map<std::string, VariationMaterial>::iterator it = m_mats.find(name);
        if (it != m_mats.end())
        {
            m_mats.erase(it);
            return true;
        }
        return false;
    }
 
    bool AgentTypeVariation::removeGroup(const std::string &name)
    {
        std::map<std::string, VariationGroup>::iterator it = m_groups.find(name);
        if (it != m_groups.end())
        {
            m_groups.erase(it);
            return true;
        }
        return false;
    }
 
    bool AgentTypeVariation::removeAllGroups()
    {
        m_groups.clear();
        return true;
    }
 
    inline VariationGroupLodCPtr VariationGroup::getLodPtr(const std::string &name) const
    {
        std::map<std::string, VariationGroupLod>::const_iterator it = m_lods.find(name);
        if (it != m_lods.cend())
            return &it->second;
        return nullptr;
    }
 
    inline bool VariationGroup::hasCombination(const std::string &geometryName, const std::string &materialName)
    {
        return std::find(m_combinations.begin(), m_combinations.end(), std::pair<std::string, std::string>(geometryName, materialName)) != m_combinations.end();
    }
 
    bool VariationGroup::removeLod(const std::string &name)
    {
        std::map<std::string, VariationGroupLod>::iterator it = m_lods.find(name);
        if (it != m_lods.end())
        {
            m_lods.erase(it);
            return true;
        }
        return false;
    }
 
    const std::pair<std::string, std::string>& VariationGroup::getCombinationAtIndex(unsigned int index) const
    {
        if (index < m_combinations.size())
            return m_combinations[index];
        return m_emptyPair;
    }
 
    bool VariationGroup::removeCombinationAtIndex(unsigned int index)
    {
        if (index < m_combinations.size())
        {
            m_combinations.erase(m_combinations.begin() + index);
            return true;
        }
        return false;
    }
 
    inline const std::pair<std::string, std::string>& VariationGroupLod::getCombinationAtIndex(unsigned int index) const
    {
        if (index < m_combinations.size())
            return m_combinations[index];
        return m_emptyPair;
    }
 
    inline bool VariationGroupLod::hasCombination(const std::string &geometryName, const std::string &materialName)
    {
        return std::find(m_combinations.begin(), m_combinations.end(), std::pair<std::string, std::string>(geometryName, materialName)) != m_combinations.end();
    }
 
    inline bool VariationGroupLod::removeCombinationAtIndex(unsigned int index)
    {
        if (index < m_combinations.size())
        {
            m_combinations.erase(m_combinations.begin() + index);
            return true;
        }
        return false;
    }
 
    std::vector<std::string> VariationGroup::getLodNames()  const
    {
        std::vector<std::string> names;
        names.reserve(m_lods.size());
        for (auto it = m_lods.cbegin(); it != m_lods.cend(); it++)
            names.push_back(it->first);
        return names;
    }
 
    size_t Variations::size() const
    {
        return m_agentTypeVariations.size();
    }
}