| The Gaudi Framework v28r2p1 (f1a77ff4)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Classes | Public Types | Private Types | Friends | List of all members
KeyedContainer< DATATYPE, MAPPING > Class Template Reference

template class KeyedContainer, KeyedContainer.h More...

`#include <GaudiKernel/KeyedContainer.h>`

Inheritance diagram for KeyedContainer< DATATYPE, MAPPING >:
[legend]
Collaboration diagram for KeyedContainer< DATATYPE, MAPPING >:
[legend]

## Classes
struct | _InsertRelease
| Internal functor for insertion of objects. More...
struct | _RemoveRelease
| Internal functor for insertion of objects. More...

## Public Types
typedef DATATYPE | contained_type
| Definition of the contained object type. More...
typedef MAPPING | container_type
| Definition of the implementing container type. More...
typedef std::vector< contained_type * > | seq_type
| General container specific type definitions. More...
typedef contained_type::key_type | key_type
| Definition of the key type: re-use definition of contained type. More...
typedef seq_type::value_type | value_type
| Sequential access: definition of type stored in sequential container. More...
typedef seq_type::reference | reference
| Sequential access: reference type used in sequential container. More...
typedef seq_type::const_reference | const_reference
| Sequential access: const reference type used in sequential container. More...
typedef seq_type::iterator | iterator
| Sequential access: iterator type used in sequential container. More...
typedef seq_type::const_iterator | const_iterator
| Sequential access: const iterator type used in sequential container. More...
typedef seq_type::reverse_iterator | reverse_iterator
| Sequential access: reverse iterator type used in sequential container. More...
typedef seq_type::const_reverse_iterator | const_reverse_iterator
| Sequential access: const reverse iterator type used in sequential container. More...
Public Types inherited from ObjectContainerBase
typedef size_t | size_type
| size_type, to conform the STL container interface More...

## Public Member Functions
Constructors/Destructors
| KeyedContainer (void)
| Standard Constructor. More...
| KeyedContainer (KeyedContainer &&other)
| KeyedContainer (const KeyedContainer &)=delete
| ~KeyedContainer () override
| Destructor. More...
NOT FOR GENERAL USE ObjectContainerBase function overloads.
The implementation of these methods ensure the behaviour of the class as a type of class ObjectContainerBase. This base class and its behaviour are only used by "generic" object handlers. These classes collaborate with several classes such as the SmartRef classes. Generic converters. Interfaces for interactivity (e.g. Python) For this reason, the entry points in this section are reserved for "generic" object handling and should NOT be used in public.
size_type | numberOfObjects () const override
| ObjectContainerBase overload: Number of objects in the container. More...
long | add (ContainedObject *pObject) override
| ObjectContainerBase overload: Add an object to the container. More...
long | remove (ContainedObject *pObject) override
| ObjectContainerBase overload: Remove an object from the container. More...
ContainedObject * | containedObject (long key_value) const override
| ObjectContainerBase overload: Retrieve the object by reference given the long integer representation of the object's key. More...
long | index (const ContainedObject *p) const override
| ObjectContainerBase overload: Retrieve the full long integer representation of the object's key from the object base class pointer. More...
virtual size_type | containedObjects (std::vector< ContainedObject * > &v) const
| Retrieve the full content of the object container. More...
Container related implementation.
These methods allow to manipulate the container as a whole and to retrieve information about the internal behaviour of the container.
size_type | size () const
| Number of objects in the container. More...
bool | empty () const
| For consistency with STL: check if container is empty. More...
void | reserve (size_type value)
| Reserve place for "value" objects in the container. More...
void | clear ()
| Clear the entire content and erase the objects from the container. More...
virtual const std::vector< const ContainedObject * > * | containedObjects () const
| Retrieve the full content of the object container by reference. More...
StatusCode | update () override
| Reconfigure direct access to elements (Needed by POOL data loading) This function reuses the "update" callback of the generic DataObject base class. More...
Sequential array access to objects using iterators.
Sequential object access using iterators is much faster then object access by key. In case all objects of the container should be addressed, use iterators rather than direct object access. If the container is accessed through the iterators defined below, the elements may be sorted according to the user needs. The container can be accesses in both const and non-const mode. Iterations are supported in both directions: From the beginning to the end and the reverse.
iterator | begin ()
| Retrieve start iterator. More...
const_iterator | begin () const
| Retrieve start const iterator. More...
iterator | end ()
| Retrieve terminating iterator. More...
const_iterator | end () const
| Retrieve terminating const iterator. More...
reverse_iterator | rbegin ()
| reverse_iterator returns the beginning of the reversed container More...
const_reverse_iterator | rbegin () const
| const reverse_iterator returns the beginning of the reversed container More...
reverse_iterator | rend ()
| reverse_iterator pointing to the end of the reversed container More...
const_reverse_iterator | rend () const
| const reverse_iterator pointing to the end of the reversed container More...
Random access to objects in the container.
Access to objects is given by Key. Please note, that random object access is nearly in all cases significantly slower than sequential access. If all objects in the contaienr should be addresses sequentially, use iterators rather than direct access. Direct access should only be used for selective retrieval of objects.
value_type | object (const key_type &kval) const
| Object access by key. More...
value_type | operator() (const key_type &kval) const
| STL algorithms support for object access. More...
Insert/Remove objects from the container.
Objects generally are identified by key. Since keys are stored with the objects, insertions and removals are possible by key or by reference.
long | erase (const key_type &kval)
| Remove/erase object (identified by key) from the container. More...
long | erase (const value_type val)
| Remove/erase object (identified by pointer value) from the container. More...
long | erase (iterator pos)
| Remove/erase object (identified by iterator) from the container. More...
void | erase (iterator pos_start, iterator pos_stop, bool use_temp=false)
| Remove/erase objects by iterator range. More...
const key_type & | insert (const value_type val, const key_type &kval)
| Insert entry to the container with a valid key. More...
const key_type & | insert (const value_type val)
| Insert entry to the container with automatic key assignment. More...
Public Member Functions inherited from DataObject
| DataObject ()
| Standard Constructor. More...
| DataObject (const DataObject &rhs)
| Copy Constructor. More...
DataObject & | operator= (const DataObject &rhs)
| Assignment Operator. More...
| DataObject (DataObject &&rhs)
| Move Constructor. More...
DataObject & | operator= (DataObject &&rhs)
| Move Assignment Operator. More...
virtual | ~DataObject ()
| Standard Destructor. More...
virtual unsigned long | addRef ()
| Add reference to object. More...
virtual unsigned long | release ()
| release reference to object More...
const std::string & | name () const
| Retreive DataObject name. It is the name when registered in the store. More...
void | setRegistry (IRegistry *pRegistry)
| Set pointer to Registry. More...
IRegistry * | registry () const
| Get pointer to Registry. More...
LinkManager * | linkMgr () const
| Retrieve Link manager. More...
unsigned char | version () const
| Retrieve version number of this object representation. More...
void | setVersion (unsigned char vsn)
| Set version number of this object representation. More...
unsigned long | refCount () const
| Return the refcount. More...
virtual std::ostream & | fillStream (std::ostream &s) const
| Fill the output stream (ASCII) More...

## Private Types
typedef Containers::traits< container_type, contained_type > | traits
| Traits class definition. More...

## Friends
struct | GaudiDict::KeyedContainerDict< DATATYPE >

## Implementation helpers.
container_type | m_cont
| Map container to facilitate object access by key. More...
seq_type | m_sequential
| Array to allow sequential access to the object (can be ordered). More...
seq_type * | m_random
| Array to allow random access to objects (not exposed) More...
FORCE_INLINE value_type | i_object (const key_type &k) const
| Internal function to access objects within the container. More...
long | i_erase (const_reference v, const key_type &k)
| Internal function to erase an object from the container. More...

## DataObject virtual function overloads.
The implementation of these methods is required by the DataObject base class and determines the persistent run-time-type information.
const CLID & | clID () const override
| Retrieve class ID. More...
static const CLID & | classID ()
| Retrieve class ID. More...

## Additional Inherited Members
Static Public Member Functions inherited from DataObject
static const CLID & | classID ()
| Retrieve reference to class definition structure (static access) More...
Protected Member Functions inherited from ObjectContainerBase
| ObjectContainerBase ()=default
| Constructor. More...
| ObjectContainerBase (ObjectContainerBase &&)=default
ObjectContainerBase & | operator= (ObjectContainerBase &&)=default

## Detailed Description

### template<class DATATYPE, class MAPPING = Containers::HashMap>
class KeyedContainer< DATATYPE, MAPPING >

template class KeyedContainer, KeyedContainer.h

This class represents a container, where the contained objects are accessed by a key. Such a key can be any class, which is able to convert to and from a 32-bit (long) integer.

To insert objects into the container, this implementation determines the key in the following way:

- If the object is already keyed, the object's key is kept and cannot be modified.
- If the object is NOT keyed, and a key is supplied, this key is used to register the object in the map and the same key is given to the object.
- If the object is NOT keyed, and NO key is supplied, a key is generated by the map implementation and this key is given to the object.
- It is not possible to insert two objects with the same key into the same container. This causes an exception.

Access to objects is given two-fold:

- Using iterators. This access is very efficient. The container however, may not be manipulated: No objects may not be inserted or removed using iterators.
- Using object keys: This access patterns provides random access to objects.

The KeyedContainer class uses for further specialization a traits class. By specializing these traits extra behaviour can be forced on request for special containers or special keys.

Author
  M.Frank CERN/LHCb

Version
  1.0

Definition at line 63 of file KeyedContainer.h.

## Member Typedef Documentation

template<class DATATYPE, class MAPPING = Containers::HashMap>

typedef seq_type::const_iterator KeyedContainer< DATATYPE, MAPPING >::const_iterator

Sequential access: const iterator type used in sequential container.

Definition at line 92 of file KeyedContainer.h.

template<class DATATYPE, class MAPPING = Containers::HashMap>

typedef seq_type::const_reference KeyedContainer< DATATYPE, MAPPING >::const_reference

Sequential access: const reference type used in sequential container.

Definition at line 88 of file KeyedContainer.h.

template<class DATATYPE, class MAPPING = Containers::HashMap>

typedef seq_type::const_reverse_iterator KeyedContainer< DATATYPE, MAPPING >::const_reverse_iterator

Sequential access: const reverse iterator type used in sequential container.

Definition at line 98 of file KeyedContainer.h.

template<class DATATYPE, class MAPPING = Containers::HashMap>

typedef DATATYPE KeyedContainer< DATATYPE, MAPPING >::contained_type

Definition of the contained object type.

Definition at line 69 of file KeyedContainer.h.

template<class DATATYPE, class MAPPING = Containers::HashMap>

typedef MAPPING KeyedContainer< DATATYPE, MAPPING >::container_type

Definition of the implementing container type.

Definition at line 71 of file KeyedContainer.h.

template<class DATATYPE, class MAPPING = Containers::HashMap>

typedef seq_type::iterator KeyedContainer< DATATYPE, MAPPING >::iterator

Sequential access: iterator type used in sequential container.

Definition at line 90 of file KeyedContainer.h.

template<class DATATYPE, class MAPPING = Containers::HashMap>

typedef contained_type::key_type KeyedContainer< DATATYPE, MAPPING >::key_type

Definition of the key type: re-use definition of contained type.

Definition at line 82 of file KeyedContainer.h.

template<class DATATYPE, class MAPPING = Containers::HashMap>

typedef seq_type::reference KeyedContainer< DATATYPE, MAPPING >::reference

Sequential access: reference type used in sequential container.

Definition at line 86 of file KeyedContainer.h.

template<class DATATYPE, class MAPPING = Containers::HashMap>

typedef seq_type::reverse_iterator KeyedContainer< DATATYPE, MAPPING >::reverse_iterator

Sequential access: reverse iterator type used in sequential container.

Definition at line 94 of file KeyedContainer.h.

template<class DATATYPE, class MAPPING = Containers::HashMap>

typedef std::vector<contained_type*> KeyedContainer< DATATYPE, MAPPING >::seq_type

General container specific type definitions.

The following type definitions are generic to most STL containers and are also presented by the KeyedContainer class. These forward declarations typically are used by STL algorithms.Definition of the STL sequential access type

Definition at line 80 of file KeyedContainer.h.

template<class DATATYPE, class MAPPING = Containers::HashMap>

typedef Containers::traits<container_type, contained_type> KeyedContainer< DATATYPE, MAPPING >::traits
| private

Traits class definition.

Specializing traits allows to specialize the container implementation for special needs.

Definition at line 104 of file KeyedContainer.h.

template<class DATATYPE, class MAPPING = Containers::HashMap>

typedef seq_type::value_type KeyedContainer< DATATYPE, MAPPING >::value_type

Sequential access: definition of type stored in sequential container.

Definition at line 84 of file KeyedContainer.h.

## Constructor & Destructor Documentation

template<class DATATYPE, class MAPPING = Containers::HashMap>

KeyedContainer< DATATYPE, MAPPING >::KeyedContainer | ( | void |  | ) |
| inline

Standard Constructor.

Definition at line 179 of file KeyedContainer.h.

180 {
181 // avoid problems with strict-aliasing rules
182 seq_type** rptr = &m_random;
183 seq_type* sptr = &m_sequential;
184 m_cont.setup((void*)sptr,(void**)rptr);
185 }
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
KeyedContainer::seq_type
std::vector< contained_type * > seq_type
General container specific type definitions.
Definition: KeyedContainer.h:80
KeyedContainer::m_cont
container_type m_cont
Map container to facilitate object access by key.
Definition: KeyedContainer.h:110
KeyedContainer::m_random
seq_type * m_random
Array to allow random access to objects (not exposed)
Definition: KeyedContainer.h:114
template<class DATATYPE, class MAPPING = Containers::HashMap>

KeyedContainer< DATATYPE, MAPPING >::KeyedContainer | ( | KeyedContainer< DATATYPE, MAPPING > && | other | ) |
| inline

Definition at line 186 of file KeyedContainer.h.

186 :
187 ObjectContainerBase(std::move(other)),
188 m_cont(std::move(other.m_cont)),
189 m_sequential(std::move(other.m_sequential))
190 {
191 m_cont.setup((void*)&m_sequential,(void**)&m_random);
192 std::for_each(begin(), end(), [this](ContainedObject* obj) {obj->setParent(this);});
193
194 other.m_cont.setup((void*)&other.m_sequential, (void**)&other.m_random);
195 }
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
KeyedContainer::begin
iterator begin()
Retrieve start iterator.
Definition: KeyedContainer.h:318
std::move
T move(T...args)
KeyedContainer::m_cont
container_type m_cont
Map container to facilitate object access by key.
Definition: KeyedContainer.h:110
ContainedObject
All classes that their objects may be contained in an LHCb ObjectContainer (e.g.
Definition: ContainedObject.h:29
KeyedContainer::end
iterator end()
Retrieve terminating iterator.
Definition: KeyedContainer.h:322
ContainedObject::setParent
void setParent(ObjectContainerBase *value)
Update parent member.
Definition: ContainedObject.h:51
std::for_each
T for_each(T...args)
KeyedContainer::m_random
seq_type * m_random
Array to allow random access to objects (not exposed)
Definition: KeyedContainer.h:114
ObjectContainerBase::ObjectContainerBase
ObjectContainerBase()=default
Constructor.
template<class DATATYPE, class MAPPING = Containers::HashMap>

KeyedContainer< DATATYPE, MAPPING >::KeyedContainer | ( | const KeyedContainer< DATATYPE, MAPPING > & |  | ) |
| delete

template<class DATATYPE , class MAPPING >

KeyedContainer< DATATYPE, MAPPING >::~KeyedContainer | ( |  | ) |
| inline override

Destructor.

Inline code for keyed container class.

Definition at line 501 of file KeyedContainer.h.

502 {
503 clear();
504 m_cont.clear();
505 }
KeyedContainer::m_cont
container_type m_cont
Map container to facilitate object access by key.
Definition: KeyedContainer.h:110
KeyedContainer::clear
void clear()
Clear the entire content and erase the objects from the container.
Definition: KeyedContainer.h:290

## Member Function Documentation

template<class DATATYPE , class MAPPING >

long KeyedContainer< DATATYPE, MAPPING >::add | ( | ContainedObject * | pObject | ) |
| inline override virtual

ObjectContainerBase overload: Add an object to the container.

Plese see the documentation of the member function

const key_type& insert(DATATYPE* pObject)

for further details.

Parameters

  pObject | Pointer to the object to be inserted into the container.

Returns
  long integer representation of the key value.

Implements ObjectContainerBase.

Definition at line 616 of file KeyedContainer.h.

617 {
618 return traits::identifier(insert(dynamic_cast<typename seq_type::value_type>(pObject)));
619 }
KeyedContainer::insert
const key_type & insert(const value_type val, const key_type &kval)
Insert entry to the container with a valid key.
Definition: KeyedContainer.h:547
Containers::key_traits< DATATYPE::key_type >::identifier
static long identifier(const key_type &k)
Full unhashed key identifier.
Definition: KeyedTraits.h:75
template<class DATATYPE, class MAPPING = Containers::HashMap>

iterator KeyedContainer< DATATYPE, MAPPING >::begin | ( |  | ) |
| inline

Retrieve start iterator.

Definition at line 318 of file KeyedContainer.h.

318 { return m_sequential.begin(); }
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
std::vector::begin
T begin(T...args)
template<class DATATYPE, class MAPPING = Containers::HashMap>

const_iterator KeyedContainer< DATATYPE, MAPPING >::begin | ( |  | ) | const
| inline

Retrieve start const iterator.

Definition at line 320 of file KeyedContainer.h.

320 { return m_sequential.begin(); }
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
std::vector::begin
T begin(T...args)
template<class DATATYPE, class MAPPING = Containers::HashMap>

static const CLID& KeyedContainer< DATATYPE, MAPPING >::classID | ( |  | ) |
| inline static

Retrieve class ID.

Definition at line 209 of file KeyedContainer.h.

209 {
210 static CLID clid = contained_type::classID() + container_type::classID();
211 return clid;
212 }
CLID
unsigned int CLID
Class ID definition.
Definition: ClassID.h:8
template<class DATATYPE, class MAPPING = Containers::HashMap>

void KeyedContainer< DATATYPE, MAPPING >::clear | ( |  | ) |
| inline

Clear the entire content and erase the objects from the container.

Definition at line 290 of file KeyedContainer.h.

290 { erase(begin(), end()); }
KeyedContainer::erase
long erase(const key_type &kval)
Remove/erase object (identified by key) from the container.
Definition: KeyedContainer.h:388
KeyedContainer::begin
iterator begin()
Retrieve start iterator.
Definition: KeyedContainer.h:318
KeyedContainer::end
iterator end()
Retrieve terminating iterator.
Definition: KeyedContainer.h:322
template<class DATATYPE, class MAPPING = Containers::HashMap>

const CLID& KeyedContainer< DATATYPE, MAPPING >::clID | ( |  | ) | const
| inline override virtual

Retrieve class ID.

Reimplemented from DataObject.

Definition at line 207 of file KeyedContainer.h.

207 { return this->classID(); }
KeyedContainer::classID
static const CLID & classID()
Retrieve class ID.
Definition: KeyedContainer.h:209
template<class DATATYPE, class MAPPING = Containers::HashMap>

ContainedObject* KeyedContainer< DATATYPE, MAPPING >::containedObject | ( | long | key_value | ) | const
| inline override virtual

ObjectContainerBase overload: Retrieve the object by reference given the long integer representation of the object's key.

Implements ObjectContainerBase.

Definition at line 263 of file KeyedContainer.h.

263 {
264 return i_object( traits::makeKey( key_value ) );
265 }
Containers::key_traits< DATATYPE::key_type >::makeKey
static key_type makeKey(long k)
Create key from its full integer representation.
Definition: KeyedTraits.h:72
KeyedContainer::i_object
FORCE_INLINE value_type i_object(const key_type &k) const
Internal function to access objects within the container.
Definition: KeyedContainer.h:132
template<class DATATYPE , class MAPPING >

KeyedContainer< DATATYPE, MAPPING >::size_type KeyedContainer< DATATYPE, MAPPING >::containedObjects | ( | std::vector< ContainedObject * > & | v | ) | const
| inline virtual

Retrieve the full content of the object container.

Parameters

  v | Vector of contained objects, which will host all objects contained in this container.

Returns
  Number of objects returned in v.

Definition at line 601 of file KeyedContainer.h.

602 {
603 typename seq_type::const_iterator i = m_sequential.begin();
604 typename seq_type::const_iterator s = m_sequential.end();
605 vec.clear();
606 vec.reserve(size());
607 for ( ; i != s; i++ ) {
608 ContainedObject* p = const_cast<typename seq_type::value_type>(*i);
609 vec.push_back(p);
610 }
611 return vec.size();
612 }
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
std::vector::end
T end(T...args)
ContainedObject
All classes that their objects may be contained in an LHCb ObjectContainer (e.g.
Definition: ContainedObject.h:29
KeyedContainer::size
size_type size() const
Number of objects in the container.
Definition: KeyedContainer.h:284
std::vector::begin
T begin(T...args)
gaudirun.s
string s
Definition: gaudirun.py:245
template<class DATATYPE , class MAPPING >

const std::vector< const ContainedObject * > * KeyedContainer< DATATYPE, MAPPING >::containedObjects | ( |  | ) | const
| inline virtual

Retrieve the full content of the object container by reference.

Returned is the random access container if in sequntial direct access mode. Otherwise the sequential access container is returned

Returns
  Reference to sequencal access container.

Definition at line 540 of file KeyedContainer.h.

540 {
541 return (const std::vector<const ContainedObject*>*)
542 ((0==m_cont.isDirect()) ? m_random : &m_sequential);
543 }
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
KeyedContainer::m_cont
container_type m_cont
Map container to facilitate object access by key.
Definition: KeyedContainer.h:110
std::vector
STL class.
KeyedContainer::m_random
seq_type * m_random
Array to allow random access to objects (not exposed)
Definition: KeyedContainer.h:114
template<class DATATYPE, class MAPPING = Containers::HashMap>

bool KeyedContainer< DATATYPE, MAPPING >::empty | ( |  | ) | const
| inline

For consistency with STL: check if container is empty.

Definition at line 286 of file KeyedContainer.h.

286 { return m_sequential.empty(); }
std::vector::empty
T empty(T...args)
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
template<class DATATYPE, class MAPPING = Containers::HashMap>

iterator KeyedContainer< DATATYPE, MAPPING >::end | ( |  | ) |
| inline

Retrieve terminating iterator.

Definition at line 322 of file KeyedContainer.h.

322 { return m_sequential.end(); }
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
std::vector::end
T end(T...args)
template<class DATATYPE, class MAPPING = Containers::HashMap>

const_iterator KeyedContainer< DATATYPE, MAPPING >::end | ( |  | ) | const
| inline

Retrieve terminating const iterator.

Definition at line 324 of file KeyedContainer.h.

324 { return m_sequential.end(); }
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
std::vector::end
T end(T...args)
template<class DATATYPE, class MAPPING = Containers::HashMap>

long KeyedContainer< DATATYPE, MAPPING >::erase | ( | const key_type & | kval | ) |
| inline

Remove/erase object (identified by key) from the container.

Parameters

  kval | Key to identify the object within the container.

Returns
  Enumeration value from the Containers namespace:
  - OBJ_NOT_FOUND: The indicated object was not found in the container
  - OBJ_ERASED: The indicated object was found and removed from the container. The object was not yet deleted, because its reference count was non zero.
  - OBJ_DELETED The indicated object was found and removed from the container. The object was deleted, because its reference count was zero.

Definition at line 388 of file KeyedContainer.h.

388 { return i_erase(0, kval); }
KeyedContainer::i_erase
long i_erase(const_reference v, const key_type &k)
Internal function to erase an object from the container.
Definition: KeyedContainer.h:139
template<class DATATYPE, class MAPPING = Containers::HashMap>

long KeyedContainer< DATATYPE, MAPPING >::erase | ( | const value_type | val | ) |
| inline

Remove/erase object (identified by pointer value) from the container.

This member function removes an object, which is identified by its reference from the container. No key value is supplied. To identify the object within the container, the key of the object is used as it can be retrieved using the KeyedObject::key() method.

Parameters

  val | Reference to object to be removed from the container.

Returns
  Enumeration value from the Containers namespace:
  - OBJ_NOT_FOUND: The indicated object was not found in the container
  - OBJ_ERASED: The indicated object was found and removed from the container. The object was not yet deleted, because its reference count was non zero.
  - OBJ_DELETED The indicated object was found and removed from the container. The object was deleted, because its reference count was zero.

Definition at line 410 of file KeyedContainer.h.

410 {
411 return (val) ? i_erase(val, val->key()) : (long) Containers::OBJ_NOT_FOUND;
412 }
Containers
Containers namespace.
Definition: KeyedObjectManager.h:18
KeyedContainer::i_erase
long i_erase(const_reference v, const key_type &k)
Internal function to erase an object from the container.
Definition: KeyedContainer.h:139
Containers::OBJ_NOT_FOUND
Object not present in the container.
Definition: KeyedTraits.h:20
template<class DATATYPE, class MAPPING = Containers::HashMap>

long KeyedContainer< DATATYPE, MAPPING >::erase | ( | iterator | pos | ) |
| inline

Remove/erase object (identified by iterator) from the container.

This member function removes an object, which is identified by its reference from the container. No key value is supplied. To identify the object within the container, the key of the object is used as it can be retrieved using the KeyedObject::key() method.

Parameters

  val | Reference to object to be removed from the container.

Returns
  Enumeration value from the Containers namespace:
  - OBJ_NOT_FOUND: The indicated object was not found in the container
  - OBJ_ERASED: The indicated object was found and removed from the container. The object was not yet deleted, because its reference count was non zero.
  - OBJ_DELETED The indicated object was found and removed from the container. The object was deleted, because its reference count was zero.

Definition at line 434 of file KeyedContainer.h.

434 { return erase(*pos); }
KeyedContainer::erase
long erase(const key_type &kval)
Remove/erase object (identified by key) from the container.
Definition: KeyedContainer.h:388
template<class DATATYPE , class MAPPING >

void KeyedContainer< DATATYPE, MAPPING >::erase | ( | iterator | pos_start,
|  | iterator | pos_stop,
|  | bool | use_temp = `false`
| ) |  |
| inline

Remove/erase objects by iterator range.

This member function removes all objects, which are within the sequential iterator range [pos_start, pos_stop[.

Parameters

  pos_start | Starting iterator of the range to be removed.
  pos_stop | Starting iterator of the range to be removed.
  use_temp | Flag to indicate that a temporary arry should be used.

Definition at line 648 of file KeyedContainer.h.

651 {
652 bool is_start = start_pos == m_sequential.begin();
653 bool is_stop = stop_pos == m_sequential.end();
654 if ( is_start && is_stop ) {
655 // Nothing special. Taken care of by Keyed object manager
656 }
657 else if ( is_start || is_stop || use_tmp ) {
658 std::vector<DATATYPE*> tmp(m_sequential.begin(), start_pos);
659 tmp.insert(tmp.end(), stop_pos, m_sequential.end());
660 std::for_each(tmp.begin(), tmp.end(), traits::addRef);
661 this->erase(m_sequential.begin(), m_sequential.end());
662 std::for_each(tmp.begin(), tmp.end(), _InsertRelease(this));
663 return;
664 }
665 std::for_each(start_pos, stop_pos, _RemoveRelease(this));
666 seq_type *sptr = &m_sequential; // avoid problems with strict-aliasing rules
667 std::vector<void*>* v = (std::vector<void*>*)sptr;
668 std::vector<void*>::iterator i1 =
669 v->begin() + std::distance(m_sequential.begin(), start_pos);
670 std::vector<void*>::iterator i2 =
671 v->begin() + std::distance(m_sequential.begin(), stop_pos);
672 m_cont.erase(i1, i2);
673 }
Containers::key_traits< DATATYPE::key_type >::addRef
static long addRef(obj_type *v)
Add reference counter to object when inserted into the container.
Definition: KeyedTraits.h:92
std::distance
T distance(T...args)
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
KeyedContainer::seq_type
std::vector< contained_type * > seq_type
General container specific type definitions.
Definition: KeyedContainer.h:80
KeyedContainer::erase
long erase(const key_type &kval)
Remove/erase object (identified by key) from the container.
Definition: KeyedContainer.h:388
std::vector::end
T end(T...args)
KeyedContainer::m_cont
container_type m_cont
Map container to facilitate object access by key.
Definition: KeyedContainer.h:110
std::vector::insert
T insert(T...args)
std::vector
STL class.
std::vector::begin
T begin(T...args)
std::for_each
T for_each(T...args)
template<class DATATYPE, class MAPPING = Containers::HashMap>

long KeyedContainer< DATATYPE, MAPPING >::i_erase | ( | const_reference | v,
|  | const key_type & | k
| ) |  |
| inline private

Internal function to erase an object from the container.

Definition at line 139 of file KeyedContainer.h.

139 {
140 value_type p = value_type(m_cont.erase(traits::hash(k), v));
141 if ( p ) {
142 if ( p->parent() == this ) {
143 p->setParent(0);
144 }
145 }
146 return traits::release(p) <= 0 ? (long) Containers::OBJ_ERASED
147 : (long) Containers::OBJ_DELETED;
148 }
Containers::OBJ_DELETED
Object was removed from the container and deleted.
Definition: KeyedTraits.h:21
Containers::key_traits< DATATYPE::key_type >::hash
static long hash(const key_type &key_value)
Hash function for this key.
Definition: KeyedTraits.h:77
KeyedContainer::value_type
seq_type::value_type value_type
Sequential access: definition of type stored in sequential container.
Definition: KeyedContainer.h:84
KeyedContainer::m_cont
container_type m_cont
Map container to facilitate object access by key.
Definition: KeyedContainer.h:110
Containers::OBJ_ERASED
Object was removed, but not deleted.
Definition: KeyedTraits.h:22
Containers::key_traits< DATATYPE::key_type >::release
static long release(obj_type *v)
Release reference to object.
Definition: KeyedTraits.h:94
template<class DATATYPE, class MAPPING = Containers::HashMap>

FORCE_INLINE value_type KeyedContainer< DATATYPE, MAPPING >::i_object | ( | const key_type & | k | ) | const
| inline private

Internal function to access objects within the container.

Definition at line 132 of file KeyedContainer.h.

132 {
133 return 0==m_cont.isDirect()
134 ? value_type(*(m_random->begin()+traits::hash(k)))
135 : value_type(m_cont.object(traits::hash(k)));
136 }
KeyedContainer::object
value_type object(const key_type &kval) const
Object access by key.
Definition: KeyedContainer.h:352
KeyedContainer::traits
Containers::traits< container_type, contained_type > traits
Traits class definition.
Definition: KeyedContainer.h:104
Containers::key_traits< DATATYPE::key_type >::hash
static long hash(const key_type &key_value)
Hash function for this key.
Definition: KeyedTraits.h:77
KeyedContainer::value_type
seq_type::value_type value_type
Sequential access: definition of type stored in sequential container.
Definition: KeyedContainer.h:84
KeyedContainer::m_cont
container_type m_cont
Map container to facilitate object access by key.
Definition: KeyedContainer.h:110
std::vector::begin
T begin(T...args)
KeyedContainer::m_random
seq_type * m_random
Array to allow random access to objects (not exposed)
Definition: KeyedContainer.h:114
template<class DATATYPE , class MAPPING >

long KeyedContainer< DATATYPE, MAPPING >::index | ( | const ContainedObject * | p | ) | const
| inline override virtual

ObjectContainerBase overload: Retrieve the full long integer representation of the object's key from the object base class pointer.

Implements ObjectContainerBase.

Definition at line 591 of file KeyedContainer.h.

592 {
593 const contained_type* ptr = dynamic_cast<const contained_type*>(p);
594 if ( ptr ) return traits::identifier(ptr->key());
595 return -1;
596 }
KeyedContainer::contained_type
DATATYPE contained_type
Definition of the contained object type.
Definition: KeyedContainer.h:69
Containers::key_traits< DATATYPE::key_type >::identifier
static long identifier(const key_type &k)
Full unhashed key identifier.
Definition: KeyedTraits.h:75
template<class DATATYPE , class MAPPING >

const KeyedContainer< DATATYPE, MAPPING >::key_type & KeyedContainer< DATATYPE, MAPPING >::insert | ( | const value_type | val,
|  | const key_type & | kval
| ) |  |
| inline

Insert entry to the container with a valid key.

This member function inserts an element, which is identified by its reference to the container. The element will be inserted using the specified key. If the object is already keyed, the long representations of the supplied key and the object's key must agree.

The object will not be inserted and an exception will be raised under the following conditions:

- The supplied key does not agree with the object's key.
- An object with the supplied key is already present in the container.

Parameters

  val | Reference to object to be inserted into the container. The object reference may NOT be NULL.
  kval | Key to identify the object within the container.

Returns
  Key, which was used to index the object within the container. If the operation is not successful, an exception is thrown.

Definition at line 547 of file KeyedContainer.h.

549 {
550 if ( val ) {
551 long k0 = traits::hash(kval);
552 if ( !val->hasKey() || (traits::hash(val->key()) == k0) ) {
553 if(m_cont.insert(this,val,val,k0) == Containers::OBJ_INSERTED) {
554 if ( !val->hasKey() ) traits::setKey(val, kval);
555 traits::addRef(val);
556 return val->key();
557 }
558 }
559 }
560 // Cannot insert object...indicate bad object insertion...
561 Containers::cannotInsertToContainer();
562 return val->key();
563 }
Containers::OBJ_INSERTED
Object was inserted into the container.
Definition: KeyedTraits.h:23
Containers::key_traits< DATATYPE::key_type >::addRef
static long addRef(obj_type *v)
Add reference counter to object when inserted into the container.
Definition: KeyedTraits.h:92
Containers::cannotInsertToContainer
GAUDI_API void cannotInsertToContainer()
Function to be called to indicate that an object cannot be inserted to the container.
Definition: KeyedObjectManager.cpp:77
Containers::key_traits< DATATYPE::key_type >::hash
static long hash(const key_type &key_value)
Hash function for this key.
Definition: KeyedTraits.h:77
KeyedContainer::m_cont
container_type m_cont
Map container to facilitate object access by key.
Definition: KeyedContainer.h:110
Containers::key_traits< DATATYPE::key_type >::setKey
static void setKey(obj_type *v, const key_type &k)
Set object key when inserted into the container.
Definition: KeyedTraits.h:79
template<class DATATYPE , class MAPPING >

const KeyedContainer< DATATYPE, MAPPING >::key_type & KeyedContainer< DATATYPE, MAPPING >::insert | ( | const value_type | val | ) |

Insert entry to the container with automatic key assignment.

This member function inserts an element, which is identified by its reference to the container. No key value is supplied. The key used to insert the object is retrieved from the element itself. In the event the object already has a key, the assigned key of the object is used. If no key was assigned to the object, (i.e. the object's key is equal to the invalid key), a key is generated according to the number of objects present in the container.

The object will not be inserted and an exception will be raised under the following conditions:

- A key was already assigned to the object, but another object with the same key is already present in the container.

Parameters

  val | Reference to object to be inserted into the container.

Returns
  Key, which was used to index the object within the container. If the operation is not successful, an exception is thrown.

Definition at line 568 of file KeyedContainer.h.

569 {
570 if ( 0 != val ) {
571 if ( val->hasKey() ) {
572 if (m_cont.insert(this,val,val,traits::hash(val->key()))
573 == Containers::OBJ_INSERTED) {
574 traits::addRef(val);
575 return val->key();
576 }
577 }
578 long k0;
579 if ( m_cont.insert(this, val, val, &k0) == Containers::OBJ_INSERTED ) {
580 traits::setKey(val, traits::makeKey(k0));
581 traits::addRef(val);
582 return val->key();
583 }
584 }
585 // Cannot insert object...indicate bad object insertion...
586 Containers::cannotInsertToContainer();
587 return val->key();
588 }
Containers::OBJ_INSERTED
Object was inserted into the container.
Definition: KeyedTraits.h:23
Containers::key_traits< DATATYPE::key_type >::addRef
static long addRef(obj_type *v)
Add reference counter to object when inserted into the container.
Definition: KeyedTraits.h:92
Containers::key_traits< DATATYPE::key_type >::makeKey
static key_type makeKey(long k)
Create key from its full integer representation.
Definition: KeyedTraits.h:72
Containers::cannotInsertToContainer
GAUDI_API void cannotInsertToContainer()
Function to be called to indicate that an object cannot be inserted to the container.
Definition: KeyedObjectManager.cpp:77
Containers::key_traits< DATATYPE::key_type >::hash
static long hash(const key_type &key_value)
Hash function for this key.
Definition: KeyedTraits.h:77
KeyedContainer::m_cont
container_type m_cont
Map container to facilitate object access by key.
Definition: KeyedContainer.h:110
Containers::key_traits< DATATYPE::key_type >::setKey
static void setKey(obj_type *v, const key_type &k)
Set object key when inserted into the container.
Definition: KeyedTraits.h:79
template<class DATATYPE, class MAPPING = Containers::HashMap>

size_type KeyedContainer< DATATYPE, MAPPING >::numberOfObjects | ( |  | ) | const
| inline override virtual

ObjectContainerBase overload: Number of objects in the container.

Implements ObjectContainerBase.

Definition at line 232 of file KeyedContainer.h.

232 { return m_sequential.size(); }
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
std::vector::size
T size(T...args)
template<class DATATYPE, class MAPPING = Containers::HashMap>

value_type KeyedContainer< DATATYPE, MAPPING >::object | ( | const key_type & | kval | ) | const
| inline

Object access by key.

Access contained objects by key.

Parameters

  kval | Key of the object to be returned.

Returns
  Valid reference to the requested object. If the key of the requested object cannot be found in the container a null reference is returned.

Definition at line 352 of file KeyedContainer.h.

352 { return i_object(kval); }
KeyedContainer::i_object
FORCE_INLINE value_type i_object(const key_type &k) const
Internal function to access objects within the container.
Definition: KeyedContainer.h:132
template<class DATATYPE, class MAPPING = Containers::HashMap>

value_type KeyedContainer< DATATYPE, MAPPING >::operator() | ( | const key_type & | kval | ) | const
| inline

STL algorithms support for object access.

Access contained objects by key using the operator(), which is demanded by STL algorithms.

Parameters

  kval | Key of the object to be returned.

Returns
  Valid reference to the requested object. If the key of the requested object cannot be found in the container a null reference is returned.

Definition at line 363 of file KeyedContainer.h.

363 { return i_object(kval); }
KeyedContainer::i_object
FORCE_INLINE value_type i_object(const key_type &k) const
Internal function to access objects within the container.
Definition: KeyedContainer.h:132
template<class DATATYPE, class MAPPING = Containers::HashMap>

reverse_iterator KeyedContainer< DATATYPE, MAPPING >::rbegin | ( |  | ) |
| inline

reverse_iterator returns the beginning of the reversed container

Definition at line 326 of file KeyedContainer.h.

326 { return m_sequential.rbegin(); }
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
std::vector::rbegin
T rbegin(T...args)
template<class DATATYPE, class MAPPING = Containers::HashMap>

const_reverse_iterator KeyedContainer< DATATYPE, MAPPING >::rbegin | ( |  | ) | const
| inline

const reverse_iterator returns the beginning of the reversed container

Definition at line 328 of file KeyedContainer.h.

328 { return m_sequential.rbegin(); }
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
std::vector::rbegin
T rbegin(T...args)
template<class DATATYPE , class MAPPING >

long KeyedContainer< DATATYPE, MAPPING >::remove | ( | ContainedObject * | pObject | ) |
| inline override virtual

ObjectContainerBase overload: Remove an object from the container.

Because this function is also called from the destructor of The ContainedObject class, it is no longer possible to deduce the key from the object itself. It is hence necessary to relay on the NON-EXISTENCE of virtual inheritance, ie. (void*)pObject = (void*)(contained_object). If the virtual object table is still intact, the normal erase is called.

Parameters

  pObject | Pointer to the object to be removed from the container.

Implements ObjectContainerBase.

Definition at line 623 of file KeyedContainer.h.

624 {
625 contained_type* p1 = dynamic_cast<contained_type*>(p);
626 if ( p1 ) { // Normal case; object still fully intact
627 return this->erase(p1);
628 }
629 else if ( p ) {
630 const ObjectContainerBase* par = p->parent();
631 // The following should never occur: object is in a funny state,
632 // Because the parent was explicitly set to NULL in the
633 // KeyeObject destructor.
634 // - It cannot be a KeyedObject: It would not have a parent
635 // - Still the parent is present: We are not in the destructor
636 // of KeyedObject
637 if ( par ) {
638 Containers::invalidContainerOperation();
639 }
640 return m_cont.erase(0, p)==0 ? (long) Containers::OBJ_ERASED
641 : (long) Containers::OBJ_NOT_FOUND;
642 }
643 return (long) Containers::OBJ_NOT_FOUND;
644 }
KeyedContainer::erase
long erase(const key_type &kval)
Remove/erase object (identified by key) from the container.
Definition: KeyedContainer.h:388
KeyedContainer::contained_type
DATATYPE contained_type
Definition of the contained object type.
Definition: KeyedContainer.h:69
compareOutputFiles.par
string par
Definition: compareOutputFiles.py:386
Containers::invalidContainerOperation
GAUDI_API void invalidContainerOperation()
Function to be called to indicate that an operation should be performed on the container or it&#39;s cont...
Definition: KeyedObjectManager.cpp:89
KeyedContainer::m_cont
container_type m_cont
Map container to facilitate object access by key.
Definition: KeyedContainer.h:110
Containers::OBJ_ERASED
Object was removed, but not deleted.
Definition: KeyedTraits.h:22
Containers::OBJ_NOT_FOUND
Object not present in the container.
Definition: KeyedTraits.h:20
HiveAlgSequencer.p1
p1
Definition: HiveAlgSequencer.py:22
ObjectContainerBase
ObjectContainerBase is the base class for Gaudi container classes.
Definition: ObjectContainerBase.h:19
template<class DATATYPE, class MAPPING = Containers::HashMap>

reverse_iterator KeyedContainer< DATATYPE, MAPPING >::rend | ( |  | ) |
| inline

reverse_iterator pointing to the end of the reversed container

Definition at line 330 of file KeyedContainer.h.

330 { return m_sequential.rend(); }
std::vector::rend
T rend(T...args)
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
template<class DATATYPE, class MAPPING = Containers::HashMap>

const_reverse_iterator KeyedContainer< DATATYPE, MAPPING >::rend | ( |  | ) | const
| inline

const reverse_iterator pointing to the end of the reversed container

Definition at line 332 of file KeyedContainer.h.

332 { return m_sequential.rend(); }
std::vector::rend
T rend(T...args)
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
template<class DATATYPE, class MAPPING = Containers::HashMap>

void KeyedContainer< DATATYPE, MAPPING >::reserve | ( | size_type | value | ) |
| inline

Reserve place for "value" objects in the container.

Definition at line 288 of file KeyedContainer.h.

288 { m_cont.reserve(value); }
KeyedContainer::m_cont
container_type m_cont
Map container to facilitate object access by key.
Definition: KeyedContainer.h:110
template<class DATATYPE, class MAPPING = Containers::HashMap>

size_type KeyedContainer< DATATYPE, MAPPING >::size | ( |  | ) | const
| inline

Number of objects in the container.

Definition at line 284 of file KeyedContainer.h.

284 { return m_sequential.size(); }
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
std::vector::size
T size(T...args)
template<class DATATYPE , class MAPPING >

StatusCode KeyedContainer< DATATYPE, MAPPING >::update | ( |  | ) |
| inline override virtual

Reconfigure direct access to elements (Needed by POOL data loading) This function reuses the "update" callback of the generic DataObject base class.

Reimplemented from DataObject.

Definition at line 509 of file KeyedContainer.h.

510 {
511 int count = 0;
512 m_cont.clearDirect();
513 typename seq_type::iterator i = m_sequential.begin();
514 typename seq_type::iterator s = m_sequential.end();
515 for ( ; i != s; i++ ) {
516 typename seq_type::value_type v = *i;
517 if ( v ) {
518 if ( !v->hasKey() ) {
519 traits::setKey(v, v->key());
520 traits::addRef(v);
521 }
522 long k0 = traits::hash(v->key());
523 if(m_cont.insertDirect(this, v, v, k0) == Containers::OBJ_INSERTED) {
524 }
525 }
526 else {
527 ++count;
528 }
529 }
530 if ( count > 0 ) {
531 Containers::cannotInsertToContainer();
532 }
533 return StatusCode::SUCCESS;
534 }
StatusCode::SUCCESS
Definition: StatusCode.h:30
Containers::OBJ_INSERTED
Object was inserted into the container.
Definition: KeyedTraits.h:23
Containers::key_traits< DATATYPE::key_type >::addRef
static long addRef(obj_type *v)
Add reference counter to object when inserted into the container.
Definition: KeyedTraits.h:92
KeyedContainer::m_sequential
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
Definition: KeyedContainer.h:112
std::vector::end
T end(T...args)
Containers::cannotInsertToContainer
GAUDI_API void cannotInsertToContainer()
Function to be called to indicate that an object cannot be inserted to the container.
Definition: KeyedObjectManager.cpp:77
Containers::key_traits< DATATYPE::key_type >::hash
static long hash(const key_type &key_value)
Hash function for this key.
Definition: KeyedTraits.h:77
KeyedContainer::m_cont
container_type m_cont
Map container to facilitate object access by key.
Definition: KeyedContainer.h:110
std::count
T count(T...args)
std::vector::begin
T begin(T...args)
gaudirun.s
string s
Definition: gaudirun.py:245
Containers::key_traits< DATATYPE::key_type >::setKey
static void setKey(obj_type *v, const key_type &k)
Set object key when inserted into the container.
Definition: KeyedTraits.h:79

## Friends And Related Function Documentation

template<class DATATYPE, class MAPPING = Containers::HashMap>

friend struct GaudiDict::KeyedContainerDict< DATATYPE >
| friend

Definition at line 65 of file KeyedContainer.h.

## Member Data Documentation

template<class DATATYPE, class MAPPING = Containers::HashMap>

container_type KeyedContainer< DATATYPE, MAPPING >::m_cont
| private

Map container to facilitate object access by key.

Definition at line 110 of file KeyedContainer.h.

template<class DATATYPE, class MAPPING = Containers::HashMap>

seq_type* KeyedContainer< DATATYPE, MAPPING >::m_random
| private

Array to allow random access to objects (not exposed)

Definition at line 114 of file KeyedContainer.h.

template<class DATATYPE, class MAPPING = Containers::HashMap>

seq_type KeyedContainer< DATATYPE, MAPPING >::m_sequential
| private

Array to allow sequential access to the object (can be ordered).

Definition at line 112 of file KeyedContainer.h.

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

- GaudiKernel/GaudiKernel/KeyedContainer.h