| # Gaudi Framework, version v22r4 |

Home |  | Generated: Fri Sep 2 2011

Classes | Public Types | Public Member Functions | Protected Types | Protected Member Functions | Private Attributes | Friends

# 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>`

Inheritance diagram for GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >:
[legend]
Collaboration diagram for GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >:
[legend]

List of all members.

## Classes
struct | _compare_type
| The actual structure used to compare the elements Only "key" is important for comparison. More...
## Public Types
typedef KEY | key_type
| the actual type of key
typedef VALUE | mapped_type
| the actual type of value
typedef KEYCOMPARE | key_compare
| comparison of keys
typedef std::pair< key_type, mapped_type > | value_type
| the actual storage item
typedef ALLOCATOR | allocator_type
| allocator (could be useful for optimizations)
typedef ALLOCATOR::const_reference | reference
| the types to conform STL
typedef ALLOCATOR::const_reference | const_reference
| the types to conform STL
typedef ALLOCATOR::size_type | size_type
| the types to conform STL
typedef ALLOCATOR::difference_type | difference_type
| the types to conform STL
typedef std::vector < value_type, allocator_type > | _vector
| the actual storage container (no export)
typedef _vector::const_iterator | iterator
| visible const_iterator (exported)
typedef _vector::const_iterator | const_iterator
| visible const_iterator (exported)
typedef std::reverse_iterator < iterator > | reverse_iterator
| visible reverse const_iterator (exported)
typedef std::reverse_iterator < const_iterator > | const_reverse_iterator
| visible reverse const_iterator (exported)
typedef std::pair< iterator, iterator > | iterators
| visible iterator pait
typedef std::pair< iterator, bool > | result_type
| visible iterator pait
typedef _compare_type | compare_type
| the actual comparison criteria for valye_type objects
## Public Member Functions
iterator | begin () const
| "begin" iterator for sequential access (const-only version!)
iterator | end () const
| "end" iterator for sequential access (const-only version!)
reverse_iterator | rbegin () const
| "rbegin" iterator for sequential access (const-only version!)
reverse_iterator | rend () const
| "rend" iterator for sequential access (const-only version!)
void | erase (iterator pos)
| erase the element using the iterator
size_type | erase (const key_type &key)
| erase the element using the key
size_type | erase (iterator first, iterator last)
| erase the sequence of elements using the iterators
template<class TYPE >
size_type | erase (TYPE first, TYPE last)
| erase the sequence of elements using the sequence of keys
result_type | insert (const key_type &key, const mapped_type &mapped)
| insert the (key,value) pair into the container
result_type | insert (const value_type &value)
| insert the (key,value) pair into the container
result_type | insert (iterator pos, const value_type &value)
| insert the element with some guess about its new position With the right guess the method could be more efficient
result_type | insert (iterator pos, const key_type &key, const mapped_type &mapped)
| insert the (key,value) pair into the container With the right guess the method could be more efficient
template<class PAIRS >
void | insert (PAIRS first, PAIRS last)
| insert the sequence of elements into the container
template<class KEYS , class VALUES >
void | insert (KEYS kf, KEYS kl, VALUES vf)
| insert into the container the elements from 2 "parallel" sequences
iterator | find (const key_type &key) const
| find the element by key
size_type | count (const key_type &key) const
| count number of elements with the certain key
iterator | lower_bound (const key_type &key) const
iterator | upper_bound (const key_type &key) const
iterators | equal_range (const key_type &key) const
bool | empty () const
| empty container ?
size_type | size () const
| number of elements
size_type | max_size () const
| maximal allowed size
void | clear ()
| clear the container
void | reserve (size_type num)
| reserve the space in the container for at least 'num' elements
void | swap (VectorMap &other)
| swap function, which 'swaps' the content of two containers
bool | operator== (const VectorMap &other) const
| comparison criteria for containers
bool | operator< (const VectorMap &other) const
| comparison criteria for containers
bool | update (const key_type &key, const mapped_type &mapped)
| forced insertion of the key/mapped pair The method acts like "insert" but it *DOES* overwrite the existing mapped value.
bool | update (const value_type &val)
| forced insertion of the key/mapped pair The method acts like "insert" but it *DOES* overwrite the mapped value.
const mapped_type & | operator() (const key_type &key) const
| access to element by key (const version) there is no container increment for missing keys
const mapped_type & | operator[] (const key_type &key) const
| access to element by key (const version) there is no container increment for missing keys
const mapped_type & | at (const key_type &key) const
| checked access to elements by key throw std::out_of_range exception for non-existing keys
| VectorMap (const allocator_type &alloc=allocator_type())
| default constructor from the the allocator
| VectorMap (const VectorMap &right)
| copy constructor
template<class INPUT >
| VectorMap (INPUT first, INPUT last, const allocator_type &alloc=allocator_type())
| templated constructor from "convertible" sequence
| ~VectorMap ()
| destructor (non-virtual!)
VectorMap & | operator= (const VectorMap &right)
const compare_type & | compare () const
| get the comparison criteria itself
const key_compare & | compare_key () const
| get the comparison criteria for keys
VectorMap & | merge (const VectorMap &right)
| merge two maps
template<class K1 , class K2 , class K3 , class K4 >
VectorMap & | merge (const VectorMap< K1, K2, K3, K4 > &right)
| merge two maps
const key_type & | key_at (const size_t index) const
| useful method for python decoration:
const mapped_type & | value_at (const size_t index) const
| useful method for python decoration:
## Protected Types
typedef _vector::iterator | _iterator
| the regular iterator (no export)
## Protected Member Functions
template<class TYPE1 , class TYPE2 >
bool | compare (const TYPE1 &obj1, const TYPE2 &obj2) const
| compare the objects using the comaprison criteria
_iterator | lower_bound (const key_type &key)
| 'lower-bound' - non-const version
_iterator | iter (iterator p)
| the conversion from 'const' to 'non-const' iterator
iterator | iter (_iterator p)
| the conversion from 'non-const' to 'const' iterator
## Private Attributes
_vector | m_vct
| the underlying sorted vector of (key,mapped) pairs
## Friends
bool | operator> (const VectorMap &left, const VectorMap &right)
bool | operator!= (const VectorMap &left, const VectorMap &right)
bool | operator>= (const VectorMap &left, const VectorMap &right)
bool | operator<= (const VectorMap &left, const VectorMap &right)
std::ostream & | operator<< (std::ostream &str, const VectorMap &)
| printout to ostream - not implemented

## 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 110 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 _vector::iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::_iterator`[protected]`

the regular iterator (no export)

Definition at line 144 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 139 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 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 _compare_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::compare_type

the actual comparison criteria for valye_type objects

Definition at line 191 of file VectorMap.h.

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 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 ALLOCATOR::const_reference GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::const_reference

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::reverse_iterator<const_iterator> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::const_reverse_iterator

visible reverse const_iterator (exported)

Definition at line 155 of file VectorMap.h.

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 134 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 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::pair<iterator,iterator> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::iterators

visible iterator pait

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

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 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 VALUE GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::mapped_type

the actual type of value

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::const_reference GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::reference

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 std::pair<iterator,bool> GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::result_type

visible iterator pait

Definition at line 159 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 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 ALLOCATOR::size_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::size_type

the types to conform STL

Definition at line 132 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 121 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 712 of file VectorMap.h.

          : m_vct ( alloc )
        {}

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

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

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

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

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

GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::~VectorMap | ( | ) | `[inline]`

destructor (non-virtual!)

Definition at line 737 of file VectorMap.h.

    { 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> >>

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

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

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

iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::begin | ( | void | ) | const`[inline]`

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

Definition at line 198 of file VectorMap.h.

    { return m_vct . begin  () ; }

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

    { m_vct.clear   ()       ; }

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

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

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

bool GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::compare | ( | const TYPE1 & | obj1,
|  | const TYPE2 & | obj2
| ) |  | const`[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 826 of file VectorMap.h.

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

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

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

get the comparison criteria for keys

Definition at line 761 of file VectorMap.h.

    { return compare()  ; }

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

size_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::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 480 of file VectorMap.h.

        { 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> >>

bool GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::empty | ( | void | ) | const`[inline]`

empty container ?

Definition at line 493 of file VectorMap.h.

    { return m_vct . empty    () ; }

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

    { return m_vct . end    () ; }

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

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

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

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

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

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

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

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

size_type GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::erase | ( | iterator | first,
|  | iterator | last
| ) |  | `[inline]`

erase the sequence of elements using the iterators

Parameters:

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

Returns:
  number of erased elements

Definition at line 242 of file VectorMap.h.

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

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

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

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

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

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

insert the (key,value) pair into the container

Attention:
  there is no replacement for the existing key!

It is STL-compliant behavior for associative containers.

      GaudiUtils::VectorMap<K,V> m ;

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

      std::cout
         << " Before insert: " << m[key]                  // should be: V()
         << std::end ;

      // insert the value into the map:
      const bool inserted1 = m.insert( key , val1 ).second ;
      std::cout
         << " 1st insert: "
         << Gaudi::Utils::toString( inserted1 )           // should be: "True"
         << " value: " << m[key]                          // should be: val1
         << std::endl ;

      // try to re-insert another value with the same key:
      const bool inserted2 = m.insert( key , val2 ).second ;
      std::cout
         << " 2nd insert: "
         << Gaudi::Utils::toString( inserted2 )           // should be: "False"
         << " value: " << m[key]                          // should be: val1
         << std::endl ;

Parameters:

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

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

Definition at line 319 of file VectorMap.h.

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

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

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

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

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

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

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

Attention:
  there is no replacement for the existing element!

Parameters:

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

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

Definition at line 403 of file VectorMap.h.

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

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

void GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::insert | ( | PAIRS | first,
|  | PAIRS | last
| ) |  | `[inline]`

insert the sequence of elements into the container

Attention:
  there is no replacement for the existing element!

Parameters:

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

Definition at line 415 of file VectorMap.h.

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

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

void GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::insert | ( | KEYS | kf,
|  | KEYS | kl,
|  | VALUES | vf
| ) |  | `[inline]`

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

Attention:
  there is no replacement for the existing element!

Parameters:

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

Definition at line 427 of file VectorMap.h.

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

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

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

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

Definition at line 848 of file VectorMap.h.

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

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

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

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

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

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

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

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

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

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

Definition at line 483 of file VectorMap.h.

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

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

    { return m_vct . max_size () ; }

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

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

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

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

merge two maps

Definition at line 778 of file VectorMap.h.

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

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

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

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

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

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

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

       // OK:
       K key = ... ;
       std::cout << " Value: " << m(key) << std::end ; // it is OK!

       // ERROR:
       V value = ... ;
       m(key) = value ;                                // ERROR!

See also:
  GaudiUtils::Map

Parameters:

  key | key value

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

Definition at line 639 of file VectorMap.h.

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

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

        { 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> >>

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

Definition at line 743 of file VectorMap.h.

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

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

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

comparison criteria for containers

Definition at line 512 of file VectorMap.h.

        { 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> >>

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

        { return (*this)( key ) ; }

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

reverse_iterator GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::rbegin | ( | void | ) | const`[inline]`

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

Definition at line 202 of file VectorMap.h.

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

    { 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 >::reserve | ( | size_type | num ) | `[inline]`

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

Definition at line 501 of file VectorMap.h.

    { m_vct.reserve ( num )  ; }

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

    { return m_vct . 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 >::swap | ( | VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > & | other ) | `[inline]`

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

Definition at line 504 of file VectorMap.h.

        {
          std::swap ( 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 563 of file VectorMap.h.

        {
          _iterator result = lower_bound ( key ) ;
          if ( end() == result || compare ( key , result -> first ) )
          {
            result = m_vct.insert ( result , value_type(key,mapped) ) ;
            return false ;
          }
          else { result->second = mapped ; }
          //
          return true ;
        }

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

        { 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> >>

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

Definition at line 485 of file VectorMap.h.

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

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

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

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

        { return !( left == right  ) ; }

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

    { return str ; }

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

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

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

        { return !( left  <  right ) ; }

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

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

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

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines