| The Gaudi Framework v29r0 (ff2e7097)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Classes | Public Types | Public Member Functions | Protected Types | Protected Member Functions | Private Attributes | Friends | List of all members
GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > Class Template Reference

A bit modified version of 'Loki::AssocVector' associative vector from Loki library by Andrei Alexandrescu. More...

`#include <GaudiKernel/VectorMap.h>`

Inheritance diagram for GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >:
[legend]
Collaboration diagram for GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >:
[legend]

## Classes
struct | _compare_type
| The actual structure used to compare the elements Only "key" is important for comparison. More...

## Public Types
typedef KEY | key_type
| the actual type of key More...
typedef VALUE | mapped_type
| the actual type of value More...
typedef KEYCOMPARE | key_compare
| comparison of keys More...
typedef std::pair< key_type, mapped_type > | value_type
| the actual storage item More...
typedef ALLOCATOR | allocator_type
| allocator (could be useful for optimizations) More...
typedef ALLOCATOR::const_reference | reference
| the types to conform STL More...
typedef ALLOCATOR::const_reference | const_reference
| the types to conform STL More...
typedef ALLOCATOR::size_type | size_type
| the types to conform STL More...
typedef ALLOCATOR::difference_type | difference_type
| the types to conform STL More...
typedef std::vector< value_type, allocator_type > | _vector
| the actual storage container (no export) More...
typedef _vector::const_iterator | iterator
| visible const_iterator (exported) More...
typedef _vector::const_iterator | const_iterator
| visible const_iterator (exported) More...
typedef std::reverse_iterator< iterator > | reverse_iterator
| visible reverse const_iterator (exported) More...
typedef std::reverse_iterator< const_iterator > | const_reverse_iterator
| visible reverse const_iterator (exported) More...
typedef std::pair< iterator, iterator > | iterators
| visible iterator pait More...
typedef std::pair< iterator, bool > | result_type
| visible iterator pait More...
typedef _compare_type | compare_type
| the actual comparison criteria for valye_type objects More...

## Public Member Functions
iterator | begin () const
| "begin" iterator for sequential access (const-only version!) More...
iterator | end () const
| "end" iterator for sequential access (const-only version!) More...
reverse_iterator | rbegin () const
| "rbegin" iterator for sequential access (const-only version!) More...
reverse_iterator | rend () const
| "rend" iterator for sequential access (const-only version!) More...
void | erase (iterator pos)
| erase the element using the iterator More...
size_type | erase (const key_type &key)
| erase the element using the key More...
size_type | erase (iterator first, iterator last)
| erase the sequence of elements using the iterators More...
template<class TYPE >
size_type | erase (TYPE first, TYPE last)
| erase the sequence of elements using the sequence of keys More...
result_type | insert (const key_type &key, const mapped_type &mapped)
| insert the (key,value) pair into the container More...
result_type | insert (const value_type &value)
| insert the (key,value) pair into the container More...
result_type | insert (iterator pos, const value_type &value)
| insert the element with some guess about its new position With the right guess the method could be more efficient More...
result_type | insert (iterator pos, const key_type &key, const mapped_type &mapped)
| insert the (key,value) pair into the container With the right guess the method could be more efficient More...
template<class PAIRS >
void | insert (PAIRS first, PAIRS last)
| insert the sequence of elements into the container More...
template<class KEYS , class VALUES >
void | insert (KEYS kf, KEYS kl, VALUES vf)
| insert into the container the elements from 2 "parallel" sequences More...
iterator | find (const key_type &key) const
| find the element by key More...
size_type | count (const key_type &key) const
| count number of elements with the certain key More...
iterator | lower_bound (const key_type &key) const
iterator | upper_bound (const key_type &key) const
iterators | equal_range (const key_type &key) const
bool | empty () const
| empty container ? More...
size_type | size () const
| number of elements More...
size_type | max_size () const
| maximal allowed size More...
void | clear ()
| clear the container More...
void | reserve (size_type num)
| reserve the space in the container for at least 'num' elements More...
void | swap (VectorMap &other)
| swap function, which 'swaps' the content of two containers More...
bool | operator== (const VectorMap &other) const
| comparison criteria for containers More...
bool | operator< (const VectorMap &other) const
| comparison criteria for containers More...
bool | update (const key_type &key, const mapped_type &mapped)
| forced insertion of the key/mapped pair The method acts like "insert" but it DOES overwrite the existing mapped value. More...
bool | update (const value_type &val)
| forced insertion of the key/mapped pair The method acts like "insert" but it DOES overwrite the mapped value. More...
const mapped_type & | operator() (const key_type &key) const
| access to element by key (const version) there is no container increment for missing keys More...
const mapped_type & | operator[] (const key_type &key) const
| access to element by key (const version) there is no container increment for missing keys More...
const mapped_type & | at (const key_type &key) const
| checked access to elements by key throw std::out_of_range exception for non-existing keys More...
| VectorMap (const allocator_type &alloc=allocator_type())
| default constructor from the the allocator More...
| VectorMap (const VectorMap &right)
| copy constructor More...
template<class INPUT >
| VectorMap (INPUT first, INPUT last, const allocator_type &alloc=allocator_type())
| templated constructor from "convertible" sequence More...
| VectorMap (std::initializer_list< value_type > first, const allocator_type &alloc=allocator_type())
| tconstructor from initializer list More...
| ~VectorMap ()
| destructor (non-virtual!) More...
VectorMap & | operator= (const VectorMap &right)
const compare_type & | compare () const
| get the comparison criteria itself More...
const key_compare & | compare_key () const
| get the comparison criteria for keys More...
VectorMap & | merge (const VectorMap &right)
| merge two maps More...
template<class K1 , class K2 , class K3 , class K4 >
VectorMap & | merge (const VectorMap< K1, K2, K3, K4 > &right)
| merge two maps More...
const key_type & | key_at (const size_t index) const
| useful method for python decoration: More...
const mapped_type & | value_at (const size_t index) const
| useful method for python decoration: More...
Public Member Functions inherited from Gaudi::Utils::MapBase
virtual | ~MapBase ()
| virtual destructor More...

## Protected Types
typedef _vector::iterator | _iterator
| the regular iterator (no export) More...

## Protected Member Functions
template<class TYPE1 , class TYPE2 >
bool | compare (const TYPE1 &obj1, const TYPE2 &obj2) const
| compare the objects using the comaprison criteria More...
_iterator | lower_bound (const key_type &key)
| 'lower-bound' - non-const version More...
_iterator | iter (iterator p)
| the conversion from 'const' to 'non-const' iterator More...
iterator | iter (_iterator p)
| the conversion from 'non-const' to 'const' iterator More...
Protected Member Functions inherited from Gaudi::Utils::MapBase
void | throw_out_of_range_exception () const
| throw std::out_of_range exception More...

## Private Attributes
_vector | m_vct
| the underlying sorted vector of (key,mapped) pairs More...

## Friends
bool | operator> (const VectorMap &left, const VectorMap &right)
bool | operator!= (const VectorMap &left, const VectorMap &right)
bool | operator>= (const VectorMap &left, const VectorMap &right)
bool | operator<= (const VectorMap &left, const VectorMap &right)
std::ostream & | operator<< (std::ostream &str, const VectorMap &)
| printout to ostream - not implemented More...

## Detailed Description

### template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>
class GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >

A bit modified version of 'Loki::AssocVector' associative vector from Loki library by Andrei Alexandrescu.

The number of "non-const" operations is reduced, e.g. all non-const iterators are not exported, therefore it is almost impossible e.g. externally re-sort the underlying sorted container.

## The nominal CPU performance:

Container insertion: O(N) Container look-up: O(log(N)) (a'la std::map, but a bit faster)

It could be used as a "light" and good alternative for std::map associative container, in the case of relatively rare insertion and frequent look-up.

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 redefind

To avoid the unnesessary expansion of dictionaries it is highly recommended to exclude from dictionary the following methods:

- lower_bound
- upper_bound
- equal_range
- insert

See also
  Gaudi::Utils::MapBase

Author
  Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@l.nosp@m.app..nosp@m.in2p3.nosp@m..fr

Date
  2005-07-23

Definition at line 103 of file VectorMap.h.

## Member Typedef Documentation

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef _vector::iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::_iterator
| protected

the regular iterator (no export)

Definition at line 137 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef std::vector<value_type, allocator_type> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::_vector

the actual storage container (no export)

Definition at line 132 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef ALLOCATOR GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::allocator_type

allocator (could be useful for optimizations)

Definition at line 119 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef _compare_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::compare_type

the actual comparison criteria for valye_type objects

Definition at line 182 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef _vector::const_iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::const_iterator

visible const_iterator (exported)

Definition at line 144 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef ALLOCATOR::const_reference GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::const_reference

the types to conform STL

Definition at line 123 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef std::reverse_iterator<const_iterator> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::const_reverse_iterator

visible reverse const_iterator (exported)

Definition at line 148 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef ALLOCATOR::difference_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::difference_type

the types to conform STL

Definition at line 127 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef _vector::const_iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::iterator

visible const_iterator (exported)

Definition at line 142 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef std::pair<iterator, iterator> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::iterators

visible iterator pait

Definition at line 150 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef KEYCOMPARE GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::key_compare

comparison of keys

Definition at line 112 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef KEY GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::key_type

the actual type of key

Definition at line 108 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef VALUE GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::mapped_type

the actual type of value

Definition at line 110 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef ALLOCATOR::const_reference GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::reference

the types to conform STL

Definition at line 121 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef std::pair<iterator, bool> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::result_type

visible iterator pait

Definition at line 152 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef std::reverse_iterator<iterator> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::reverse_iterator

visible reverse const_iterator (exported)

Definition at line 146 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef ALLOCATOR::size_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::size_type

the types to conform STL

Definition at line 125 of file VectorMap.h.

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

typedef std::pair<key_type, mapped_type> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::value_type

the actual storage item

Definition at line 114 of file VectorMap.h.

## Constructor & Destructor Documentation

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::VectorMap | ( | const allocator_type & | alloc = `allocator_type()` | ) |
| inline

default constructor from the the allocator

Parameters

  cmp | comparison criteria for the key
  alloc | allocator to be used

Definition at line 688 of file VectorMap.h.

688 : m_vct( alloc ) {}
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::VectorMap | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right | ) |
| inline

copy constructor

Parameters

  right | object to be copied

Definition at line 693 of file VectorMap.h.

693 : Gaudi::Utils::MapBase( right ), m_vct( right.m_vct ) {}
std::right
T right(T...args)
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
Gaudi::Utils::MapBase
Helper base-class to allow the generic Python-decoration for all "map-like" classes in Gaudi...
Definition: MapBase.h:44
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>
template<class INPUT >

GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::VectorMap | ( | INPUT | first,
|  | INPUT | last,
|  | const allocator_type & | alloc = `allocator_type()`
| ) |  |
| inline

templated constructor from "convertible" sequence

Parameters

  first | 'begin'-iterator for the convertible sequence
  last | 'end'-iterator for the convertible sequence
  cmp | comparison criteria for the key
  alloc | allocator to be used

Definition at line 702 of file VectorMap.h.

702 : m_vct( first, last, alloc )
703 {
704 std::sort( m_vct.begin(), m_vct.end(), compare() );
705 }
std::vector::end
T end(T...args)
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
std::vector::begin
T begin(T...args)
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:739
std::sort
T sort(T...args)
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::VectorMap | ( | std::initializer_list< value_type > | first,
|  | const allocator_type & | alloc = `allocator_type()`
| ) |  |
| inline

tconstructor from initializer list

Parameters

  list |
  cmp | comparison criteria for the key
  alloc | allocator to be used

Definition at line 712 of file VectorMap.h.

713 : m_vct( first, alloc )
714 {
715 std::sort( m_vct.begin(), m_vct.end(), compare() );
716 }
std::vector::end
T end(T...args)
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
std::vector::begin
T begin(T...args)
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:739
std::sort
T sort(T...args)
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::~VectorMap | ( |  | ) |
| inline

destructor (non-virtual!)

Definition at line 719 of file VectorMap.h.

719 { clear(); }
GaudiUtils::VectorMap::clear
void clear()
clear the container
Definition: VectorMap.h:488

## Member Function Documentation

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

const mapped_type& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::at | ( | const key_type & | key | ) | const
| inline

checked access to elements by key throw std::out_of_range exception for non-existing keys

GaudiUtils::VectorMap<K,V> m = ... ;
// OK:
K key = ... ;
std::cout << " Value: " << m.at(key) << std::end ; // it is OK!

Exceptions

  std::out_of_range | for non-existing keys

Parameters

  key | key value

Returns
  mapped value

Definition at line 671 of file VectorMap.h.

672 {
673 iterator res = find( key );
674 if ( end() == res ) {
675 this->throw_out_of_range_exception();
676 }
677 return res->second;
678 }
GaudiUtils::VectorMap::iterator
_vector::const_iterator iterator
visible const_iterator (exported)
Definition: VectorMap.h:142
GaudiUtils::VectorMap::find
iterator find(const key_type &key) const
find the element by key
Definition: VectorMap.h:449
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:191
Gaudi::Utils::MapBase::throw_out_of_range_exception
void throw_out_of_range_exception() const
throw std::out_of_range exception
Definition: MapBase.cpp:28
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::begin | ( |  | ) | const
| inline

"begin" iterator for sequential access (const-only version!)

Definition at line 189 of file VectorMap.h.

189 { return m_vct.begin(); }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
std::vector::begin
T begin(T...args)
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

void GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::clear | ( |  | ) |
| inline

clear the container

Definition at line 488 of file VectorMap.h.

488 { m_vct.clear(); }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
std::vector::clear
T clear(T...args)
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

const compare_type& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::compare | ( |  | ) | const
| inline

get the comparison criteria itself

Definition at line 739 of file VectorMap.h.

740 {
741 static const compare_type s_cmp = compare_type();
742 return s_cmp;
743 }
GaudiUtils::VectorMap::compare_type
_compare_type compare_type
the actual comparison criteria for valye_type objects
Definition: VectorMap.h:182
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>
template<class TYPE1 , class TYPE2 >

bool GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::compare | ( | const TYPE1 & | obj1,
|  | const TYPE2 & | obj2
| ) |  | const
| inline protected

compare the objects using the comaprison criteria

Parameters

  obj | the first object
  obj | the second object

Returns
  result of (obj1,obj2) comparison

Definition at line 810 of file VectorMap.h.

811 {
812 return compare()( obj1, obj2 );
813 }
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:739
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

const key_compare& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::compare_key | ( |  | ) | const
| inline

get the comparison criteria for keys

Definition at line 745 of file VectorMap.h.

745 { return compare(); }
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:739
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

size_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::count | ( | const key_type & | key | ) | const
| inline

count number of elements with the certain key

GaudiUtils::VectorMap<K,V> m = ... ;
K key = ... ;
std::cout << " # of elements for the key: " << m.count(key) << std::end ;

Parameters

  key | key to be searched

Returns
  number of elements with the given key (0 or 1)

Definition at line 473 of file VectorMap.h.

473 { return end() == find( key ) ? 0 : 1; }
GaudiUtils::VectorMap::find
iterator find(const key_type &key) const
find the element by key
Definition: VectorMap.h:449
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:191
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

bool GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::empty | ( |  | ) | const
| inline

empty container ?

Definition at line 482 of file VectorMap.h.

482 { return m_vct.empty(); }
std::vector::empty
T empty(T...args)
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::end | ( |  | ) | const
| inline

"end" iterator for sequential access (const-only version!)

Definition at line 191 of file VectorMap.h.

191 { return m_vct.end(); }
std::vector::end
T end(T...args)
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

iterators GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::equal_range | ( | const key_type & | key | ) | const
| inline

Definition at line 477 of file VectorMap.h.

477 { return std::equal_range( begin(), end(), key, compare() ); }
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:191
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:189
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:739
std::equal_range
T equal_range(T...args)
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

void GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::erase | ( | iterator | pos | ) |
| inline

erase the element using the iterator

Parameters

  pos | position of the element to be erased

Definition at line 202 of file VectorMap.h.

202 { m_vct.erase( iter( pos ) ); }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
std::vector::erase
T erase(T...args)
GaudiUtils::VectorMap::iter
_iterator iter(iterator p)
the conversion from &#39;const&#39; to &#39;non-const&#39; iterator
Definition: VectorMap.h:822
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

size_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::erase | ( | const key_type & | key | ) |
| inline

erase the element using the key

GaudiUtils::VectorMap<K,V> m = ... ;
...
K key = ... ;
std::cout << " # of erased elements "
<< m.erase ( key ) << std::endl ;

Parameters

  key | key for the element to be erased

Returns
  number of erased elements (0 or 1)

Definition at line 220 of file VectorMap.h.

221 {
222 iterator pos = find( key );
223 if ( end() == pos ) {
224 return 0;
225 }
226 erase( pos );
227 return 1;
228 }
GaudiUtils::VectorMap::iterator
_vector::const_iterator iterator
visible const_iterator (exported)
Definition: VectorMap.h:142
GaudiUtils::VectorMap::find
iterator find(const key_type &key) const
find the element by key
Definition: VectorMap.h:449
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:191
GaudiUtils::VectorMap::erase
void erase(iterator pos)
erase the element using the iterator
Definition: VectorMap.h:202
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

size_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::erase | ( | iterator | first,
|  | iterator | last
| ) |  |
| inline

erase the sequence of elements using the iterators

Parameters

  first | begin iterator of sub-sequence to be erased
  end | end iterator of the sub_sequence to be erased

Returns
  number of erased elements

Definition at line 235 of file VectorMap.h.

236 {
237 m_vct.erase( iter( first ), iter( last ) );
238 return last - first;
239 }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
std::vector::erase
T erase(T...args)
GaudiUtils::VectorMap::iter
_iterator iter(iterator p)
the conversion from &#39;const&#39; to &#39;non-const&#39; iterator
Definition: VectorMap.h:822
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>
template<class TYPE >

size_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::erase | ( | TYPE | first,
|  | TYPE | last
| ) |  |
| inline

erase the sequence of elements using the sequence of keys

GaudiUtils::VectorMap<K,V> m = ... ;
// some sequence of keys, to be removed
KEYS keys = ... ;
std::cout
<< " # keys to be removed: " << keys.size()
<< " # keys removed: " << m.erase( keys.begin() , keys.end() )
<< std::endl ;

Parameters

  first | begin-iterator for the sequence of keys
  last | end-iterator for the sequence of keys

Returns
  number of erased elements

Definition at line 262 of file VectorMap.h.

263 {
264 size_type res = 0;
265 for ( ; first != last; ++first ) {
266 res += erase( *first );
267 }
268 return res;
269 }
GaudiUtils::VectorMap::size_type
ALLOCATOR::size_type size_type
the types to conform STL
Definition: VectorMap.h:125
GaudiUtils::VectorMap::erase
void erase(iterator pos)
erase the element using the iterator
Definition: VectorMap.h:202
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::find | ( | const key_type & | key | ) | const
| inline

find the element by key

typedef GaudiUtils::VectorMap<K,V> Map ;
Map m = ... ;
K key = ...;
// Is key in the container?
Map::iterator ifound = m.find( key ) ;
if ( m.end() != ifound )
{
std::cout << "The value is : " << ifound->second << std::endl ;
}

Parameters

  key | key to be searched

Returns
  iterator to the element position in the container

Definition at line 449 of file VectorMap.h.

450 {
451 iterator res = lower_bound( key );
452 if ( end() != res && compare( key, res->first ) ) {
453 res = end();
454 }
455 return res;
456 }
GaudiUtils::VectorMap::iterator
_vector::const_iterator iterator
visible const_iterator (exported)
Definition: VectorMap.h:142
GaudiUtils::VectorMap::lower_bound
iterator lower_bound(const key_type &key) const
Definition: VectorMap.h:475
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:191
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:739
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

result_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::insert | ( | const key_type & | key,
|  | const mapped_type & | mapped
| ) |  |
| inline

insert the (key,value) pair into the container

Attention
  there is no replacement for the existing key!

It is STL-compliant behavior for associative containers.

GaudiUtils::VectorMap<K,V> m ;
K key = ... ;
V val1 = ... ;
V val2 = ... ;
std::cout
<< " Before insert: " << m[key] // should be: V()
<< std::end ;
// insert the value into the map:
const bool inserted1 = m.insert( key , val1 ).second ;
std::cout
<< " 1st insert: "
<< Gaudi::Utils::toString( inserted1 ) // should be: "True"
<< " value: " << m[key] // should be: val1
<< std::endl ;
// try to re-insert another value with the same key:
const bool inserted2 = m.insert( key , val2 ).second ;
std::cout
<< " 2nd insert: "
<< Gaudi::Utils::toString( inserted2 ) // should be: "False"
<< " value: " << m[key] // should be: val1
<< std::endl ;

Parameters

  key | key value to be inserted
  mapped | value to be associated with the key

Returns
  position of the inserted elements with the flag which allows to distinguish the actual insertion

Definition at line 312 of file VectorMap.h.

312 { return insert( value_type( key, mapped ) ); }
GaudiUtils::VectorMap::insert
result_type insert(const key_type &key, const mapped_type &mapped)
insert the (key,value) pair into the container
Definition: VectorMap.h:312
GaudiUtils::VectorMap::value_type
std::pair< key_type, mapped_type > value_type
the actual storage item
Definition: VectorMap.h:114
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

result_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::insert | ( | const value_type & | value | ) |
| inline

insert the (key,value) pair into the container

Attention
  there is no replacement for the existing element!

It is STL-compliant behavior for associative containers.

GaudiUtils::VectorMap<K,V> m ;
K key = ... ;
V val1 = ... ;
V val2 = ... ;
std::cout
<< " Before insert: " << m[key] // should be: V()
<< std::end ;
// insert the value into the map:
const bool inserted1 = m.insert ( std::make_pair( key , val1 ) ).second ;
std::cout
<< " 1st insert: "
<< Gaudi::Utils::toString( inserted1 ) // should be: "True"
<< " value: " << m[key] // should be: val1
<< std::endl ;
// try to re-insert another value with the same key:
const bool inserted2 = m.insert ( std::make_pair( key , val2 ) ).second ;
std::cout
<< " 2nd insert: "
<< Gaudi::Utils::toString( inserted2 ) // should be: "False"
<< " value: " << m[key] // should be: val1
<< std::endl ;

Parameters

  value | value to be inserted

Returns
  position of the inserted elements with the flag which allows to distinguish the actual insertion

Definition at line 354 of file VectorMap.h.

355 {
356 bool found = true;
357 _iterator result = lower_bound( value.first );
358 if ( end() == result || compare( value.first, result->first ) ) {
359 result = m_vct.insert( result, value );
360 found = false;
361 }
362 return result_type( iter( result ), !found );
363 }
GaudiUtils::VectorMap::result_type
std::pair< iterator, bool > result_type
visible iterator pait
Definition: VectorMap.h:152
GaudiUtils::VectorMap::_iterator
_vector::iterator _iterator
the regular iterator (no export)
Definition: VectorMap.h:137
GaudiUtils::VectorMap::lower_bound
iterator lower_bound(const key_type &key) const
Definition: VectorMap.h:475
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:191
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
std::vector::insert
T insert(T...args)
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:739
GaudiUtils::VectorMap::iter
_iterator iter(iterator p)
the conversion from &#39;const&#39; to &#39;non-const&#39; iterator
Definition: VectorMap.h:822
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

result_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::insert | ( | iterator | pos,
|  | const value_type & | value
| ) |  |
| inline

insert the element with some guess about its new position With the right guess the method could be more efficient

Attention
  there is no replacement for the existing element!

Parameters

  pos | the guess about position where to insert the element
  value | value to be inserted

Returns
  position of the inserted elements with the flag which indicated the actual insertion

Definition at line 373 of file VectorMap.h.

374 {
375 if ( pos != end() && compare( *pos, value ) &&
376 ( pos == end() - 1 || ( !compare( value, *( pos + 1 ) ) && compare( *( pos + 1 ), value ) ) ) ) {
377 return result_type( m_vct.insert( iter( pos ), value ), true );
378 }
379 return insert( value );
380 }
GaudiUtils::VectorMap::result_type
std::pair< iterator, bool > result_type
visible iterator pait
Definition: VectorMap.h:152
GaudiUtils::VectorMap::insert
result_type insert(const key_type &key, const mapped_type &mapped)
insert the (key,value) pair into the container
Definition: VectorMap.h:312
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:191
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
std::vector::insert
T insert(T...args)
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:739
GaudiUtils::VectorMap::iter
_iterator iter(iterator p)
the conversion from &#39;const&#39; to &#39;non-const&#39; iterator
Definition: VectorMap.h:822
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

result_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::insert | ( | iterator | pos,
|  | const key_type & | key,
|  | const mapped_type & | mapped
| ) |  |
| inline

insert the (key,value) pair into the container With the right guess the method could be more efficient

Attention
  there is no replacement for the existing element!

Parameters

  pos | the guess about position where to insert the element
  key | key value to be inserted
  mapped | value to be associated with the key

Returns
  position of the inserted elements with the flag which indicated the actual insertion

Definition at line 391 of file VectorMap.h.

392 {
393 return insert( pos, value_type( key, mapped ) );
394 }
GaudiUtils::VectorMap::insert
result_type insert(const key_type &key, const mapped_type &mapped)
insert the (key,value) pair into the container
Definition: VectorMap.h:312
GaudiUtils::VectorMap::value_type
std::pair< key_type, mapped_type > value_type
the actual storage item
Definition: VectorMap.h:114
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>
template<class PAIRS >

void GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::insert | ( | PAIRS | first,
|  | PAIRS | last
| ) |  |
| inline

insert the sequence of elements into the container

Attention
  there is no replacement for the existing element!

Parameters

  first | the begin iterator of the sequence
  last | the end iterator of the sequence

Definition at line 402 of file VectorMap.h.

403 {
404 for ( ; first != last; ++first ) {
405 insert( *first );
406 }
407 }
GaudiUtils::VectorMap::insert
result_type insert(const key_type &key, const mapped_type &mapped)
insert the (key,value) pair into the container
Definition: VectorMap.h:312
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>
template<class KEYS , class VALUES >

void GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::insert | ( | KEYS | kf,
|  | KEYS | kl,
|  | VALUES | vf
| ) |  |
| inline

insert into the container the elements from 2 "parallel" sequences

Attention
  there is no replacement for the existing element!

Parameters

  kf | the begin iterator of the sequence of keys
  kl | the end iterator of the sequence of keys
  vf | the begin iterator of the sequence of values

Definition at line 417 of file VectorMap.h.

418 {
419 for ( ; kf != kl; ++kf, ++vf ) {
420 insert( *kf, *vf );
421 }
422 }
GaudiUtils::VectorMap::insert
result_type insert(const key_type &key, const mapped_type &mapped)
insert the (key,value) pair into the container
Definition: VectorMap.h:312
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

_iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::iter | ( | iterator | p | ) |
| inline protected

the conversion from 'const' to 'non-const' iterator

Definition at line 822 of file VectorMap.h.

823 {
824 auto result = m_vct.begin();
825 std::advance( result, std::distance( begin(), p ) );
826 return result;
827 }
std::distance
T distance(T...args)
std::advance
T advance(T...args)
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:189
std::vector::begin
T begin(T...args)
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::iter | ( | _iterator | p | ) |
| inline protected

the conversion from 'non-const' to 'const' iterator

Definition at line 830 of file VectorMap.h.

831 {
832 auto result = begin();
833 std::advance( result, std::distance( m_vct.begin(), p ) );
834 return result;
835 }
std::distance
T distance(T...args)
std::advance
T advance(T...args)
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:189
std::vector::begin
T begin(T...args)
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

const key_type& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::key_at | ( | const size_t | 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 776 of file VectorMap.h.

777 {
778 if ( index >= size() ) {
779 this->throw_out_of_range_exception();
780 }
781 auto it = this->begin();
782 std::advance( it, index );
783 return it->first;
784 }
std::advance
T advance(T...args)
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:189
Gaudi::Utils::MapBase::throw_out_of_range_exception
void throw_out_of_range_exception() const
throw std::out_of_range exception
Definition: MapBase.cpp:28
GaudiUtils::VectorMap::size
size_type size() const
number of elements
Definition: VectorMap.h:484
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::lower_bound | ( | const key_type & | key | ) | const
| inline

Definition at line 475 of file VectorMap.h.

475 { return std::lower_bound( begin(), end(), key, compare() ); }
std::lower_bound
T lower_bound(T...args)
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:191
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:189
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:739
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

_iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::lower_bound | ( | const key_type & | key | ) |
| inline protected

'lower-bound' - non-const version

Definition at line 816 of file VectorMap.h.

817 {
818 return std::lower_bound( m_vct.begin(), m_vct.end(), key, compare() );
819 }
std::vector::end
T end(T...args)
std::lower_bound
T lower_bound(T...args)
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
std::vector::begin
T begin(T...args)
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:739
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

size_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::max_size | ( |  | ) | const
| inline

maximal allowed size

Definition at line 486 of file VectorMap.h.

486 { return m_vct.max_size(); }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
std::vector::max_size
T max_size(T...args)
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

VectorMap& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::merge | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right | ) |
| inline

merge two maps

Definition at line 752 of file VectorMap.h.

753 {
754 for ( const auto& i : right ) {
755 update( i.first, i.second );
756 }
757 return *this;
758 }
GaudiUtils::VectorMap::update
bool update(const key_type &key, const mapped_type &mapped)
forced insertion of the key/mapped pair The method acts like "insert" but it DOES overwrite the exist...
Definition: VectorMap.h:538
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>
template<class K1 , class K2 , class K3 , class K4 >

VectorMap& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::merge | ( | const VectorMap< K1, K2, K3, K4 > & | right | ) |
| inline

merge two maps

Definition at line 761 of file VectorMap.h.

762 {
763 for ( const auto& i : right ) {
764 update( i.first, i.second );
765 }
766 return *this;
767 }
GaudiUtils::VectorMap::update
bool update(const key_type &key, const mapped_type &mapped)
forced insertion of the key/mapped pair The method acts like "insert" but it DOES overwrite the exist...
Definition: VectorMap.h:538
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

const mapped_type& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::operator() | ( | const key_type & | key | ) | const
| inline

access to element by key (const version) there is no container increment for missing keys

Attention
  The behavior different from std::map, it is similar to GaudiUtils::Map

The method is added on request from ATLAS (see Savannah report #21395 and #21394) For typical usage of this class in LHCb context as "ExtraInfo" field I would like to recommend to AVOID this method

GaudiUtils::VectorMap<K,V> m = ... ;
// OK:
K key = ... ;
std::cout << " Value: " << m(key) << std::end ; // it is OK!
// ERROR:
V value = ... ;
m(key) = value ; // ERROR!

See also
  GaudiUtils::Map

Parameters

  key | key value

Returns
  mapped value for existing key and the default value for non-existing key

Definition at line 612 of file VectorMap.h.

613 {
614 static const mapped_type s_default = mapped_type();
615 iterator res = find( key );
616 if ( end() == res ) {
617 return s_default;
618 }
619 return res->second;
620 }
GaudiUtils::VectorMap::iterator
_vector::const_iterator iterator
visible const_iterator (exported)
Definition: VectorMap.h:142
GaudiUtils::VectorMap::find
iterator find(const key_type &key) const
find the element by key
Definition: VectorMap.h:449
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:191
GaudiUtils::VectorMap::mapped_type
VALUE mapped_type
the actual type of value
Definition: VectorMap.h:110
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

bool GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::operator< | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | other | ) | const
| inline

comparison criteria for containers

Definition at line 500 of file VectorMap.h.

500 { return m_vct < other.m_vct; }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

VectorMap& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::operator= | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right | ) |
| inline

Definition at line 725 of file VectorMap.h.

726 {
727 if ( &right == this ) {
728 return *this;
729 }
730 m_vct = right.m_vct;
731 return *this;
732 }
std::right
T right(T...args)
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

bool GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::operator== | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | other | ) | const
| inline

comparison criteria for containers

Definition at line 498 of file VectorMap.h.

498 { return m_vct == other.m_vct; }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

const mapped_type& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::operator[] | ( | const key_type & | key | ) | const
| inline

access to element by key (const version) there is no container increment for missing keys

Attention
  The behavior different from std::map, it is similar to GaudiUtils::Map

The method is added on request from ATLAS (see Savannah report #21395 and #21394) For typical usage of this class in LHCb context as "ExtraInfo" field I would like to recommend to AVOID this method

GaudiUtils::VectorMap<K,V> m = ... ;
// OK:
K key = ... ;
std::cout << " Value: " << m[key] << std::end ; // it is OK!
// ERROR:
V value = ... ;
m[key] = value ; // ERROR!

See also
  GaudiUtils::Map

Parameters

  key | key value

Returns
  mapped value

Definition at line 652 of file VectorMap.h.

652 { return ( *this )( key ); }
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

reverse_iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::rbegin | ( |  | ) | const
| inline

"rbegin" iterator for sequential access (const-only version!)

Definition at line 193 of file VectorMap.h.

193 { return m_vct.rbegin(); }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
std::vector::rbegin
T rbegin(T...args)
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

reverse_iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::rend | ( |  | ) | const
| inline

"rend" iterator for sequential access (const-only version!)

Definition at line 195 of file VectorMap.h.

195 { return m_vct.rend(); }
std::vector::rend
T rend(T...args)
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

void GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::reserve | ( | size_type | num | ) |
| inline

reserve the space in the container for at least 'num' elements

Definition at line 490 of file VectorMap.h.

490 { m_vct.reserve( num ); }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
std::vector::reserve
T reserve(T...args)
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

size_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::size | ( |  | ) | const
| inline

number of elements

Definition at line 484 of file VectorMap.h.

484 { return m_vct.size(); }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
std::vector::size
T size(T...args)
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

void GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::swap | ( | VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | other | ) |
| inline

swap function, which 'swaps' the content of two containers

Definition at line 493 of file VectorMap.h.

493 { std::swap( m_vct, other.m_vct ); }
std::swap
T swap(T...args)
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

bool GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::update | ( | const key_type & | key,
|  | const mapped_type & | mapped
| ) |  |
| inline

forced insertion of the key/mapped pair The method acts like "insert" but it DOES overwrite the existing mapped value.

Attention
  There is no STL analogue

The method is added on request from ATLAS (see Savannah report #21395 and #21394)

GaudiUtils::VectorMap<K,V> m = ... ;
K key = ... ;
V val1 = ... ;
V val2 = ... ;
std::cout << "Value " << m[key] << std::endl ; // should be: V()
m.update ( key , val1 ) ;
std::cout << "Value " << m[key] << std::endl ; // should be: val1
m.update ( key , val2 ) ;
std::cout << "Value " << m[key] << std::endl ; // should be: val2

Parameters

  key | key value
  mapped | mapped value

Returns
  true if the existing value has been replaced

Definition at line 538 of file VectorMap.h.

539 {
540 _iterator result = lower_bound( key );
541 if ( end() == result || compare( key, result->first ) ) {
542 result = m_vct.insert( result, value_type( key, mapped ) );
543 return false;
544 } else {
545 result->second = mapped;
546 }
547 //
548 return true;
549 }
GaudiUtils::VectorMap::_iterator
_vector::iterator _iterator
the regular iterator (no export)
Definition: VectorMap.h:137
GaudiUtils::VectorMap::value_type
std::pair< key_type, mapped_type > value_type
the actual storage item
Definition: VectorMap.h:114
GaudiUtils::VectorMap::lower_bound
iterator lower_bound(const key_type &key) const
Definition: VectorMap.h:475
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:191
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:840
std::vector::insert
T insert(T...args)
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:739
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

bool GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::update | ( | const value_type & | val | ) |
| inline

forced insertion of the key/mapped pair The method acts like "insert" but it DOES overwrite the mapped value.

Attention
  There is no STL analogue

The method is added on request from ATLAS (see Savannah report #21395 and #21394)

GaudiUtils::VectorMap<K,V> m = ... ;
K key = ... ;
V val1 = ... ;
V val2 = ... ;
std::cout << "Value " << m[key] << std::endl ; // should be: V()
m.update ( std::make_pair ( key , val1 ) ) ;
std::cout << "Value " << m[key] << std::endl ; // should be: val1
m.update ( std::make_pair ( key , val2 ) ) ;
std::cout << "Value " << m[key] << std::endl ; // should be: val2

Parameters

  val | a pair of (key,value)

Returns
  true if the existing value has been replaced

Definition at line 579 of file VectorMap.h.

579 { return update( val.first, val.second ); }
GaudiUtils::VectorMap::update
bool update(const key_type &key, const mapped_type &mapped)
forced insertion of the key/mapped pair The method acts like "insert" but it DOES overwrite the exist...
Definition: VectorMap.h:538
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::upper_bound | ( | const key_type & | key | ) | const
| inline

Definition at line 476 of file VectorMap.h.

476 { return std::upper_bound( begin(), end(), key, compare() ); }
std::upper_bound
T upper_bound(T...args)
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:191
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:189
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:739
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

const mapped_type& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::value_at | ( | const size_t | 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 790 of file VectorMap.h.

791 {
792 if ( index >= size() ) {
793 this->throw_out_of_range_exception();
794 }
795 auto it = this->begin();
796 std::advance( it, index );
797 return it->second;
798 }
std::advance
T advance(T...args)
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:189
Gaudi::Utils::MapBase::throw_out_of_range_exception
void throw_out_of_range_exception() const
throw std::out_of_range exception
Definition: MapBase.cpp:28
GaudiUtils::VectorMap::size
size_type size() const
number of elements
Definition: VectorMap.h:484

## Friends And Related Function Documentation

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

bool operator!= | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | left,
|  | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right
| ) |  |
| friend

Definition at line 505 of file VectorMap.h.

505 { return !( left == right ); }
std::left
T left(T...args)
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

std::ostream& operator<< | ( | std::ostream & | str,
|  | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & |
| ) |  |
| friend

printout to ostream - not implemented

Definition at line 747 of file VectorMap.h.

747 { return str; }
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

bool operator<= | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | left,
|  | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right
| ) |  |
| friend

Definition at line 507 of file VectorMap.h.

507 { return !( right < left ); }
std::right
T right(T...args)
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

bool operator> | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | left,
|  | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right
| ) |  |
| friend

Definition at line 504 of file VectorMap.h.

504 { return right < left; }
std::right
T right(T...args)
template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

bool operator>= | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | left,
|  | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right
| ) |  |
| friend

Definition at line 506 of file VectorMap.h.

506 { return !( left < right ); }
std::left
T left(T...args)

## Member Data Documentation

template<class KEY, class VALUE, class KEYCOMPARE = std::less<const KEY>, class ALLOCATOR = std::allocator<std::pair<KEY, VALUE>>>

_vector GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::m_vct
| private

the underlying sorted vector of (key,mapped) pairs

Definition at line 840 of file VectorMap.h.

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

- GaudiKernel/GaudiKernel/VectorMap.h