| The Gaudi Framework v28r2-patches (bc4ad17a)

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

- File List
- File Members

KeyedContainer.h
Go to the documentation of this file.
1 #ifndef GAUDIKERNEL_KEYEDCONTAINER_H
2 #define GAUDIKERNEL_KEYEDCONTAINER_H
3
4 // Include files
5 #include <iterator>
6 #include <algorithm>
7
8 namespace GaudiDict {
9 template <class T> struct KeyedContainerDict;
10 }
11
12 // Framework include files
13 #include "GaudiKernel/ObjectContainerBase.h"
14 #include "GaudiKernel/KeyedObjectManager.h"
15 #include "GaudiKernel/KeyedObject.h"
16
17 // Forward declarations
18 // template <class T, class M> class KeyedContainer;
19
20 #ifdef WIN32
21 #define FORCE_INLINE __forceinline
22 #else
23 #define FORCE_INLINE inline
24 #endif
25
62 template <class DATATYPE, class MAPPING=Containers::HashMap >
63 class GAUDI_API KeyedContainer: public ObjectContainerBase
64 {
65 friend struct GaudiDict::KeyedContainerDict<DATATYPE>;
66
67 public:
69 typedef DATATYPE contained_type;
71 typedef MAPPING container_type;
72
79 typedef typename std::vector<contained_type*> seq_type;
82 typedef typename contained_type::key_type key_type;
84 typedef typename seq_type::value_type value_type;
86 typedef typename seq_type::reference reference;
88 typedef typename seq_type::const_reference const_reference;
90 typedef typename seq_type::iterator iterator;
92 typedef typename seq_type::const_iterator const_iterator;
94 typedef typename seq_type::reverse_iterator reverse_iterator;
98 typedef typename seq_type::const_reverse_iterator const_reverse_iterator;
100 private:
104 typedef typename Containers::traits<container_type, contained_type> traits;
105
109 container_type m_cont;
112 seq_type m_sequential;
114 seq_type* m_random;
115
117 #ifdef CHECK_KEYED_CONTAINER
118 value_type i_object(const key_type& k) const {
119 if ( 0 == m_cont.isDirect() ) {
120 if ( traits::checkBounds(m_random, k) ) {
121 value_type p = *(m_random->begin()+traits::hash(k));
122 if ( traits::checkKey(p, k) ) {
123 return p;
124 }
125 }
126 return 0;
127 }
128 value_type p = value_type(m_cont.object(traits::hash(k)));
129 return traits::checkKey(p, k) ? p : 0;
130 }
131 #else
132 FORCE_INLINE value_type i_object(const key_type& k) const {
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 }
137 #endif
138 long i_erase(const_reference v, const key_type& k) {
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 }
149
151 struct _InsertRelease {
152 KeyedContainer<DATATYPE,MAPPING>* m_obj;
153 _InsertRelease(KeyedContainer<DATATYPE,MAPPING>* p) : m_obj(p) {}
154 void operator()(value_type p) {
155 m_obj->insert(p);
156 traits::release(p);
157 }
158 };
159
161 struct _RemoveRelease {
162 ObjectContainerBase* m_obj;
163 _RemoveRelease(ObjectContainerBase* p) : m_obj(p) {}
164 void operator()(value_type p) {
165 const ObjectContainerBase* par = p->parent();
166 if ( par == m_obj ) {
167 p->setParent(0);
168 }
169 traits::release(p);
170 }
171 };
173
174 public:
178 KeyedContainer(void)
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 }
186 KeyedContainer(KeyedContainer&& other):
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 }
196 KeyedContainer(const KeyedContainer&) = delete;
198 ~KeyedContainer() override;
200
206 const CLID& clID() const override { return this->classID(); }
209 static const CLID& classID() {
210 static CLID clid = contained_type::classID() + container_type::classID();
211 return clid;
212 }
214
231 size_type numberOfObjects() const override { return m_sequential.size(); }
244 long add(ContainedObject* pObject) override;
245
258 long remove(ContainedObject* pObject) override;
259
263 ContainedObject* containedObject(long key_value) const override {
264 return i_object( traits::makeKey( key_value ) );
265 }
269 long index(const ContainedObject* p) const override;
275 virtual size_type containedObjects(std::vector<ContainedObject*>& v) const;
277
283 size_type size() const { return m_sequential.size(); }
286 bool empty() const { return m_sequential.empty(); }
288 void reserve(size_type value) { m_cont.reserve(value); }
290 void clear() { erase(begin(), end()); }
296 virtual const std::vector<const ContainedObject*>* containedObjects() const;
301 StatusCode update() override;
303
317 iterator begin() { return m_sequential.begin(); }
320 const_iterator begin() const { return m_sequential.begin(); }
322 iterator end() { return m_sequential.end(); }
324 const_iterator end() const { return m_sequential.end(); }
326 reverse_iterator rbegin() { return m_sequential.rbegin(); }
328 const_reverse_iterator rbegin() const { return m_sequential.rbegin(); }
330 reverse_iterator rend() { return m_sequential.rend(); }
332 const_reverse_iterator rend() const { return m_sequential.rend(); }
334
352 value_type object(const key_type& kval) const { return i_object(kval); }
353
363 value_type operator()(const key_type& kval) const { return i_object(kval); }
365
388 long erase(const key_type& kval) { return i_erase(0, kval); }
389
410 long erase(const value_type val) {
411 return (val) ? i_erase(val, val->key()) : (long) Containers::OBJ_NOT_FOUND;
412 }
413
434 long erase(iterator pos) { return erase(*pos); }
435
444 void erase(iterator pos_start, iterator pos_stop, bool use_temp=false);
445
464 const key_type& insert(const value_type val, const key_type& kval);
465
487 const key_type& insert(const value_type val);
489 };
490
491
499 // Destructor
500 template <class DATATYPE, class MAPPING> inline
501 KeyedContainer<DATATYPE, MAPPING>::~KeyedContainer()
502 {
503 clear();
504 m_cont.clear();
505 }
506
507 // Configure direct access
508 template <class DATATYPE, class MAPPING> inline
509 StatusCode KeyedContainer<DATATYPE, MAPPING>::update()
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 }
535
536
537 // Retrieve the full content of the object container by reference.
538 template <class DATATYPE, class MAPPING> inline
539 const std::vector<const ContainedObject*>*
540 KeyedContainer<DATATYPE, MAPPING>::containedObjects() const {
541 return (const std::vector<const ContainedObject*>*)
542 ((0==m_cont.isDirect()) ? m_random : &m_sequential);
543 }
544
545 template <class DATATYPE, class MAPPING> inline
546 const typename KeyedContainer<DATATYPE, MAPPING>::key_type&
547 KeyedContainer<DATATYPE, MAPPING>::insert(const value_type val,
548 const key_type& kval)
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 }
564
565 // Insert object
566 template <class DATATYPE, class MAPPING> //inline
567 const typename KeyedContainer<DATATYPE, MAPPING>::key_type&
568 KeyedContainer<DATATYPE, MAPPING>::insert(const value_type val)
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 }
589
590 template <class DATATYPE, class MAPPING> inline
591 long KeyedContainer<DATATYPE, MAPPING>::index(const ContainedObject* p) const
592 {
593 const contained_type* ptr = dynamic_cast<const contained_type*>(p);
594 if ( ptr ) return traits::identifier(ptr->key());
595 return -1;
596 }
597
598 // Retrieve the full content of the object container.
599 template <class DATATYPE, class MAPPING> inline
600 typename KeyedContainer<DATATYPE, MAPPING>::size_type KeyedContainer<DATATYPE, MAPPING>::containedObjects
601 (std::vector<ContainedObject*>& vec) const
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 }
613
614 // ObjectContainerBase overload: Add an object to the container.
615 template <class DATATYPE, class MAPPING> inline
616 long KeyedContainer<DATATYPE, MAPPING>::add(ContainedObject* pObject)
617 {
618 return traits::identifier(insert(dynamic_cast<typename seq_type::value_type>(pObject)));
619 }
620
621 // ObjectContainerBase overload: Remove an object from the container.
622 template <class DATATYPE, class MAPPING> inline
623 long KeyedContainer<DATATYPE, MAPPING>::remove(ContainedObject* p)
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 }
645
646 template <class DATATYPE, class MAPPING> inline
647 void
648 KeyedContainer<DATATYPE, MAPPING>::erase(iterator start_pos,
649 iterator stop_pos,
650 bool use_tmp)
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 }
674
675 #undef FORCE_INLINE
676 #endif // GAUDIKERNEL_KEYEDCONTAINER_H
KeyedContainer::containedObjects
virtual const std::vector< const ContainedObject * > * containedObjects() const
Retrieve the full content of the object container by reference.
Definition: KeyedContainer.h:540
GaudiDict::KeyedContainerDict
Definition: KeyedContainer.h:9
KeyedContainer::_InsertRelease::operator()
void operator()(value_type p)
Definition: KeyedContainer.h:154
KeyedContainer::rbegin
reverse_iterator rbegin()
reverse_iterator returns the beginning of the reversed container
Definition: KeyedContainer.h:326
StatusCode::SUCCESS
Definition: StatusCode.h:30
Containers::OBJ_INSERTED
Object was inserted into the container.
Definition: KeyedTraits.h:23
KeyedContainer::reverse_iterator
seq_type::reverse_iterator reverse_iterator
Sequential access: reverse iterator type used in sequential container.
Definition: KeyedContainer.h:94
std::vector::empty
T empty(T...args)
Containers::traits
Container traits class.
Definition: KeyedTraits.h:30
KeyedContainer::const_reference
seq_type::const_reference const_reference
Sequential access: const reference type used in sequential container.
Definition: KeyedContainer.h:88
KeyedContainer::reserve
void reserve(size_type value)
Reserve place for "value" objects in the container.
Definition: KeyedContainer.h:288
KeyedContainer::object
value_type object(const key_type &kval) const
Object access by key.
Definition: KeyedContainer.h:352
std::distance
T distance(T...args)
KeyedContainer::erase
long erase(iterator pos)
Remove/erase object (identified by iterator) from the container.
Definition: KeyedContainer.h:434
KeyedContainer::add
long add(ContainedObject *pObject) override
ObjectContainerBase overload: Add an object to the container.
Definition: KeyedContainer.h:616
ObjectContainerBase::size_type
size_t size_type
size_type, to conform the STL container interface
Definition: ObjectContainerBase.h:31
KeyedContainer::rbegin
const_reverse_iterator rbegin() const
const reverse_iterator returns the beginning of the reversed container
Definition: KeyedContainer.h:328
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
KeyedContainer::reference
seq_type::reference reference
Sequential access: reference type used in sequential container.
Definition: KeyedContainer.h:86
Gaudi::Functional::details::insert
constexpr struct Gaudi::Functional::details::insert_t insert
KeyedContainer::_RemoveRelease::m_obj
ObjectContainerBase * m_obj
Definition: KeyedContainer.h:162
KeyedContainer
template class KeyedContainer, KeyedContainer.h
Definition: KeyedContainer.h:63
std
STL namespace.
ObjectContainerBase.h
KeyedContainer::_InsertRelease::m_obj
KeyedContainer< DATATYPE, MAPPING > * m_obj
Definition: KeyedContainer.h:152
KeyedContainer::erase
long erase(const key_type &kval)
Remove/erase object (identified by key) from the container.
Definition: KeyedContainer.h:388
KeyedContainer::remove
long remove(ContainedObject *pObject) override
ObjectContainerBase overload: Remove an object from the container.
Definition: KeyedContainer.h:623
std::vector::end
T end(T...args)
KeyedContainer::traits
Containers::traits< container_type, contained_type > traits
Traits class definition.
Definition: KeyedContainer.h:104
KeyedContainer::classID
static const CLID & classID()
Retrieve class ID.
Definition: KeyedContainer.h:209
KeyedContainer::iterator
seq_type::iterator iterator
Sequential access: iterator type used in sequential container.
Definition: KeyedContainer.h:90
KeyedContainer::_InsertRelease
Internal functor for insertion of objects.
Definition: KeyedContainer.h:151
KeyedContainer::contained_type
DATATYPE contained_type
Definition of the contained object type.
Definition: KeyedContainer.h:69
KeyedContainer::operator()
value_type operator()(const key_type &kval) const
STL algorithms support for object access.
Definition: KeyedContainer.h:363
Containers::OBJ_DELETED
Object was removed from the container and deleted.
Definition: KeyedTraits.h:21
ContainedObject::parent
const ObjectContainerBase * parent() const
Access to parent object.
Definition: ContainedObject.h:49
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::cannotInsertToContainer
GAUDI_API void cannotInsertToContainer()
Function to be called to indicate that an object cannot be inserted to the container.
Definition: KeyedObjectManager.cpp:77
begin
auto begin(reverse_wrapper< T > &w)
Definition: reverse.h:48
KeyedContainer::rend
const_reverse_iterator rend() const
const reverse_iterator pointing to the end of the reversed container
Definition: KeyedContainer.h:332
KeyedContainer::empty
bool empty() const
For consistency with STL: check if container is empty.
Definition: KeyedContainer.h:286
KeyedContainer::index
long index(const ContainedObject *p) const override
ObjectContainerBase overload: Retrieve the full long integer representation of the object&#39;s key from ...
Definition: KeyedContainer.h:591
GaudiPython.Persistency.add
def add(instance)
Definition: Persistency.py:32
std::vector::push_back
T push_back(T...args)
KeyedContainer::rend
reverse_iterator rend()
reverse_iterator pointing to the end of the reversed container
Definition: KeyedContainer.h:330
KeyedContainer::_RemoveRelease::_RemoveRelease
_RemoveRelease(ObjectContainerBase *p)
Definition: KeyedContainer.h:163
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::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
KeyedContainer::KeyedContainer
KeyedContainer(KeyedContainer &&other)
Definition: KeyedContainer.h:186
KeyedContainer::update
StatusCode update() override
Reconfigure direct access to elements (Needed by POOL data loading) This function reuses the "update"...
Definition: KeyedContainer.h:509
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
KeyedContainer::end
const_iterator end() const
Retrieve terminating const iterator.
Definition: KeyedContainer.h:324
KeyedContainer::value_type
seq_type::value_type value_type
Sequential access: definition of type stored in sequential container.
Definition: KeyedContainer.h:84
end
auto end(reverse_wrapper< T > &w)
Definition: reverse.h:50
KeyedContainer::containedObject
ContainedObject * containedObject(long key_value) const override
ObjectContainerBase overload: Retrieve the object by reference given the long integer representation ...
Definition: KeyedContainer.h:263
KeyedContainer::const_iterator
seq_type::const_iterator const_iterator
Sequential access: const iterator type used in sequential container.
Definition: KeyedContainer.h:92
CLID
unsigned int CLID
Class ID definition.
Definition: ClassID.h:8
std::vector::clear
T clear(T...args)
FORCE_INLINE
#define FORCE_INLINE
Definition: KeyedContainer.h:23
std::vector::insert
T insert(T...args)
KeyedObject.h
KeyedContainer::~KeyedContainer
~KeyedContainer() override
Destructor.
Definition: KeyedContainer.h:501
Containers::OBJ_ERASED
Object was removed, but not deleted.
Definition: KeyedTraits.h:22
ContainedObject
All classes that their objects may be contained in an LHCb ObjectContainer (e.g.
Definition: ContainedObject.h:29
std::vector::size
T size(T...args)
std::vector< contained_type * >
std::vector::begin
T begin(T...args)
KeyedContainer::erase
long erase(const value_type val)
Remove/erase object (identified by pointer value) from the container.
Definition: KeyedContainer.h:410
KeyedContainer::_InsertRelease::_InsertRelease
_InsertRelease(KeyedContainer< DATATYPE, MAPPING > *p)
Definition: KeyedContainer.h:153
KeyedContainer::end
iterator end()
Retrieve terminating iterator.
Definition: KeyedContainer.h:322
Containers::OBJ_NOT_FOUND
Object not present in the container.
Definition: KeyedTraits.h:20
ContainedObject::setParent
void setParent(ObjectContainerBase *value)
Update parent member.
Definition: ContainedObject.h:51
KeyedContainer::key_type
contained_type::key_type key_type
Definition of the key type: re-use definition of contained type.
Definition: KeyedContainer.h:82
KeyedContainer::_RemoveRelease
Internal functor for insertion of objects.
Definition: KeyedContainer.h:161
gaudirun.s
string s
Definition: gaudirun.py:245
HiveAlgSequencer.p1
p1
Definition: HiveAlgSequencer.py:22
KeyedContainer::begin
const_iterator begin() const
Retrieve start const iterator.
Definition: KeyedContainer.h:320
ObjectContainerBase
ObjectContainerBase is the base class for Gaudi container classes.
Definition: ObjectContainerBase.h:19
KeyedContainer::_RemoveRelease::operator()
void operator()(value_type p)
Definition: KeyedContainer.h:164
KeyedContainer::const_reverse_iterator
seq_type::const_reverse_iterator const_reverse_iterator
Sequential access: const reverse iterator type used in sequential container.
Definition: KeyedContainer.h:98
KeyedObjectManager.h
std::for_each
T for_each(T...args)
GaudiDict
Definition: KeyedContainer.h:8
GAUDI_API
#define GAUDI_API
Definition: Kernel.h:107
Objects::reference
TO * reference(FROM *from)
Definition: KeyedObject.cpp:20
KeyedContainer::container_type
MAPPING container_type
Definition of the implementing container type.
Definition: KeyedContainer.h:71
GaudiPython.Pythonizations.update
update
Definition: Pythonizations.py:94
KeyedContainer::m_random
seq_type * m_random
Array to allow random access to objects (not exposed)
Definition: KeyedContainer.h:114
std::vector::reserve
T reserve(T...args)
KeyedContainer::clear
void clear()
Clear the entire content and erase the objects from the container.
Definition: KeyedContainer.h:290
std::vector::rbegin
T rbegin(T...args)