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 >:
Inheritance graph
[legend]
Collaboration diagram for GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >:
Collaboration graph
[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 108 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 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::vector<value_type,allocator_type> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::_vector

the actual storage container (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 ALLOCATOR GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::allocator_type

allocator (could be useful for optimizations)

Definition at line 124 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 189 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 149 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 128 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 153 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 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 _vector::const_iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::iterator

visible const_iterator (exported)

Definition at line 147 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 155 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 117 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 113 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 115 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 126 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 157 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 151 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 130 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 119 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
cmpcomparison criteria for the key
allocallocator to be used

Definition at line 710 of file VectorMap.h.

711  : m_vct ( alloc )
712  {}
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
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
rightobject to be copied

Definition at line 717 of file VectorMap.h.

718  : Gaudi::Utils::MapBase(right), m_vct ( right.m_vct )
719  {}
std::right
T right(T...args)
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
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
cmpcomparison criteria for the key
allocallocator to be used

Definition at line 728 of file VectorMap.h.

731  : m_vct ( first , last , alloc )
732  { std::sort ( m_vct.begin(), m_vct.end(), compare() ) ; }
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:861
std::vector::begin
T begin(T...args)
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:763
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
cmpcomparison criteria for the key
allocallocator to be used

Definition at line 739 of file VectorMap.h.

741  : m_vct ( first , alloc )
742  { std::sort ( m_vct.begin(), m_vct.end(), compare() ) ; }
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:861
std::vector::begin
T begin(T...args)
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:763
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 745 of file VectorMap.h.

745 { clear() ; } // destructor (non-virtual!)
GaudiUtils::VectorMap::clear
void clear()
clear the container
Definition: VectorMap.h:497

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_rangefor non-existing keys
Parameters
keykey value
Returns
mapped value

Definition at line 695 of file VectorMap.h.

696  {
697  iterator res = find ( key ) ;
698  if ( end() == res ) { this->throw_out_of_range_exception () ; }
699  return res->second ;
700  }
GaudiUtils::VectorMap::iterator
_vector::const_iterator iterator
visible const_iterator (exported)
Definition: VectorMap.h:147
GaudiUtils::VectorMap::find
iterator find(const key_type &key) const
find the element by key
Definition: VectorMap.h:455
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:198
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 196 of file VectorMap.h.

196 { return m_vct . begin () ; }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:196
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 497 of file VectorMap.h.

497 { m_vct.clear () ; }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
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 763 of file VectorMap.h.

764  {
765  static const compare_type s_cmp = compare_type() ;
766  return s_cmp ;
767  }
GaudiUtils::VectorMap::compare_type
_compare_type compare_type
the actual comparison criteria for valye_type objects
Definition: VectorMap.h:189
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
inlineprotected

compare the objects using the comaprison criteria

Parameters
objthe first object
objthe second object
Returns
result of (obj1,obj2) comparison

Definition at line 829 of file VectorMap.h.

831  {
832  return compare() ( obj1 , obj2 ) ;
833  }
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:763
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 769 of file VectorMap.h.

769 { return compare() ; }
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:763
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
keykey to be searched
Returns
number of elements with the given key (0 or 1)

Definition at line 478 of file VectorMap.h.

479  { return end() == find ( key ) ? 0 : 1 ; }
GaudiUtils::VectorMap::find
iterator find(const key_type &key) const
find the element by key
Definition: VectorMap.h:455
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:198
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 491 of file VectorMap.h.

491 { return m_vct . empty () ; }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
GaudiUtils::VectorMap::empty
bool empty() const
empty container ?
Definition: VectorMap.h:491
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 198 of file VectorMap.h.

198 { return m_vct . end () ; }
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:198
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
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 485 of file VectorMap.h.

486  { 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:198
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:196
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:763
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
posposition of the element to be erased

Definition at line 209 of file VectorMap.h.

209 { m_vct.erase ( iter ( pos ) ) ; }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
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:843
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
keykey for the element to be erased
Returns
number of erased elements (0 or 1)

Definition at line 227 of file VectorMap.h.

228  {
229  iterator pos = find ( key ) ;
230  if ( end() == pos ) { return 0 ; }
231  erase ( pos ) ;
232  return 1 ;
233  }
GaudiUtils::VectorMap::iterator
_vector::const_iterator iterator
visible const_iterator (exported)
Definition: VectorMap.h:147
GaudiUtils::VectorMap::find
iterator find(const key_type &key) const
find the element by key
Definition: VectorMap.h:455
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:198
GaudiUtils::VectorMap::erase
void erase(iterator pos)
erase the element using the iterator
Definition: VectorMap.h:209
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
firstbegin iterator of sub-sequence to be erased
endend iterator of the sub_sequence to be erased
Returns
number of erased elements

Definition at line 240 of file VectorMap.h.

242  {
243  m_vct.erase ( iter ( first ) , iter ( last ) ) ;
244  return last - first ;
245  }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
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:843
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
firstbegin-iterator for the sequence of keys
lastend-iterator for the sequence of keys
Returns
number of erased elements

Definition at line 268 of file VectorMap.h.

269  {
270  size_type res = 0 ;
271  for ( ; first != last ; ++first ) { res += erase ( *first ) ; }
272  return res ;
273  }
GaudiUtils::VectorMap::size_type
ALLOCATOR::size_type size_type
the types to conform STL
Definition: VectorMap.h:130
GaudiUtils::VectorMap::erase
void erase(iterator pos)
erase the element using the iterator
Definition: VectorMap.h:209
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
keykey to be searched
Returns
iterator to the element position in the container

Definition at line 455 of file VectorMap.h.

456  {
457  iterator res = lower_bound ( key ) ;
458  if ( end() != res && compare ( key , res->first ) )
459  { res = end(); }
460  return res ;
461  }
GaudiUtils::VectorMap::iterator
_vector::const_iterator iterator
visible const_iterator (exported)
Definition: VectorMap.h:147
GaudiUtils::VectorMap::lower_bound
iterator lower_bound(const key_type &key) const
Definition: VectorMap.h:481
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:198
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:763
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
keykey value to be inserted
mappedvalue 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 317 of file VectorMap.h.

319  { 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:317
GaudiUtils::VectorMap::value_type
std::pair< key_type, mapped_type > value_type
the actual storage item
Definition: VectorMap.h:119
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
valuevalue to be inserted
Returns
position of the inserted elements with the flag which allows to distinguish the actual insertion

Definition at line 362 of file VectorMap.h.

363  {
364  bool found = true ;
365  _iterator result = lower_bound ( value.first ) ;
366  if ( end() == result || compare( value.first , result -> first ) )
367  { result = m_vct.insert ( result , value ) ; found = false ; }
368  return result_type ( iter ( result ) , !found ) ;
369  }
GaudiUtils::VectorMap::_iterator
_vector::iterator _iterator
the regular iterator (no export)
Definition: VectorMap.h:142
GaudiUtils::VectorMap::lower_bound
iterator lower_bound(const key_type &key) const
Definition: VectorMap.h:481
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:198
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
GaudiUtils::VectorMap::result_type
std::pair< iterator, bool > result_type
visible iterator pait
Definition: VectorMap.h:157
std::vector::insert
T insert(T...args)
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:763
GaudiUtils::VectorMap::iter
_iterator iter(iterator p)
the conversion from &#39;const&#39; to &#39;non-const&#39; iterator
Definition: VectorMap.h:843
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
posthe guess about position where to insert the element
valuevalue to be inserted
Returns
position of the inserted elements with the flag which indicated the actual insertion

Definition at line 380 of file VectorMap.h.

382  {
383  if ( pos != end() && compare ( *pos , value ) &&
384  ( pos == end() - 1 ||
385  ( !compare ( value , *( pos + 1 ) )
386  && compare ( *( pos + 1 ) , value ) ) ) )
387  { return result_type( m_vct.insert ( iter ( pos ) , value ) , true ) ; }
388  return insert ( value ) ;
389  }
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:317
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:198
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
GaudiUtils::VectorMap::result_type
std::pair< iterator, bool > result_type
visible iterator pait
Definition: VectorMap.h:157
std::vector::insert
T insert(T...args)
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:763
GaudiUtils::VectorMap::iter
_iterator iter(iterator p)
the conversion from &#39;const&#39; to &#39;non-const&#39; iterator
Definition: VectorMap.h:843
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
posthe guess about position where to insert the element
keykey value to be inserted
mappedvalue to be associated with the key
Returns
position of the inserted elements with the flag which indicated the actual insertion

Definition at line 401 of file VectorMap.h.

404  { return insert ( pos , 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:317
GaudiUtils::VectorMap::value_type
std::pair< key_type, mapped_type > value_type
the actual storage item
Definition: VectorMap.h:119
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
firstthe begin iterator of the sequence
lastthe end iterator of the sequence

Definition at line 413 of file VectorMap.h.

415  { for ( ; first != last ; ++first ) { insert ( *first ) ; } }
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:317
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
kfthe begin iterator of the sequence of keys
klthe end iterator of the sequence of keys
vfthe begin iterator of the sequence of values

Definition at line 425 of file VectorMap.h.

428  { for ( ; kf != kl ; ++kf, ++vf ) { insert ( *kf , *vf ) ; } }
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:317
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)
inlineprotected

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

Definition at line 843 of file VectorMap.h.

844  {
845  auto result = m_vct.begin() ;
846  std::advance ( result , std::distance ( begin() , p ) ) ;
847  return result ;
848  }
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:861
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:196
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)
inlineprotected

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

Definition at line 851 of file VectorMap.h.

852  {
853  auto result = begin();
854  std::advance ( result , std::distance ( m_vct.begin() , p ) ) ;
855  return result ;
856  }
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:861
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:196
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_rangefor invalid index

Definition at line 797 of file VectorMap.h.

798  {
799  if ( index >= size() )
800  { this->throw_out_of_range_exception () ; }
801  auto it = this->begin() ;
802  std::advance ( it , index ) ;
803  return it -> first ;
804  }
std::advance
T advance(T...args)
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:196
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:493
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 481 of file VectorMap.h.

482  { 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:198
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:196
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:763
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)
inlineprotected

'lower-bound' - non-const version

Definition at line 836 of file VectorMap.h.

837  {
838  return std::lower_bound
839  ( m_vct.begin() , m_vct.end() , key , compare() ) ;
840  }
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:861
std::vector::begin
T begin(T...args)
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:763
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 495 of file VectorMap.h.

495 { return m_vct . max_size () ; }
GaudiUtils::VectorMap::max_size
size_type max_size() const
maximal allowed size
Definition: VectorMap.h:495
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
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 777 of file VectorMap.h.

778  {
779  for ( const auto& i : right ) { update ( i.first , i.second ) ; }
780  return *this ;
781  }
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:561
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 784 of file VectorMap.h.

785  {
786  for ( const auto& i : right ) { update ( i.first , i.second ) ; }
787  return *this ;
788  }
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:561
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
keykey value
Returns
mapped value for existing key and the default value for non-existing key

Definition at line 637 of file VectorMap.h.

638  {
639  static const mapped_type s_default = mapped_type() ;
640  iterator res = find ( key ) ;
641  if ( end() == res ) { return s_default ; }
642  return res->second ;
643  }
GaudiUtils::VectorMap::iterator
_vector::const_iterator iterator
visible const_iterator (exported)
Definition: VectorMap.h:147
GaudiUtils::VectorMap::find
iterator find(const key_type &key) const
find the element by key
Definition: VectorMap.h:455
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:198
GaudiUtils::VectorMap::mapped_type
VALUE mapped_type
the actual type of value
Definition: VectorMap.h:115
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 513 of file VectorMap.h.

514  { return m_vct < other.m_vct ; }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
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 751 of file VectorMap.h.

752  {
753  if ( &right == this ) { return *this ; }
754  m_vct = right.m_vct ;
755  return *this ;
756  }
std::right
T right(T...args)
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
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 510 of file VectorMap.h.

511  { return m_vct == other.m_vct ; }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
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
keykey value
Returns
mapped value

Definition at line 675 of file VectorMap.h.

676  { 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 200 of file VectorMap.h.

200 { return m_vct . rbegin () ; }
GaudiUtils::VectorMap::rbegin
reverse_iterator rbegin() const
"rbegin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:200
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
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 202 of file VectorMap.h.

202 { return m_vct . rend () ; }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
GaudiUtils::VectorMap::rend
reverse_iterator rend() const
"rend" iterator for sequential access (const-only version!)
Definition: VectorMap.h:202
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 499 of file VectorMap.h.

499 { m_vct.reserve ( num ) ; }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
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 493 of file VectorMap.h.

493 { return m_vct . size () ; }
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
GaudiUtils::VectorMap::size
size_type size() const
number of elements
Definition: VectorMap.h:493
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 502 of file VectorMap.h.

503  {
504  std::swap ( m_vct , other.m_vct ) ;
505  }
std::swap
T swap(T...args)
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
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
keykey value
mappedmapped value
Returns
true if the existing value has been replaced

Definition at line 561 of file VectorMap.h.

563  {
564  _iterator result = lower_bound ( key ) ;
565  if ( end() == result || compare ( key , result -> first ) )
566  {
567  result = m_vct.insert ( result , value_type(key,mapped) ) ;
568  return false ;
569  }
570  else { result->second = mapped ; }
571  //
572  return true ;
573  }
GaudiUtils::VectorMap::_iterator
_vector::iterator _iterator
the regular iterator (no export)
Definition: VectorMap.h:142
GaudiUtils::VectorMap::lower_bound
iterator lower_bound(const key_type &key) const
Definition: VectorMap.h:481
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:198
GaudiUtils::VectorMap::m_vct
_vector m_vct
the underlying sorted vector of (key,mapped) pairs
Definition: VectorMap.h:861
std::vector::insert
T insert(T...args)
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:763
GaudiUtils::VectorMap::value_type
std::pair< key_type, mapped_type > value_type
the actual storage item
Definition: VectorMap.h:119
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
vala pair of (key,value)
Returns
true if the existing value has been replaced

Definition at line 603 of file VectorMap.h.

604  { 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:561
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 483 of file VectorMap.h.

484  { 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:198
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:196
GaudiUtils::VectorMap::compare
const compare_type & compare() const
get the comparison criteria itself
Definition: VectorMap.h:763
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_rangefor invalid index

Definition at line 810 of file VectorMap.h.

811  {
812  if ( index >= size() )
813  { this->throw_out_of_range_exception () ; }
814  auto it = this->begin() ;
815  std::advance ( it , index ) ;
816  return it -> second ;
817  }
std::advance
T advance(T...args)
Gaudi::Units::second
constexpr double second
Definition: SystemOfUnits.h:122
GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:196
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:493

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 521 of file VectorMap.h.

523  { 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 772 of file VectorMap.h.

772 { 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 527 of file VectorMap.h.

529  { 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 518 of file VectorMap.h.

520  { 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 524 of file VectorMap.h.

526  { 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 861 of file VectorMap.h.

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