attribute_map_collection.inl

Go to the documentation of this file.

/*
    mesh3d
    Copyright (C) 2010  Timo Suoranta

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef MESH3D__ATTRIBUTE_MAP_COLLECTION__INL
#define MESH3D__ATTRIBUTE_MAP_COLLECTION__INL

#include "mesh3d/exception.h"

namespace mesh3d {

namespace detail {
    void throw_incompatible_attribute_type(
        std::string const   &name,
        char const          *type_name, 
        char const          *expected_type_name
    );
}

template<typename Key>
inline attribute_map_collection<Key>::attribute_map_collection()
{
}

template<typename Key>
inline void attribute_map_collection<Key>::clear()
{
    m_maps.clear();
}


template<typename Key>
inline size_t attribute_map_collection<Key>::size() const
{
    return m_maps.size();
}

template<typename Key>
inline void attribute_map_collection<Key>::insert(std::string const &name,
    std::tr1::shared_ptr<attribute_map_base<Key> > const &map)
{
    assert(m_maps.find(name) == m_maps.end());

    m_maps.insert(map_map::value_type(name, map));
}

template<typename Key>
inline void attribute_map_collection<Key>::remove(std::string const &name)
{
    m_maps.erase(name);
}

template<typename Key>
inline bool attribute_map_collection<Key>::has(std::string const &name) const
{
    return m_maps.find(name) != m_maps.end();
}

template<typename Key>
inline std::tr1::shared_ptr<attribute_map_base<Key> >
    attribute_map_collection<Key>::find_any(std::string const &name) const
{
    const_iterator i = m_maps.find(name);

    if(i == m_maps.end())
    {
        throw attribute_map_not_found_exception(name);
    }

    assert(i != m_maps.end());
    return i->second;
}

template<typename Key>
inline typename attribute_map_collection<Key>::const_iterator
    attribute_map_collection<Key>::begin() const
{
    return m_maps.begin();
}

template<typename Key>
inline typename attribute_map_collection<Key>::const_iterator
    attribute_map_collection<Key>::end() const
{
    return m_maps.end();
}

template<typename Key>
template<typename Value>
inline std::tr1::shared_ptr<attribute_map<Key, Value> >
    attribute_map_collection<Key>::create(std::string const &name)
{
    std::tr1::shared_ptr<attribute_map<Key, Value> > p(new attribute_map<Key, Value>);
    insert(name, p);
    return p;
}

template<typename Key>
template<typename Value>
inline std::tr1::shared_ptr<attribute_map<Key, Value> >
    attribute_map_collection<Key>::find(std::string const &name) const
{
    std::tr1::shared_ptr<attribute_map_base<Key> > p = find_any(name);

    if(
        std::tr1::shared_ptr<attribute_map<Key, Value> > 
            t = std::tr1::dynamic_pointer_cast<attribute_map<Key, Value> >(p)
    )
    {
        return t;
    }
    else
    {
        throw incompatible_attribute_type_exception(
            name, 
            p->value_type_id().name(),
            typeid(Value).name()
        );

        //return std::tr1::shared_ptr<attribute_map<Key, Value> >();
    }
}

template<typename Key>
template<typename Value>
inline std::tr1::shared_ptr<attribute_map<Key, Value> >
    attribute_map_collection<Key>::find_or_create(std::string const &name)
{
    map_map::iterator i = m_maps.find(name);
    if(i != m_maps.end())
    {
        if(
            std::tr1::shared_ptr<attribute_map<Key, Value> > 
                t = std::tr1::dynamic_pointer_cast<attribute_map<Key, Value> >(i->second)
        )
        {
            return t;
        }
        else
        {
            throw incompatible_attribute_type_exception(
                name, 
                t->value_type_id().name(),
                typeid(Value).name()
            );

            //return std::tr1::shared_ptr<attribute_map<Key, Value> >();
        }
    }
    else
    {
        return create<Value>(name);
    }
}

}

#endif