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 >:

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 81 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 90 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 98 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 93 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 97 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 86 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 85 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 87 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 91 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 95 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 92 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 114 of file Map.h.

: m_map( other ) {}

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.

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

{ return m_map.at( key ); }

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.

{ return m_map.begin(); }

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.

{ return m_map.begin(); }

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.

{ m_map.clear(); }

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.

{ return m_map.count( key ); }

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.

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

{ return size() == 0; }

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.

{ return m_map.end(); }

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.

{ return m_map.end(); }

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.

{ return m_map.equal_range( key ); }

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.

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

{ return m_map.erase( pos ); }

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.

{ return m_map.erase( key ); }

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.

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

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.

{ return m_map.find( key ); }

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.

{ return m_map.find( key ); }

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.

                                                             {
      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 171 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 175 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 179 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 288 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 152 of file Map.h.

{ return m_map.lower_bound( key ); }

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.

{ return m_map.lower_bound( key ); }

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.

{ return m_map.max_size(); }

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.

                                               {
      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 262 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 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>>

GaudiUtils::Map< K, T, M >::operator const map_type & ( ) const

inline

Definition at line 279 of file Map.h.

{ return m_map; }

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.

{ return m_map; }

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.

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

{ return m_map[key]; }

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.

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

{ return m_map.size(); }

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.

{ m_map.swap( other ); }

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.

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

{ return m_map.upper_bound( key ); }

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.

{ return m_map.upper_bound( key ); }

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.

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

---

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

• GaudiKernel/GaudiKernel/Map.h