| # Gaudi Framework, version v21r10p1 |

Home |  | Generated: 29 Jul 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 <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
bool | update (const key_type &key, const mapped_type &mapped)
| forced insertion of the key/mapped pair The method acts like "insert" but it *DOES* overwrite the existing mapped value.
bool | update (const value_type &val)
| forced insertion of the key/mapped pair The method acts like "insert" but it *DOES* overwrite the mapped value.
const mapped_type & | operator() (const key_type &key) const
| access to element by key (const version) there is no container increment for missing keys
const mapped_type & | operator[] (const key_type &key) const
| access to element by key (const version) there is no container increment for missing keys
const mapped_type & | at (const key_type &key) const
| checked access to elements by key throw std::out_of_range exception for non-existing keys
| VectorMap (const allocator_type &alloc=allocator_type())
| default constructor from the the allocator
| VectorMap (const VectorMap &right)
| copy constructor
template<class INPUT>
| VectorMap (INPUT first, INPUT last, const allocator_type &alloc=allocator_type())
| templated constructor from "convertible" sequence
| ~VectorMap ()
| destructor (non-virtual!)
VectorMap & | operator= (const VectorMap &right)
const compare_type & | compare () const
| get the comparison criteria itself
const key_compare & | compare_key () const
| get the comparison criteria for keys
VectorMap & | merge (const VectorMap &right)
| merge two maps
template<class K1, class K2, class K3, class K4>
VectorMap & | merge (const VectorMap< K1, K2, K3, K4 > &right)
| merge two maps
const key_type & | key_at (const size_t index) const
| useful method for python decoration:
const mapped_type & | value_at (const size_t index) const
| useful method for python decoration:
## Protected Types
typedef _vector::iterator | _iterator
| the regular iterator (no export)
## Protected Member Functions
template<class TYPE1, class TYPE2>
bool | compare (const TYPE1 &obj1, const TYPE2 &obj2) const
| compare the objects using the comaprison criteria
_iterator | lower_bound (const key_type &key)
| 'lower-bound' - non-const version
_iterator | iter (iterator p)
| the conversion from 'const' to 'non-const' iterator
iterator | iter (_iterator p)
| the conversion from 'non-const' to 'const' iterator
## Private Attributes
_vector | m_vct
| the underlying sorted vector of (key,mapped) pairs
## Friends
bool | operator> (const VectorMap &left, const VectorMap &right)
bool | operator!= (const VectorMap &left, const VectorMap &right)
bool | operator>= (const VectorMap &left, const VectorMap &right)
bool | operator<= (const VectorMap &left, const VectorMap &right)
std::ostream & | operator<< (std::ostream &str, const VectorMap &)
| printout to ostream - not implemented
## 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.

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.Belyaev@lapp.in2p3.fr

Date:
  2005-07-23

Definition at line 106 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 111 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 113 of file VectorMap.h.

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

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

comparison of keys

Definition at line 115 of file VectorMap.h.

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

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

the actual storage item

Definition at line 117 of file VectorMap.h.

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

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

allocator (could be useful for optimizations)

Definition at line 122 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 124 of file VectorMap.h.

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

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

the types to conform STL

Definition at line 126 of file VectorMap.h.

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

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

the types to conform STL

Definition at line 128 of file VectorMap.h.

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

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

the types to conform STL

Definition at line 130 of file VectorMap.h.

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

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

the actual storage container (no export)

Definition at line 135 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 140 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 145 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 147 of file VectorMap.h.

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

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

visible reverse const_iterator (exported)

Definition at line 149 of file VectorMap.h.

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

typedef 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.

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

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

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

visible iterator pait

Definition at line 155 of file VectorMap.h.

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

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

the actual comparison criteria for valye_type objects

Definition at line 187 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 708 of file VectorMap.h.

    00709       : m_vct ( alloc )
    00710     {}

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

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

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

    00729       : m_vct ( first , last , alloc )
    00730     { 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 733 of file VectorMap.h.

    00733 { clear() ; }                     // destructor (non-virtual!)

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

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

Definition at line 194 of file VectorMap.h.

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

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

Definition at line 196 of file VectorMap.h.

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

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

Definition at line 198 of file VectorMap.h.

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

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

Definition at line 200 of file VectorMap.h.

    00200 { 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 207 of file VectorMap.h.

    00207 { 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 225 of file VectorMap.h.

    00226     {
    00227       iterator pos = find ( key ) ;
    00228       if ( end() == pos ) { return 0 ; }
    00229       erase ( pos ) ;
    00230       return 1 ;
    00231     }

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

    00240     {
    00241       m_vct.erase ( iter ( first ) , iter ( last )  ) ;
    00242       return last - first ;
    00243     }

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

    00267     {
    00268       size_type res = 0 ;
    00269       for ( ; first != last ; ++first ) { res += erase ( *first ) ; }
    00270       return res ;
    00271     }

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

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

    00361     {
    00362       bool found = true ;
    00363       _iterator result = lower_bound ( value.first ) ;
    00364       if ( end() == result || compare( value.first , result -> first ) )
    00365       { result = m_vct.insert ( result , value ) ; found = false ; }
    00366       return result_type ( iter ( result ) , !found ) ;
    00367     }

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

    00380     {
    00381       if ( pos != end() && compare ( *pos , value ) &&
    00382            ( pos == end() - 1 ||
    00383               ( !compare ( value , *( pos + 1 ) )
    00384                 && compare ( *( pos + 1 ) , value ) ) ) )
    00385       { return result_type( m_vct.insert ( iter ( pos ) , value ) , true ) ; }
    00386       return insert ( value ) ;
    00387     }

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

    00402     { 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 411 of file VectorMap.h.

    00413     { 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 423 of file VectorMap.h.

    00426     { 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 453 of file VectorMap.h.

    00454     {
    00455       iterator res = lower_bound ( key ) ;
    00456       if ( end() != res && compare ( key , res->first ) )
    00457       { res = end(); }
    00458       return res ;
    00459     }

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

    00477     { 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 479 of file VectorMap.h.

    00480     { 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 481 of file VectorMap.h.

    00482     { 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 483 of file VectorMap.h.

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

empty container ?

Definition at line 489 of file VectorMap.h.

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

number of elements

Definition at line 491 of file VectorMap.h.

    00491 { 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 493 of file VectorMap.h.

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

clear the container

Definition at line 495 of file VectorMap.h.

    00495 { 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 497 of file VectorMap.h.

    00497 { 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 500 of file VectorMap.h.

    00501     {
    00502       std::swap ( m_vct , other.m_vct ) ;
    00503     }

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

    00509     { 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 511 of file VectorMap.h.

    00512     { 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 >::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 559 of file VectorMap.h.

    00561     {
    00562       _iterator result = lower_bound ( key ) ;
    00563       if ( end() == result || compare ( key , result -> first ) )
    00564       {
    00565         result = m_vct.insert ( result , value_type(key,mapped) ) ;
    00566         return false ;
    00567       }
    00568       else { result->second = mapped ; }
    00569       //
    00570       return true ;
    00571     }

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

bool GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::update | ( | const value_type & | val | ) | `[inline]`

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

Attention:
  There is no STL analogue

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

      GaudiUtils::VectorMap<K,V> m = ... ;

      K key  = ... ;
      V val1 = ... ;
      V val2 = ... ;

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

Parameters:

  | val | a pair of (key,value)

Returns:
  true if the existing value has been replaced

Definition at line 601 of file VectorMap.h.

    00602     { 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 635 of file VectorMap.h.

    00636     {
    00637       static const mapped_type s_default = mapped_type() ;
    00638       iterator res = find ( key ) ;
    00639       if ( end() == res ) { return s_default ; }
    00640       return res->second ;
    00641     }

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

    00674     { 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 693 of file VectorMap.h.

    00694     {
    00695       iterator res = find ( key ) ;
    00696       if ( end() == res ) { this->throw_out_of_range_exception () ; }
    00697       return res->second ;
    00698     }

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

    00740     {
    00741       if ( &right == this ) { return *this ; }
    00742       m_vct = right.m_vct ;
    00743       return *this ;
    00744     }

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

    00752     {
    00753       static const  compare_type s_cmp = compare_type() ;
    00754       return s_cmp ;
    00755     }

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

    00757 { return compare()  ; }

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

VectorMap& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::merge | ( | const VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | right | ) | `[inline]`

merge two maps

Definition at line 765 of file VectorMap.h.

    00766     {
    00767       for ( const_iterator it = right.begin() ; right.end() != it ; ++it )
    00768       { update ( it->first , it->second ) ; }
    00769       //
    00770       return *this ;
    00771     }

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

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

merge two maps

Definition at line 774 of file VectorMap.h.

    00775     {
    00776       for ( typename VectorMap<K1,K2,K3,K4>::const_iterator it =
    00777               right.begin() ; right.end() != it ; ++it )
    00778       { update ( it->first , it->second ) ; }
    00779       //
    00780       return *this ;
    00781     }

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

const key_type& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::key_at | ( | const size_t | index | ) | const`[inline]`

useful method for python decoration:

Parameters:

  | index | (INPUT) the index

Returns:
  the key at given index

Exceptions:

  | std::out_of_range | for invalid index

Definition at line 790 of file VectorMap.h.

    00791     {
    00792       if ( index  >= size() )
    00793       { this->throw_out_of_range_exception () ; }
    00794       const_iterator it = this->begin() ;
    00795       std::advance ( it , index ) ;
    00796       return it -> first ;
    00797     }

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

const mapped_type& GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::value_at | ( | const size_t | index | ) | const`[inline]`

useful method for python decoration:

Parameters:

  | index | (INPUT) the index

Returns:
  the value at given index

Exceptions:

  | std::out_of_range | for invalid index

Definition at line 803 of file VectorMap.h.

    00804     {
    00805       if ( index  >= size() )
    00806       { this->throw_out_of_range_exception () ; }
    00807       const_iterator it = this->begin() ;
    00808       std::advance ( it , index ) ;
    00809       return it -> second ;
    00810     }

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

    00824     {
    00825       return compare() ( obj1 , obj2 )  ;
    00826     }

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

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

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

    00837     {
    00838       _iterator result = m_vct.begin() ;
    00839       std::advance ( result , std::distance ( begin() , p ) ) ;
    00840       return result ;
    00841     }

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

    00845     {
    00846       iterator result ( begin() ) ;
    00847       std::advance ( result , std::distance (  m_vct.begin() , p ) ) ;
    00848       return result ;
    00849     }

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

    00518     { 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 519 of file VectorMap.h.

    00521     { 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 522 of file VectorMap.h.

    00524     { 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 525 of file VectorMap.h.

    00527     { 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 760 of file VectorMap.h.

    00760 { 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 854 of file VectorMap.h.

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

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