| # Gaudi Framework, version v21r10p1 |

Home |  | Generated: 29 Jul 2010

# SharedObjectsContainer< TYPE > Class Template Reference

Very simple class to represent the container of objects which are not ownered by the container. More...

`#include <SharedObjectsContainer.h>`

Inheritance diagram for SharedObjectsContainer< TYPE >:

[legend]
Collaboration diagram for SharedObjectsContainer< TYPE >:

[legend]

List of all members.

## Public Types
typedef std::vector< const TYPE * > | ConstVector
| the actual container type
typedef ConstVector::value_type | value_type
| various types (to make STL happy)
typedef ConstVector::size_type | size_type
| size_type, to conform the STL container interface
typedef ConstVector::reference | reference
typedef ConstVector::const_reference | const_reference
typedef ConstVector::iterator | iterator
typedef ConstVector::const_iterator | const_iterator
typedef ConstVector::reverse_iterator | reverse_iterator
typedef ConstVector::const_reverse_iterator | const_reverse_iterator
## Public Member Functions
| SharedObjectsContainer ()
| SharedObjectsContainer (const ConstVector &data)
template<class DATA>
| SharedObjectsContainer (DATA first, DATA last)
| the templated constructor from the pair of iterators
template<class DATA, class PREDICATE>
| SharedObjectsContainer (DATA first, DATA last, const PREDICATE &cut)
| the templated constructor from the pair of iterators and the predicate.
| ~SharedObjectsContainer ()
| destructor
virtual const CLID & | clID () const
| Retrieve the unique class ID (virtual).
const ConstVector & | data () const
| get the access to the underlying container (const)
| operator const ConstVector & () const
| cast to the underlying container
size_type | size () const
| get the actual size of the container
bool | empty () const
| empty container?
void | push_back (const TYPE *object)
| insert one object into the container
void | insert (const TYPE *object)
| insert one object into the container
template<class DATA>
void | insert (DATA first, DATA last)
| add the sequence of objects into the container
template<class DATA, class PREDICATE>
void | insert (DATA first, DATA last, const PREDICATE &cut)
| add the sequence of 'good'objects into the container
template<class OUTPUT, class PREDICATE>
OUTPUT | get (const PREDICATE &cut, OUTPUT output) const
| get from the container all objects which satisfy the certain criteria
void | erase (iterator i)
| erase the object by iterator
template<class PREDICATE>
void | erase (const PREDICATE &cut)
| erase the objects which satisfy the criteria
bool | erase (const TYPE *object)
| erase the first occurance of the certain element
reference | operator[] (size_type index)
| index access
const_reference | operator[] (size_type index) const
| index access (const-version)
reference | operator() (size_type index)
| 'functional'-access
const_reference | operator() (size_type index) const
| 'functional'-access (const version)
reference | at (size_type index)
| checked access
const_reference | at (size_type index) const
| checked access (const-version)
iterator | begin ()
iterator | end ()
const_iterator | begin () const
const_iterator | end () const
reverse_iterator | rbegin ()
reverse_iterator | rend ()
const_reverse_iterator | rbegin () const
const_reverse_iterator | rend () const
reference | front ()
| the first element (only for non-empty vectors)
const_reference | front () const
| the first element (only for non-empty vectors) (const-version)
reference | back ()
| the last element (only for non-empty vectors)
const_reference | back () const
| the last element (only for non-empty vectors) (const-version)
bool | operator== (const SharedObjectsContainer &right) const
| equal content with other container ?
bool | operator== (const ConstVector &right) const
| equal content with corresponding vector ?
bool | operator< (const SharedObjectsContainer &right) const
| comparisons with other container
bool | operator< (const ConstVector &right) const
| comparisons with corresponding vector
virtual long | index (const ContainedObject *object) const
| Distance of a given object from the beginning of its container.
virtual ContainedObject * | containedObject (long index) const
| Pointer to an object of a given distance.
virtual size_type | numberOfObjects () const
| Number of objects in the container.
virtual long | add (ContainedObject *object)
| Virtual functions (forwards to the concrete container definitions) Add an object to the container.
virtual long | remove (ContainedObject *value)
| Release object from the container (the pointer will be removed from the container, but the object itself will remain alive).
## Static Public Member Functions
static const CLID & | classID ()
| Retrieve the unuqie class ID (static).
## Private Attributes
ConstVector | m_data

## Detailed Description

### template<class TYPE>
class SharedObjectsContainer< TYPE >

Very simple class to represent the container of objects which are not ownered by the container.

This concept seem to be very useful for LHCb HLT, DaVinci, tracking, alignments.

Warning:
  the container is not persistable (on-purpose)

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2008-07-23

Definition at line 30 of file SharedObjectsContainer.h.

## Member Typedef Documentation

template<class TYPE>

typedef std::vector<const TYPE*> SharedObjectsContainer< TYPE >::ConstVector

the actual container type

Definition at line 35 of file SharedObjectsContainer.h.

template<class TYPE>

typedef ConstVector::value_type SharedObjectsContainer< TYPE >::value_type

various types (to make STL happy)

Definition at line 37 of file SharedObjectsContainer.h.

template<class TYPE>

typedef ConstVector::size_type SharedObjectsContainer< TYPE >::size_type

size_type, to conform the STL container interface

Reimplemented from ObjectContainerBase.

Definition at line 38 of file SharedObjectsContainer.h.

template<class TYPE>

typedef ConstVector::reference SharedObjectsContainer< TYPE >::reference

Definition at line 39 of file SharedObjectsContainer.h.

template<class TYPE>

typedef ConstVector::const_reference SharedObjectsContainer< TYPE >::const_reference

Definition at line 40 of file SharedObjectsContainer.h.

template<class TYPE>

typedef ConstVector::iterator SharedObjectsContainer< TYPE >::iterator

Definition at line 41 of file SharedObjectsContainer.h.

template<class TYPE>

typedef ConstVector::const_iterator SharedObjectsContainer< TYPE >::const_iterator

Definition at line 42 of file SharedObjectsContainer.h.

template<class TYPE>

typedef ConstVector::reverse_iterator SharedObjectsContainer< TYPE >::reverse_iterator

Definition at line 43 of file SharedObjectsContainer.h.

template<class TYPE>

typedef ConstVector::const_reverse_iterator SharedObjectsContainer< TYPE >::const_reverse_iterator

Definition at line 44 of file SharedObjectsContainer.h.

## Constructor & Destructor Documentation

template<class TYPE>

SharedObjectsContainer< TYPE >::SharedObjectsContainer | ( |  | ) | `[inline]`

Definition at line 49 of file SharedObjectsContainer.h.

    00050     : ObjectContainerBase  () , m_data() {} ;

template<class TYPE>

SharedObjectsContainer< TYPE >::SharedObjectsContainer | ( | const ConstVector & | data | ) | `[inline]`

Definition at line 52 of file SharedObjectsContainer.h.

    00053     : ObjectContainerBase  () , m_data ( data ) {}

template<class TYPE>
template<class DATA>

SharedObjectsContainer< TYPE >::SharedObjectsContainer | ( | DATA | first,
|  | DATA | last |
| ) |  |  | `[inline]`

the templated constructor from the pair of iterators

Parameters:

  | first | 'begin'-iterator of the input sequence
  | last | 'last'-iterator of the input sequence

Definition at line 60 of file SharedObjectsContainer.h.

    00062     : DataObject ()
    00063     , m_data ( first , last )
    00064   {}

template<class TYPE>
template<class DATA, class PREDICATE>

SharedObjectsContainer< TYPE >::SharedObjectsContainer | ( | DATA | first,
|  | DATA | last,
|  | const PREDICATE & | cut |
| ) |  |  | `[inline]`

the templated constructor from the pair of iterators and the predicate.

Only the elements which satisfy the criteria goes into the container e.g. create the container only with "basic" particles:

       typedef SharedObjectsContainer<LHCb::Particle>  PARTICLES ;

       // some sequence of someting, convertiblle to "const LHCb::Particle*":
       SEQUENCE source = ... ;

       PARTICLES* particles = new PARTICLES
              ( source.begin() ,
                source.end  () ,
                std::mem_fun(&LHCb::Particle::isBasic) ) ;

Parameters:

  | first | 'begin'-iterator if the input sequence
  | last | 'last'-iterator of the input sequence
  | cut | pre predicate

Definition at line 90 of file SharedObjectsContainer.h.

    00093     : DataObject ()
    00094     , m_data     ()
    00095   {
    00096     insert ( first , last , cut ) ;
    00097   }

template<class TYPE>

SharedObjectsContainer< TYPE >::~SharedObjectsContainer | ( |  | ) | `[inline]`

destructor

Definition at line 99 of file SharedObjectsContainer.h.

    00099 { m_data.clear() ; }

## Member Function Documentation

template<class TYPE>

virtual const CLID& SharedObjectsContainer< TYPE >::clID | ( |  | ) | const`[inline, virtual]`

Retrieve the unique class ID (virtual).

Reimplemented from DataObject.

Definition at line 104 of file SharedObjectsContainer.h.

    00105   { return SharedObjectsContainer<TYPE>::classID(); }

template<class TYPE>

static const CLID& SharedObjectsContainer< TYPE >::classID | ( |  | ) | `[inline, static]`

Retrieve the unuqie class ID (static).

Reimplemented from DataObject.

Definition at line 107 of file SharedObjectsContainer.h.

    00108   {
    00109     static const CLID s_clid =
    00110       ( ( static_cast<CLID>  ( -1 ) << 16 )  // 16 used and 16 empty bits
    00111         & !CLID_ObjectVector                 // not an ObjectVector
    00112         & !CLID_ObjectList                   // not an ObjectList
    00113         & !static_cast<CLID> ( 0x00030000 )  // not a  KeyedContainer/map
    00114         & !static_cast<CLID> ( 0x00040000 ) )// not a  KeyedContainer/hashmap
    00115       + TYPE::classID() ;                // the specific CLID from the contents
    00116     //
    00117     return s_clid;
    00118   }

template<class TYPE>

const ConstVector& SharedObjectsContainer< TYPE >::data | ( |  | ) | const`[inline]`

get the access to the underlying container (const)

Definition at line 123 of file SharedObjectsContainer.h.

    00123 { return m_data ; }

template<class TYPE>

SharedObjectsContainer< TYPE >::operator const ConstVector & | ( |  | ) | const`[inline]`

cast to the underlying container

Definition at line 125 of file SharedObjectsContainer.h.

    00125 { return data () ; }

template<class TYPE>

size_type SharedObjectsContainer< TYPE >::size | ( |  | ) | const`[inline]`

get the actual size of the container

Definition at line 130 of file SharedObjectsContainer.h.

    00130 { return m_data.size  () ; }

template<class TYPE>

bool SharedObjectsContainer< TYPE >::empty | ( |  | ) | const`[inline]`

empty container?

Definition at line 132 of file SharedObjectsContainer.h.

    00132 { return m_data.empty () ; }

template<class TYPE>

void SharedObjectsContainer< TYPE >::push_back | ( | const TYPE * | object | ) | `[inline]`

insert one object into the container

Parameters:

  | object | object to be added

Definition at line 136 of file SharedObjectsContainer.h.

    00136 { m_data.push_back ( object ) ; }

template<class TYPE>

void SharedObjectsContainer< TYPE >::insert | ( | const TYPE * | object | ) | `[inline]`

insert one object into the container

Parameters:

  | object | object to be added

Definition at line 140 of file SharedObjectsContainer.h.

    00140 { m_data.push_back ( object ) ; }

template<class TYPE>
template<class DATA>

void SharedObjectsContainer< TYPE >::insert | ( | DATA | first,
|  | DATA | last |
| ) |  |  | `[inline]`

add the sequence of objects into the container

Parameters:

  | first | 'begin'-iterator for the sequnce
  | last | 'end'-iterator for the sequence

Definition at line 147 of file SharedObjectsContainer.h.

    00148                  { m_data.insert ( end() , first ,last ) ; }

template<class TYPE>
template<class DATA, class PREDICATE>

void SharedObjectsContainer< TYPE >::insert | ( | DATA | first,
|  | DATA | last,
|  | const PREDICATE & | cut |
| ) |  |  | `[inline]`

add the sequence of 'good'objects into the container

Only the objects which satisfy the predicate go to the container, e.g. put into container only particles which transverse momentum in excess of 1 * GeV:

       namespace bl = boost::lambda ;
       typedef SharedObjectsContainer<LHCb::Particle>  PARTICLES ;

       // some sequence of someting, convertible to "const LHCb::Particle*":
       SEQUENCE source = ... ;

       PARTICLES* particles = ... ;

       particles -> insert
             ( source.begin() ,
               source.end  () ,
               bl::bind(&LHCb::Particle::pt,bl::_1) > 1 * Gaudi::Units::GeV ) ;

Parameters:

  | first | 'begin'-iterator for the sequnce
  | last | 'end'-iterator for the sequence
  | cut | the predicate to be applied

Definition at line 177 of file SharedObjectsContainer.h.

    00180   {
    00181     m_data.reserve ( m_data.size() + std::distance ( first , last ) ) ;
    00182     for ( ; first != last ; ++first )
    00183     { if ( cut ( *first ) ) { m_data.push_back ( *first ) ; } }
    00184   }

template<class TYPE>
template<class OUTPUT, class PREDICATE>

OUTPUT SharedObjectsContainer< TYPE >::get | ( | const PREDICATE & | cut,
|  | OUTPUT | output |
| ) |  |  | const`[inline]`

get from the container all objects which satisfy the certain criteria

E.g. get all particles with transverse momentum in excess of 1 * GeV

       namespace bl = boost::lambda ;
       typedef SharedObjectsContainer<LHCb::Particle>  PARTICLES ;
       typedef std::vector<const LHCb::Particle*>      TARGET    ;

       PARTICLES* particles = ... ;

       TARGET target ;

       particles -> get
             ( bl::bind(&LHCb::Particle::pt,bl::_1) > 1 * Gaudi::Units::GeV ,
               std::back_inserter ( target ) ) ;

Essentially this functionality is very useful due to missing "std::copy_if".

Parameters:

  | cut | the predicate
  | outptut | the output iterator

Returns:
  the current position of the output itrator (almost useless)

Definition at line 213 of file SharedObjectsContainer.h.

    00215   {
    00216     for ( const_iterator iobj = begin() ; end() != iobj ; ++iobj )
    00217     { if ( cut ( *iobj ) ) { *output = *iobj ; ++output ; } }
    00218     return output ;
    00219   }

template<class TYPE>

void SharedObjectsContainer< TYPE >::erase | ( | iterator | i | ) | `[inline]`

erase the object by iterator

Definition at line 221 of file SharedObjectsContainer.h.

    00221 { m_data.erase ( i ) ; }

template<class TYPE>
template<class PREDICATE>

void SharedObjectsContainer< TYPE >::erase | ( | const PREDICATE & | cut | ) | `[inline]`

erase the objects which satisfy the criteria

E.g. remove all particles with small transverse momentum

       namespace bl = boost::lambda ;
       typedef SharedObjectsContainer<LHCb::Particle>  PARTICLES ;

       PARTICLES* particles = ... ;
       particles -> erase
             ( bl::bind(&LHCb::Particle::pt,bl::_1) < 1 * Gaudi::Units::GeV ) ;

See also:
  std::remove_if

Parameters:

  | cut | predicate

Definition at line 240 of file SharedObjectsContainer.h.

    00241   { m_data.erase( std::remove_if (  begin() , end() , cut ) , end() ) ; }

template<class TYPE>

bool SharedObjectsContainer< TYPE >::erase | ( | const TYPE * | object | ) | `[inline]`

erase the first occurance of the certain element

To remove all occurances one can use:

       typedef SharedObjectsContainer<LHCb::Particle>  PARTICLES ;
       PARTICLES* particles = ... ;

       const LHCb::Particle* B = ... ;

       // remove all occurances
       while ( particles -> erase ( B ) ) {} ;

Parameters:

  | object | the element to be removed

Returns:
  true if the element is removed

Definition at line 260 of file SharedObjectsContainer.h.

    00261   {
    00262     iterator i = std::find ( begin() , end() , object ) ;
    00263     if ( end() == i ) { return false ; }
    00264     m_data.erase ( i ) ;
    00265     return true ;
    00266   }

template<class TYPE>

reference SharedObjectsContainer< TYPE >::operator[] | ( | size_type | index | ) | `[inline]`

index access

Definition at line 271 of file SharedObjectsContainer.h.

    00271 { return m_data   [index] ; }

template<class TYPE>

const_reference SharedObjectsContainer< TYPE >::operator[] | ( | size_type | index | ) | const`[inline]`

index access (const-version)

Definition at line 273 of file SharedObjectsContainer.h.

    00273 { return m_data   [index] ; }

template<class TYPE>

reference SharedObjectsContainer< TYPE >::operator() | ( | size_type | index | ) | `[inline]`

'functional'-access

Definition at line 275 of file SharedObjectsContainer.h.

    00275 { return m_data   [index] ; }

template<class TYPE>

const_reference SharedObjectsContainer< TYPE >::operator() | ( | size_type | index | ) | const`[inline]`

'functional'-access (const version)

Definition at line 277 of file SharedObjectsContainer.h.

    00277 { return m_data   [index] ; }

template<class TYPE>

reference SharedObjectsContainer< TYPE >::at | ( | size_type | index | ) | `[inline]`

checked access

Definition at line 279 of file SharedObjectsContainer.h.

    00279 { return m_data.at(index) ; }

template<class TYPE>

const_reference SharedObjectsContainer< TYPE >::at | ( | size_type | index | ) | const`[inline]`

checked access (const-version)

Definition at line 281 of file SharedObjectsContainer.h.

    00281 { return m_data.at(index) ; }

template<class TYPE>

iterator SharedObjectsContainer< TYPE >::begin | ( |  | ) | `[inline]`

Definition at line 285 of file SharedObjectsContainer.h.

    00285 { return m_data .  begin () ; }

template<class TYPE>

iterator SharedObjectsContainer< TYPE >::end | ( |  | ) | `[inline]`

Definition at line 286 of file SharedObjectsContainer.h.

    00286 { return m_data .  end   () ; }

template<class TYPE>

const_iterator SharedObjectsContainer< TYPE >::begin | ( |  | ) | const`[inline]`

Definition at line 287 of file SharedObjectsContainer.h.

    00287 { return m_data .  begin () ; }

template<class TYPE>

const_iterator SharedObjectsContainer< TYPE >::end | ( |  | ) | const`[inline]`

Definition at line 288 of file SharedObjectsContainer.h.

    00288 { return m_data .  end   () ; }

template<class TYPE>

reverse_iterator SharedObjectsContainer< TYPE >::rbegin | ( |  | ) | `[inline]`

Definition at line 289 of file SharedObjectsContainer.h.

    00289 { return m_data . rbegin () ; }

template<class TYPE>

reverse_iterator SharedObjectsContainer< TYPE >::rend | ( |  | ) | `[inline]`

Definition at line 290 of file SharedObjectsContainer.h.

    00290 { return m_data . rend   () ; }

template<class TYPE>

const_reverse_iterator SharedObjectsContainer< TYPE >::rbegin | ( |  | ) | const`[inline]`

Definition at line 291 of file SharedObjectsContainer.h.

    00291 { return m_data . rbegin () ; }

template<class TYPE>

const_reverse_iterator SharedObjectsContainer< TYPE >::rend | ( |  | ) | const`[inline]`

Definition at line 292 of file SharedObjectsContainer.h.

    00292 { return m_data . rend   () ; }

template<class TYPE>

reference SharedObjectsContainer< TYPE >::front | ( |  | ) | `[inline]`

the first element (only for non-empty vectors)

Definition at line 297 of file SharedObjectsContainer.h.

    00297 { return m_data . front () ; }

template<class TYPE>

const_reference SharedObjectsContainer< TYPE >::front | ( |  | ) | const`[inline]`

the first element (only for non-empty vectors) (const-version)

Definition at line 299 of file SharedObjectsContainer.h.

    00299 { return m_data . front () ; }

template<class TYPE>

reference SharedObjectsContainer< TYPE >::back | ( |  | ) | `[inline]`

the last element (only for non-empty vectors)

Definition at line 301 of file SharedObjectsContainer.h.

    00301 { return m_data . back  () ; }

template<class TYPE>

const_reference SharedObjectsContainer< TYPE >::back | ( |  | ) | const`[inline]`

the last element (only for non-empty vectors) (const-version)

Definition at line 303 of file SharedObjectsContainer.h.

    00303 { return m_data . back  () ; }

template<class TYPE>

bool SharedObjectsContainer< TYPE >::operator== | ( | const SharedObjectsContainer< TYPE > & | right | ) | const`[inline]`

equal content with other container ?

Definition at line 308 of file SharedObjectsContainer.h.

    00309   { return &right == this || right.m_data == m_data ; }

template<class TYPE>

bool SharedObjectsContainer< TYPE >::operator== | ( | const ConstVector & | right | ) | const`[inline]`

equal content with corresponding vector ?

Definition at line 311 of file SharedObjectsContainer.h.

    00312   { return m_data == right ; }

template<class TYPE>

bool SharedObjectsContainer< TYPE >::operator< | ( | const SharedObjectsContainer< TYPE > & | right | ) | const`[inline]`

comparisons with other container

Definition at line 314 of file SharedObjectsContainer.h.

    00315   { return m_data <  right.m_data ; }

template<class TYPE>

bool SharedObjectsContainer< TYPE >::operator< | ( | const ConstVector & | right | ) | const`[inline]`

comparisons with corresponding vector

Definition at line 317 of file SharedObjectsContainer.h.

    00318   { return m_data <  right        ; }

template<class TYPE>

virtual long SharedObjectsContainer< TYPE >::index | ( | const ContainedObject * | object | ) | const`[inline, virtual]`

Distance of a given object from the beginning of its container.

Parameters:

  | object | the object to be checked

Implements ObjectContainerBase.

Definition at line 325 of file SharedObjectsContainer.h.

    00326   {
    00327     const_iterator _i = std::find ( begin() , end() , object ) ;
    00328     return end() != _i ? ( _i - begin() ) : -1 ;                  // RETURN
    00329   }

template<class TYPE>

virtual ContainedObject* SharedObjectsContainer< TYPE >::containedObject | ( | long | index | ) | const`[inline, virtual]`

Pointer to an object of a given distance.

Parameters:

  | index | th eindex to be checked

Returns:
  the object

Implements ObjectContainerBase.

Definition at line 334 of file SharedObjectsContainer.h.

    00335   {
    00336     if ( 0 > index || !(index < (long) size () ) ) { return 0 ; }    // RETURN
    00337     const ContainedObject* co = m_data[index] ;
    00338     return const_cast<ContainedObject*>( co ) ;
    00339   }

template<class TYPE>

virtual size_type SharedObjectsContainer< TYPE >::numberOfObjects | ( |  | ) | const`[inline, virtual]`

Number of objects in the container.

Implements ObjectContainerBase.

Definition at line 341 of file SharedObjectsContainer.h.

    00341 { return m_data.size() ; }

template<class TYPE>

virtual long SharedObjectsContainer< TYPE >::add | ( | ContainedObject * | object | ) | `[inline, virtual]`

Virtual functions (forwards to the concrete container definitions) Add an object to the container.

On success the object's index is returned.

Implements ObjectContainerBase.

Definition at line 346 of file SharedObjectsContainer.h.

    00347   {
    00348     if ( 0 == object ) { return -1 ; }                           // RETURN
    00349     TYPE* _obj = dynamic_cast<TYPE*> ( object ) ;
    00350     if ( 0 == _obj   ) { return -1 ; }                           // RETURN
    00351     const size_type pos = size() ;
    00352     push_back ( _obj ) ;
    00353     return pos ;
    00354   }

template<class TYPE>

virtual long SharedObjectsContainer< TYPE >::remove | ( | ContainedObject * | value | ) | `[inline, virtual]`

Release object from the container (the pointer will be removed from the container, but the object itself will remain alive).

If the object was found it's index is returned.

Implements ObjectContainerBase.

Definition at line 359 of file SharedObjectsContainer.h.

    00360   {
    00361     iterator _i = std::find ( begin() , end() , value ) ;
    00362     if ( end() == _i ) { return -1 ; }                          // RETURN
    00363     const size_type pos = _i - begin() ;
    00364     m_data.erase ( _i ) ;
    00365     return pos ;                                                // RETURN
    00366   }

## Member Data Documentation

template<class TYPE>

ConstVector SharedObjectsContainer< TYPE >::m_data`[private]`

Definition at line 371 of file SharedObjectsContainer.h.

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

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