| # Gaudi Framework, version v21r9 |

Home |  | Generated: 3 May 2010

# GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > Class Template Reference

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

`#include <GaudiKernel/VectorMap.h>`

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

[legend]

List of all members.

## 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
iterator | 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.
iterator | 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
## 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
## Classes
struct | _compare_type
| The actual structure used to compare the elements Only "key" is important for comparison. More...

## Detailed Description

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

A bit modified version of '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.

Author:
  Vanya BELYAEV Ivan.Belyaev@lapp.in2p3.fr

Date:
  2005-07-23

Definition at line 55 of file VectorMap.h.

## Member Typedef Documentation

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

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

the actual type of key

Definition at line 59 of file VectorMap.h.

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

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

the actual type of value

Definition at line 61 of file VectorMap.h.

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

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

comparison of keys

Definition at line 63 of file VectorMap.h.

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

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

the actual storage item

Definition at line 65 of file VectorMap.h.

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

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

allocator (could be useful for optimizations)

Definition at line 68 of file VectorMap.h.

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

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

the types to conform STL

Definition at line 70 of file VectorMap.h.

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

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

the types to conform STL

Definition at line 72 of file VectorMap.h.

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

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

the types to conform STL

Definition at line 74 of file VectorMap.h.

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

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

the types to conform STL

Definition at line 76 of file VectorMap.h.

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

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

the actual storage container (no export)

Definition at line 79 of file VectorMap.h.

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

typedef _vector::iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::_iterator`[protected]`

the regular iterator (no export)

Definition at line 82 of file VectorMap.h.

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

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

visible const_iterator (exported)

Definition at line 85 of file VectorMap.h.

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

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

visible const_iterator (exported)

Definition at line 87 of file VectorMap.h.

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

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

visible reverse const_iterator (exported)

Definition at line 89 of file VectorMap.h.

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

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

visible reverse const_iterator (exported)

Definition at line 91 of file VectorMap.h.

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

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

visible iterator pait

Definition at line 93 of file VectorMap.h.

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

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

visible iterator pait

Definition at line 95 of file VectorMap.h.

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

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

the actual comparison criteria for valye_type objects

Definition at line 122 of file VectorMap.h.

## Constructor & Destructor Documentation

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

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

default constructor from the the allocator

Parameters:

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

Definition at line 658 of file VectorMap.h.

    00659       : m_vct ( alloc )
    00660     {}

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

    00666       : m_vct ( right.m_vct )
    00667     {}

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

    00679       : m_vct ( first , last , alloc )
    00680     { 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 683 of file VectorMap.h.

    00683 { clear() ; }

## Member Function Documentation

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 | ( | void |  | ) | const`[inline]`

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

Definition at line 130 of file VectorMap.h.

    00130 { return m_vct . begin  () ; }

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 | ( | void |  | ) | const`[inline]`

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

Definition at line 132 of file VectorMap.h.

    00132 { return m_vct . end    () ; }

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 | ( | void |  | ) | const`[inline]`

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

Definition at line 134 of file VectorMap.h.

    00134 { return m_vct . rbegin () ; }

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 | ( | void |  | ) | const`[inline]`

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

Definition at line 136 of file VectorMap.h.

    00136 { return m_vct . rend   () ; }

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

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

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

    00164     {
    00165       iterator pos = find ( key ) ;
    00166       if ( end() == pos ) { return 0 ; }
    00167       erase ( pos ) ;
    00168       return 1 ;
    00169     } ;

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

    00178     {
    00179       m_vct.erase ( iter ( first ) , iter ( last )  ) ;
    00180       return last - first ;
    00181     }

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

    00205     {
    00206       size_type res = 0 ;
    00207       for ( ; first != last ; ++first ) { res += erase ( *first ) ; }
    00208       return res ;
    00209     }

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

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

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

    00299     {
    00300       bool found = true ;
    00301       _iterator result = lower_bound ( value.first ) ;
    00302       if ( end() == result || compare( value.first , result -> first ) )
    00303       { result = m_vct.insert ( result , value ) ; found = false ; }
    00304       return result_type ( iter ( result ) , !found ) ;
    00305     }

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

    00318     {
    00319       if ( pos != end() && compare ( *pos , value ) &&
    00320            ( pos == end() - 1 ||
    00321               ( !compare ( value , *( pos + 1 ) )
    00322                 && compare ( *( pos + 1 ) , value ) ) ) )
    00323       { return result_type( m_vct.insert ( iter ( pos ) , value ) , true ) ; }
    00324       return insert ( value ) ;
    00325     }

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

    00340     { 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 349 of file VectorMap.h.

    00351     { 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 360 of file VectorMap.h.

    00363     { 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 >::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 392 of file VectorMap.h.

    00393     {
    00394       iterator res = lower_bound ( key ) ;
    00395       if ( end() != res && compare ( key , res->first ) )
    00396       { res = end(); }
    00397       return res ;
    00398     }

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

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

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

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

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

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

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

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

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 | ( | void |  | ) | const`[inline]`

empty container ?

Definition at line 430 of file VectorMap.h.

    00430 { return m_vct . empty    () ; }

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 | ( | void |  | ) | const`[inline]`

number of elements

Definition at line 432 of file VectorMap.h.

    00432 { return m_vct . size     () ; }

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

    00434 { return m_vct . max_size () ; }

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 | ( | void |  | ) | `[inline]`

clear the container

Definition at line 437 of file VectorMap.h.

    00437 { m_vct.clear   ()       ; }

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

    00439 { m_vct.reserve ( num )  ; }

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

    00443     {
    00444       std::swap ( m_vct , other.m_vct ) ;
    00445     }

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

    00453     { return m_vct == other.m_vct ; }

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

    00457     { return m_vct <  other.m_vct ; }

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 >::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:
  the position of the inserted or modified element

Definition at line 510 of file VectorMap.h.

    00512     {
    00513       _iterator result = lower_bound ( key ) ;
    00514       if ( end() == result || compare ( key , result -> first ) )
    00515       { result = m_vct.insert ( result , value_type(key,mapped) ) ; }
    00516       else
    00517       { result->second = mapped ; }
    00518       return iter ( result ) ;
    00519     }

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 >::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:
  the position of the inserted or modified element

Definition at line 549 of file VectorMap.h.

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

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

    00584     {
    00585       static const mapped_type s_default = mapped_type() ;
    00586       iterator res = find ( key ) ;
    00587       if ( end() == res ) { return s_default ; }
    00588       return res->second ;
    00589     }

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

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

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

    00641     {
    00642       iterator res = find ( key ) ;
    00643       if ( end() == res )
    00644       { GaudiUtils::_throw_out_of_range_exception_() ; }
    00645       return res->second ;
    00646     }

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

    00690     {
    00691       if ( &right == this ) { return *this ; }
    00692       m_vct = right.m_vct ;
    00693       return *this ;
    00694     }

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

    00704     {
    00705       static const  compare_type s_cmp = compare_type() ;
    00706       return s_cmp ;
    00707     }

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

    00709 { return compare()  ; }

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

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

compare the objects using the comaprison criteria

Parameters:

  | obj | the first object
  | obj | the second object

Returns:
  result of (obj1,obj2) comparison

Definition at line 727 of file VectorMap.h.

    00729     {
    00730       return compare() ( obj1 , obj2 )  ;
    00731     }

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

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

'lower-bound' - non-const version

Definition at line 734 of file VectorMap.h.

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

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

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

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

Definition at line 740 of file VectorMap.h.

    00741     {
    00742       _iterator result = m_vct.begin() ;
    00743       std::advance ( result , std::distance ( begin() , p ) ) ;
    00744       return result ;
    00745     };

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

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

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

Definition at line 747 of file VectorMap.h.

    00748     {
    00749       iterator result ( begin() ) ;
    00750       std::advance ( result , std::distance (  m_vct.begin() , p ) ) ;
    00751       return result ;
    00752     }

## Friends And Related Function Documentation

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

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

Definition at line 463 of file VectorMap.h.

    00465     { return    right < left     ; }

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

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

Definition at line 467 of file VectorMap.h.

    00469     { return !( left == right  ) ; }

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

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

Definition at line 471 of file VectorMap.h.

    00473     { return !( left  <  right ) ; }

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

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

Definition at line 475 of file VectorMap.h.

    00477     { return !( right <  left  ) ; }

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

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

printout to ostream - not implemented

Definition at line 713 of file VectorMap.h.

    00713 { return str ; }

## Member Data Documentation

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

_vector GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::m_vct`[private]`

the underlying sorted vector of (key,mapped) pairs

Definition at line 756 of file VectorMap.h.

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

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r9/GaudiKernel/GaudiKernel/VectorMap.h