Extension of the STL map. More...

#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

	Map (const map_type &other)
	Constructor from a standard map.

template<typename In>
	Map (In &&first, In &&last)
	Construct from a subset.

virtual	~Map ()=default
	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

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.

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

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_type index) const
	useful method for python decoration:

const mapped_type &	value_at (const size_type index) const
	useful method for python decoration:

Public Member Functions inherited from Gaudi::Utils::MapBase
virtual	~MapBase ()

Protected Attributes
map_type	m_map

Static Protected Attributes
static const result_type	s_null_value

Friends
std::ostream &	operator<< (std::ostream &s, const GaudiUtils::Map< K, T, M > &m)
	Serialize a GaudiUtils::Map in a python like format. E.g. "{a: 1, b: 2}".

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

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 83 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 91 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 99 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 94 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 98 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 87 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 86 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 88 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 92 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 96 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 93 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

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

109: m_map( other ) {}

GaudiUtils::Map

Extension of the STL map.

Definition Map.h:83

GaudiUtils::Map::m_map

map_type m_map

Definition Map.h:102

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

113: 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 239 of file Map.h.

239{ 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 122 of file Map.h.

122{ 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 125 of file Map.h.

125{ 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 172 of file Map.h.

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

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

178{ return size() == 0; }

GaudiUtils::Map::size

size_type size() const

Definition Map.h:176

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

123{ 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 126 of file Map.h.

126{ 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 144 of file Map.h.

144{ 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 145 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 170 of file Map.h.

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

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

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

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

135{ 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 162 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 166 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 158 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 155 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 268 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 139 of file Map.h.

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

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

177{ 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 246 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 252 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 241 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 262 of file Map.h.

262{ 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 261 of file Map.h.

261{ 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 205 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 130 of file Map.h.

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

233{ 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 176 of file Map.h.

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

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

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

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

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

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

Friends And Related Symbol Documentation

◆ operator<<

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

std::ostream & operator<<	(	std::ostream &	s,
		const GaudiUtils::Map< K, T, M > &	m )

friend

Serialize a GaudiUtils::Map in a python like format. E.g. "{a: 1, b: 2}".

Definition at line 283 of file Map.h.

                                                                                    {
      return s << static_cast<const M&>( m );
    }

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

◆ s_null_value

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

const result_type GaudiUtils::Map< K, T, M >::s_null_value

staticprotected

Definition at line 103 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

Friends

Additional Inherited Members

Detailed Description

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

Friends And Related Symbol Documentation

◆ operator<<

Member Data Documentation

◆ m_map

◆ s_null_value