sprint/container/unordered_map.h

Go to the documentation of this file.

/******************************************************************************
*   sprint::unordered_map
*
*   Copyright (C) 2005-2011  Paolo Medici <www.pmx.it>
*
*  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 _SPRINT_UNORDERED_MAP_H
#define _SPRINT_UNORDERED_MAP_H

#include <vector>
#include <utility> // std::pair

namespace sprint {

template <typename _Key, typename _Tp>
class unordered_map: public std::vector< std::pair<_Key,_Tp> > {
        public:
                typedef _Key                                                            key_type;
    typedef _Tp                                                                 mapped_type;
    typedef std::pair<_Key, _Tp>                 value_type;

                typedef typename std::vector< value_type >      parent;
        public:
                typedef typename parent::iterator               iterator;
    typedef typename parent::const_iterator         const_iterator;    
  public: // temporary interface
                iterator
                force_insert(const key_type & __x, const mapped_type & type)
                {
                        parent::push_back(value_type(__x, mapped_type() ));
                        return parent::end() - 1;
                }       
        public:
    
                iterator find(const key_type& __x)      {
                        for(iterator i = parent::begin(); i!= parent::end(); i++)
                                if(i->first == __x)
                                                return i;
                        return parent::end();
                        }
                const_iterator find(const key_type& __x)        const {
                        for(const_iterator i = parent::begin(); i!= parent::end(); i++)
                                if(i->first == __x)
                                                return i;
                        return parent::end();
                }       
                
                mapped_type &
                operator[](const key_type & __x)
                {
                        iterator i = find(__x);
                        if(i==parent::end())
                                i = force_insert(__x, mapped_type());
                return i->second;
                }
                
                void insert(const value_type & __x)
                 {
             parent::push_back(__x);
         }

};

}

#endif