Extension of the STL map. More...

#include <GaudiKernel/Map.h>

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

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

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.

                                  : m_map( std::forward<In>( first ), std::forward<In>( last ) )
     {
     }

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

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

virtualdefault

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

265 { return m_map.at( 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 >::begin ( )

inline

Definition at line 133 of file Map.h.

133 { 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 136 of file Map.h.

136 { 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 195 of file Map.h.

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

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

     {
       return m_map.emplace( std::forward<Args>( args )... );
     }

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

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

inline

Definition at line 201 of file Map.h.

201 { return size() == 0; }

GaudiUtils::Map::size

size_type size() const

Definition: Map.h:199

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

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

inline

Definition at line 134 of file Map.h.

134 { 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 137 of file Map.h.

137 { 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 161 of file Map.h.

161 { 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 162 of file Map.h.

     {
       return m_map.equal_range( key );
     }

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

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

193 { 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 194 of file Map.h.

194 { 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 151 of file Map.h.

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

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

     {
       return m_map.insert( std::forward<ValueType>( val ) );
     }

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

     {
       return m_map.insert( std::forward<value_type>( 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 183 of file Map.h.

     {
       m_map.insert( std::forward<In>( first ), std::forward<In>( last ) );
     }

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

     {
       return m_map.insert( /* pos, */ std::forward<ValueType>( val ) ).first;
     }

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

     {
       if ( index >= size() ) {
         this->throw_out_of_range_exception();
       }
       return std::next( this->begin(), index )->first;
     }

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

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

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

200 { 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 268 of file Map.h.

     {
       m_map.insert( std::begin( other ), std::end( other ) );
       return *this;
     }

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

     {
       m_map.insert( std::begin( other ), std::end( other ) );
       return *this;
     }

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

     {
       m_map.insert( std::begin( other ), std::end( other ) );
       return *this;
     }

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

293 { 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 292 of file Map.h.

292 { 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 228 of file Map.h.

     {
       // static const result_type s_null_value;
       auto it = m_map.find( key );
       return it != m_map.end() ? it->second : s_null_value;
     }

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

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

258 { 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 199 of file Map.h.

199 { 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 202 of file Map.h.

202 { 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 287 of file Map.h.

287 { ( *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 158 of file Map.h.

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

159 { 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 314 of file Map.h.

     {
       if ( index >= size() ) {
         this->throw_out_of_range_exception();
       }
       return std::next( this->begin(), index )->second;
     }

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()

staticprotected

Definition at line 107 of file Map.h.

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

GaudiKernel/GaudiKernel/Map.h

Public Types

Public Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

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

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

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