Map.hpp

/* ***** BEGIN LICENSE BLOCK *****
 * FW4SPL - Copyright (C) IRCAD, 2009-2017.
 * Distributed under the terms of the GNU Lesser General Public License (LGPL) as
 * published by the Free Software Foundation.
 * ****** END LICENSE BLOCK ****** */

#ifndef __FWATOMS_MAP_HPP__
#define __FWATOMS_MAP_HPP__

#include "fwAtoms/Base.hpp"
#include "fwAtoms/config.hpp"
#include "fwAtoms/factory/new.hpp"
#include "fwAtoms/Object.hpp"

#include <map>
#include <string>

namespace fwAtoms
{

class FWATOMS_CLASS_API Map : public Base
{
public:
    fwCoreClassDefinitionsWithFactoryMacro( (Map)(::fwAtoms::Base), (()), ::fwAtoms::factory::New< Map >);

    typedef std::map<std::string, Base::sptr> MapType;

    typedef MapType::key_type KeyType;
    typedef MapType::mapped_type MappedType;
    typedef MapType::value_type ValueType;
    typedef MapType::iterator IteratorType;
    typedef MapType::const_iterator ConstIteratorType;
    typedef MapType::reverse_iterator ReverseIteratorType;
    typedef MapType::const_reverse_iterator ConstReverseIteratorType;
    typedef MapType::size_type SizeType;

    typedef MapType::key_type key_type;
    typedef MapType::mapped_type mapped_type;
    typedef MapType::value_type value_type;
    typedef MapType::iterator iterator;
    typedef MapType::const_iterator const_iterator;
    typedef MapType::reverse_iterator reverse_iterator;
    typedef MapType::const_reverse_iterator const_reverse_iterator;
    typedef MapType::size_type size_type;

    Map(::fwAtoms::Base::Key key)
    {
    }

    virtual ~Map()
    {
    }

    std::pair<IteratorType, bool> insert(const std::string& key, const Base::sptr& value)
    {
        return m_value.insert( ValueType(key, value) );
    }

    size_t size() const
    {
        return m_value.size();
    }

    IteratorType begin()
    {
        return m_value.begin();
    }

    ConstIteratorType begin() const
    {
        return m_value.begin();
    }

    IteratorType end()
    {
        return m_value.end();
    }

    ConstIteratorType end() const
    {
        return m_value.end();
    }

    void  clear()
    {
        m_value.clear();
    }

    bool empty() const
    {
        return m_value.empty();
    }

    const MapType& getValue() const
    {
        return m_value;
    }

    MapType::const_iterator find(const std::string& key) const
    {
        return m_value.find(key);
    }

    Base::sptr operator[](const std::string& key)
    {
        return m_value[key];
    }

    FWATOMS_API virtual Base::sptr clone() const override;

    ::fwAtoms::Base::AtomType type() const override
    {
        return ::fwAtoms::Base::MAP;
    }

protected:
    MapType m_value;
};

}

#endif /* __FWATOMS_MAP_HPP__ */