The Gaudi Framework: GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

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

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

inline

copy constructor

Parameters

right object to be copied

Definition at line 693 of file VectorMap.h.

693 : Gaudi::Utils::MapBase( right ), m_vct( right.m_vct ) {}

std::right

T right(T...args)

GaudiUtils::VectorMap::clear

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

Gaudi::Utils::MapBase

Helper base-class to allow the generic Python-decoration for all "map-like" classes in Gaudi...

Definition: MapBase.h:44

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

template<class INPUT >

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

inline

templated constructor from "convertible" sequence

Parameters

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

Definition at line 702 of file VectorMap.h.

                                                                                          : m_vct( first, last, alloc )
     {
       std::sort( m_vct.begin(), m_vct.end(), compare() );
     }

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

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

inline

tconstructor from initializer list

Parameters

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

Definition at line 712 of file VectorMap.h.

         : m_vct( first, alloc )
     {
       std::sort( m_vct.begin(), m_vct.end(), compare() );
     }

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

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

inline

destructor (non-virtual!)

Definition at line 719 of file VectorMap.h.

719 { clear(); }

void clear()

clear the container

Definition: VectorMap.h:488

Member Function Documentation

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

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

inline

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

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

Exceptions

std::out_of_range for non-existing keys

Parameters

key key value

Returns: mapped value

Definition at line 671 of file VectorMap.h.

     {
       iterator res = find( key );
       if ( end() == res ) {
         this->throw_out_of_range_exception();
       }
       return res->second;
     }

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

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

inline

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

Definition at line 189 of file VectorMap.h.

189 { return m_vct.begin(); }

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

std::vector::begin

T begin(T...args)

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

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

inline

clear the container

Definition at line 488 of file VectorMap.h.

488 { m_vct.clear(); }

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

std::vector::clear

T clear(T...args)

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

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

inline

get the comparison criteria itself

Definition at line 739 of file VectorMap.h.

     {
       static const compare_type s_cmp = compare_type();
       return s_cmp;
     }

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

obj	the first object
obj	the second object

Returns: result of (obj1,obj2) comparison

Definition at line 810 of file VectorMap.h.

     {
       return compare()( obj1, obj2 );
     }

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

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

inline

get the comparison criteria for keys

Definition at line 745 of file VectorMap.h.

745 { return compare(); }

GaudiUtils::VectorMap::find

const compare_type & compare() const

get the comparison criteria itself

Definition: VectorMap.h:739

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

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

inline

count number of elements with the certain key

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

Parameters

key	key to be searched

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

Definition at line 473 of file VectorMap.h.

473 { return end() == find( key ) ? 0 : 1; }

iterator find(const key_type &key) const

find the element by key

Definition: VectorMap.h:449

iterator end() const

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

Definition: VectorMap.h:191

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

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

inline

empty container ?

Definition at line 482 of file VectorMap.h.

482 { return m_vct.empty(); }

std::vector::empty

T empty(T...args)

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

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

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

inline

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

Definition at line 191 of file VectorMap.h.

191 { return m_vct.end(); }

std::vector::end

T end(T...args)

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

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

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

inline

Definition at line 477 of file VectorMap.h.

477 { return std::equal_range( begin(), end(), key, compare() ); }

GaudiUtils::VectorMap::begin

iterator end() const

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

Definition: VectorMap.h:191

iterator begin() const

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

Definition: VectorMap.h:189

const compare_type & compare() const

get the comparison criteria itself

Definition: VectorMap.h:739

std::equal_range

T equal_range(T...args)

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

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

inline

erase the element using the iterator

Parameters

pos	position of the element to be erased

Definition at line 202 of file VectorMap.h.

202 { m_vct.erase( iter( pos ) ); }

GaudiUtils::VectorMap::iter

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

std::vector::erase

T erase(T...args)

_iterator iter(iterator p)

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

Definition: VectorMap.h:822

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

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

inline

erase the element using the key

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

Parameters

key	key for the element to be erased

Returns: number of erased elements (0 or 1)

Definition at line 220 of file VectorMap.h.

     {
       iterator pos = find( key );
       if ( end() == pos ) {
         return 0;
       }
       erase( pos );
       return 1;
     }

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

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

inline

erase the sequence of elements using the iterators

Parameters

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

Returns: number of erased elements

Definition at line 235 of file VectorMap.h.

     {
       m_vct.erase( iter( first ), iter( last ) );
       return last - first;
     }

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

template<class TYPE >

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

inline

erase the sequence of elements using the sequence of keys

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

Parameters

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

Returns: number of erased elements

Definition at line 262 of file VectorMap.h.

     {
       size_type res = 0;
       for ( ; first != last; ++first ) {
         res += erase( *first );
       }
       return res;
     }

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

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

inline

find the element by key

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

Parameters

key	key to be searched

Returns: iterator to the element position in the container

Definition at line 449 of file VectorMap.h.

     {
       iterator res = lower_bound( key );
       if ( end() != res && compare( key, res->first ) ) {
         res = end();
       }
       return res;
     }

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

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

inline

insert the (key,value) pair into the container

Attention: there is no replacement for the existing key!

It is STL-compliant behavior for associative containers.

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

Parameters

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

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

Definition at line 312 of file VectorMap.h.

312 { return insert( value_type( key, mapped ) ); }

GaudiUtils::VectorMap::insert

result_type insert(const key_type &key, const mapped_type &mapped)

insert the (key,value) pair into the container

Definition: VectorMap.h:312

GaudiUtils::VectorMap::value_type

std::pair< key_type, mapped_type > value_type

the actual storage item

Definition: VectorMap.h:114

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

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

inline

insert the (key,value) pair into the container

Attention: there is no replacement for the existing element!

It is STL-compliant behavior for associative containers.

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

Parameters

value value to be inserted

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

Definition at line 354 of file VectorMap.h.

     {
       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 );
     }

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

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

inline

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

Attention: there is no replacement for the existing element!

Parameters

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

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

Definition at line 373 of file VectorMap.h.

     {
       if ( pos != end() && compare( *pos, value ) &&
            ( pos == end() - 1 || ( !compare( value, *( pos + 1 ) ) && compare( *( pos + 1 ), value ) ) ) ) {
         return result_type( m_vct.insert( iter( pos ), value ), true );
       }
       return insert( value );
     }

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

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

inline

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

Attention: there is no replacement for the existing element!

Parameters

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

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

Definition at line 391 of file VectorMap.h.

     {
       return insert( pos, value_type( key, mapped ) );
     }

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

template<class PAIRS >

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

inline

insert the sequence of elements into the container

Attention: there is no replacement for the existing element!

Parameters

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

Definition at line 402 of file VectorMap.h.

     {
       for ( ; first != last; ++first ) {
         insert( *first );
       }
     }

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

template<class KEYS , class VALUES >

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

inline

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

Attention: there is no replacement for the existing element!

Parameters

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

Definition at line 417 of file VectorMap.h.

     {
       for ( ; kf != kl; ++kf, ++vf ) {
         insert( *kf, *vf );
       }
     }

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

     {
       auto result = m_vct.begin();
       std::advance( result, std::distance( begin(), p ) );
       return result;
     }

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

     {
       auto result = begin();
       std::advance( result, std::distance( m_vct.begin(), p ) );
       return result;
     }

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

const key_type& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::key_at ( const size_t index ) const

inline

useful method for python decoration:

Parameters

index (INPUT) the index

Returns: the key at given index

Exceptions

std::out_of_range for invalid index

Definition at line 776 of file VectorMap.h.

     {
       if ( index >= size() ) {
         this->throw_out_of_range_exception();
       }
       auto it = this->begin();
       std::advance( it, index );
       return it->first;
     }

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

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

inline

Definition at line 475 of file VectorMap.h.

475 { return std::lower_bound( begin(), end(), key, compare() ); }

std::lower_bound

T lower_bound(T...args)

GaudiUtils::VectorMap::begin

iterator end() const

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

Definition: VectorMap.h:191

iterator begin() const

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

Definition: VectorMap.h:189

const compare_type & compare() const

get the comparison criteria itself

Definition: VectorMap.h:739

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

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

inlineprotected

'lower-bound' - non-const version

Definition at line 816 of file VectorMap.h.

     {
       return std::lower_bound( m_vct.begin(), m_vct.end(), key, compare() );
     }

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

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

inline

maximal allowed size

Definition at line 486 of file VectorMap.h.

486 { return m_vct.max_size(); }

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

std::vector::max_size

T max_size(T...args)

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

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

inline

merge two maps

Definition at line 752 of file VectorMap.h.

     {
       for ( const auto& i : right ) {
         update( i.first, i.second );
       }
       return *this;
     }

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

template<class K1 , class K2 , class K3 , class K4 >

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

inline

merge two maps

Definition at line 761 of file VectorMap.h.

     {
       for ( const auto& i : right ) {
         update( i.first, i.second );
       }
       return *this;
     }

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

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

inline

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

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

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

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

See also: GaudiUtils::Map

Parameters

key key value

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

Definition at line 612 of file VectorMap.h.

     {
       static const mapped_type s_default = mapped_type();
       iterator                 res       = find( key );
       if ( end() == res ) {
         return s_default;
       }
       return res->second;
     }

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

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

inline

comparison criteria for containers

Definition at line 500 of file VectorMap.h.

500 { return m_vct < other.m_vct; }

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

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

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

inline

Definition at line 725 of file VectorMap.h.

     {
       if ( &right == this ) {
         return *this;
       }
       m_vct = right.m_vct;
       return *this;
     }

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

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

inline

comparison criteria for containers

Definition at line 498 of file VectorMap.h.

498 { return m_vct == other.m_vct; }

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

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

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

inline

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

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

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

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

See also: GaudiUtils::Map

Parameters

key key value

Returns: mapped value

Definition at line 652 of file VectorMap.h.

652 { return ( *this )( key ); }

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

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

inline

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

Definition at line 193 of file VectorMap.h.

193 { return m_vct.rbegin(); }

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

std::vector::rbegin

T rbegin(T...args)

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

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

inline

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

Definition at line 195 of file VectorMap.h.

195 { return m_vct.rend(); }

std::vector::rend

T rend(T...args)

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

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

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

inline

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

Definition at line 490 of file VectorMap.h.

490 { m_vct.reserve( num ); }

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

std::vector::reserve

T reserve(T...args)

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

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

inline

number of elements

Definition at line 484 of file VectorMap.h.

484 { return m_vct.size(); }

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

std::vector::size

T size(T...args)

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

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

inline

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

Definition at line 493 of file VectorMap.h.

493 { std::swap( m_vct, other.m_vct ); }

std::swap

T swap(T...args)

GaudiUtils::VectorMap::update

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition: VectorMap.h:840

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

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

inline

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

Attention: There is no STL analogue

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

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

Parameters

key	key value
mapped	mapped value

Returns: true if the existing value has been replaced

Definition at line 538 of file VectorMap.h.

     {
       _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;
     }

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

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

inline

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

Attention: There is no STL analogue

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

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

Parameters

val	a pair of (key,value)

Returns: true if the existing value has been replaced

Definition at line 579 of file VectorMap.h.

579 { return update( val.first, val.second ); }

bool update(const key_type &key, const mapped_type &mapped)

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

Definition: VectorMap.h:538

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

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

inline

Definition at line 476 of file VectorMap.h.

476 { return std::upper_bound( begin(), end(), key, compare() ); }

std::upper_bound

T upper_bound(T...args)

GaudiUtils::VectorMap::begin

iterator end() const

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

Definition: VectorMap.h:191

iterator begin() const

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

Definition: VectorMap.h:189