|
| | Map () |
| | Standard constructor.
|
| |
| | Map (const map_type &other) |
| | Constructor from a standard map.
|
| |
| template<typename In > |
| | Map (In first, In last) |
| | Construct from a subset.
|
| |
| virtual | ~Map () |
| | 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 |
| |
| std::pair< iterator, bool > | insert (const value_type &val) |
| |
| std::pair< iterator, bool > | insert (const key_type &key, const mapped_type &val) |
| |
| template<typename In > |
| void | insert (In first, In last) |
| |
| iterator | insert (iterator, const value_type &val) |
| |
| void | erase (iterator pos) |
| |
| size_type | erase (const key_type &key) |
| |
| void | erase (iterator first, 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
- Exceptions
-
| std::out_of_range | for missing keys |
|
| |
| 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:
|
| |
| virtual | ~MapBase () |
| | virtual destructor
|
| |
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
>>> value
m[key] ## unchecked
access through the key
...
- 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.
template<typename K, typename T, typename M = std::map<K,T>>
template<class K1 , class K2 , class K3 >
Merge two maps.
Definition at line 271 of file Map.h.
{
for ( typename Map<K1,K2,K3>::const_iterator it = other.begin() ;
other.end() != it ; ++it ) { (*this)[it->first] = it->second ; }
return *this;
}
Public Member Functions inherited from Gaudi::Utils::MapBase
