The Gaudi Framework  v36r9 (fd2bdac3)
Public Member Functions | Static Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
Containers::KeyedObjectManager< SETUP > Class Template Reference

KeyedObjectManager Class to manage keyed objects. More...

#include </builds/gaudi/Gaudi/GaudiKernel/include/GaudiKernel/KeyedObjectManager.h>

Collaboration diagram for Containers::KeyedObjectManager< SETUP >:
Collaboration graph
[legend]

Public Member Functions

 KeyedObjectManager ()
 Standard Constructor. More...
 
 KeyedObjectManager (KeyedObjectManager &&other)
 
virtual ~KeyedObjectManager ()
 Standard Destructor. More...
 
void clearDirect ()
 Clear all direct access fields. More...
 
long insertDirect (ObjectContainerBase *b, ContainedObject *c, void *o, long k)
 Insert element into direct access map. More...
 
long isDirect () const
 Check if the container is dirty. More...
 
void * object (long key) const
 Retrieve object identified by a key from the container. More...
 
long insert (ObjectContainerBase *b, ContainedObject *c, void *o, long *k)
 Insert new object into container. More...
 
long insert (ObjectContainerBase *b, ContainedObject *c, void *o, long k)
 Insert new object into container. More...
 
void * erase (long key, const void *obj)
 Remove object from container (very inefficient if key is invalid) More...
 
long erase (seq_type::iterator beg, seq_type::iterator end)
 Remove object by sequential iterators. More...
 
void reserve (long size)
 Reserve buffer space. More...
 
void clear ()
 Clear content of the vector. More...
 
void setup (void *seq, void **rndm)
 Setup of the Map and the parent object. More...
 
CLID classID ()
 
CLID classID ()
 
void * object (long value) const
 
long insert (ObjectContainerBase *b, ContainedObject *c, void *o, long *k)
 
long insert (ObjectContainerBase *b, ContainedObject *c, void *o, long k)
 
long insertDirect (ObjectContainerBase *b, ContainedObject *c, void *o, long k)
 
void clearDirect ()
 
void * erase (long key, const void *obj)
 
long erase (seq_type::iterator beg, seq_type::iterator end)
 
CLID classID ()
 
void * object (long) const
 
long insert (ObjectContainerBase *b, ContainedObject *c, void *o, long *k)
 
long insert (ObjectContainerBase *b, ContainedObject *c, void *o, long k)
 
long insertDirect (ObjectContainerBase *b, ContainedObject *c, void *o, long k)
 
void clearDirect ()
 
void * erase (long, const void *)
 
long erase (seq_type::iterator beg, seq_type::iterator end)
 
CLID classID ()
 

Static Public Member Functions

static CLID classID ()
 Access CLID for this type of container. More...
 

Private Types

typedef std::vector< void * > seq_type
 

Private Member Functions

void onDirty () const
 Callback when the container becomes dirty. More...
 
void onDirty () const
 
void onDirty () const
 

Private Attributes

seq_type * m_seq
 Container holding array like container. More...
 
long m_direct
 Dirty flag. More...
 
long m_keyCtxt
 
union {
   char   buffer [128]
 Buffer space to hold keyed container. More...
 
   SETUP *   s
 
} m_setup
 

Detailed Description

template<class SETUP>
class Containers::KeyedObjectManager< SETUP >

KeyedObjectManager Class to manage keyed objects.

Object manager class.

This class is instantiated for two container types: map and hashmap. Other types are possible, but currently not supported. Other implementations may be achieved by specializing the SETUP class.

As an example below the specialization for a vector like implementation is shown.

Author
M.Frank CERN/LHCb
Version
1.0

Definition at line 55 of file KeyedObjectManager.h.

Member Typedef Documentation

◆ seq_type

template<class SETUP >
typedef std::vector<void*> Containers::KeyedObjectManager< SETUP >::seq_type
private

Definition at line 57 of file KeyedObjectManager.h.

Constructor & Destructor Documentation

◆ KeyedObjectManager() [1/2]

template<class T >
Containers::KeyedObjectManager< T >::KeyedObjectManager

Standard Constructor.

Definition at line 98 of file KeyedObjectManager.cpp.

98  : m_seq( nullptr ), m_direct( 0 ) {
99  if ( sizeof( typename T::map_type ) > sizeof( m_setup.buffer ) ) {
100  throw GaudiException( "Basic STL contaier sizes are incompatible", "KeyedContainer", StatusCode::FAILURE );
101  }
102  m_setup.s = ::new ( m_setup.buffer + sizeof( m_setup.s ) ) T();
103  m_keyCtxt = -1;
104 }

◆ KeyedObjectManager() [2/2]

template<class T >
Containers::KeyedObjectManager< T >::KeyedObjectManager ( KeyedObjectManager< SETUP > &&  other)

Definition at line 107 of file KeyedObjectManager.cpp.

108  : m_seq( nullptr ), m_direct( other.m_direct ), m_keyCtxt( other.m_keyCtxt ) {
109  m_setup.s = ::new ( m_setup.buffer + sizeof( m_setup.s ) ) T( std::move( *other.m_setup.s ) );
110 
111  other.m_keyCtxt = -1;
112  other.m_seq = nullptr;
113  other.m_direct = 0;
114 }

◆ ~KeyedObjectManager()

template<class T >
Containers::KeyedObjectManager< T >::~KeyedObjectManager< T >
virtual

Standard Destructor.

Definition at line 107 of file KeyedObjectManager.cpp.

117  {
118  m_setup.s->~T();
119 }

Member Function Documentation

◆ classID() [1/5]

template<class SETUP >
static CLID Containers::KeyedObjectManager< SETUP >::classID ( )
static

Access CLID for this type of container.

◆ classID() [2/5]

CLID Containers::KeyedObjectManager< Containers::map >::classID ( )

Definition at line 293 of file KeyedObjectManager.cpp.

293  {
294  return CLID_ObjectVector + 0x00030000;
295  }

◆ classID() [3/5]

CLID Containers::KeyedObjectManager< Containers::hashmap >::classID ( )

Definition at line 297 of file KeyedObjectManager.cpp.

297  {
298  return CLID_ObjectVector + 0x00040000;
299  }

◆ classID() [4/5]

CLID Containers::KeyedObjectManager< __A >::classID ( )

Definition at line 487 of file KeyedObjectManager.cpp.

487  {
488  return CLID_ObjectVector + 0x00050000;
489  }

◆ classID() [5/5]

CLID Containers::KeyedObjectManager< __V >::classID ( )

Definition at line 571 of file KeyedObjectManager.cpp.

571  {
572  return CLID_ObjectVector + 0x00060000;
573  }

◆ clear()

template<class T >
void Containers::KeyedObjectManager< T >::clear

Clear content of the vector.

Definition at line 240 of file KeyedObjectManager.cpp.

240  {
241  clearDirect();
242  m_seq->clear();
243 }

◆ clearDirect() [1/3]

template<class T >
void Containers::KeyedObjectManager< T >::clearDirect

Clear all direct access fields.

Definition at line 246 of file KeyedObjectManager.cpp.

246  {
247  switch ( m_direct ) {
248  case 1:
249  m_setup.s->m.clear();
250  break;
251  case 0:
252  m_setup.s->v.clear();
253  break;
254  default:
255  break;
256  }
257  m_direct = 0;
258  m_keyCtxt = -1;
259 }

◆ clearDirect() [2/3]

void Containers::KeyedObjectManager< __A >::clearDirect ( )

Definition at line 409 of file KeyedObjectManager.cpp.

409  {
410  m_setup.s->v.clear();
411  m_setup.s->m_idx.clear();
412  m_direct = 0;
413  m_keyCtxt = -1;
414  }

◆ clearDirect() [3/3]

void Containers::KeyedObjectManager< __V >::clearDirect ( )

Definition at line 546 of file KeyedObjectManager.cpp.

546  {
547  m_setup.s->v.clear();
548  m_direct = 0;
549  m_keyCtxt = -1;
550  }

◆ erase() [1/6]

template<class T >
void * Containers::KeyedObjectManager< T >::erase ( long  key,
const void *  obj 
)

Remove object from container (very inefficient if key is invalid)

Definition at line 196 of file KeyedObjectManager.cpp.

196  {
197  typedef typename T::map_type MTYP;
198  typedef find<MTYP> FND;
199  if ( 1 == m_direct ) {
200  auto& m = m_setup.s->m;
201  auto i = ( obj ? std::find_if( m.begin(), m.end(), FND( obj ) ) : m_setup.s->m.find( key ) );
202  if ( i != m_setup.s->m.end() ) {
203  void* o = i->second;
204  auto j = std::find( m_seq->begin(), m_seq->end(), o );
205  if ( j != m_seq->end() ) {
206  m_seq->erase( j );
207  m_setup.s->m.erase( i );
208  return o;
209  }
210  }
211  containerIsInconsistent();
212  }
213  onDirty();
214  return erase( key, obj );
215 }

◆ erase() [2/6]

void * Containers::KeyedObjectManager< __A >::erase ( long  key,
const void *  obj 
)

Definition at line 418 of file KeyedObjectManager.cpp.

418  {
419  if ( 0 == m_direct ) {
420  onDirty();
421  return erase( key, obj );
422  }
423  if ( obj ) {
424  auto& idx = m_setup.s->m_idx;
425  for ( auto& elem : idx ) {
426  auto j = m_setup.s->v.begin() + ( elem );
427  auto k = std::find( m_seq->begin(), m_seq->end(), *j );
428  if ( *j == obj ) {
429  void* o = *j;
430  m_seq->erase( k );
431  m_setup.s->v.erase( j );
432  std::for_each( m_setup.s->m_idx.begin(), m_setup.s->m_idx.end(), array::decrement( elem ) );
433  elem = -1;
434  return o;
435  }
436  }
437  } else if ( key >= 0 && key < long( m_setup.s->m_idx.size() ) ) {
438  auto idx = m_setup.s->m_idx.begin() + key;
439  if ( *idx != -1 ) {
440  auto i = m_setup.s->v.begin() + ( *idx );
441  if ( i == m_setup.s->v.end() ) { containerIsInconsistent(); }
442  void* o = *i;
443  auto j = std::find( m_seq->begin(), m_seq->end(), o );
444  if ( j == m_seq->end() ) { containerIsInconsistent(); }
445  m_seq->erase( j );
446  m_setup.s->v.erase( i );
447  std::for_each( m_setup.s->m_idx.begin(), m_setup.s->m_idx.end(), array::decrement( *idx ) );
448  *idx = -1;
449  return o;
450  }
451  }
452  containerIsInconsistent();
453  return nullptr;
454  }

◆ erase() [3/6]

void * Containers::KeyedObjectManager< __V >::erase ( long  ,
const void *   
)

Definition at line 554 of file KeyedObjectManager.cpp.

554  {
555  invalidContainerOperation();
556  return nullptr;
557  }

◆ erase() [4/6]

template<class T >
long Containers::KeyedObjectManager< T >::erase ( seq_type::iterator  beg,
seq_type::iterator  end 
)

Remove object by sequential iterators.

Definition at line 263 of file KeyedObjectManager.cpp.

263  {
264  typedef typename T::map_type MTYP;
265  typedef find<MTYP> FND;
266  if ( 0 == m_direct ) {
267  onDirty();
268  return erase( beg, end );
269  }
270  if ( beg == m_seq->begin() && end == m_seq->end() ) {
271  clear();
272  } else {
273  for ( auto j = beg; j != end; ++j ) {
274  // auto& m = m_setup.s->m;
275  auto i = std::find_if( m_setup.s->m.begin(), m_setup.s->m.end(), FND( *j ) );
276  if ( i != m_setup.s->m.end() ) {
277  m_setup.s->m.erase( i );
278  continue;
279  }
280  containerIsInconsistent();
281  }
282  m_seq->erase( beg, end );
283  }
284  return OBJ_ERASED;
285 }

◆ erase() [5/6]

long Containers::KeyedObjectManager< __A >::erase ( seq_type::iterator  beg,
seq_type::iterator  end 
)

Definition at line 458 of file KeyedObjectManager.cpp.

458  {
459  if ( beg == m_seq->begin() && end == m_seq->end() ) {
460  clear();
461  return OBJ_ERASED;
462  } else if ( 0 == m_direct ) {
463  onDirty();
464  return erase( beg, end );
465  } else {
466  long cnt = 0, nobj = end - beg;
467  auto& idx = m_setup.s->m_idx;
468  for ( auto& elem : idx ) {
469  auto j = m_setup.s->v.begin() + ( elem );
470  auto k = std::find( beg, end, *j );
471  if ( k != end ) {
472  m_setup.s->v.erase( j );
473  std::for_each( m_setup.s->m_idx.begin(), m_setup.s->m_idx.end(), array::decrement( elem ) );
474  elem = -1;
475  cnt++;
476  if ( cnt == nobj ) break;
477  }
478  }
479  m_seq->erase( beg, end );
480  if ( cnt != nobj ) { containerIsInconsistent(); }
481  return OBJ_ERASED;
482  }
483  // cannot reach this point
484  }

◆ erase() [6/6]

long Containers::KeyedObjectManager< __V >::erase ( seq_type::iterator  beg,
seq_type::iterator  end 
)

Definition at line 561 of file KeyedObjectManager.cpp.

561  {
562  if ( beg == m_seq->begin() && end == m_seq->end() ) {
563  clear();
564  return OBJ_ERASED;
565  }
566  invalidContainerOperation();
567  return OBJ_ERASED;
568  }

◆ insert() [1/6]

template<class T >
long Containers::KeyedObjectManager< T >::insert ( ObjectContainerBase *  b,
ContainedObject *  c,
void *  o,
long *  k 
)

Insert new object into container.

Definition at line 138 of file KeyedObjectManager.cpp.

139  {
140  *key = ++m_keyCtxt;
141  return insert( pBase, pObject, obj, *key );
142 }

◆ insert() [2/6]

long Containers::KeyedObjectManager< __A >::insert ( ObjectContainerBase *  b,
ContainedObject *  c,
void *  o,
long *  k 
)

Definition at line 342 of file KeyedObjectManager.cpp.

342  {
343  // auto key creation only possible for direct access!
344  if ( 0 == m_direct ) {
345  m_seq->push_back( o );
346  m_setup.s->v.push_back( o );
347  if ( !c->parent() ) c->setParent( b );
348  *k = ++m_keyCtxt;
349  return OBJ_INSERTED;
350  }
351  cannotInsertToContainer();
352  return OBJ_CANNOT_INSERT;
353  }

◆ insert() [3/6]

long Containers::KeyedObjectManager< __V >::insert ( ObjectContainerBase *  b,
ContainedObject *  c,
void *  o,
long *  k 
)

Definition at line 516 of file KeyedObjectManager.cpp.

516  {
517  m_seq->push_back( o );
518  m_setup.s->v.push_back( o );
519  if ( !c->parent() ) c->setParent( b );
520  *k = ( m_setup.s->v.size() - 1 );
521  return OBJ_INSERTED;
522  }

◆ insert() [4/6]

template<class T >
long Containers::KeyedObjectManager< T >::insert ( ObjectContainerBase *  b,
ContainedObject *  c,
void *  o,
long  k 
)

Insert new object into container.

Keep major key value

Definition at line 145 of file KeyedObjectManager.cpp.

146  {
148  if ( key > m_keyCtxt ) { m_keyCtxt = key; }
149  if ( 1 == m_direct ) {
150  if ( m_setup.s->insert( obj, key ) ) {
151  if ( !pObject->parent() ) { pObject->setParent( pBase ); }
152  m_seq->push_back( obj );
153  return OBJ_INSERTED;
154  }
155  } else if ( key == long( m_setup.s->v.size() ) ) {
156  m_setup.s->v.push_back( obj );
157  if ( !pObject->parent() ) { pObject->setParent( pBase ); }
158  m_seq->push_back( obj );
159  return OBJ_INSERTED;
160  } else {
161  // Document is dirty now...
162  // need to copy all pointers from the vector to the map
163  onDirty();
164  return insert( pBase, pObject, obj, key );
165  }
166  cannotInsertToContainer();
167  return OBJ_CANNOT_INSERT;
168 }

◆ insert() [5/6]

long Containers::KeyedObjectManager< __A >::insert ( ObjectContainerBase *  b,
ContainedObject *  c,
void *  o,
long  k 
)

Keep major key value

Extend redirection array and insert

Definition at line 357 of file KeyedObjectManager.cpp.

357  {
358  if ( 0 == m_direct ) {
359  if ( k == m_keyCtxt + 1 ) { return insert( b, c, o, &k ); }
360  onDirty();
361  return insert( b, c, o, k );
362  }
364  if ( k > m_keyCtxt ) m_keyCtxt = k;
366  if ( k + 1 > long( m_setup.s->m_idx.size() ) ) { m_setup.s->m_idx.resize( k + 1, -1 ); }
367  auto idx = m_setup.s->m_idx.begin() + k;
368  if ( *idx == -1 ) {
369  *idx = m_setup.s->v.size();
370  m_setup.s->v.push_back( o );
371  m_seq->push_back( o );
372  if ( !c->parent() ) c->setParent( b );
373  return OBJ_INSERTED;
374  }
375  cannotInsertToContainer();
376  return OBJ_CANNOT_INSERT;
377  }

◆ insert() [6/6]

long Containers::KeyedObjectManager< __V >::insert ( ObjectContainerBase *  b,
ContainedObject *  c,
void *  o,
long  k 
)

Definition at line 526 of file KeyedObjectManager.cpp.

526  {
527  if ( k == long( m_setup.s->v.size() ) ) { return insert( b, c, o, &k ); }
528  cannotInsertToContainer();
529  return OBJ_CANNOT_INSERT;
530  }

◆ insertDirect() [1/3]

template<class T >
long Containers::KeyedObjectManager< T >::insertDirect ( ObjectContainerBase *  b,
ContainedObject *  c,
void *  o,
long  k 
)

Insert element into direct access map.

Keep major key value

Definition at line 171 of file KeyedObjectManager.cpp.

172  {
174  if ( key > m_keyCtxt ) { m_keyCtxt = key; }
175  if ( 1 == m_direct ) {
176  if ( m_setup.s->insert( obj, key ) ) {
177  if ( !pObject->parent() ) { pObject->setParent( pBase ); }
178  return OBJ_INSERTED;
179  }
180  } else if ( key == long( m_setup.s->v.size() ) ) {
181  m_setup.s->v.push_back( obj );
182  if ( !pObject->parent() ) { pObject->setParent( pBase ); }
183  return OBJ_INSERTED;
184  } else {
185  // Document is dirty now...
186  // need to copy all pointers from the vector to the map
187  onDirty();
188  return insertDirect( pBase, pObject, obj, key );
189  }
190  cannotInsertToContainer();
191  return OBJ_CANNOT_INSERT;
192 }

◆ insertDirect() [2/3]

long Containers::KeyedObjectManager< __A >::insertDirect ( ObjectContainerBase *  b,
ContainedObject *  c,
void *  o,
long  k 
)

Keep major key value

Extend redirection array and insert

Definition at line 381 of file KeyedObjectManager.cpp.

381  {
382  if ( 0 == m_direct ) {
383  if ( k == m_keyCtxt + 1 ) {
384  m_setup.s->v.push_back( o );
385  if ( !c->parent() ) c->setParent( b );
386  ++m_keyCtxt;
387  return OBJ_INSERTED;
388  }
389  onDirty();
390  return insertDirect( b, c, o, k );
391  }
393  if ( k > m_keyCtxt ) m_keyCtxt = k;
395  if ( k + 1 > long( m_setup.s->m_idx.size() ) ) { m_setup.s->m_idx.resize( k + 1, -1 ); }
396  auto idx = m_setup.s->m_idx.begin() + k;
397  if ( *idx == -1 ) {
398  *idx = m_setup.s->v.size();
399  m_setup.s->v.push_back( o );
400  if ( !c->parent() ) c->setParent( b );
401  return OBJ_INSERTED;
402  }
403  cannotInsertToContainer();
404  return OBJ_CANNOT_INSERT;
405  }

◆ insertDirect() [3/3]

long Containers::KeyedObjectManager< __V >::insertDirect ( ObjectContainerBase *  b,
ContainedObject *  c,
void *  o,
long  k 
)

Definition at line 534 of file KeyedObjectManager.cpp.

534  {
535  if ( k == long( m_setup.s->v.size() ) ) {
536  m_setup.s->v.push_back( o );
537  if ( !c->parent() ) c->setParent( b );
538  return OBJ_INSERTED;
539  }
540  cannotInsertToContainer();
541  return OBJ_CANNOT_INSERT;
542  }

◆ isDirect()

template<class SETUP >
long Containers::KeyedObjectManager< SETUP >::isDirect ( ) const
inline

Check if the container is dirty.

Definition at line 83 of file KeyedObjectManager.h.

83 { return m_direct; }

◆ object() [1/3]

template<class T >
void * Containers::KeyedObjectManager< T >::object ( long  key) const

Retrieve object identified by a key from the container.

Definition at line 218 of file KeyedObjectManager.cpp.

218  {
219  if ( 0 == m_direct ) onDirty();
220  auto i = m_setup.s->m.find( key );
221  if ( i != m_setup.s->m.end() ) return ( *i ).second;
222  return nullptr;
223 }

◆ object() [2/3]

void * Containers::KeyedObjectManager< __A >::object ( long  value) const

Definition at line 317 of file KeyedObjectManager.cpp.

317  {
318 #ifdef CHECK_KEYED_CONTAINER
319  unsigned long siz = m_setup.s->m_idx.size();
320  if ( value >= 0 && size_t( value ) < siz ) {
321  long ent = *( m_setup.s->m_idx.begin() + value );
322  if ( ent >= 0 ) { return *( m_setup.s->v.begin() + ent ); }
323  }
324  return nullptr;
325 #else
326  return *( m_setup.s->v.begin() + ( *( m_setup.s->m_idx.begin() + value ) ) );
327 #endif
328  }

◆ object() [3/3]

void * Containers::KeyedObjectManager< __V >::object ( long  ) const

Definition at line 504 of file KeyedObjectManager.cpp.

504  {
505  invalidContainerOperation();
506  return nullptr;
507  }

◆ onDirty() [1/3]

template<class T >
void Containers::KeyedObjectManager< T >::onDirty
private

Callback when the container becomes dirty.

Definition at line 129 of file KeyedObjectManager.cpp.

129  {
130  m_direct = 1;
131  auto& s = *m_setup.s;
132  long i = 0;
133  for ( auto p : s.v ) s.insert( p, i++ );
134  s.v.clear();
135 }

◆ onDirty() [2/3]

void Containers::KeyedObjectManager< __A >::onDirty ( ) const
private

Definition at line 331 of file KeyedObjectManager.cpp.

331  {
332  m_direct = 1;
333  m_setup.s->m_idx.reserve( m_setup.s->v.size() + 1 );
334  for ( size_t i = 0, stop = m_setup.s->v.size(); i < stop; ++i ) {
335  if ( !m_setup.s->v[i] ) { containerIsInconsistent(); }
336  m_setup.s->m_idx.push_back( i );
337  }
338  }

◆ onDirty() [3/3]

void Containers::KeyedObjectManager< __V >::onDirty ( ) const
private

Definition at line 510 of file KeyedObjectManager.cpp.

510  {
511  invalidContainerOperation();
512  }

◆ reserve()

template<class T >
void Containers::KeyedObjectManager< T >::reserve ( long  size)

Reserve buffer space.

Definition at line 226 of file KeyedObjectManager.cpp.

226  {
227  switch ( m_direct ) {
228  case 1:
229  break;
230  case 0:
231  m_setup.s->v.reserve( len );
232  break;
233  default:
234  break;
235  }
236  m_seq->reserve( len );
237 }

◆ setup()

template<class T >
void Containers::KeyedObjectManager< T >::setup ( void *  seq,
void **  rndm 
)

Setup of the Map and the parent object.

Definition at line 123 of file KeyedObjectManager.cpp.

123  {
124  m_seq = (seq_type*)seq;
125  *rndm = &m_setup.s->v;
126 }

Member Data Documentation

◆ buffer

template<class SETUP >
char Containers::KeyedObjectManager< SETUP >::buffer[128]

Buffer space to hold keyed container.

Definition at line 65 of file KeyedObjectManager.h.

◆ m_direct

template<class SETUP >
long Containers::KeyedObjectManager< SETUP >::m_direct
mutableprivate

Dirty flag.

Definition at line 61 of file KeyedObjectManager.h.

◆ m_keyCtxt

template<class SETUP >
long Containers::KeyedObjectManager< SETUP >::m_keyCtxt
mutableprivate

Definition at line 62 of file KeyedObjectManager.h.

◆ m_seq

template<class SETUP >
seq_type* Containers::KeyedObjectManager< SETUP >::m_seq
private

Container holding array like container.

Definition at line 59 of file KeyedObjectManager.h.

◆ m_setup

union { ... } Containers::KeyedObjectManager< SETUP >::m_setup

◆ s

template<class SETUP >
SETUP* Containers::KeyedObjectManager< SETUP >::s

Definition at line 66 of file KeyedObjectManager.h.

The documentation for this class was generated from the following files:
Containers::cannotInsertToContainer
GAUDI_API void cannotInsertToContainer()
Function to be called to indicate that an object cannot be inserted to the container.
Definition: KeyedObjectManager.cpp:83
std::for_each
T for_each(T... args)
Containers::KeyedObjectManager::insertDirect
long insertDirect(ObjectContainerBase *b, ContainedObject *c, void *o, long k)
Insert element into direct access map.
Definition: KeyedObjectManager.cpp:171
Containers::KeyedObjectManager::s
SETUP * s
Definition: KeyedObjectManager.h:66
std::vector::reserve
T reserve(T... args)
Containers::KeyedObjectManager::onDirty
void onDirty() const
Callback when the container becomes dirty.
Definition: KeyedObjectManager.cpp:129
std::find_if
T find_if(T... args)
GaudiException
Definition: GaudiException.h:31
Containers::KeyedObjectManager::m_direct
long m_direct
Dirty flag.
Definition: KeyedObjectManager.h:61
Containers::KeyedObjectManager::insert
long insert(ObjectContainerBase *b, ContainedObject *c, void *o, long *k)
Insert new object into container.
Definition: KeyedObjectManager.cpp:138
Containers::KeyedObjectManager::clearDirect
void clearDirect()
Clear all direct access fields.
Definition: KeyedObjectManager.cpp:246
Containers::OBJ_INSERTED
@ OBJ_INSERTED
Object was inserted into the container.
Definition: KeyedTraits.h:36
gaudirun.c
c
Definition: gaudirun.py:525
Containers::invalidContainerOperation
GAUDI_API void invalidContainerOperation()
Function to be called to indicate that an operation should be performed on the container or it's cont...
Definition: KeyedObjectManager.cpp:92
Containers::KeyedObjectManager::m_keyCtxt
long m_keyCtxt
Definition: KeyedObjectManager.h:62
std::vector::clear
T clear(T... args)
std::vector::push_back
T push_back(T... args)
Containers::OBJ_ERASED
@ OBJ_ERASED
Object was removed, but not deleted
Definition: KeyedTraits.h:35
Gaudi::Units::m
constexpr double m
Definition: SystemOfUnits.h:108
std::vector::erase
T erase(T... args)
Containers::KeyedObjectManager::m_setup
union Containers::KeyedObjectManager::@2 m_setup
HistogramsTiming.seq
seq
Definition: HistogramsTiming.py:24
Containers::OBJ_CANNOT_INSERT
@ OBJ_CANNOT_INSERT
Cannot insert object into container.
Definition: KeyedTraits.h:37
IOTest.end
def end
Definition: IOTest.py:128
Containers::KeyedObjectManager::erase
void * erase(long key, const void *obj)
Remove object from container (very inefficient if key is invalid)
Definition: KeyedObjectManager.cpp:196
std::vector::begin
T begin(T... args)
std
STL namespace.
Containers::KeyedObjectManager::seq_type
std::vector< void * > seq_type
Definition: KeyedObjectManager.h:57
std::vector::end
T end(T... args)
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition: StatusCode.h:101
ProduceConsume.key
key
Definition: ProduceConsume.py:81
Containers::containerIsInconsistent
GAUDI_API void containerIsInconsistent()
Function to be called to indicate that the container is found to be inconsistent.
Definition: KeyedObjectManager.cpp:87
Containers::KeyedObjectManager::m_seq
seq_type * m_seq
Container holding array like container.
Definition: KeyedObjectManager.h:59
Containers::KeyedObjectManager::clear
void clear()
Clear content of the vector.
Definition: KeyedObjectManager.cpp:240