Loading [MathJax]/extensions/tex2jax.js
The Gaudi Framework  v31r0 (aeb156f0)
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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 <algorithm>
6 #include <iterator>
7 
8 namespace GaudiDict {
9  template <class T>
11 }
12 
13 // Framework include files
17 
18 // Forward declarations
19 // template <class T, class M> class KeyedContainer;
20 
21 #ifdef WIN32
22 # define FORCE_INLINE __forceinline
23 #else
24 # define FORCE_INLINE inline
25 #endif
26 
63 template <class DATATYPE, class MAPPING = Containers::HashMap>
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:
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 ) ) { return p; }
123  }
124  return 0;
125  }
126  value_type p = value_type( m_cont.object( traits::hash( k ) ) );
127  return traits::checkKey( p, k ) ? p : 0;
128  }
129 #else
130  FORCE_INLINE value_type i_object( const key_type& k ) const {
131  return 0 == m_cont.isDirect() ? value_type( *( m_random->begin() + traits::hash( k ) ) )
132  : value_type( m_cont.object( traits::hash( k ) ) );
133  }
134 #endif
135  long i_erase( const_reference v, const key_type& k ) {
137  value_type p = value_type( m_cont.erase( traits::hash( k ), v ) );
138  if ( p ) {
139  if ( p->parent() == this ) { p->setParent( 0 ); }
140  }
141  return traits::release( p ) <= 0 ? (long)Containers::OBJ_ERASED : (long)Containers::OBJ_DELETED;
142  }
143 
145  struct _InsertRelease {
148  void operator()( value_type p ) {
149  m_obj->insert( p );
150  traits::release( p );
151  }
152  };
153 
155  struct _RemoveRelease {
157  _RemoveRelease( ObjectContainerBase* p ) : m_obj( p ) {}
158  void operator()( value_type p ) {
159  const ObjectContainerBase* par = p->parent();
160  if ( par == m_obj ) { p->setParent( 0 ); }
161  traits::release( p );
162  }
163  };
165 
166 public:
170  KeyedContainer( void ) {
172  // avoid problems with strict-aliasing rules
173  seq_type** rptr = &m_random;
174  seq_type* sptr = &m_sequential;
175  m_cont.setup( (void*)sptr, (void**)rptr );
176  }
178  : ObjectContainerBase( std::move( other ) )
179  , m_cont( std::move( other.m_cont ) )
180  , m_sequential( std::move( other.m_sequential ) ) {
181  m_cont.setup( (void*)&m_sequential, (void**)&m_random );
182  std::for_each( begin(), end(), [this]( ContainedObject* obj ) { obj->setParent( this ); } );
183 
184  other.m_cont.setup( (void*)&other.m_sequential, (void**)&other.m_random );
185  }
186  KeyedContainer( const KeyedContainer& ) = delete;
188  ~KeyedContainer() override;
190 
196  const CLID& clID() const override { return this->classID(); }
199  static const CLID& classID() {
200  static CLID clid = contained_type::classID() + container_type::classID();
201  return clid;
202  }
204 
221  size_type numberOfObjects() const override { return m_sequential.size(); }
234  long add( ContainedObject* pObject ) override;
235 
248  long remove( ContainedObject* pObject ) override;
249 
253  ContainedObject* containedObject( long key_value ) const override { return i_object( traits::makeKey( key_value ) ); }
257  long index( const ContainedObject* p ) const override;
263  virtual size_type containedObjects( std::vector<ContainedObject*>& v ) const;
265 
271  size_type size() const { return m_sequential.size(); }
274  bool empty() const { return m_sequential.empty(); }
276  void reserve( size_type value ) { m_cont.reserve( value ); }
278  void clear() { erase( begin(), end() ); }
284  virtual const std::vector<const ContainedObject*>* containedObjects() const;
289  StatusCode update() override;
291 
305  iterator begin() { return m_sequential.begin(); }
308  const_iterator begin() const { return m_sequential.begin(); }
310  iterator end() { return m_sequential.end(); }
312  const_iterator end() const { return m_sequential.end(); }
314  reverse_iterator rbegin() { return m_sequential.rbegin(); }
316  const_reverse_iterator rbegin() const { return m_sequential.rbegin(); }
318  reverse_iterator rend() { return m_sequential.rend(); }
320  const_reverse_iterator rend() const { return m_sequential.rend(); }
322 
340  value_type object( const key_type& kval ) const { return i_object( kval ); }
341 
351  value_type operator()( const key_type& kval ) const { return i_object( kval ); }
353 
376  long erase( const key_type& kval ) { return i_erase( 0, kval ); }
377 
398  long erase( const value_type val ) { return ( val ) ? i_erase( val, val->key() ) : (long)Containers::OBJ_NOT_FOUND; }
399 
420  long erase( iterator pos ) { return erase( *pos ); }
421 
430  void erase( iterator pos_start, iterator pos_stop, bool use_temp = false );
431 
450  const key_type& insert( const value_type val, const key_type& kval );
451 
473  const key_type& insert( const value_type val );
475 };
476 
484 // Destructor
485 template <class DATATYPE, class MAPPING>
487  clear();
488  m_cont.clear();
489 }
490 
491 // Configure direct access
492 template <class DATATYPE, class MAPPING>
494  int count = 0;
495  m_cont.clearDirect();
496  typename seq_type::iterator i = m_sequential.begin();
497  typename seq_type::iterator s = m_sequential.end();
498  for ( ; i != s; i++ ) {
499  typename seq_type::value_type v = *i;
500  if ( v ) {
501  if ( !v->hasKey() ) {
502  traits::setKey( v, v->key() );
503  traits::addRef( v );
504  }
505  long k0 = traits::hash( v->key() );
506  if ( m_cont.insertDirect( this, v, v, k0 ) == Containers::OBJ_INSERTED ) {}
507  } else {
508  ++count;
509  }
510  }
511  if ( count > 0 ) { Containers::cannotInsertToContainer(); }
512  return StatusCode::SUCCESS;
513 }
514 
515 // Retrieve the full content of the object container by reference.
516 template <class DATATYPE, class MAPPING>
518  return (const std::vector<const ContainedObject*>*)( ( 0 == m_cont.isDirect() ) ? m_random : &m_sequential );
519 }
520 
521 template <class DATATYPE, class MAPPING>
522 inline const typename KeyedContainer<DATATYPE, MAPPING>::key_type&
524  if ( val ) {
525  long k0 = traits::hash( kval );
526  if ( !val->hasKey() || ( traits::hash( val->key() ) == k0 ) ) {
527  if ( m_cont.insert( this, val, val, k0 ) == Containers::OBJ_INSERTED ) {
528  if ( !val->hasKey() ) traits::setKey( val, kval );
529  traits::addRef( val );
530  return val->key();
531  }
532  }
533  }
534  // Cannot insert object...indicate bad object insertion...
536  return val->key();
537 }
538 
539 // Insert object
540 template <class DATATYPE, class MAPPING> // inline
543  if ( 0 != val ) {
544  if ( val->hasKey() ) {
545  if ( m_cont.insert( this, val, val, traits::hash( val->key() ) ) == Containers::OBJ_INSERTED ) {
546  traits::addRef( val );
547  return val->key();
548  }
549  }
550  long k0;
551  if ( m_cont.insert( this, val, val, &k0 ) == Containers::OBJ_INSERTED ) {
552  traits::setKey( val, traits::makeKey( k0 ) );
553  traits::addRef( val );
554  return val->key();
555  }
556  }
557  // Cannot insert object...indicate bad object insertion...
559  return val->key();
560 }
561 
562 template <class DATATYPE, class MAPPING>
564  const contained_type* ptr = dynamic_cast<const contained_type*>( p );
565  if ( ptr ) return traits::identifier( ptr->key() );
566  return -1;
567 }
568 
569 // Retrieve the full content of the object container.
570 template <class DATATYPE, class MAPPING>
573  typename seq_type::const_iterator i = m_sequential.begin();
574  typename seq_type::const_iterator s = m_sequential.end();
575  vec.clear();
576  vec.reserve( size() );
577  for ( ; i != s; i++ ) {
578  ContainedObject* p = const_cast<typename seq_type::value_type>( *i );
579  vec.push_back( p );
580  }
581  return vec.size();
582 }
583 
584 // ObjectContainerBase overload: Add an object to the container.
585 template <class DATATYPE, class MAPPING>
587  return traits::identifier( insert( dynamic_cast<typename seq_type::value_type>( pObject ) ) );
588 }
589 
590 // ObjectContainerBase overload: Remove an object from the container.
591 template <class DATATYPE, class MAPPING>
593  contained_type* p1 = dynamic_cast<contained_type*>( p );
594  if ( p1 ) { // Normal case; object still fully intact
595  return this->erase( p1 );
596  } else if ( p ) {
597  const ObjectContainerBase* par = p->parent();
598  // The following should never occur: object is in a funny state,
599  // Because the parent was explicitly set to NULL in the
600  // KeyeObject destructor.
601  // - It cannot be a KeyedObject: It would not have a parent
602  // - Still the parent is present: We are not in the destructor
603  // of KeyedObject
604  if ( par ) { Containers::invalidContainerOperation(); }
605  return m_cont.erase( 0, p ) == 0 ? (long)Containers::OBJ_ERASED : (long)Containers::OBJ_NOT_FOUND;
606  }
607  return (long)Containers::OBJ_NOT_FOUND;
608 }
609 
610 template <class DATATYPE, class MAPPING>
611 inline void KeyedContainer<DATATYPE, MAPPING>::erase( iterator start_pos, iterator stop_pos, bool use_tmp ) {
612  bool is_start = start_pos == m_sequential.begin();
613  bool is_stop = stop_pos == m_sequential.end();
614  if ( is_start && is_stop ) {
615  // Nothing special. Taken care of by Keyed object manager
616  } else if ( is_start || is_stop || use_tmp ) {
617  std::vector<DATATYPE*> tmp( m_sequential.begin(), start_pos );
618  tmp.insert( tmp.end(), stop_pos, m_sequential.end() );
619  std::for_each( tmp.begin(), tmp.end(), traits::addRef );
620  this->erase( m_sequential.begin(), m_sequential.end() );
621  std::for_each( tmp.begin(), tmp.end(), _InsertRelease( this ) );
622  return;
623  }
624  std::for_each( start_pos, stop_pos, _RemoveRelease( this ) );
625  seq_type* sptr = &m_sequential; // avoid problems with strict-aliasing rules
627  std::vector<void*>::iterator i1 = v->begin() + std::distance( m_sequential.begin(), start_pos );
628  std::vector<void*>::iterator i2 = v->begin() + std::distance( m_sequential.begin(), stop_pos );
629  m_cont.erase( i1, i2 );
630 }
631 
632 #undef FORCE_INLINE
633 #endif // GAUDIKERNEL_KEYEDCONTAINER_H
virtual const std::vector< const ContainedObject * > * containedObjects() const
Retrieve the full content of the object container by reference.
reverse_iterator rbegin()
reverse_iterator returns the beginning of the reversed container
seq_type::reverse_iterator reverse_iterator
Sequential access: reverse iterator type used in sequential container.
T empty(T...args)
Container traits class.
Definition: KeyedTraits.h:34
seq_type::const_reference const_reference
Sequential access: const reference type used in sequential container.
void reserve(size_type value)
Reserve place for "value" objects in the container.
value_type object(const key_type &kval) const
Object access by key.
T distance(T...args)
long erase(iterator pos)
Remove/erase object (identified by iterator) from the container.
long add(ContainedObject *pObject) override
ObjectContainerBase overload: Add an object to the container.
size_t size_type
size_type, to conform the STL container interface
const_reverse_iterator rbegin() const
const reverse_iterator returns the beginning of the reversed container
T rend(T...args)
seq_type m_sequential
Array to allow sequential access to the object (can be ordered).
seq_type::reference reference
Sequential access: reference type used in sequential container.
constexpr struct Gaudi::Functional::details::insert_t insert
Object not present in the container.
Definition: KeyedTraits.h:23
ObjectContainerBase * m_obj
constexpr static const auto SUCCESS
Definition: StatusCode.h:85
template class KeyedContainer, KeyedContainer.h
STL namespace.
long erase(const key_type &kval)
Remove/erase object (identified by key) from the container.
long remove(ContainedObject *pObject) override
ObjectContainerBase overload: Remove an object from the container.
T end(T...args)
Containers::traits< container_type, contained_type > traits
Traits class definition.
static const CLID & classID()
Retrieve class ID.
seq_type::iterator iterator
Sequential access: iterator type used in sequential container.
Internal functor for insertion of objects.
DATATYPE contained_type
Definition of the contained object type.
value_type operator()(const key_type &kval) const
STL algorithms support for object access.
Object was inserted into the container.
Definition: KeyedTraits.h:26
const ObjectContainerBase * parent() const
Access to parent object.
const key_type & insert(const value_type val, const key_type &kval)
Insert entry to the container with a valid key.
constexpr auto size(const C &c) noexcept(noexcept(c.size())) -> decltype(c.size())
KeyedContainer< DATATYPE, MAPPING > * m_obj
GAUDI_API void cannotInsertToContainer()
Function to be called to indicate that an object cannot be inserted to the container.
const_reverse_iterator rend() const
const reverse_iterator pointing to the end of the reversed container
bool empty() const
For consistency with STL: check if container is empty.
long index(const ContainedObject *p) const override
ObjectContainerBase overload: Retrieve the full long integer representation of the object&#39;s key from ...
T push_back(T...args)
reverse_iterator rend()
reverse_iterator pointing to the end of the reversed container
_RemoveRelease(ObjectContainerBase *p)
GAUDI_API void invalidContainerOperation()
Function to be called to indicate that an operation should be performed on the container or it&#39;s cont...
FORCE_INLINE value_type i_object(const key_type &k) const
Internal function to access objects within the container.
KeyedContainer(KeyedContainer &&other)
StatusCode update() override
Reconfigure direct access to elements (Needed by POOL data loading) This function reuses the "update"...
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:50
const_iterator end() const
Retrieve terminating const iterator.
seq_type::value_type value_type
Sequential access: definition of type stored in sequential container.
Object was removed, but not deleted.
Definition: KeyedTraits.h:25
ContainedObject * containedObject(long key_value) const override
ObjectContainerBase overload: Retrieve the object by reference given the long integer representation ...
seq_type::const_iterator const_iterator
Sequential access: const iterator type used in sequential container.
unsigned int CLID
Class ID definition.
Definition: ClassID.h:8
T clear(T...args)
#define FORCE_INLINE
T insert(T...args)
~KeyedContainer() override
Destructor.
All classes that their objects may be contained in an LHCb ObjectContainer (e.g.
T size(T...args)
T begin(T...args)
long erase(const value_type val)
Remove/erase object (identified by pointer value) from the container.
_InsertRelease(KeyedContainer< DATATYPE, MAPPING > *p)
iterator end()
Retrieve terminating iterator.
void setParent(ObjectContainerBase *value)
Update parent member.
contained_type::key_type key_type
Definition of the key type: re-use definition of contained type.
Internal functor for insertion of objects.
string s
Definition: gaudirun.py:312
const_iterator begin() const
Retrieve start const iterator.
ObjectContainerBase is the base class for Gaudi container classes.
seq_type::const_reverse_iterator const_reverse_iterator
Sequential access: const reverse iterator type used in sequential container.
AttribStringParser::Iterator begin(const AttribStringParser &parser)
T for_each(T...args)
#define GAUDI_API
Definition: Kernel.h:71
Object was removed from the container and deleted.
Definition: KeyedTraits.h:24
MAPPING container_type
Definition of the implementing container type.
seq_type * m_random
Array to allow random access to objects (not exposed)
T reserve(T...args)
void clear()
Clear the entire content and erase the objects from the container.
T rbegin(T...args)