| # Gaudi Framework, version v21r10p1 |

Home |  | Generated: 29 Jul 2010

# GaudiUtils::Map< K, T, M > Class Template Reference

Extension of the STL map. More...

`#include <Map.h>`

Inheritance diagram for GaudiUtils::Map< K, T, M >:

[legend]
Collaboration diagram for GaudiUtils::Map< K, T, M >:

[legend]

List of all members.

## Public Types
typedef M | map_type
typedef K | key_type
typedef T | mapped_type
typedef K | argument_type
typedef T | result_type
typedef std::pair< const K, T > | value_type
typedef map_type::size_type | size_type
typedef map_type::iterator | iterator
typedef map_type::const_iterator | const_iterator
## Public Member Functions
| Map ()
| Standard constructor.
| Map (const map_type &other)
| Constructor from a standard map.
template<typename In>
| Map (In first, In last)
| Construct from a subset.
virtual | ~Map ()
| Virtual destructor. You can inherit from this map type.
iterator | begin ()
iterator | end ()
const_iterator | begin () const
const_iterator | end () const
mapped_type & | operator[] (const key_type &key)
iterator | find (const key_type &key)
const_iterator | find (const key_type &key) const
size_type | count (const key_type &key) const
iterator | lower_bound (const key_type &key)
const_iterator | lower_bound (const key_type &key) const
iterator | upper_bound (const key_type &key)
const_iterator | upper_bound (const key_type &key) const
std::pair< iterator, iterator > | equal_range (const key_type &key)
std::pair< const_iterator, const_iterator > | equal_range (const key_type &key) const
std::pair< iterator, bool > | insert (const value_type &val)
std::pair< iterator, bool > | insert (const key_type &key, const mapped_type &val)
template<typename In>
void | insert (In first, In last)
iterator | insert (iterator, const value_type &val)
void | erase (iterator pos)
size_type | erase (const key_type &key)
void | erase (iterator first, iterator last)
void | clear ()
size_type | size () const
size_type | max_size () const
bool | empty () const
void | swap (map_type &other)
const result_type & | operator() (const argument_type &key) const
| Allow to use Map as an unary function.
const mapped_type & | operator[] (const key_type &key) const
| Access elements of a const Map.
const result_type & | at (const argument_type &key) const
  | checked access to the map Exceptions:
  | std::out_of_range | for missing keys
Map & | merge (const map_type &other)
| Merge two maps.
Map & | merge (const Map &other)
| Merge two maps.
template<class K1, class K2, class K3>
Map & | merge (const Map< K1, K2, K3 > &other)
| Merge two maps.
void | update (const key_type &key, const mapped_type &mapped)
| operator map_type & ()
| Allows to use the Map wherever an std::map is explicitly requested.
| operator const map_type & () const
const key_type & | key_at (const size_t index) const
| useful method for python decoration:
const mapped_type & | value_at (const size_t index) const
| useful method for python decoration:
## Protected Attributes
map_type | m_map
## Static Protected Attributes
static const result_type | s_null_value = typename Map<K,T,M>::result_type()

## Detailed Description

### template<typename K, typename T, typename M = std::map<K,T>>
class GaudiUtils::Map< K, T, M >

Extension of the STL map.

Provides const accessors and can be extended by inheritance.

See also:
  std::map Note: in order to make it possible to use either a map or a hash_map, reverse iterators are not defined.

Due to helper base class Gaudi::Utils::MapBase, this class is "python-friendly", and one can perform all python manipulaitons in intuitive way:

        >>> m = ...        ## get the map
        >>> print m        ## print the map a'la python class dict
        ...
        >>> for key in m :  print key, m[key]   ## iteration over the map
        ...
        >>> for key,value in m.iteritems() : print key, value
        ...
        >>> keys   = m.keys()                     ## get the list of keys
        >>> values = m.values ()                  ## get the list of values
        >>  items  = m.items  ()                  ## get the list of items

        >>> if 'one' in m           ## check the presence of the key in map

        >>>  v = m.get(key', None) ## return m[key] for existing key, else None

        >>>  del m[key]      ## erase the key form the map

        >>> value m[key]     ## unchecked access through the key
        ...
        >>> m.update( key, value ) ## update/insert key/value pair

Attention:
  The syntax can be drastically simplified, if one redefines the __setitem__ attribute:

        >>> type(m).__setitem__ = Gaudi.Utils.MapBase.__setitem__

        >>> m[key] = value  ## much more intuitive semantics for key insertion

In a similar way `__getitem__` and `__delitem__` methods can be redefined.

Attention:
  To avoid the unnesessary expansion of dictionaries it is recommended to exclude from dictionary the following methods:
  - lower_bound
  - upper_bound
  - equal_range
  - insert

Warning:
  This action is required for `HashMap` to avodi the compilation problems

See also:
  Gaudi::Utils::MapBase

Author:
  Marco Clemencic

Date:
  2005-10-06

Definition at line 86 of file Map.h.

## Member Typedef Documentation

template<typename K, typename T, typename M = std::map<K,T>>

typedef M GaudiUtils::Map< K, T, M >::map_type

Definition at line 91 of file Map.h.

template<typename K, typename T, typename M = std::map<K,T>>

typedef K GaudiUtils::Map< K, T, M >::key_type

Definition at line 92 of file Map.h.

template<typename K, typename T, typename M = std::map<K,T>>

typedef T GaudiUtils::Map< K, T, M >::mapped_type

Definition at line 93 of file Map.h.

template<typename K, typename T, typename M = std::map<K,T>>

typedef K GaudiUtils::Map< K, T, M >::argument_type

Definition at line 96 of file Map.h.

template<typename K, typename T, typename M = std::map<K,T>>

typedef T GaudiUtils::Map< K, T, M >::result_type

Definition at line 97 of file Map.h.

template<typename K, typename T, typename M = std::map<K,T>>

typedef std::pair<const K,T> GaudiUtils::Map< K, T, M >::value_type

Definition at line 98 of file Map.h.

template<typename K, typename T, typename M = std::map<K,T>>

typedef map_type::size_type GaudiUtils::Map< K, T, M >::size_type

Definition at line 100 of file Map.h.

template<typename K, typename T, typename M = std::map<K,T>>

typedef map_type::iterator GaudiUtils::Map< K, T, M >::iterator

Definition at line 102 of file Map.h.

template<typename K, typename T, typename M = std::map<K,T>>

typedef map_type::const_iterator GaudiUtils::Map< K, T, M >::const_iterator

Definition at line 103 of file Map.h.

## Constructor & Destructor Documentation

template<typename K, typename T, typename M = std::map<K,T>>

GaudiUtils::Map< K, T, M >::Map | ( |  | ) | `[inline]`

Standard constructor.

Definition at line 116 of file Map.h.

    00116 : m_map() {}

template<typename K, typename T, typename M = std::map<K,T>>

GaudiUtils::Map< K, T, M >::Map | ( | const map_type & | other | ) | `[inline]`

Constructor from a standard map.

Definition at line 119 of file Map.h.

    00119 : m_map(other) {}

template<typename K, typename T, typename M = std::map<K,T>>
template<typename In>

GaudiUtils::Map< K, T, M >::Map | ( | In | first,
|  | In | last |
| ) |  |  | `[inline]`

Construct from a subset.

Definition at line 125 of file Map.h.

    00125 : m_map(first,last) {}

template<typename K, typename T, typename M = std::map<K,T>>

virtual GaudiUtils::Map< K, T, M >::~Map | ( |  | ) | `[inline, virtual]`

Virtual destructor. You can inherit from this map type.

Definition at line 128 of file Map.h.

    00128 {}

## Member Function Documentation

template<typename K, typename T, typename M = std::map<K,T>>

iterator GaudiUtils::Map< K, T, M >::begin | ( |  | ) | `[inline]`

Definition at line 134 of file Map.h.

    00134 { return m_map.begin(); }

template<typename K, typename T, typename M = std::map<K,T>>

iterator GaudiUtils::Map< K, T, M >::end | ( |  | ) | `[inline]`

Definition at line 135 of file Map.h.

    00135 { return m_map.end(); }

template<typename K, typename T, typename M = std::map<K,T>>

const_iterator GaudiUtils::Map< K, T, M >::begin | ( |  | ) | const`[inline]`

Definition at line 137 of file Map.h.

    00137 { return m_map.begin(); }

template<typename K, typename T, typename M = std::map<K,T>>

const_iterator GaudiUtils::Map< K, T, M >::end | ( |  | ) | const`[inline]`

Definition at line 138 of file Map.h.

    00138 { return m_map.end(); }

template<typename K, typename T, typename M = std::map<K,T>>

mapped_type& GaudiUtils::Map< K, T, M >::operator[] | ( | const key_type & | key | ) | `[inline]`

Definition at line 148 of file Map.h.

    00148 { return m_map[key]; }

template<typename K, typename T, typename M = std::map<K,T>>

iterator GaudiUtils::Map< K, T, M >::find | ( | const key_type & | key | ) | `[inline]`

Definition at line 152 of file Map.h.

    00152 { return m_map.find(key); }

template<typename K, typename T, typename M = std::map<K,T>>

const_iterator GaudiUtils::Map< K, T, M >::find | ( | const key_type & | key | ) | const`[inline]`

Definition at line 153 of file Map.h.

    00153 { return m_map.find(key); }

template<typename K, typename T, typename M = std::map<K,T>>

size_type GaudiUtils::Map< K, T, M >::count | ( | const key_type & | key | ) | const`[inline]`

Definition at line 155 of file Map.h.

    00155 { return m_map.count(key); }

template<typename K, typename T, typename M = std::map<K,T>>

iterator GaudiUtils::Map< K, T, M >::lower_bound | ( | const key_type & | key | ) | `[inline]`

Definition at line 157 of file Map.h.

    00157 { return m_map.lower_bound(key); }

template<typename K, typename T, typename M = std::map<K,T>>

const_iterator GaudiUtils::Map< K, T, M >::lower_bound | ( | const key_type & | key | ) | const`[inline]`

Definition at line 158 of file Map.h.

    00158 { return m_map.lower_bound(key); }

template<typename K, typename T, typename M = std::map<K,T>>

iterator GaudiUtils::Map< K, T, M >::upper_bound | ( | const key_type & | key | ) | `[inline]`

Definition at line 159 of file Map.h.

    00159 { return m_map.upper_bound(key); }

template<typename K, typename T, typename M = std::map<K,T>>

const_iterator GaudiUtils::Map< K, T, M >::upper_bound | ( | const key_type & | key | ) | const`[inline]`

Definition at line 160 of file Map.h.

    00160 { return m_map.upper_bound(key); }

template<typename K, typename T, typename M = std::map<K,T>>

std::pair<iterator,iterator> GaudiUtils::Map< K, T, M >::equal_range | ( | const key_type & | key | ) | `[inline]`

Definition at line 162 of file Map.h.

    00163     { return m_map.equal_range(key); }

template<typename K, typename T, typename M = std::map<K,T>>

std::pair<const_iterator,const_iterator> GaudiUtils::Map< K, T, M >::equal_range | ( | const key_type & | key | ) | const`[inline]`

Definition at line 164 of file Map.h.

    00165     { return m_map.equal_range(key); }

template<typename K, typename T, typename M = std::map<K,T>>

std::pair<iterator,bool> GaudiUtils::Map< K, T, M >::insert | ( | const value_type & | val | ) | `[inline]`

Definition at line 169 of file Map.h.

    00169 { return m_map.insert(val); }

template<typename K, typename T, typename M = std::map<K,T>>

std::pair<iterator,bool> GaudiUtils::Map< K, T, M >::insert | ( | const key_type & | key,
|  | const mapped_type & | val |
| ) |  |  | `[inline]`

Definition at line 171 of file Map.h.

    00172                                 { return insert ( value_type ( key , val ) ) ; }

template<typename K, typename T, typename M = std::map<K,T>>
template<typename In>

void GaudiUtils::Map< K, T, M >::insert | ( | In | first,
|  | In | last |
| ) |  |  | `[inline]`

Definition at line 174 of file Map.h.

    00174 { m_map.insert(first,last); }

template<typename K, typename T, typename M = std::map<K,T>>

iterator GaudiUtils::Map< K, T, M >::insert | ( | iterator | ,
|  | const value_type & | val |
| ) |  |  | `[inline]`

Definition at line 175 of file Map.h.

    00176     { return m_map.insert( /* pos, */ val ).first ; }

template<typename K, typename T, typename M = std::map<K,T>>

void GaudiUtils::Map< K, T, M >::erase | ( | iterator | pos | ) | `[inline]`

Definition at line 177 of file Map.h.

    00177 { m_map.erase(pos); }

template<typename K, typename T, typename M = std::map<K,T>>

size_type GaudiUtils::Map< K, T, M >::erase | ( | const key_type & | key | ) | `[inline]`

Definition at line 178 of file Map.h.

    00178 { return m_map.erase(key); }

template<typename K, typename T, typename M = std::map<K,T>>

void GaudiUtils::Map< K, T, M >::erase | ( | iterator | first,
|  | iterator | last |
| ) |  |  | `[inline]`

Definition at line 179 of file Map.h.

    00179 { m_map.erase(first,last); }

template<typename K, typename T, typename M = std::map<K,T>>

void GaudiUtils::Map< K, T, M >::clear | ( |  | ) | `[inline]`

Definition at line 180 of file Map.h.

    00180 { m_map.clear(); }

template<typename K, typename T, typename M = std::map<K,T>>

size_type GaudiUtils::Map< K, T, M >::size | ( |  | ) | const`[inline]`

Definition at line 184 of file Map.h.

    00184 { return m_map.size(); }

template<typename K, typename T, typename M = std::map<K,T>>

size_type GaudiUtils::Map< K, T, M >::max_size | ( |  | ) | const`[inline]`

Definition at line 185 of file Map.h.

    00185 { return m_map.max_size(); }

template<typename K, typename T, typename M = std::map<K,T>>

bool GaudiUtils::Map< K, T, M >::empty | ( |  | ) | const`[inline]`

Definition at line 186 of file Map.h.

    00186 { return size() == 0; }

template<typename K, typename T, typename M = std::map<K,T>>

void GaudiUtils::Map< K, T, M >::swap | ( | map_type & | other | ) | `[inline]`

Definition at line 187 of file Map.h.

    00187 { m_map.swap(other); }

template<typename K, typename T, typename M = std::map<K,T>>

const result_type& GaudiUtils::Map< K, T, M >::operator() | ( | const argument_type & | key | ) | const`[inline]`

Allow to use Map as an unary function.

There is no automatic extension of the map for missing keys!

Attention:
  The behaviour is different from std::map

       const GaudiUtils::Map<KEY,VALUE> m = ... ;

       // OK:
       KEY key = ... ;
       std::cout << " Value: " << m(key) << std::end ; // it is OK!

       // ERROR:
       VALUE value = ... ;
       m(key) = value ;                                // ERROR!

Parameters:

  | key | the key

Returns:
  the mapped value(const reference!) for the existing key, and the default value overwise

return the default value

Definition at line 213 of file Map.h.

    00214     {
    00215       // static const result_type s_null_value;
    00216       const_iterator it = m_map.find(key);
    00217       if ( it != m_map.end() ) { return it->second ; }
    00219       return s_null_value;  // return the default value
    00220     }

template<typename K, typename T, typename M = std::map<K,T>>

const mapped_type& GaudiUtils::Map< K, T, M >::operator[] | ( | const key_type & | key | ) | const`[inline]`

Access elements of a const Map.

There is no automatic extension of the map for missing keys!

Attention:
  The behaviour is different from std::map

       const GaudiUtils::Map<KEY,VALUE> m = ... ;

       // OK:
       KEY key = ... ;
       std::cout << " Value: " << m[key] << std::end ; // it is OK!

       // ERROR:
       VALUE value = ... ;
       m[key] = value ;                                // ERROR!

Parameters:

  | key | the key

Returns:
  the mapped value(const reference!) for the existing key, and the default value overwise

Definition at line 244 of file Map.h.

    00245     { return (*this)(key); }

template<typename K, typename T, typename M = std::map<K,T>>

const result_type& GaudiUtils::Map< K, T, M >::at | ( | const argument_type & | key | ) | const`[inline]`

checked access to the map

Exceptions:

  | std::out_of_range | for missing keys

Parameters:

  | key | (INPUT) the key

Returns:
  the value for the existing key

Definition at line 252 of file Map.h.

    00253     {
    00254       const_iterator it = m_map.find ( key ) ;
    00255       if ( it == m_map.end() ) { this->throw_out_of_range_exception () ; }
    00256       return it->second ;
    00257     }

template<typename K, typename T, typename M = std::map<K,T>>

Map& GaudiUtils::Map< K, T, M >::merge | ( | const map_type & | other | ) | `[inline]`

Merge two maps.

Definition at line 260 of file Map.h.

    00261     {
    00262       for ( typename map_type::const_iterator it = other.begin() ;
    00263             other.end() != it ; ++it ) { (*this)[it->first] = it->second ; }
    00264       return *this;
    00265     }

template<typename K, typename T, typename M = std::map<K,T>>

Map& GaudiUtils::Map< K, T, M >::merge | ( | const Map< K, T, M > & | other | ) | `[inline]`

Merge two maps.

Definition at line 267 of file Map.h.

    00268     {
    00269       for ( const_iterator it = other.begin() ;
    00270             other.end() != it ; ++it ) { (*this)[it->first] = it->second ; }
    00271       return *this;
    00272     }

template<typename K, typename T, typename M = std::map<K,T>>
template<class K1, class K2, class K3>

Map& GaudiUtils::Map< K, T, M >::merge | ( | const Map< K1, K2, K3 > & | other | ) | `[inline]`

Merge two maps.

Definition at line 275 of file Map.h.

    00276     {
    00277       for ( typename Map<K1,K2,K3>::const_iterator it = other.begin() ;
    00278             other.end() != it ; ++it ) { (*this)[it->first] = it->second ; }
    00279       return *this;
    00280     }

template<typename K, typename T, typename M = std::map<K,T>>

void GaudiUtils::Map< K, T, M >::update | ( | const key_type & | key,
|  | const mapped_type & | mapped |
| ) |  |  | `[inline]`

Definition at line 283 of file Map.h.

    00284                                   { (*this)[ key ] = mapped ; }

template<typename K, typename T, typename M = std::map<K,T>>

GaudiUtils::Map< K, T, M >::operator map_type & | ( |  | ) | `[inline]`

Allows to use the Map wherever an std::map is explicitly requested.

Definition at line 289 of file Map.h.

    00289 { return m_map ; }

template<typename K, typename T, typename M = std::map<K,T>>

GaudiUtils::Map< K, T, M >::operator const map_type & | ( |  | ) | const`[inline]`

Definition at line 290 of file Map.h.

    00290 { return m_map ; }

template<typename K, typename T, typename M = std::map<K,T>>

const key_type& GaudiUtils::Map< K, T, M >::key_at | ( | const size_t | index | ) | const`[inline]`

useful method for python decoration:

Parameters:

  | index | (INPUT) the index

Returns:
  the key at given index

Exceptions:

  | std::out_of_range | for invalid index

Definition at line 299 of file Map.h.

    00300     {
    00301       if ( index >= size() )
    00302       { this->throw_out_of_range_exception () ; }
    00303       const_iterator it = this->begin() ;
    00304       std::advance ( it , index ) ;
    00305       return it -> first ;
    00306     }

template<typename K, typename T, typename M = std::map<K,T>>

const mapped_type& GaudiUtils::Map< K, T, M >::value_at | ( | const size_t | index | ) | const`[inline]`

useful method for python decoration:

Parameters:

  | index | (INPUT) the index

Returns:
  the value at given index

Exceptions:

  | std::out_of_range | for invalid index

Definition at line 312 of file Map.h.

    00313     {
    00314       if ( index >= size() )
    00315       { this->throw_out_of_range_exception () ; }
    00316       const_iterator it = this->begin() ;
    00317       std::advance ( it , index ) ;
    00318       return it -> second ;
    00319     }

## Member Data Documentation

template<typename K, typename T, typename M = std::map<K,T>>

map_type GaudiUtils::Map< K, T, M >::m_map`[protected]`

Definition at line 109 of file Map.h.

template<typename K, typename T, typename M = std::map<K,T>>

const Map< K, T, M >::result_type GaudiUtils::Map< K, T, M >::s_null_value = typename Map<K,T,M>::result_type()`[inline, static, protected]`

Definition at line 110 of file Map.h.

The documentation for this class was generated from the following file:

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r10p1/GaudiKernel/GaudiKernel/Map.h