Map.h

Go to the documentation of this file.

// $Id: Map.h,v 1.6 2007/12/19 15:42:56 marcocle Exp $
// ============================================================================
// CVS tag $Name:  $, version $Revision: 1.6 $
// ============================================================================
#ifndef GAUDIKERNEL_MAP_H
#define GAUDIKERNEL_MAP_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL 
// ============================================================================
#include <map>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/MapBase.h"
// ============================================================================
namespace GaudiUtils 
{
  // ==========================================================================
  template <typename K, typename T, typename M = std::map<K,T> >
  class Map : public Gaudi::Utils::MapBase
  {
  public:
    // ========================================================================
    // ---- types
    typedef M                      map_type;
    typedef K                      key_type;
    typedef T                      mapped_type;
    
    // -- from unary_function
    typedef K                      argument_type;
    typedef T                      result_type;
    typedef std::pair<const K,T>   value_type;
    
    typedef typename map_type::size_type size_type;
  
    typedef typename map_type::iterator iterator;
    typedef typename map_type::const_iterator const_iterator;
    // typedef typename map_type::reverse_iterator reverse_iterator;
    // typedef typename map_type::const_reverse_iterator const_reverse_iterator;
    // ========================================================================    
  protected:
    // ========================================================================
    map_type m_map;
    static const result_type s_null_value;
    // ========================================================================    
  public:
    // ---- Constructors
    
    Map(): m_map() {}
    
    Map(const map_type& other): m_map(other) {}
    
    // /// Copy Constructor
    // Map(const Map& other): m_map(other.m_map) {}
    template <typename In>
    Map(In first, In last): m_map(first,last) {}
    
    virtual ~Map() {}
    
    // ---- std::map interface
    
    //    -- iterators
    
    inline iterator begin() { return m_map.begin(); }
    inline iterator end()   { return m_map.end(); }
    
    inline const_iterator begin() const { return m_map.begin(); }
    inline const_iterator end()   const { return m_map.end(); }
  
    // inline reverse_iterator rbegin() { return m_map.rbegin(); }
    // inline reverse_iterator rend()   { return m_map.rend(); }
  
    // inline const_reverse_iterator rbegin() const { return m_map.rbegin(); }
    // inline const_reverse_iterator rend()   const { return m_map.rend(); }
  
    //    -- subscription
  
    inline mapped_type &operator[] (const key_type &key) { return m_map[key]; }
  
    //    -- map operations
  
    inline iterator find(const key_type &key) { return m_map.find(key); }
    inline const_iterator find(const key_type &key) const { return m_map.find(key); }
  
    inline size_type count(const key_type &key) const { return m_map.count(key); }
  
    inline iterator lower_bound(const key_type &key) { return m_map.lower_bound(key); }
    inline const_iterator lower_bound(const key_type &key) const { return m_map.lower_bound(key); }
    inline iterator upper_bound(const key_type &key) { return m_map.upper_bound(key); }  
    inline const_iterator upper_bound(const key_type &key) const { return m_map.upper_bound(key); }
  
    inline std::pair<iterator,iterator> equal_range(const key_type &key)
    { return m_map.equal_range(key); }
    inline std::pair<const_iterator,const_iterator> equal_range(const key_type &key) const
    { return m_map.equal_range(key); }
  
    //    -- list operations
    
    inline std::pair<iterator,bool> insert(const value_type &val) { return m_map.insert(val); }
    inline std::pair<iterator,bool> insert
    ( const key_type    & key , 
      const mapped_type & val ) { return insert ( value_type ( key , val ) ) ; }
    template <typename In>
    inline void insert(In first, In last) { m_map.insert(first,last); }
    inline iterator insert( iterator /* pos */ , const value_type &val) 
    { return m_map.insert( /* pos, */ val ).first ; }
    inline void erase(iterator pos) { m_map.erase(pos); }
    inline size_type erase(const key_type &key) { return m_map.erase(key); }
    inline void erase(iterator first, iterator last) { m_map.erase(first,last); }
    inline void clear() { m_map.clear(); }
  
    //    -- container operations
  
    inline size_type size() const { return m_map.size(); }
    inline size_type max_size() const { return m_map.max_size(); }
    inline bool empty() const { return size() == 0; }
    inline void swap(map_type& other) { m_map.swap(other); }
  
    // ---- extra functionalities
    
    inline const result_type &operator() ( const argument_type &key ) const
    {
      // static const result_type s_null_value;
      const_iterator it = m_map.find(key);
      if ( it != m_map.end() ) { return it->second ; }   
      return s_null_value;  // return the default value 
    }
    // ========================================================================
    inline const mapped_type &operator[] ( const key_type &key ) const
    { return (*this)(key); }
    // ========================================================================
    inline const result_type & at ( const argument_type &key ) const
    {
      const_iterator it = m_map.find ( key ) ;
      if ( it == m_map.end() ) { this->throw_out_of_range_exception () ; }
      return it->second ;    
    }
    // ========================================================================
    inline Map& merge ( const map_type& other ) 
    {
      for ( typename map_type::const_iterator it = other.begin() ; 
            other.end() != it ; ++it ) { (*this)[it->first] = it->second ; }
      return *this;
    }
    inline Map& merge ( const Map& other ) 
    {
      for ( const_iterator it = other.begin() ; 
            other.end() != it ; ++it ) { (*this)[it->first] = it->second ; }
      return *this;
    }
    template <class K1,class K2, class K3>
    inline Map& merge ( const Map<K1,K2,K3>& other ) 
    {
      for ( typename Map<K1,K2,K3>::const_iterator it = other.begin() ; 
            other.end() != it ; ++it ) { (*this)[it->first] = it->second ; }
      return *this;
    }
    // update the key
    void update 
    ( const key_type&    key    ,
      const mapped_type& mapped ) { (*this)[ key ] = mapped ; }
    // ========================================================================
  public:
    // ========================================================================
    inline operator       map_type &()       { return m_map ; }
    inline operator const map_type &() const { return m_map ; }
    // ========================================================================
  public:
    // ========================================================================
    const key_type&    key_at   ( const size_t index ) const 
    {
      if ( index >= size() ) 
      { this->throw_out_of_range_exception () ; }
      const_iterator it = this->begin() ;
      std::advance ( it , index ) ;
      return it -> first ;
    }
    const mapped_type& value_at ( const size_t index ) const 
    {
      if ( index >= size() ) 
      { this->throw_out_of_range_exception () ; }
      const_iterator it = this->begin() ;
      std::advance ( it , index ) ;
      return it -> second ;
    }
    // ========================================================================
  };
  // ==========================================================================
  template <typename K, typename T, typename M>
  const typename Map<K,T,M>::result_type Map<K,T,M>::s_null_value = typename Map<K,T,M>::result_type();
  // ==========================================================================
} //                                                end of GaudiUtils namespace
// ============================================================================

// ============================================================================
// The END 
// ============================================================================
#endif // GAUDIKERNEL_MAP_H
// ============================================================================