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

#include </builds/gaudi/Gaudi/GaudiKernel/include/GaudiKernel/VectorMap.h>

Inheritance diagram for GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >:

Collaboration diagram for GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >:

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)
using	reference = typename ALLOCATOR::value_type const&
	the types to conform STL
using	const_reference = typename ALLOCATOR::value_type const&
	the types to conform STL
using	size_type = typename ALLOCATOR::size_type
	the types to conform STL
using	difference_type = typename ALLOCATOR::difference_type
	the types to conform STL
typedef std::vector< value_type, allocator_type >	_vector
	the actual storage container (no export)
using	iterator = typename _vector::const_iterator
	visible const_iterator (exported)
using	const_iterator = typename _vector::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
template<detail::key_comparable< key_type, key_compare > K>
size_type	erase (const K &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, key_type key, 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
template<detail::key_comparable< key_type, key_compare > K>
iterator	find (const K &key) const
size_type	count (const key_type &key) const
	count number of elements with the certain key
template<detail::key_comparable< key_type, key_compare > K>
size_type	count (const K &key) const
iterator	lower_bound (const key_type &key) const
template<detail::key_comparable< key_type, key_compare > K>
iterator	lower_bound (const K &key) const
iterator	upper_bound (const key_type &key) const
template<detail::key_comparable< key_type, key_compare > K>
iterator	upper_bound (const K &key) const
iterators	equal_range (const key_type &key) const
template<detail::key_comparable< key_type, key_compare > K>
iterators	equal_range (const K &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
auto	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.
template<detail::key_comparable< key_type, key_compare > K>
bool	update (const K &key, const mapped_type &mapped)
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
template<detail::key_comparable< key_type, key_compare > K>
const mapped_type &	operator() (const K &key) const
const mapped_type &	operator[] (const key_type &key) const
	access to element by key (const version) there is no container increment for missing keys
template<detail::key_comparable< key_type, key_compare > K>
const mapped_type &	operator[] (const K &key) const
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
template<detail::key_comparable< key_type, key_compare > K>
const mapped_type &	at (const K &key) const
	VectorMap (const allocator_type &alloc=allocator_type())
	default constructor from the the allocator
template<class INPUT>
	VectorMap (INPUT first, INPUT last, const allocator_type &alloc=allocator_type())
	templated constructor from "convertible" sequence
	VectorMap (std::initializer_list< value_type > first, const allocator_type &alloc=allocator_type())
	tconstructor from initializer list
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:
Public Member Functions inherited from Gaudi::Utils::MapBase
virtual	~MapBase ()

Protected Types
using	_iterator = typename _vector::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
template<detail::key_comparable< key_type, key_compare > K>
_iterator	lower_bound (const K &key)
_iterator	iter (iterator p)
	the conversion from 'const' to 'non-const' iterator
iterator	iter (_iterator p)
	the conversion from 'non-const' to 'const' iterator
Protected Member Functions inherited from Gaudi::Utils::MapBase
void	throw_out_of_range_exception () const
	throw std::out_of_range exception

Private Attributes
_vector	m_vct
	the underlying sorted vector of (key,mapped) pairs

Friends
std::ostream &	operator<< (std::ostream &str, const VectorMap &)
	printout to ostream - not implemented

Detailed Description

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 112 of file VectorMap.h.

Member Typedef Documentation

◆ _iterator

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

using GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::_iterator = typename _vector::iterator

protected

the regular iterator (no export)

Definition at line 141 of file VectorMap.h.

◆ _vector

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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.

◆ allocator_type

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 125 of file VectorMap.h.

◆ compare_type

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 181 of file VectorMap.h.

◆ const_iterator

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

using GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::const_iterator = typename _vector::const_iterator

visible const_iterator (exported)

Definition at line 147 of file VectorMap.h.

◆ const_reference

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

using GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::const_reference = typename ALLOCATOR::value_type const&

the types to conform STL

Definition at line 129 of file VectorMap.h.

◆ const_reverse_iterator

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 151 of file VectorMap.h.

◆ difference_type

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

using GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::difference_type = typename ALLOCATOR::difference_type

the types to conform STL

Definition at line 133 of file VectorMap.h.

◆ iterator

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

using GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::iterator = typename _vector::const_iterator

visible const_iterator (exported)

Definition at line 145 of file VectorMap.h.

◆ iterators

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 153 of file VectorMap.h.

◆ key_compare

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

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

comparison of keys

Definition at line 119 of file VectorMap.h.

◆ key_type

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 115 of file VectorMap.h.

◆ mapped_type

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 117 of file VectorMap.h.

◆ reference

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

using GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::reference = typename ALLOCATOR::value_type const&

the types to conform STL

Definition at line 127 of file VectorMap.h.

◆ result_type

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 155 of file VectorMap.h.

◆ reverse_iterator

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 149 of file VectorMap.h.

◆ size_type

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

using GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::size_type = typename ALLOCATOR::size_type

the types to conform STL

Definition at line 131 of file VectorMap.h.

◆ value_type

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 121 of file VectorMap.h.

Constructor & Destructor Documentation

◆ VectorMap() [1/3]

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

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

inline

default constructor from the the allocator

Parameters

cmp	comparison criteria for the key
alloc	allocator to be used

Definition at line 656 of file VectorMap.h.

656: m_vct( alloc ) {}

GaudiUtils::VectorMap

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

Definition VectorMap.h:112

GaudiUtils::VectorMap::m_vct

_vector m_vct

the underlying sorted vector of (key,mapped) pairs

Definition VectorMap.h:758

◆ VectorMap() [2/3]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 664 of file VectorMap.h.

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

◆ VectorMap() [3/3]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 672 of file VectorMap.h.

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

Member Function Documentation

◆ at() [1/2]

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

template<detail::key_comparable< key_type, key_compare > K>

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

inline

Definition at line 644 of file VectorMap.h.

                                                {
      iterator res = find( key );
      if ( end() == res ) this->throw_out_of_range_exception();
      return res->second; // cppcheck-suppress derefInvalidIteratorRedundantCheck; the above throws
    }

◆ at() [2/2]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 642 of file VectorMap.h.

642{ return at<key_type>( key ); }

GaudiUtils::VectorMap::at

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

Definition VectorMap.h:642

◆ begin()

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 186 of file VectorMap.h.

186{ return m_vct.begin(); }

◆ clear()

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

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

inline

clear the container

Definition at line 470 of file VectorMap.h.

470{ m_vct.clear(); }

◆ compare() [1/2]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 680 of file VectorMap.h.

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

◆ compare() [2/2]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 734 of file VectorMap.h.

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

◆ compare_key()

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 685 of file VectorMap.h.

685{ return compare(); }

◆ count() [1/2]

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

template<detail::key_comparable< key_type, key_compare > K>

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

inline

Definition at line 444 of file VectorMap.h.

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

◆ count() [2/2]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 442 of file VectorMap.h.

442{ return count<key_type>( key ); }

GaudiUtils::VectorMap::count

size_type count(const key_type &key) const

count number of elements with the certain key

Definition VectorMap.h:442

◆ empty()

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

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

inline

empty container ?

Definition at line 464 of file VectorMap.h.

464{ return m_vct.empty(); }

◆ end()

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 188 of file VectorMap.h.

188{ return m_vct.end(); }

◆ equal_range() [1/2]

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

template<detail::key_comparable< key_type, key_compare > K>

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

inline

Definition at line 459 of file VectorMap.h.

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

◆ equal_range() [2/2]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 457 of file VectorMap.h.

457{ return equal_range<key_type>( key ); }

GaudiUtils::VectorMap::equal_range

iterators equal_range(const key_type &key) const

Definition VectorMap.h:457

◆ erase() [1/5]

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

template<detail::key_comparable< key_type, key_compare > K>

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

inline

Definition at line 216 of file VectorMap.h.

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

◆ erase() [2/5]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 214 of file VectorMap.h.

214{ return erase<key_type>( key ); }

◆ erase() [3/5]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 227 of file VectorMap.h.

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

◆ erase() [4/5]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 197 of file VectorMap.h.

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

◆ erase() [5/5]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 252 of file VectorMap.h.

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

◆ find() [1/2]

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

template<detail::key_comparable< key_type, key_compare > K>

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

inline

Definition at line 421 of file VectorMap.h.

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

◆ find() [2/2]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 419 of file VectorMap.h.

419{ return find<key_type>( key ); }

◆ insert() [1/6]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 298 of file VectorMap.h.

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

GaudiUtils::VectorMap::value_type

std::pair< key_type, mapped_type > value_type

the actual storage item

Definition VectorMap.h:121

◆ insert() [2/6]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 339 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 );
    }

◆ insert() [3/6]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 356 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 );
    }

◆ insert() [4/6]

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

result_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::insert	(	iterator	pos,
		key_type	key,
		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 372 of file VectorMap.h.

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

◆ insert() [5/6]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 392 of file VectorMap.h.

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

◆ insert() [6/6]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 381 of file VectorMap.h.

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

◆ iter() [1/2]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 750 of file VectorMap.h.

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

◆ iter() [2/2]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 744 of file VectorMap.h.

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

◆ key_at()

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 708 of file VectorMap.h.

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

◆ lower_bound() [1/4]

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

template<detail::key_comparable< key_type, key_compare > K>

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

inlineprotected

Definition at line 740 of file VectorMap.h.

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

◆ lower_bound() [2/4]

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

template<detail::key_comparable< key_type, key_compare > K>

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

inline

Definition at line 449 of file VectorMap.h.

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

◆ lower_bound() [3/4]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 738 of file VectorMap.h.

738{ return lower_bound<key_type>( key ); }

◆ lower_bound() [4/4]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 447 of file VectorMap.h.

447{ return lower_bound<key_type>( key ); }

◆ max_size()

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 468 of file VectorMap.h.

468{ return m_vct.max_size(); }

◆ merge() [1/2]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 691 of file VectorMap.h.

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

◆ merge() [2/2]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 697 of file VectorMap.h.

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

◆ operator()() [1/2]

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

template<detail::key_comparable< key_type, key_compare > K>

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

inline

Definition at line 584 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;
    }

◆ operator()() [2/2]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 582 of file VectorMap.h.

582{ return this->template operator()<key_type>( key ); }

GaudiUtils::VectorMap::key_type

KEY key_type

the actual type of key

Definition VectorMap.h:115

◆ operator<=>()

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

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

inline

comparison criteria for containers

Definition at line 479 of file VectorMap.h.

479=>( const VectorMap& other ) const { return m_vct <=> other.m_vct; }

GaudiUtils::VectorMap::VectorMap

VectorMap(const allocator_type &alloc=allocator_type())

default constructor from the the allocator

Definition VectorMap.h:656

◆ operator==()

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 477 of file VectorMap.h.

477{ return m_vct == other.m_vct; }

◆ operator[]() [1/2]

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

template<detail::key_comparable< key_type, key_compare > K>

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

inline

Definition at line 622 of file VectorMap.h.

                                                        {
      return ( *this )( key );
    }

◆ operator[]() [2/2]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 620 of file VectorMap.h.

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

◆ rbegin()

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 190 of file VectorMap.h.

190{ return m_vct.rbegin(); }

◆ rend()

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 192 of file VectorMap.h.

192{ return m_vct.rend(); }

◆ reserve()

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 472 of file VectorMap.h.

472{ m_vct.reserve( num ); }

◆ size()

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

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

inline

number of elements

Definition at line 466 of file VectorMap.h.

466{ return m_vct.size(); }

◆ swap()

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 474 of file VectorMap.h.

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

std::swap

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

the definition of specialized algorithm for swapping

Definition VectorMap.h:767

◆ update() [1/3]

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

template<detail::key_comparable< key_type, key_compare > K>

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

inline

Definition at line 511 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;
    }

◆ update() [2/3]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 509 of file VectorMap.h.

509{ return update<key_type>( key, mapped ); }

◆ update() [3/3]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 550 of file VectorMap.h.

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

◆ upper_bound() [1/2]

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

template<detail::key_comparable< key_type, key_compare > K>

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

inline

Definition at line 454 of file VectorMap.h.

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

◆ upper_bound() [2/2]

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 452 of file VectorMap.h.

452{ return upper_bound<key_type>( key ); }

GaudiUtils::VectorMap::upper_bound

iterator upper_bound(const key_type &key) const

Definition VectorMap.h:452

◆ value_at()

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

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

inline

useful method for python decoration:

Parameters

index (INPUT) the index

Returns: the value at given index

Exceptions

std::out_of_range for invalid index

Definition at line 719 of file VectorMap.h.

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

◆ operator<<

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 687 of file VectorMap.h.

687{ return str; }

Member Data Documentation

◆ m_vct

template<typename KEY, typename VALUE, typename KEYCOMPARE = std::less<>, typename 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 758 of file VectorMap.h.

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

GaudiKernel/include/GaudiKernel/VectorMap.h

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Private Attributes

Friends

Detailed Description

The nominal CPU performance:

Member Typedef Documentation

◆ _iterator

◆ _vector

◆ allocator_type

◆ compare_type

◆ const_iterator

◆ const_reference

◆ const_reverse_iterator

◆ difference_type

◆ iterator

◆ iterators

◆ key_compare

◆ key_type

◆ mapped_type

◆ reference

◆ result_type

◆ reverse_iterator

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ VectorMap() [1/3]

◆ VectorMap() [2/3]

◆ VectorMap() [3/3]

Member Function Documentation

◆ at() [1/2]

◆ at() [2/2]

◆ begin()

◆ clear()

◆ compare() [1/2]

◆ compare() [2/2]

◆ compare_key()

◆ count() [1/2]

◆ count() [2/2]

◆ empty()

◆ end()

◆ equal_range() [1/2]

◆ equal_range() [2/2]

◆ erase() [1/5]

◆ erase() [2/5]

◆ erase() [3/5]

◆ erase() [4/5]

◆ erase() [5/5]

◆ find() [1/2]

◆ find() [2/2]

◆ insert() [1/6]

◆ insert() [2/6]

◆ insert() [3/6]

◆ insert() [4/6]

◆ insert() [5/6]

◆ insert() [6/6]

◆ iter() [1/2]

◆ iter() [2/2]

◆ key_at()

◆ lower_bound() [1/4]

◆ lower_bound() [2/4]

◆ lower_bound() [3/4]

◆ lower_bound() [4/4]

◆ max_size()

◆ merge() [1/2]

◆ merge() [2/2]

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ operator<=>()

◆ operator==()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ rbegin()

◆ rend()

◆ reserve()

◆ size()

◆ swap()