#include </builds/gaudi/Gaudi/GaudiKernel/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 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 91 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 100 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 108 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 103 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 107 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 96 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 95 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 97 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 101 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 105 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 102 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 124 of file Map.h.

124 : m_map( other ) {}

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

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

◆ ~Map()

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

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

264 { return m_map.at( key ); }

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

139 { return m_map.begin(); }

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

142 { return m_map.begin(); }

◆ clear()

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

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

160 { return m_map.count( key ); }

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

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

◆ empty()

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; }

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

140 { return m_map.end(); }

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

143 { return m_map.end(); }

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

167 { return m_map.equal_range( key ); }

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

                                                                                             {
       return m_map.equal_range( key );
     }

◆ erase() [1/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 193 of file Map.h.

193 { return m_map.erase( key ); }

◆ erase() [2/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 194 of file Map.h.

194 { return m_map.erase( first, last ); }

◆ erase() [3/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 192 of file Map.h.

192 { return m_map.erase( pos ); }

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

157 { return m_map.find( key ); }

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

158 { return m_map.find( key ); }

◆ insert() [1/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 185 of file Map.h.

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

◆ insert() [2/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 189 of file Map.h.

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

◆ insert() [3/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 181 of file Map.h.

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

◆ insert() [4/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 178 of file Map.h.

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

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

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

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

162 { return m_map.lower_bound( key ); }

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

163 { return m_map.lower_bound( key ); }

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

200 { return m_map.max_size(); }

◆ merge() [1/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 272 of file Map.h.

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

◆ merge() [2/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 278 of file Map.h.

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

◆ merge() [3/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 267 of file Map.h.

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

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

289 { return m_map; }

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

288 { return m_map; }

◆ 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 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;
     }

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

153 { return m_map[key]; }

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

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

199 { return m_map.size(); }

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

202 { m_map.swap( other ); }

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

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

164 { return m_map.upper_bound( key ); }

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

165 { return m_map.upper_bound( key ); }

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

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

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

◆ s_null_value

template<typename K , typename T , typename M >

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

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

GaudiKernel/include/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

◆ argument_type

◆ const_iterator

◆ const_reference

◆ iterator

◆ key_type

◆ map_type

◆ mapped_type

◆ result_type

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ Map() [1/3]

◆ Map() [2/3]

◆ Map() [3/3]

◆ ~Map()

Member Function Documentation

◆ at()

◆ begin() [1/2]

◆ begin() [2/2]

◆ clear()

◆ count()

◆ emplace()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ equal_range() [1/2]

◆ equal_range() [2/2]

◆ erase() [1/3]

◆ erase() [2/3]

◆ erase() [3/3]

◆ find() [1/2]

◆ find() [2/2]

◆ insert() [1/4]

◆ insert() [2/4]

◆ insert() [3/4]

◆ insert() [4/4]

◆ key_at()

◆ lower_bound() [1/2]

◆ lower_bound() [2/2]

◆ max_size()

◆ merge() [1/3]

◆ merge() [2/3]

◆ merge() [3/3]

◆ operator const map_type &()

◆ operator map_type &()

◆ operator()()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ size()

◆ swap()

◆ update()

◆ upper_bound() [1/2]

◆ upper_bound() [2/2]

◆ value_at()

Member Data Documentation

◆ m_map

◆ s_null_value

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