---

map.hh

/*
*  Name:      map.hh
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Extension class for STL map
*  Date:      $Date: 2003/04/14 00:18:35 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1994-2001  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program 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 General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#ifndef _MPCL_UTIL_COLLECTION_MAP__
#define _MPCL_UTIL_COLLECTION_MAP__

#include <map>
#include "../../exceptions.hh"


namespace mpcl
{

  namespace util
  {

    namespace collection
    {

      template < typename TKey                                   ,
                 typename TItem                                  ,
                 typename TCompare       = std::less<TKey>       ,
                 typename TItemAllocator = std::allocator<TItem> >
      class TMap : public std::map<TKey, TItem, TCompare, TItemAllocator>
      {

        public:

          typedef
            typename std::map<TKey, TItem, TCompare, TItemAllocator>::const_iterator
            const_iterator;

          typedef
            typename std::map<TKey, TItem, TCompare, TItemAllocator>::const_pointer
            const_pointer;

          typedef
            typename std::map<TKey, TItem, TCompare, TItemAllocator>::const_reference
            const_reference;

          typedef
            typename std::map<TKey, TItem, TCompare, TItemAllocator>::const_reverse_iterator
            const_reverse_iterator;

          typedef
            typename std::map<TKey, TItem, TCompare, TItemAllocator>::difference_type
            difference_type;

          typedef
            typename std::map<TKey, TItem, TCompare, TItemAllocator>::iterator
            iterator;

          typedef
            typename std::map<TKey, TItem, TCompare, TItemAllocator>::key_compare
            key_compare;

          typedef
            typename std::map<TKey, TItem, TCompare, TItemAllocator>::key_type
            key_type;

          typedef
            typename std::map<TKey, TItem, TCompare, TItemAllocator>::mapped_type
            mapped_type;

          typedef
            typename std::map<TKey, TItem, TCompare, TItemAllocator>::pointer
            pointer;

          typedef
            typename std::map<TKey, TItem, TCompare, TItemAllocator>::reference
            reference;

          typedef
            typename std::map<TKey, TItem, TCompare, TItemAllocator>::reverse_iterator
            reverse_iterator;

          typedef
            typename std::map<TKey, TItem, TCompare, TItemAllocator>::size_type
            size_type;

          typedef
            typename std::map<TKey, TItem, TCompare, TItemAllocator>::value_type
            value_type;


        public:

          //
          //  C O N S T R U C T O R S
          //

          TMap (void)                                         :
            std::map<TKey, TItem, TCompare, TItemAllocator>() {}

          explicit TMap (const TCompare& rktCOMPARE)                     :
            std::map<TKey, TItem, TCompare, TItemAllocator> (rktCOMPARE) {}

          template <typename InputIterator>
          TMap (InputIterator tBEGIN, InputIterator tEND)                  :
            std::map<TKey, TItem, TCompare, TItemAllocator> (tBEGIN, tEND) {}

          template <typename InputIterator>
          TMap ( InputIterator   tBEGIN     ,
                 InputIterator   tEND       ,
                 const TCompare& rktCOMPARE )                                          :
            std::map<TKey, TItem, TCompare, TItemAllocator> (tBEGIN, tEND, rktCOMPARE) {}

          TMap (const std::map<TKey, TItem, TCompare, TItemAllocator>& rktSOURCE_MAP) :
            std::map<TKey, TItem, TCompare, TItemAllocator> (rktSOURCE_MAP)           {}

          TMap& operator = (const TMap& rktSOURCE_MAP)
          {
            std::map<TKey, TItem, TCompare, TItemAllocator>::operator = (rktSOURCE_MAP);
            return *this;
          }

          TMap& bind (const TKey& rktKEY, const TItem& rktITEM)
          {
            insert (std::make_pair (rktKEY, rktITEM));
            return *this;
          }


        public:

          //
          //  S E L E C T O R S
          //

          bool isBound (const key_type& rktKEY) const
          {
            return ( find (rktKEY) != end() );
          }

          TItem& operator [] (const key_type& rktKEY)
          {
            iterator   tIter = find (rktKEY);

            if ( tIter == end() )
            {
              throw TConstraintException ("item not in map", __FILE__, __LINE__);
            }
            return tIter->second;
          }

          const TItem& operator [] (const key_type& rktKEY) const
          {
            const_iterator   ktIter = find (rktKEY);

            if ( ktIter == end() )
            {
              throw TConstraintException ("item not in map", __FILE__, __LINE__);
            }
            return ktIter->second;
          }

      };  // class TMap

    }  // namespace collection

  }  // namespace util

}  // namespace mpcl


#endif  // not _MPCL_UTIL_COLLECTION_MAP__

---