it_bus/string_map.h

#ifndef _IT_BUS_STRING_MAP_H_
#define _IT_BUS_STRING_MAP_H_

// @Copyright 2004 IONA Technologies, Plc. All Rights Reserved.
//

#include <it_bus/types.h>
#include <it_bus/string_hash.h>
#include <it_dsa/hash_map.h>

namespace IT_Bus
{
    template<class Data>
    class StringMap
    {
      public:
        typedef String                           key_type;
        typedef Data                             data_type;
        typedef Data&                            reference_type;
        typedef const Data&                      const_reference_type;
        typedef IT_Pair<const String, data_type> value_type;
        typedef size_t                           size_type;
        typedef ptrdiff_t                        difference_type;
        typedef StringHash                       hasher;
        typedef StringEq                         key_equal;

        typedef IT_TYPENAME
        IT_HashMap<String, Data, StringHash, StringEq>::iterator iterator;

        typedef IT_TYPENAME
        IT_HashMap<String, Data, StringHash, StringEq>::const_iterator
        const_iterator;

        StringMap(
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );

        IT_EXPLICIT StringMap(
            size_type            count,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );

        StringMap(
            size_type            count,
            hasher               hash_fn,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        StringMap(
            size_type            count,
            hasher               hash_fn,
            key_equal            key_eq,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );

        // Note: This method is inlined here due to a bug in the AIX linker.
        //
        StringMap(
            const StringMap<Data>& map_
        ) : m_map(map_.m_map)
        {
            // complete
        }

        ~StringMap();

        StringMap<Data>&
        operator=(
            const StringMap<Data>& map_
        );

        iterator
        begin();

        const_iterator
        begin() const;

        iterator
        end();

        const_iterator
        end() const;

        hasher
        hash_funct() const;

        key_equal
        key_eq() const;

        void
        swap(
            StringMap<Data>& map_
        );

        IT_Pair<iterator, IT_Bool>
        insert(
            const value_type&    val,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );

        void
        insert(
            const value_type*    first,
            const value_type*    last,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );

        size_type
        erase(
            const key_type& key
        );

        void
        erase(
            const iterator& pos
        );

        void
        erase(
            const iterator& first,
            const iterator& last
        );

        iterator
        find(
            const key_type& key
        );
        const_iterator
        find(
            const key_type& key
        ) const;

        size_type
        size() const;

        data_type&
        operator[](
            const IT_ConstPairWithException<key_type>& key
        );

        size_type
        bucket_count() const;

        void
        resize(
            size_type            count,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );

      private:
        IT_HashMap<String, Data, StringHash, StringEq> m_map;
    };
}


// Inline functions.
//
template<class Data>
inline IT_TYPENAME IT_Bus::StringMap<Data>::iterator
IT_Bus::StringMap<Data>::begin()
{
    return m_map.begin();
}

template<class Data>
inline IT_TYPENAME IT_Bus::StringMap<Data>::const_iterator
IT_Bus::StringMap<Data>::begin() const
{
    return m_map.begin();
}

template<class Data>
inline IT_TYPENAME IT_Bus::StringMap<Data>::iterator
IT_Bus::StringMap<Data>::end()
{
    return m_map.end();
}

template<class Data>
inline IT_TYPENAME IT_Bus::StringMap<Data>::const_iterator
IT_Bus::StringMap<Data>::end() const
{
    return m_map.end();
}

template<class Data>
inline IT_TYPENAME IT_Bus::StringMap<Data>::hasher
IT_Bus::StringMap<Data>::hash_funct() const
{
    return m_map.hash_funct();
}

template<class Data>
inline IT_TYPENAME IT_Bus::StringMap<Data>::key_equal
IT_Bus::StringMap<Data>::key_eq() const
{
    return m_map.key_eq();
}

template<class Data>
inline void
IT_Bus::StringMap<Data>::swap(
    IT_Bus::StringMap<Data>& map_
)
{
    m_map.swap(map_.m_map);
}

template<class Data>
inline IT_Pair<IT_TYPENAME IT_Bus::StringMap<Data>::iterator, IT_Bool>
IT_Bus::StringMap<Data>::insert(
    const IT_TYPENAME IT_Bus::StringMap<Data>::value_type& val,
    IT_ExceptionHandler&                              eh
)
{
    return m_map.insert(val, eh);
}

template<class Data>
inline void
IT_Bus::StringMap<Data>::insert(
    const IT_TYPENAME IT_Bus::StringMap<Data>::value_type* first,
    const IT_TYPENAME IT_Bus::StringMap<Data>::value_type* last,
    IT_ExceptionHandler&                              eh
)
{
    m_map.insert(first, last, eh);
}

template<class Data>
inline IT_TYPENAME IT_Bus::StringMap<Data>::size_type
IT_Bus::StringMap<Data>::erase(
    const IT_TYPENAME IT_Bus::StringMap<Data>::key_type& key
)
{
    return m_map.erase(key);
}

template<class Data>
inline void
IT_Bus::StringMap<Data>::erase(
    const IT_TYPENAME IT_Bus::StringMap<Data>::iterator& pos
)
{
    m_map.erase(pos);
}

template<class Data>
inline void
IT_Bus::StringMap<Data>::erase(
    const IT_TYPENAME IT_Bus::StringMap<Data>::iterator& first,
    const IT_TYPENAME IT_Bus::StringMap<Data>::iterator& last
)
{
    m_map.erase(first, last);
}

template<class Data>
inline IT_TYPENAME IT_Bus::StringMap<Data>::iterator
IT_Bus::StringMap<Data>::find(
    const IT_TYPENAME IT_Bus::StringMap<Data>::key_type& key
)
{
    return m_map.find(key);
}

template<class Data>
inline IT_TYPENAME IT_Bus::StringMap<Data>::const_iterator
IT_Bus::StringMap<Data>::find(
    const IT_TYPENAME IT_Bus::StringMap<Data>::key_type& key
) const
{
    return m_map.find(key);
}

template<class Data>
inline IT_TYPENAME IT_Bus::StringMap<Data>::size_type
IT_Bus::StringMap<Data>::size() const
{
    return m_map.size();
}

template<class Data>
inline IT_TYPENAME IT_Bus::StringMap<Data>::data_type&
IT_Bus::StringMap<Data>::operator[](
    const IT_ConstPairWithException<key_type>& key
)
{
    return m_map[key];
}

template<class Data>
inline IT_TYPENAME IT_Bus::StringMap<Data>::size_type
IT_Bus::StringMap<Data>::bucket_count() const
{
    return m_map.bucket_count();
}

template<class Data>
inline void
IT_Bus::StringMap<Data>::resize(
    IT_TYPENAME IT_Bus::StringMap<Data>::size_type count,
    IT_ExceptionHandler&                      eh
)
{
    m_map.resize(count, eh);
}

#if IT_SUPPORTS_COMPILE_TIME_INSTANTIATION
#include <it_bus/string_map.cxx>
#endif 

#endif  

---