| The Gaudi Framework v32r1 (f65d50dc)

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

## Member Typedef Documentation

## ◆ argument_type

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

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

Definition at line 90 of file Map.h.

## ◆ const_iterator

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

## ◆ const_reference

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

## ◆ iterator

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

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

Definition at line 97 of file Map.h.

## ◆ key_type

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

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

Definition at line 86 of file Map.h.

## ◆ map_type

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

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

Definition at line 85 of file Map.h.

## ◆ mapped_type

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

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

Definition at line 87 of file Map.h.

## ◆ result_type

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

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

Definition at line 91 of file Map.h.

## ◆ size_type

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

## ◆ value_type

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

## Constructor & Destructor Documentation

## ◆ Map() [1/3]

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

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

Standard constructor.

## ◆ Map() [2/3]

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

114 : m_map( other ) {}
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ Map() [3/3]

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

120 : m_map( std::forward<In>( first ), std::forward<In>( last ) ) {}
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ ~Map()

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

## ◆ at()

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

254 { return m_map.at( key ); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ begin() [1/2]

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

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

Definition at line 129 of file Map.h.

129 { return m_map.begin(); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ begin() [2/2]

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

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

Definition at line 132 of file Map.h.

132 { return m_map.begin(); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ clear()

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

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

Definition at line 185 of file Map.h.

185 { m_map.clear(); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ count()

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

150 { return m_map.count( key ); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ emplace()

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

164 {
165 return m_map.emplace( std::forward<Args>( args )... );
166 }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104
gaudirun.args
args
Definition: gaudirun.py:307

## ◆ empty()

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

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

Definition at line 191 of file Map.h.

191 { return size() == 0; }
GaudiUtils::Map::size
size_type size() const
Definition: Map.h:189

## ◆ end() [1/2]

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

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

Definition at line 130 of file Map.h.

130 { return m_map.end(); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ end() [2/2]

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

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

Definition at line 133 of file Map.h.

133 { return m_map.end(); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ equal_range() [1/2]

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

157 { return m_map.equal_range( key ); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ equal_range() [2/2]

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

158 {
159 return m_map.equal_range( key );
160 }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ erase() [1/3]

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

182 { return m_map.erase( pos ); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ erase() [2/3]

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

183 { return m_map.erase( key ); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ erase() [3/3]

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

184 { return m_map.erase( first, last ); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ find() [1/2]

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

147 { return m_map.find( key ); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ find() [2/2]

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

148 { return m_map.find( key ); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ insert() [1/4]

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 {
169 return m_map.insert( std::forward<ValueType>( val ) );
170 }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ insert() [2/4]

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

171 {
172 return m_map.insert( std::forward<value_type>( val ) );
173 }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ insert() [3/4]

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

175 {
176 m_map.insert( std::forward<In>( first ), std::forward<In>( last ) );
177 }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ insert() [4/4]

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

179 {
180 return m_map.insert( /* pos, */ std::forward<ValueType>( val ) ).first;
181 }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ key_at()

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

288 {
289 if ( index >= size() ) { this->throw_out_of_range_exception(); }
290 return std::next( this->begin(), index )->first;
291 }
std::next
T next(T... args)
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
GaudiUtils::Map::begin
iterator begin()
Definition: Map.h:129
GaudiUtils::Map::size
size_type size() const
Definition: Map.h:189

## ◆ lower_bound() [1/2]

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

152 { return m_map.lower_bound( key ); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ lower_bound() [2/2]

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

153 { return m_map.lower_bound( key ); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ max_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 190 of file Map.h.

190 { return m_map.max_size(); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ merge() [1/3]

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

257 {
258 m_map.insert( std::begin( other ), std::end( other ) );
259 return *this;
260 }
std::end
T end(T... args)
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104
std::begin
T begin(T... args)

## ◆ merge() [2/3]

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 262 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:104
std::begin
T begin(T... args)

## ◆ merge() [3/3]

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.

268 {
269 m_map.insert( std::begin( other ), std::end( other ) );
270 return *this;
271 }
std::end
T end(T... args)
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104
std::begin
T begin(T... args)

## ◆ operator const map_type &()

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

279 { return m_map; }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ operator map_type &()

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

278 { return m_map; }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ operator()()

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

218 {
219 // static const result_type s_null_value;
220 auto it = m_map.find( key );
222 return it != m_map.end() ? it->second : s_null_value;
223 }
GaudiUtils::Map::s_null_value
static const result_type s_null_value
Definition: Map.h:105
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ operator[]() [1/2]

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

143 { return m_map[key]; }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ operator[]() [2/2]

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

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

## ◆ size()

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

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

Definition at line 189 of file Map.h.

189 { return m_map.size(); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ swap()

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

192 { m_map.swap( other ); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ update()

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

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

## ◆ upper_bound() [1/2]

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

154 { return m_map.upper_bound( key ); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ upper_bound() [2/2]

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

155 { return m_map.upper_bound( key ); }
GaudiUtils::Map::m_map
map_type m_map
Definition: Map.h:104

## ◆ value_at()

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

297 {
298 if ( index >= size() ) { this->throw_out_of_range_exception(); }
299 return std::next( this->begin(), index )->second;
300 }
std::next
T next(T... args)
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
GaudiUtils::Map::begin
iterator begin()
Definition: Map.h:129
GaudiUtils::Map::size
size_type size() const
Definition: Map.h:189

## Member Data Documentation

## ◆ m_map

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

map_type GaudiUtils::Map< K, T, M >::m_map
| protected

Definition at line 104 of file Map.h.

## ◆ s_null_value

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

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

- GaudiKernel/GaudiKernel/Map.h