Gaudi Framework, version v23r0 |
Home | Generated: Mon Jan 30 2012 |
A bit modified version of 'LokiAssocVector' associative vector from Loki library by Andrei Alexandrescu. More...
#include <VectorMap.h>
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 | |
typedef VALUE | mapped_type |
the actual type of value | |
typedef KEYCOMPARE | key_compare |
comparison of keys | |
typedef std::pair< key_type, mapped_type > | value_type |
the actual storage item | |
typedef ALLOCATOR | allocator_type |
allocator (could be useful for optimizations) | |
typedef ALLOCATOR::const_reference | reference |
the types to conform STL | |
typedef ALLOCATOR::const_reference | const_reference |
the types to conform STL | |
typedef ALLOCATOR::size_type | size_type |
the types to conform STL | |
typedef ALLOCATOR::difference_type | difference_type |
the types to conform STL | |
typedef std::vector < value_type, allocator_type > | _vector |
the actual storage container (no export) | |
typedef _vector::const_iterator | iterator |
visible const_iterator (exported) | |
typedef _vector::const_iterator | const_iterator |
visible const_iterator (exported) | |
typedef std::reverse_iterator < iterator > | reverse_iterator |
visible reverse const_iterator (exported) | |
typedef std::reverse_iterator < const_iterator > | const_reverse_iterator |
visible reverse const_iterator (exported) | |
typedef std::pair< iterator, iterator > | iterators |
visible iterator pait | |
typedef std::pair< iterator, bool > | result_type |
visible iterator pait | |
typedef _compare_type | compare_type |
the actual comparison criteria for valye_type objects | |
Public Member Functions | |
iterator | begin () const |
"begin" iterator for sequential access (const-only version!) | |
iterator | end () const |
"end" iterator for sequential access (const-only version!) | |
reverse_iterator | rbegin () const |
"rbegin" iterator for sequential access (const-only version!) | |
reverse_iterator | rend () const |
"rend" iterator for sequential access (const-only version!) | |
void | erase (iterator pos) |
erase the element using the iterator | |
size_type | erase (const key_type &key) |
erase the element using the key | |
size_type | erase (iterator first, iterator last) |
erase the sequence of elements using the iterators | |
template<class TYPE > | |
size_type | erase (TYPE first, TYPE last) |
erase the sequence of elements using the sequence of keys | |
result_type | insert (const key_type &key, const mapped_type &mapped) |
insert the (key,value) pair into the container | |
result_type | insert (const value_type &value) |
insert the (key,value) pair into the container | |
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 | |
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 | |
template<class PAIRS > | |
void | insert (PAIRS first, PAIRS last) |
insert the sequence of elements into the container | |
template<class KEYS , class VALUES > | |
void | insert (KEYS kf, KEYS kl, VALUES vf) |
insert into the container the elements from 2 "parallel" sequences | |
iterator | find (const key_type &key) const |
find the element by key | |
size_type | count (const key_type &key) const |
count number of elements with the certain key | |
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 ? | |
size_type | size () const |
number of elements | |
size_type | max_size () const |
maximal allowed size | |
void | clear () |
clear the container | |
void | reserve (size_type num) |
reserve the space in the container for at least 'num' elements | |
void | swap (VectorMap &other) |
swap function, which 'swaps' the content of two containers | |
bool | operator== (const VectorMap &other) const |
comparison criteria for containers | |
bool | operator< (const VectorMap &other) const |
comparison criteria for containers | |
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. | |
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. | |
const mapped_type & | operator() (const key_type &key) const |
access to element by key (const version) there is no container increment for missing keys | |
const mapped_type & | operator[] (const key_type &key) const |
access to element by key (const version) there is no container increment for missing keys | |
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 | |
VectorMap (const allocator_type &alloc=allocator_type()) | |
default constructor from the the allocator | |
VectorMap (const VectorMap &right) | |
copy constructor | |
template<class INPUT > | |
VectorMap (INPUT first, INPUT last, const allocator_type &alloc=allocator_type()) | |
templated constructor from "convertible" sequence | |
~VectorMap () | |
destructor (non-virtual!) | |
VectorMap & | operator= (const VectorMap &right) |
const compare_type & | compare () const |
get the comparison criteria itself | |
const key_compare & | compare_key () const |
get the comparison criteria for keys | |
VectorMap & | merge (const VectorMap &right) |
merge two maps | |
template<class K1 , class K2 , class K3 , class K4 > | |
VectorMap & | merge (const VectorMap< K1, K2, K3, K4 > &right) |
merge two maps | |
const key_type & | key_at (const size_t index) const |
useful method for python decoration: | |
const mapped_type & | value_at (const size_t index) const |
useful method for python decoration: | |
Protected Types | |
typedef _vector::iterator | _iterator |
the regular iterator (no export) | |
Protected Member Functions | |
template<class TYPE1 , class TYPE2 > | |
bool | compare (const TYPE1 &obj1, const TYPE2 &obj2) const |
compare the objects using the comaprison criteria | |
_iterator | lower_bound (const key_type &key) |
'lower-bound' - non-const version | |
_iterator | iter (iterator p) |
the conversion from 'const' to 'non-const' iterator | |
iterator | iter (_iterator p) |
the conversion from 'non-const' to 'const' iterator | |
Private Attributes | |
_vector | m_vct |
the underlying sorted vector of (key,mapped) pairs | |
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 |
A bit modified version of 'LokiAssocVector' 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
>>> 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:
Definition at line 110 of file VectorMap.h.
typedef _vector::iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::_iterator [protected] |
the regular iterator (no export)
Definition at line 144 of file VectorMap.h.
typedef std::vector<value_type,allocator_type> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::_vector |
the actual storage container (no export)
Definition at line 139 of file VectorMap.h.
typedef ALLOCATOR GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::allocator_type |
allocator (could be useful for optimizations)
Definition at line 126 of file VectorMap.h.
typedef _compare_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::compare_type |
the actual comparison criteria for valye_type objects
Definition at line 191 of file VectorMap.h.
typedef _vector::const_iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::const_iterator |
visible const_iterator (exported)
Definition at line 151 of file VectorMap.h.
typedef ALLOCATOR::const_reference GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::const_reference |
the types to conform STL
Definition at line 130 of file VectorMap.h.
typedef std::reverse_iterator<const_iterator> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::const_reverse_iterator |
visible reverse const_iterator (exported)
Definition at line 155 of file VectorMap.h.
typedef ALLOCATOR::difference_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::difference_type |
the types to conform STL
Definition at line 134 of file VectorMap.h.
typedef _vector::const_iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::iterator |
visible const_iterator (exported)
Definition at line 149 of file VectorMap.h.
typedef std::pair<iterator,iterator> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::iterators |
visible iterator pait
Definition at line 157 of file VectorMap.h.
typedef KEYCOMPARE GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::key_compare |
comparison of keys
Definition at line 119 of file VectorMap.h.
typedef KEY GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::key_type |
the actual type of key
Definition at line 115 of file VectorMap.h.
typedef VALUE GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::mapped_type |
the actual type of value
Definition at line 117 of file VectorMap.h.
typedef ALLOCATOR::const_reference GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::reference |
the types to conform STL
Definition at line 128 of file VectorMap.h.
typedef std::pair<iterator,bool> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::result_type |
visible iterator pait
Definition at line 159 of file VectorMap.h.
typedef std::reverse_iterator<iterator> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::reverse_iterator |
visible reverse const_iterator (exported)
Definition at line 153 of file VectorMap.h.
typedef ALLOCATOR::size_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::size_type |
the types to conform STL
Definition at line 132 of file VectorMap.h.
typedef std::pair<key_type,mapped_type> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::value_type |
the actual storage item
Definition at line 121 of file VectorMap.h.
GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::VectorMap | ( | const allocator_type & | alloc = allocator_type () ) |
[inline] |
default constructor from the the allocator
cmp | comparison criteria for the key |
alloc | allocator to be used |
Definition at line 712 of file VectorMap.h.
: m_vct ( alloc ) {}
GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::VectorMap | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right ) | [inline] |
GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::VectorMap | ( | INPUT | first, |
INPUT | last, | ||
const allocator_type & | alloc = allocator_type () |
||
) | [inline] |
templated constructor from "convertible" sequence
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 730 of file VectorMap.h.
GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::~VectorMap | ( | ) | [inline] |
destructor (non-virtual!)
Definition at line 737 of file VectorMap.h.
{ clear() ; } // destructor (non-virtual!)
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!
std::out_of_range | for non-existing keys |
key | key value |
Definition at line 697 of file VectorMap.h.
{ iterator res = find ( key ) ; if ( end() == res ) { this->throw_out_of_range_exception () ; } return res->second ; }
iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::begin | ( | void | ) | const [inline] |
"begin" iterator for sequential access (const-only version!)
Definition at line 198 of file VectorMap.h.
void GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::clear | ( | void | ) | [inline] |
const compare_type& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::compare | ( | ) | const [inline] |
get the comparison criteria itself
Definition at line 755 of file VectorMap.h.
{ static const compare_type s_cmp = compare_type() ; return s_cmp ; }
bool GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::compare | ( | const TYPE1 & | obj1, |
const TYPE2 & | obj2 | ||
) | const [inline, protected] |
compare the objects using the comaprison criteria
obj | the first object |
obj | the second object |
Definition at line 826 of file VectorMap.h.
{ return compare() ( obj1 , obj2 ) ; }
const key_compare& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::compare_key | ( | ) | const [inline] |
get the comparison criteria for keys
Definition at line 761 of file VectorMap.h.
{ return compare() ; }
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 ;
key | key to be searched |
Definition at line 480 of file VectorMap.h.
bool GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::empty | ( | void | ) | const [inline] |
iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::end | ( | void | ) | const [inline] |
"end" iterator for sequential access (const-only version!)
Definition at line 200 of file VectorMap.h.
iterators GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::equal_range | ( | const key_type & | key ) | const [inline] |
Definition at line 487 of file VectorMap.h.
{ return std::equal_range ( begin () , end () , key , compare () ) ; }
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 ;
first | begin-iterator for the sequence of keys |
last | end-iterator for the sequence of keys |
Definition at line 270 of file VectorMap.h.
void GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::erase | ( | iterator | pos ) | [inline] |
erase the element using the iterator
pos | position of the element to be erased |
Definition at line 211 of file VectorMap.h.
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 ;
key | key for the element to be erased |
Definition at line 229 of file VectorMap.h.
size_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::erase | ( | iterator | first, |
iterator | last | ||
) | [inline] |
erase the sequence of elements using the iterators
first | begin iterator of sub-sequence to be erased |
end | end iterator of the sub_sequence to be erased |
Definition at line 242 of file VectorMap.h.
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 ; }
key | key to be searched |
Definition at line 457 of file VectorMap.h.
{ iterator res = lower_bound ( key ) ; if ( end() != res && compare ( key , res->first ) ) { res = end(); } return res ; }
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
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 ;
key | key value to be inserted |
mapped | value to be associated with the key |
Definition at line 319 of file VectorMap.h.
{ return insert ( value_type ( key , mapped ) ) ; }
result_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::insert | ( | const value_type & | value ) | [inline] |
insert the (key,value) pair into the container
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 ;
value | value to be inserted |
Definition at line 364 of file VectorMap.h.
{ bool found = true ; _iterator result = lower_bound ( value.first ) ; if ( end() == result || compare( value.first , result -> first ) ) { result = m_vct.insert ( result , value ) ; found = false ; } return result_type ( iter ( result ) , !found ) ; }
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
pos | the guess about position where to insert the element |
value | value to be inserted |
Definition at line 382 of file VectorMap.h.
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
pos | the guess about position where to insert the element |
key | key value to be inserted |
mapped | value to be associated with the key |
Definition at line 403 of file VectorMap.h.
{ return insert ( pos , value_type ( key , mapped ) ) ; }
void GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::insert | ( | PAIRS | first, |
PAIRS | last | ||
) | [inline] |
insert the sequence of elements into the container
first | the begin iterator of the sequence |
last | the end iterator of the sequence |
Definition at line 415 of file VectorMap.h.
{ for ( ; first != last ; ++first ) { insert ( *first ) ; } }
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
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 427 of file VectorMap.h.
{ for ( ; kf != kl ; ++kf, ++vf ) { insert ( *kf , *vf ) ; } }
iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::iter | ( | _iterator | p ) | [inline, protected] |
the conversion from 'non-const' to 'const' iterator
Definition at line 848 of file VectorMap.h.
{ iterator result ( begin() ) ; std::advance ( result , std::distance ( m_vct.begin() , p ) ) ; return result ; }
_iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::iter | ( | iterator | p ) | [inline, protected] |
the conversion from 'const' to 'non-const' iterator
Definition at line 840 of file VectorMap.h.
{ _iterator result = m_vct.begin() ; std::advance ( result , std::distance ( begin() , p ) ) ; return result ; }
const key_type& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::key_at | ( | const size_t | index ) | const [inline] |
useful method for python decoration:
index | (INPUT) the index |
std::out_of_range | for invalid index |
Definition at line 794 of file VectorMap.h.
{ if ( index >= size() ) { this->throw_out_of_range_exception () ; } const_iterator it = this->begin() ; std::advance ( it , index ) ; return it -> first ; }
_iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::lower_bound | ( | const key_type & | key ) | [inline, protected] |
'lower-bound' - non-const version
Definition at line 833 of file VectorMap.h.
iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::lower_bound | ( | const key_type & | key ) | const [inline] |
Definition at line 483 of file VectorMap.h.
{ return std::lower_bound ( begin () , end () , key , compare () ) ; }
size_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::max_size | ( | ) | const [inline] |
VectorMap& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::merge | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right ) | [inline] |
merge two maps
Definition at line 769 of file VectorMap.h.
{ for ( const_iterator it = right.begin() ; right.end() != it ; ++it ) { update ( it->first , it->second ) ; } // return *this ; }
VectorMap& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::merge | ( | const VectorMap< K1, K2, K3, K4 > & | right ) | [inline] |
merge two maps
Definition at line 778 of file VectorMap.h.
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
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!
key | key value |
Definition at line 639 of file VectorMap.h.
{ static const mapped_type s_default = mapped_type() ; iterator res = find ( key ) ; if ( end() == res ) { return s_default ; } return res->second ; }
bool GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::operator< | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | other ) | const [inline] |
comparison criteria for containers
Definition at line 515 of file VectorMap.h.
{ return m_vct < other.m_vct ; }
VectorMap& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::operator= | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right ) | [inline] |
Definition at line 743 of file VectorMap.h.
bool GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::operator== | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | other ) | const [inline] |
comparison criteria for containers
Definition at line 512 of file VectorMap.h.
{ return m_vct == other.m_vct ; }
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
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!
key | key value |
Definition at line 677 of file VectorMap.h.
{ return (*this)( key ) ; }
reverse_iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::rbegin | ( | void | ) | const [inline] |
"rbegin" iterator for sequential access (const-only version!)
Definition at line 202 of file VectorMap.h.
reverse_iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::rend | ( | void | ) | const [inline] |
"rend" iterator for sequential access (const-only version!)
Definition at line 204 of file VectorMap.h.
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 501 of file VectorMap.h.
size_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::size | ( | void | ) | const [inline] |
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 504 of file VectorMap.h.
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.
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
key | key value |
mapped | mapped value |
Definition at line 563 of file VectorMap.h.
{ _iterator result = lower_bound ( key ) ; if ( end() == result || compare ( key , result -> first ) ) { result = m_vct.insert ( result , value_type(key,mapped) ) ; return false ; } else { result->second = mapped ; } // return true ; }
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.
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
val | a pair of (key,value) |
Definition at line 605 of file VectorMap.h.
{ return update ( val.first , val.second ) ; }
iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::upper_bound | ( | const key_type & | key ) | const [inline] |
Definition at line 485 of file VectorMap.h.
{ return std::upper_bound ( begin () , end () , key , compare () ) ; }
const mapped_type& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::value_at | ( | const size_t | index ) | const [inline] |
useful method for python decoration:
index | (INPUT) the index |
std::out_of_range | for invalid index |
Definition at line 807 of file VectorMap.h.
{ if ( index >= size() ) { this->throw_out_of_range_exception () ; } const_iterator it = this->begin() ; std::advance ( it , index ) ; return it -> second ; }
bool operator!= | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | left, |
const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right | ||
) | [friend] |
Definition at line 523 of file VectorMap.h.
std::ostream& operator<< | ( | std::ostream & | str, |
const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | |||
) | [friend] |
bool operator<= | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | left, |
const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right | ||
) | [friend] |
Definition at line 529 of file VectorMap.h.
bool operator> | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | left, |
const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right | ||
) | [friend] |
Definition at line 520 of file VectorMap.h.
bool operator>= | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | left, |
const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right | ||
) | [friend] |
Definition at line 526 of file VectorMap.h.
_vector GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::m_vct [private] |
the underlying sorted vector of (key,mapped) pairs
Definition at line 858 of file VectorMap.h.