| The Gaudi Framework v28r2-patches (bc4ad17a)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Public Types | Public Member Functions | Protected Attributes | Static Protected Attributes | List of all members
GaudiUtils::Map< K, T, M > Class Template Reference

Extension of the STL map. More...

`#include <GaudiKernel/Map.h>`

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

## 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 const value_type & | const_reference
typedef map_type::size_type | size_type
typedef map_type::iterator | iterator
typedef map_type::const_iterator | const_iterator

## Public Member Functions
| Map ()=default
| Standard constructor. More...
| Map (const map_type &other)
| Constructor from a standard map. More...
template<typename In >
| Map (In &&first, In &&last)
| Construct from a subset. More...
virtual | ~Map ()=default
| Virtual destructor. You can inherit from this map type. More...
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
template<class... Args>
std::pair< iterator, bool > | emplace (Args &&...args)
template<typename ValueType >
std::pair< iterator, bool > | insert (ValueType &&val)
std::pair< iterator, bool > | insert (value_type &&val)
template<typename In >
void | insert (In &&first, In &&last)
template<typename ValueType >
iterator | insert (iterator, ValueType &&val)
iterator | erase (const_iterator pos)
size_type | erase (const key_type &key)
iterator | erase (const_iterator first, const_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. More...
const mapped_type & | operator[] (const key_type &key) const
| Access elements of a const Map. More...
const result_type & | at (const argument_type &key) const
  | checked access to the map Exceptions
  std::out_of_range | for missing keys
More...
Map & | merge (const map_type &other)
| Merge two maps. More...
Map & | merge (const Map &other)
| Merge two maps. More...
template<class K1 , class K2 , class K3 >
Map & | merge (const Map< K1, K2, K3 > &other)
| Merge two maps. More...
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. More...
| operator const map_type & () const
const key_type & | key_at (const size_type index) const
| useful method for python decoration: More...
const mapped_type & | value_at (const size_type index) const
| useful method for python decoration: More...
Public Member Functions inherited from Gaudi::Utils::MapBase
virtual | ~MapBase ()
| virtual destructor More...

## Protected Attributes
map_type | m_map

## Static Protected Attributes
static const result_type | s_null_value = typename Map<K,T,M>::result_type()

## Additional Inherited Members
Protected Member Functions inherited from Gaudi::Utils::MapBase
void | throw_out_of_range_exception () const
| throw std::out_of_range exception More...

## 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 82 of file Map.h.

## Member Typedef Documentation

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

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

Definition at line 92 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 100 of file Map.h.

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

typedef const value_type& GaudiUtils::Map< K, T, M >::const_reference

Definition at line 95 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 99 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 88 of file Map.h.

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

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

Definition at line 87 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 89 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 93 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 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 94 of file Map.h.

## Constructor & Destructor Documentation

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

GaudiUtils::Map< K, T, M >::Map | ( |  | ) |
| default

Standard constructor.

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 116 of file Map.h.

116 : m_map(other) {}
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 122 of file Map.h.

122 : m_map(std::forward<In>(first),std::forward<In>(last)) {}
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
template<typename K, typename T, typename M = std::map<K,T>>

virtual GaudiUtils::Map< K, T, M >::~Map | ( |  | ) |
| virtual default

Virtual destructor. You can inherit from this map type.

## Member Function Documentation

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 249 of file Map.h.

250 {
251 return m_map.at(key);
252 }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
template<typename K, typename T, typename M = std::map<K,T>>

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

Definition at line 131 of file Map.h.

131 { return m_map.begin(); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
template<typename K, typename T, typename M = std::map<K,T>>

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

Definition at line 134 of file Map.h.

134 { return m_map.begin(); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
template<typename K, typename T, typename M = std::map<K,T>>

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

Definition at line 178 of file Map.h.

178 { m_map.clear(); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 152 of file Map.h.

152 { return m_map.count(key); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
template<typename K, typename T, typename M = std::map<K,T>>
template<class... Args>

std::pair<iterator,bool> GaudiUtils::Map< K, T, M >::emplace | ( | Args &&... | args | ) |
| inline

Definition at line 166 of file Map.h.

166 { return m_map.emplace(std::forward<Args>(args)...); }
gaudirun.args
args
Definition: gaudirun.py:236
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
template<typename K, typename T, typename M = std::map<K,T>>

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

Definition at line 184 of file Map.h.

184 { return size() == 0; }
GaudiUtils::Map::size
size_type size() const
Definition: Map.h:182
template<typename K, typename T, typename M = std::map<K,T>>

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

Definition at line 132 of file Map.h.

132 { return m_map.end(); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
template<typename K, typename T, typename M = std::map<K,T>>

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

Definition at line 135 of file Map.h.

135 { return m_map.end(); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 159 of file Map.h.

160 { return m_map.equal_range(key); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 161 of file Map.h.

162 { return m_map.equal_range(key); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
template<typename K, typename T, typename M = std::map<K,T>>

iterator GaudiUtils::Map< K, T, M >::erase | ( | const_iterator | pos | ) |
| inline

Definition at line 175 of file Map.h.

175 { return m_map.erase(pos); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 176 of file Map.h.

176 { return m_map.erase(key); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
template<typename K, typename T, typename M = std::map<K,T>>

iterator GaudiUtils::Map< K, T, M >::erase | ( | const_iterator | first,
|  | const_iterator | last
| ) |  |
| inline

Definition at line 177 of file Map.h.

177 { return m_map.erase(first,last); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 149 of file Map.h.

149 { return m_map.find(key); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 150 of file Map.h.

150 { return m_map.find(key); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
template<typename K, typename T, typename M = std::map<K,T>>
template<typename ValueType >

std::pair<iterator,bool> GaudiUtils::Map< K, T, M >::insert | ( | ValueType && | val | ) |
| inline

Definition at line 168 of file Map.h.

168 { return m_map.insert(std::forward<ValueType>(val)); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
template<typename K, typename T, typename M = std::map<K,T>>

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

Definition at line 169 of file Map.h.

169 { return m_map.insert(std::forward<value_type>(val)); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 171 of file Map.h.

171 { m_map.insert(std::forward<In>(first),std::forward<In>(last)); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
template<typename K, typename T, typename M = std::map<K,T>>
template<typename ValueType >

iterator GaudiUtils::Map< K, T, M >::insert | ( | iterator | ,
|  | ValueType && | val
| ) |  |
| inline

Definition at line 173 of file Map.h.

174 { return m_map.insert( /* pos, */ std::forward<ValueType>(val) ).first ; }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
template<typename K, typename T, typename M = std::map<K,T>>

const key_type& GaudiUtils::Map< K, T, M >::key_at | ( | const size_type | 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 291 of file Map.h.

292 {
293 if ( index >= size() )
294 { this->throw_out_of_range_exception () ; }
295 return std::next ( this->begin() , index )->first ;
296 }
GaudiUtils::Map::size
size_type size() const
Definition: Map.h:182
std::next
T next(T...args)
GaudiUtils::Map::begin
iterator begin()
Definition: Map.h:131
Gaudi::Utils::MapBase::throw_out_of_range_exception
void throw_out_of_range_exception() const
throw std::out_of_range exception
Definition: MapBase.cpp:28
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 154 of file Map.h.

154 { return m_map.lower_bound(key); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 155 of file Map.h.

155 { return m_map.lower_bound(key); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 183 of file Map.h.

183 { return m_map.max_size(); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 255 of file Map.h.

256 {
257 m_map.insert( std::begin(other), std::end(other) );
258 return *this;
259 }
std::end
T end(T...args)
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
std::begin
T begin(T...args)
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 261 of file Map.h.

262 {
263 m_map.insert( std::begin(other), std::end(other) );
264 return *this;
265 }
std::end
T end(T...args)
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
std::begin
T begin(T...args)
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 268 of file Map.h.

269 {
270 m_map.insert( std::begin(other), std::end(other) );
271 return *this;
272 }
std::end
T end(T...args)
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
std::begin
T begin(T...args)
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 282 of file Map.h.

282 { return m_map ; }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 281 of file Map.h.

281 { return m_map ; }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 if not present

Definition at line 211 of file Map.h.

212 {
213 // static const result_type s_null_value;
214 auto it = m_map.find(key);
216 return it != m_map.end() ? it->second : s_null_value;
217 }
GaudiUtils::Map::s_null_value
static const result_type s_null_value
Definition: Map.h:107
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 145 of file Map.h.

145 { return m_map[key]; }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 241 of file Map.h.

242 { return (*this)(key); }
template<typename K, typename T, typename M = std::map<K,T>>

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

Definition at line 182 of file Map.h.

182 { return m_map.size(); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 185 of file Map.h.

185 { m_map.swap(other); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 275 of file Map.h.

276 { (*this)[ key ] = mapped ; }
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 156 of file Map.h.

156 { return m_map.upper_bound(key); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
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 157 of file Map.h.

157 { return m_map.upper_bound(key); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:106
template<typename K, typename T, typename M = std::map<K,T>>

const mapped_type& GaudiUtils::Map< K, T, M >::value_at | ( | const size_type | 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 302 of file Map.h.

303 {
304 if ( index >= size() )
305 { this->throw_out_of_range_exception () ; }
306 return std::next( this->begin() , index )->second ;
307 }
GaudiUtils::Map::size
size_type size() const
Definition: Map.h:182
std::next
T next(T...args)
GaudiUtils::Map::begin
iterator begin()
Definition: Map.h:131
Gaudi::Utils::MapBase::throw_out_of_range_exception
void throw_out_of_range_exception() const
throw std::out_of_range exception
Definition: MapBase.cpp:28

## 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 106 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()
| static protected

Definition at line 107 of file Map.h.

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

- GaudiKernel/GaudiKernel/Map.h