it_bus_pdk/qname_ordered_map.h

//
//  @Copyright (c) 2003 IONA Technologies PLC. All Rights Reserved.
//

#ifndef _QNAME_ORDERED_MAP_H_
#define _QNAME_ORDERED_MAP_H_

#include <it_bus/types.h>
#include <it_dsa/vector.h>
#include <it_bus/qname.h>

// This class can be used to maintain an ordered mapping of QNames to
// other objects, while still maintaining hash-based performance for
// insertions. The mapping order is based on the order of insertions 
// into the map.

namespace IT_Bus
{
    template <class T>
    class QNameOrderedMap
    {
      public:

        typedef IT_Vector<T>    ValueSet;       
        typedef QNameHashMap<T> QNameTable;

        QNameOrderedMap();
        ~QNameOrderedMap();

        IT_TYPENAME QNameTable::const_iterator 
        get(
            const QName& q
        ) const;

        void 
        put(
            const QName& q, 
            const T obj
        );
        
        void 
        remove(
            const QName& q
        );      

        ValueSet
        get_values() const;

        size_t
        get_size() const;               

        IT_TYPENAME QNameTable::const_iterator
        end() const;

      private:                  

        QNameTable m_map;
        IT_Vector<IT_TYPENAME QNameTable::iterator> m_ordering;

        // Not implemented:
        QNameOrderedMap&
        operator=(const QNameOrderedMap&);

        QNameOrderedMap(const QNameOrderedMap&);
    };
}

// Inline functions

template <class T>
IT_Bus::QNameOrderedMap<T>::QNameOrderedMap()
{
    // complete
}

template <class T>
IT_Bus::QNameOrderedMap<T>::~QNameOrderedMap()
{
    IT_TYPENAME QNameTable::iterator iter = m_map.begin();    

    while (iter != m_map.end())
    {
        m_map.erase(iter++);
    }
}

template <class T>
IT_TYPENAME IT_Bus::QNameOrderedMap<T>::QNameTable::const_iterator
IT_Bus::QNameOrderedMap<T>::get(
    const QName& q
) const
{
    IT_TYPENAME QNameTable::const_iterator i = m_map.find(q);    
    return i;
}

template <class T>
void
IT_Bus::QNameOrderedMap<T>::put(
    const QName& q,
    const T obj
)
{
    m_map[q] = obj;
    m_ordering.push_back(m_map.find(q));
}

template <class T>
void
IT_Bus::QNameOrderedMap<T>::remove(
    const QName& q
)
{
    IT_TYPENAME QNameTable::iterator i = m_map.find(q);

    IT_TYPENAME IT_Vector<IT_TYPENAME QNameTable::iterator>::iterator k =
        m_ordering.begin();
    for ( ; k != m_ordering.end(); ++k)
    {
        if (*k == i)
        {
            m_ordering.erase(k);            
        }
    }
    m_map.erase(i);
}

template <class T>
IT_Vector<T>
IT_Bus::QNameOrderedMap<T>::get_values() const
{
    ValueSet values;

    IT_TYPENAME IT_Vector<IT_TYPENAME QNameTable::iterator>::const_iterator k =
        m_ordering.begin();

    for ( ; k != m_ordering.end(); ++k)
    {
        values.push_back((*(*k)).second);
    }
    return values;
}

template <class T>
size_t
IT_Bus::QNameOrderedMap<T>::get_size() const
{
    return m_map.size();
}

template <class T>
IT_TYPENAME IT_Bus::QNameOrderedMap<T>::QNameTable::const_iterator
IT_Bus::QNameOrderedMap<T>::end() const
{
    return m_map.end();
}

#endif 

---