ATLAS Offline Software
Public Types | Public Member Functions | Static Public Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
xAOD::ShallowAuxContainer Class Referenceabstract

Class creating a shallow copy of an existing auxiliary container. More...

#include <ShallowAuxContainer.h>

Inheritance diagram for xAOD::ShallowAuxContainer:
Collaboration diagram for xAOD::ShallowAuxContainer:

Public Types

typedef SG::auxid_t auxid_t
 The aux ID type definition. More...
 
typedef SG::auxid_set_t auxid_set_t
 The aux ID set type definition. More...
 
enum  AuxStoreType { AST_ObjectStore = 0, AST_ContainerStore = 1 }
 Type of the auxiliary store. More...
 

Public Member Functions

 ShallowAuxContainer (bool standalone=false)
 Default constructor. More...
 
 ShallowAuxContainer (const ShallowAuxContainer &parent)
 Copy constructor. More...
 
 ShallowAuxContainer (const DataLink< SG::IConstAuxStore > &parent, bool standalone=false)
 Constructor with a parent object. More...
 
 ~ShallowAuxContainer ()
 Destructor. More...
 
ShallowAuxContaineroperator= (const ShallowAuxContainer &rhs)
 Assignment operator. More...
 
const DataLink< SG::IConstAuxStore > & parent () const
 Get the parent store. More...
 
void setParent (const DataLink< SG::IConstAuxStore > &link)
 Set the parent store. More...
 
bool shallowIO () const
 Check whether only the overriden parameters will be written out or not. More...
 
void setShallowIO (bool value)
 Set whether only the overriden parameters should be written out. More...
 
virtual const void * getData (SG::auxid_t auxid) const=0
 Pick up the const version from the base class. More...
 
virtual bool insertMove (size_t pos, IAuxStore &other, const SG::auxid_set_t &ignore=SG::auxid_set_t())=0
 Move all elements from other to this store. More...
 
virtual bool setOption (auxid_t, const AuxDataOption &)
 Set an option for a given auxiliary variable. More...
 
virtual IAuxTypeVector * linkedVector (SG::auxid_t)
 
virtual const IAuxTypeVector * linkedVector (SG::auxid_t) const
 Return interface for a linked variable. More...
 
virtual const IAuxTypeVector * linkedVector (SG::auxid_t) const
 Return interface for a linked variable. More...
 

Static Public Attributes

static constexpr bool supportsThinning = true
 Mark that this type supports thinning operations. More...
 

Private Types

typedef AthContainers_detail::recursive_mutex mutex_t
 Mutex for multithread synchronization. More...
 
typedef AthContainers_detail::lock_guard< mutex_tguard_t
 

Private Member Functions

void remakeAuxIDs () const
 

Private Attributes

AuxSelection m_selection
 Dynamic attributes selection implementation. More...
 
SG::IAuxStorem_store
 Internal dynamic auxiliary store object. More...
 
SG::IAuxStoreIOm_storeIO
 The IO interface to the internal auxiliary store. More...
 
bool m_ownsStore
 Flag deciding if the object owns the dynamic store or not. More...
 
bool m_locked
 Flag keeping track of whether this object is locked or not. More...
 
DataLink< SG::IConstAuxStorem_parentLink
 Link to the parent object. More...
 
const SG::IAuxStoreIOm_parentIO
 Optional pointer to the IO interface of the parent object. More...
 
bool m_shallowIO
 Flag for whether to do "shallow IO" or not. More...
 
mutex_t m_mutex
 
auxid_set_t m_auxids ATLAS_THREAD_SAFE
 
auxid_set_t m_decorids ATLAS_THREAD_SAFE
 
bool m_auxidsValid ATLAS_THREAD_SAFE
 
std::string m_name
 Name of the container in memory. Set externally. More...
 

Functions implementing the SG::IAuxStoreHolder interface

virtual SG::IAuxStoregetStore () override
 Get the currently used internal store object. More...
 
virtual const SG::IAuxStoregetStore () const override
 
virtual void setStore (SG::IAuxStore *store) override
 Set a different internal store object. More...
 
virtual AuxStoreType getStoreType () const override
 Return the type of the store object. More...
 

Detailed Description

Class creating a shallow copy of an existing auxiliary container.

During analysis, in order to create objects that override just some of the properties of an original, it's wasteful to make full copies of the objects. Not to mention that the full copies have generally issues with dynamic variables.

The behaviour of this class is that it takes all the properties that it doesn't know about from the parent auxiliary store, but the ones that it has an override for, it provides itself.

The object is persistifiable. The user can choose whether to only write out the variables that were modified wrt. the original container, or possibly all the variables. (In case the original container is not getting written out.)

Author
Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h
Revision
793737
Date
2017-01-24 21:11:10 +0100 (Tue, 24 Jan 2017)

Definition at line 48 of file ShallowAuxContainer.h.

Member Typedef Documentation

◆ auxid_set_t

The aux ID set type definition.

Definition at line 60 of file ShallowAuxContainer.h.

◆ auxid_t

The aux ID type definition.

Definition at line 58 of file ShallowAuxContainer.h.

◆ guard_t

typedef AthContainers_detail::lock_guard<mutex_t> xAOD::ShallowAuxContainer::guard_t
private

Definition at line 202 of file ShallowAuxContainer.h.

◆ mutex_t

typedef AthContainers_detail::recursive_mutex xAOD::ShallowAuxContainer::mutex_t
private

Mutex for multithread synchronization.

Definition at line 201 of file ShallowAuxContainer.h.

Member Enumeration Documentation

◆ AuxStoreType

Type of the auxiliary store.

In the xAOD EDM we use auxiliary store objects in some cases to describe a single object, and in most cases to describe a container of objects. This enumeration declares which type the object implementing this interface is.

Enumerator
AST_ObjectStore 

The store describes a single object.

AST_ContainerStore 

The store describes a container.

Definition at line 66 of file IAuxStoreHolder.h.

66  {
67  AST_ObjectStore = 0,
69  };

Constructor & Destructor Documentation

◆ ShallowAuxContainer() [1/3]

xAOD::ShallowAuxContainer::ShallowAuxContainer ( bool  standalone = false)

Default constructor.

Parameters
standalonetrue if the store will be used for a standalone object, false for a container

Definition at line 31 of file ShallowAuxContainer.cxx.

32  : m_selection(),
34  m_storeIO( nullptr ), m_ownsStore( true ), m_locked( false ),
35  m_parentLink(), m_parentIO( nullptr ), m_shallowIO( true ),
36  m_auxids (),
37  m_auxidsValid (false),
38  m_name( "UNKNOWN" ) {
39 
40  m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
41  }

◆ ShallowAuxContainer() [2/3]

xAOD::ShallowAuxContainer::ShallowAuxContainer ( const ShallowAuxContainer parent)

Copy constructor.

Definition at line 43 of file ShallowAuxContainer.cxx.

45  m_store( parent.m_store ), m_storeIO( parent.m_storeIO ),
46  m_ownsStore( false ), m_locked( parent.m_locked ),
47  m_parentLink( parent.m_parentLink ),
48  m_parentIO( parent.m_parentIO ), m_shallowIO( parent.m_shallowIO ),
49  m_auxids (),
50  m_auxidsValid (false)
51  {
52  // Keep the source unmutable during copy
53  guard_t guard( parent.m_mutex );
54  m_selection = parent.m_selection;
55  m_name = parent.m_name;
56  }

◆ ShallowAuxContainer() [3/3]

xAOD::ShallowAuxContainer::ShallowAuxContainer ( const DataLink< SG::IConstAuxStore > &  parent,
bool  standalone = false 
)

Constructor with a parent object.

Parameters
parentThe parent object to make a shallow copy of
standalonetrue if the store will be used for a standalone object, false for a container

Definition at line 62 of file ShallowAuxContainer.cxx.

65  : m_selection(),
67  m_storeIO( nullptr ), m_ownsStore( true ), m_locked( false ),
68  m_parentLink( parent ), m_parentIO( nullptr ), m_shallowIO( true ),
69  m_auxids (),
70  m_auxidsValid (false),
71  m_name( "UNKNOWN" ) {
72 
73  m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
74  m_parentIO = dynamic_cast< const SG::IAuxStoreIO* >( m_parentLink.cptr() );
75  }

◆ ~ShallowAuxContainer()

xAOD::ShallowAuxContainer::~ShallowAuxContainer ( )

Destructor.

Definition at line 77 of file ShallowAuxContainer.cxx.

77  {
78 
79  if( m_ownsStore && m_store ) {
80  delete m_store;
81  }
82  }

Member Function Documentation

◆ clearDecorations()

bool xAOD::ShallowAuxContainer::clearDecorations ( )
overridevirtual

Clear all decorations.

Implements SG::IConstAuxStore.

Definition at line 374 of file ShallowAuxContainer.cxx.

375  {
376  guard_t guard (m_mutex);
377  bool ret = m_store->clearDecorations();
378  if (ret) {
379  remakeAuxIDs();
380  }
381  return ret;
382  }

◆ getAuxIDs()

const ShallowAuxContainer::auxid_set_t & xAOD::ShallowAuxContainer::getAuxIDs ( ) const
overridevirtual

Get the types(names) of variables handled by this container.

Implements SG::IConstAuxStore.

Definition at line 227 of file ShallowAuxContainer.cxx.

227  {
228 
229  guard_t guard( m_mutex );
230  if (!m_auxidsValid) {
231  remakeAuxIDs();
232  }
233  return m_auxids;
234  }

◆ getData() [1/3]

const void * xAOD::ShallowAuxContainer::getData ( auxid_t  auxid) const
overridevirtual

Get a pointer to a given array.

Implements SG::IConstAuxStore.

Definition at line 187 of file ShallowAuxContainer.cxx.

187  {
188 
189  const SG::IAuxTypeVector* v = getVector( auxid );
190  if( v ) {
191  return v->toPtr();
192  }
193  return nullptr;
194  }

◆ getData() [2/3]

void * xAOD::ShallowAuxContainer::getData ( auxid_t  auxid,
size_t  size,
size_t  capacity 
)
overridevirtual

Get a pointer to a given array, creating the array if necessary.

Implements SG::IAuxStore.

Definition at line 393 of file ShallowAuxContainer.cxx.

394  {
395 
396  guard_t guard (m_mutex);
397 
398  // Check if we already have this variable by any chance.
399  const void* cptr = m_store->getData( auxid );
400 
401  // Create the variable in the dynamic store:
402  void* ptr = m_store->getData( auxid, size, capacity );
403 
404  remakeAuxIDs();
405 
406  // If in some weird way we already had this variable before, then don't
407  // try to overwrite it with the parent's payload, and finish here already.
408  if( cptr != nullptr ) {
409  return ptr;
410  }
411 
412  // If the parent doesn't have this variable, then we're done already:
413  if( ! m_parentLink.isValid() ) {
414  return ptr;
415  }
416  const void* pptr = m_parentLink->getData( auxid );
417  if( ! pptr ) {
418  return ptr;
419  }
420 
421  // If the variable does exist in the parent, then copy it over to this
422  // store before returning.
423 
424  // Get the registry:
426 
427  // Get the type of this variable:
428  const std::type_info* type = reg.getType( auxid );
429  if( type == nullptr ) {
430  std::ostringstream message;
431  message << "Couldn't find the type of auxiliary ID " << auxid;
432  throw std::runtime_error( message.str() );
433  }
434 
435  // And the allocator type for this variable.
436  const std::type_info* allocType = reg.getAllocType( auxid );
437  if( allocType == nullptr ) {
438  std::ostringstream message;
439  message << "Couldn't find the allocator type of auxiliary ID " << auxid;
440  throw std::runtime_error( message.str() );
441  }
442 
443  // First let's get the vector factory of this variable:
444  const SG::IAuxTypeVectorFactory* factory =
446  if( factory == nullptr ) {
447  std::ostringstream message;
448  message << "Couldn't find a factory for type " << type->name();
449  throw std::runtime_error( message.str() );
450  }
451 
452  // Copy each element of the parent's decoration:
453  factory->copy( auxid,
454  SG::AuxVectorInterface( *this ), 0,
456 
457  // Now we're done:
458  return ptr;
459  }

◆ getData() [3/3]

virtual const void* SG::IConstAuxStore::getData
inherited

Pick up the const version from the base class.

◆ getDecoration()

void * xAOD::ShallowAuxContainer::getDecoration ( auxid_t  auxid,
size_t  size,
size_t  capacity 
)
overridevirtual

Return the data vector for one aux data decoration item.

Implements SG::IConstAuxStore.

Definition at line 258 of file ShallowAuxContainer.cxx.

260  {
261 
262  guard_t guard( m_mutex );
263 
264  // Check if we already have this variable by any chance.
265  const void* cptr = m_store->getData( auxid );
266 
267  // If the parent has such a variable, then we need to check one more
268  // thing. If it's a decoration on the parent, then we should be allowed
269  // to override it in this (possibly locked) shallow copy. But let's leave
270  // the logic of this up to the parent.
271  if( m_locked && m_parentLink.isValid() &&
272  ( m_parentLink->getAuxIDs().count( auxid ) > 0 ) )
273  {
274  if (!m_parentLink->isDecoration (auxid)) {
275  throw SG::ExcStoreLocked (auxid);
276  }
277  }
278 
279  // If we got this far without any exception, then let the internal store
280  // try to provide the decoration for us:
281  const size_t nids = m_store->getAuxIDs().size();
282  void* result = m_store->getDecoration( auxid, size, capacity );
283  if( result && ( nids != m_store->getAuxIDs().size() ) ) {
284  remakeAuxIDs();
285  }
286 
287  // If we already had this variable before, then don't try to overwrite it
288  // with the parent's payload, and finish here already.
289  if( cptr != nullptr ) {
290  return result;
291  }
292 
293  // If the parent doesn't have this variable, then we're done.
294  if( ! m_parentLink.isValid() ) {
295  return result;
296  }
297  const void* pptr = m_parentLink->getData( auxid );
298  if( pptr == nullptr ) {
299  return result;
300  }
301 
302  // If the variable does exist in the parent, then copy it over to this
303  // store before returning.
304 
305  // Get the registry.
307 
308  // Get the type of this variable.
309  const std::type_info* type = reg.getType( auxid );
310  if( type == nullptr ) {
311  std::ostringstream message;
312  message << "Couldn't find the type of auxiliary ID " << auxid;
313  throw std::runtime_error( message.str() );
314  }
315 
316  // And the allocator type for this variable.
317  const std::type_info* allocType = reg.getAllocType( auxid );
318  if( allocType == nullptr ) {
319  std::ostringstream message;
320  message << "Couldn't find the allocator type of auxiliary ID " << auxid;
321  throw std::runtime_error( message.str() );
322  }
323 
324  // Get the vector factory of this variable.
325  const SG::IAuxTypeVectorFactory* factory =
327  if( factory == nullptr ) {
328  std::ostringstream message;
329  message << "Couldn't find a factory for type " << type->name();
330  throw std::runtime_error( message.str() );
331  }
332 
333  // Copy each element of the parent's decoration.
334  factory->copy( auxid,
335  SG::AuxVectorInterface( *this ), 0,
337 
338  // Now we're done.
339  return result;
340  }

◆ getDecorIDs()

const ShallowAuxContainer::auxid_set_t & xAOD::ShallowAuxContainer::getDecorIDs ( ) const
overridevirtual

Get the types(names) of decorations handled by this container.

Implements SG::IConstAuxStore.

Definition at line 237 of file ShallowAuxContainer.cxx.

237  {
238 
239  guard_t guard( m_mutex );
240  if (!m_auxidsValid) {
241  remakeAuxIDs();
242  }
243  return m_decorids;
244  }

◆ getDynamicAuxIDs()

const ShallowAuxContainer::auxid_set_t & xAOD::ShallowAuxContainer::getDynamicAuxIDs ( ) const
overridevirtual

Get the types(names) of variables created dynamically.

Implements SG::IAuxStoreIO.

Definition at line 563 of file ShallowAuxContainer.cxx.

563  {
564 
565  if( m_shallowIO ) {
566  if( m_storeIO ) {
567  return m_store->getAuxIDs();
568  } else {
569  static const auxid_set_t dummy (0);
570  return dummy;
571  }
572  } else {
573  return getAuxIDs();
574  }
575  }

◆ getIOData()

const void * xAOD::ShallowAuxContainer::getIOData ( auxid_t  auxid) const
overridevirtual

Get a pointer to the data being stored for one aux data item.

Implements SG::IAuxStoreIO.

Definition at line 510 of file ShallowAuxContainer.cxx.

510  {
511 
512  guard_t guard (m_mutex);
513  // Do we have it?
514  if( m_storeIO && m_store->getAuxIDs().test (auxid)) {
515  return m_storeIO->getIOData( auxid );
516  }
517 
518  // Do we have a parent that has it?
519  const SG::IAuxStoreIO* parentIO = m_parentIO;
520  if( ( parentIO == nullptr ) && m_parentLink.isValid() ) {
521  parentIO =
522  dynamic_cast< const SG::IAuxStoreIO* >( m_parentLink.cptr() );
523  }
524  if( parentIO ) {
525  return parentIO->getIOData( auxid );
526  }
527 
528  // If not, then where did this variable come from?!?
529  std::cerr << "ERROR xAOD::ShallowAuxContainer::getIOData Unknown "
530  << "variable ("
532  << ") requested" << std::endl;
533  return nullptr;
534  }

◆ getIOType()

const std::type_info * xAOD::ShallowAuxContainer::getIOType ( auxid_t  auxid) const
overridevirtual

Return the type of the data to be stored for one aux data item.

Implements SG::IAuxStoreIO.

Definition at line 536 of file ShallowAuxContainer.cxx.

536  {
537 
538  guard_t guard (m_mutex);
539  // Do we have it?
540  if( m_storeIO && m_store->getAuxIDs().test (auxid)) {
541  return m_storeIO->getIOType( auxid );
542  }
543 
544  // Do we have a parent that has it?
545  const SG::IAuxStoreIO* parentIO = m_parentIO;
546  if( ( parentIO == nullptr ) && m_parentLink.isValid() ) {
547  parentIO =
548  dynamic_cast< const SG::IAuxStoreIO* >( m_parentLink.cptr() );
549  }
550  if( parentIO ) {
551  return parentIO->getIOType( auxid );
552  }
553 
554  // If not, then where did this variable come from?!?
555  std::cerr << "ERROR xAOD::ShallowAuxContainer::getIOType Unknown "
556  << "variable ("
558  << ") requested" << std::endl;
559  return nullptr;
560  }

◆ getSelectedAuxIDs()

ShallowAuxContainer::auxid_set_t xAOD::ShallowAuxContainer::getSelectedAuxIDs ( ) const
overridevirtual

Get the IDs of the selected dynamic Aux variables (for writing)

Reimplemented from SG::IAuxStoreIO.

Definition at line 578 of file ShallowAuxContainer.cxx.

578  {
579 
580  if( m_shallowIO ) {
581  if( m_storeIO ) {
583  } else {
584  return auxid_set_t();
585  }
586  } else {
588  }
589  }

◆ getStore() [1/2]

const SG::IAuxStore * xAOD::ShallowAuxContainer::getStore ( ) const
overridevirtual

Implements SG::IAuxStoreHolder.

Definition at line 154 of file ShallowAuxContainer.cxx.

155  {
156  return m_store;
157  }

◆ getStore() [2/2]

SG::IAuxStore * xAOD::ShallowAuxContainer::getStore ( )
overridevirtual

Get the currently used internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 149 of file ShallowAuxContainer.cxx.

150  {
151  return m_store;
152  }

◆ getStoreType()

virtual AuxStoreType xAOD::ShallowAuxContainer::getStoreType ( ) const
inlineoverridevirtual

Return the type of the store object.

Implements SG::IAuxStoreHolder.

Reimplemented in xAOD::ShallowAuxInfo.

Definition at line 94 of file ShallowAuxContainer.h.

94 { return AST_ContainerStore; }

◆ getVector()

const SG::IAuxTypeVector * xAOD::ShallowAuxContainer::getVector ( SG::auxid_t  auxid) const
finaloverridevirtual

Return vector interface for one aux data item.

Implements SG::IConstAuxStore.

Definition at line 196 of file ShallowAuxContainer.cxx.

196  {
197 
198  guard_t guard( m_mutex );
199 
200  // Check if we have this variable ourselves. I use getData(...)
201  // instead of getAuxIDs(), as a dynamic store may not have connected
202  // to all the variables yet that it has available...
203  size_t nids = m_store->getAuxIDs().size();
204  const SG::IAuxTypeVector* result = m_store->getVector( auxid );
205  if( result != nullptr && result->toPtr() != nullptr ) {
206  if( nids != m_store->getAuxIDs().size() ) {
207  remakeAuxIDs();
208  }
209  return result;
210  }
211 
212  // If not, then leave it up to the parent object do deal with this:
213  if( m_parentLink.isValid() ) {
214  nids = m_parentLink->getAuxIDs().size();
215  result = m_parentLink->getVector( auxid );
216  if( result && ( nids != m_parentLink->getAuxIDs().size() ) ) {
217  remakeAuxIDs();
218  }
219  return result;
220  }
221 
222  // Apparently the variable wasn't found:
223  return nullptr;
224  }

◆ getWritableAuxIDs()

const ShallowAuxContainer::auxid_set_t & xAOD::ShallowAuxContainer::getWritableAuxIDs ( ) const
overridevirtual

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 462 of file ShallowAuxContainer.cxx.

462  {
463 
464  // Only the variables in the dynamic store are writable. Maybe not
465  // even all of those...
466  return m_store->getWritableAuxIDs();
467  }

◆ insertMove() [1/2]

bool xAOD::ShallowAuxContainer::insertMove ( size_t  pos,
IAuxStore &  other,
const SG::auxid_set_t ignore 
)
overridevirtual

Insert contents of another store via move.

Definition at line 493 of file ShallowAuxContainer.cxx.

495  {
496 
497  // Nope, not allowed...
498  throw std::runtime_error( "Trying to call insertMove on a shallow copy "
499  "container" );
500  }

◆ insertMove() [2/2]

virtual bool SG::IAuxStore::insertMove ( size_t  pos,
IAuxStore other,
const SG::auxid_set_t ignore = SG::auxid_set_t() 
)
pure virtualinherited

Move all elements from other to this store.

Parameters
posThe starting index of the insertion.
otherStore from which to do the move.
ignoreSet of variables that should not be added to the store.

Let len be the size of other. The store will be increased in size by len elements, with the elements at pos being copied to pos+len. Then, for each auxiliary variable, the entire contents of that variable for other will be moved to this store at index pos. This will be done via move semantics if possible; otherwise, it will be done with a copy. Variables present in this store but not in other will have the corresponding elements default-initialized. Variables in other but not in this store will be added unless they are in ignore.

Returns true if it is known that none of the vectors' memory moved, false otherwise.

Implemented in SG::AuxStoreInternal.

◆ isDecoration()

bool xAOD::ShallowAuxContainer::isDecoration ( auxid_t  auxid) const
overridevirtual

Test if a variable is a decoration.

Implements SG::IConstAuxStore.

Definition at line 246 of file ShallowAuxContainer.cxx.

247  {
248  guard_t guard( m_mutex );
249  if (m_parentLink.isValid()) {
250  if (m_parentLink->isDecoration (auxid)) {
251  return true;
252  }
253  }
254  return m_store->isDecoration (auxid);
255  }

◆ linkedVector() [1/3]

virtual IAuxTypeVector* SG::IAuxStore::linkedVector ( SG::auxid_t  )
inlinevirtualinherited

Reimplemented in SG::AuxStoreInternal, xAOD::AuxContainerBase, xAOD::AuxInfoBase, xAOD::TAuxStore, and xAOD::RAuxStore.

Definition at line 187 of file IAuxStore.h.

188  { return nullptr; }

◆ linkedVector() [2/3]

virtual const IAuxTypeVector* SG::IConstAuxStore::linkedVector
inlineinherited

Return interface for a linked variable.

Parameters
auxidThe ID of the parent variable.

If auxid has a linked variable, then return the IAuxTypeVector describing it. Otherwise, return nullptr. May return nullptr unconditionally if this store does not support linked variables.

Definition at line 189 of file IConstAuxStore.h.

190  { return nullptr; }

◆ linkedVector() [3/3]

virtual const IAuxTypeVector* SG::IConstAuxStore::linkedVector ( SG::auxid_t  ) const
inlinevirtualinherited

Return interface for a linked variable.

Parameters
auxidThe ID of the parent variable.

If auxid has a linked variable, then return the IAuxTypeVector describing it. Otherwise, return nullptr. May return nullptr unconditionally if this store does not support linked variables.

Reimplemented in SG::AuxStoreInternal, xAOD::TAuxStore, xAOD::AuxContainerBase, xAOD::AuxInfoBase, and xAOD::RAuxStore.

Definition at line 189 of file IConstAuxStore.h.

190  { return nullptr; }

◆ lock()

void xAOD::ShallowAuxContainer::lock ( )
overridevirtual

Lock the container.

Implements ILockable.

Definition at line 344 of file ShallowAuxContainer.cxx.

345  {
346  guard_t guard (m_mutex);
347  m_locked = true;
348  m_store->lock();
349  }

◆ lockDecoration()

void xAOD::ShallowAuxContainer::lockDecoration ( SG::auxid_t  auxid)
overridevirtual

Lock a decoration.

Implements SG::IConstAuxStore.

Definition at line 353 of file ShallowAuxContainer.cxx.

354  {
355  guard_t guard (m_mutex);
356  m_store->lockDecoration (auxid);
357  m_auxidsValid = false;
358  }

◆ name()

const char * xAOD::ShallowAuxContainer::name ( ) const

Get the name of the container instance.

Definition at line 595 of file ShallowAuxContainer.cxx.

595  {
596 
597  return m_name.c_str();
598  }

◆ operator=()

ShallowAuxContainer & xAOD::ShallowAuxContainer::operator= ( const ShallowAuxContainer rhs)

Assignment operator.

Definition at line 85 of file ShallowAuxContainer.cxx.

85  {
86 
87  // Check if anything needs to be done:
88  if( this == &rhs ) {
89  return *this;
90  }
91 
92  // Keep the source unmutable during copy
93  std::scoped_lock lck{m_mutex, rhs.m_mutex};
94 
95  // Clean up if necessary:
96  if( m_ownsStore && m_store ) {
97  delete m_store;
98  m_store = nullptr;
99  }
100 
101  m_selection = rhs.m_selection;
102  m_ownsStore = false;
103  m_store = rhs.m_store;
104  m_storeIO = rhs.m_storeIO;
105  m_locked = rhs.m_locked;
106  m_parentLink = rhs.m_parentLink;
107  m_parentIO = rhs.m_parentIO;
108  m_shallowIO = rhs.m_shallowIO;
109  m_name = rhs.m_name;
110  m_auxids = rhs.m_auxids;
111  m_auxidsValid= rhs.m_auxidsValid;
112 
113  // Return this object:
114  return *this;
115  }

◆ parent()

const DataLink< SG::IConstAuxStore > & xAOD::ShallowAuxContainer::parent ( ) const

Get the parent store.

Definition at line 117 of file ShallowAuxContainer.cxx.

117  {
118 
119  return m_parentLink;
120  }

◆ remakeAuxIDs()

void xAOD::ShallowAuxContainer::remakeAuxIDs ( ) const
private

Definition at line 606 of file ShallowAuxContainer.cxx.

606  {
608  if( m_parentLink.isValid() ) {
609  ids.insert (m_parentLink->getAuxIDs());
610  }
611  m_auxids = ids;
612 
613  auxid_set_t decors = m_store->getDecorIDs();
614  if( m_parentLink.isValid() ) {
615  ids.insert (m_parentLink->getDecorIDs());
616  }
617  m_decorids = decors;
618 
619  m_auxidsValid = true;
620  }

◆ reserve()

void xAOD::ShallowAuxContainer::reserve ( size_t  size)
overridevirtual

Reserve a given size for the arrays.

Implements SG::IAuxStore.

Definition at line 479 of file ShallowAuxContainer.cxx.

479  {
480 
481  // Nope, not allowed...
482  throw std::runtime_error( "Trying to call reserve on a shallow copy "
483  "container" );
484  }

◆ resize()

bool xAOD::ShallowAuxContainer::resize ( size_t  size)
overridevirtual

Resize the arrays to a given size.

Implements SG::IAuxStore.

Definition at line 469 of file ShallowAuxContainer.cxx.

470  {
471  if (size == this->size()) {
472  return false;
473  }
474  // Nope, not allowed...
475  throw std::runtime_error( "Trying to call resize on a shallow copy "
476  "container" );
477  }

◆ setName()

void xAOD::ShallowAuxContainer::setName ( const char name)

Set the name of the container instance.

Definition at line 600 of file ShallowAuxContainer.cxx.

600  {
601 
602  m_name = name;
603  return;
604  }

◆ setOption()

virtual bool SG::IAuxStore::setOption ( auxid_t  ,
const AuxDataOption  
)
inlinevirtualinherited

Set an option for a given auxiliary variable.

Parameters
auxidThe identifier of the desired aux data item.
optionThe option to set.

The interpretation of the option depends on the particular representation of the variable.

Returns true if the option setting was successful; false otherwise.

Reimplemented in xAOD::AuxContainerBase, xAOD::AuxInfoBase, and SG::AuxStoreInternal.

Definition at line 173 of file IAuxStore.h.

174  { return false; }

◆ setParent()

void xAOD::ShallowAuxContainer::setParent ( const DataLink< SG::IConstAuxStore > &  link)

Set the parent store.

Definition at line 122 of file ShallowAuxContainer.cxx.

123  {
124 
125  guard_t guard (m_mutex);
126  m_parentLink = link;
127  m_parentIO = dynamic_cast< const SG::IAuxStoreIO* >( m_parentLink.cptr() );
128  m_auxidsValid = false;
129  return;
130  }

◆ setShallowIO()

void xAOD::ShallowAuxContainer::setShallowIO ( bool  value)

Set whether only the overriden parameters should be written out.

Definition at line 137 of file ShallowAuxContainer.cxx.

137  {
138 
139  guard_t guard (m_mutex);
140  m_shallowIO = value;
141  return;
142  }

◆ setStore()

void xAOD::ShallowAuxContainer::setStore ( SG::IAuxStore store)
overridevirtual

Set a different internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 159 of file ShallowAuxContainer.cxx.

159  {
160 
161  // Check if anything needs to be done:
162  guard_t guard (m_mutex);
163  if( store == m_store ) return;
164 
165  if( m_ownsStore && m_store ) {
166  delete m_store;
167  m_store = nullptr;
168  }
169 
170  // Do the assignment:
171  m_store = store;
172  m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
173  m_ownsStore = true;
174  m_auxidsValid = false;
175 
176  return;
177  }

◆ shallowIO()

bool xAOD::ShallowAuxContainer::shallowIO ( ) const

Check whether only the overriden parameters will be written out or not.

Definition at line 132 of file ShallowAuxContainer.cxx.

132  {
133 
134  return m_shallowIO;
135  }

◆ shift()

void xAOD::ShallowAuxContainer::shift ( size_t  pos,
ptrdiff_t  offs 
)
overridevirtual

Shift the contents of the stored arrays.

Implements SG::IAuxStore.

Definition at line 486 of file ShallowAuxContainer.cxx.

486  {
487 
488  // Nope, not allowed...
489  throw std::runtime_error( "Trying to call shift on a shallow copy "
490  "container" );
491  }

◆ size()

size_t xAOD::ShallowAuxContainer::size ( ) const
overridevirtual

Get the size of the container.

Implements SG::IConstAuxStore.

Definition at line 360 of file ShallowAuxContainer.cxx.

360  {
361 
362  guard_t guard( m_mutex );
363  size_t sz = m_store->size();
364  if( sz > 0 ) {
365  return sz;
366  }
367  if( m_parentLink.isValid() ) {
368  return m_parentLink->size();
369  }
370  return 0;
371  }

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/3]

auxid_set_t m_auxids xAOD::ShallowAuxContainer::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 207 of file ShallowAuxContainer.h.

◆ ATLAS_THREAD_SAFE [2/3]

auxid_set_t m_decorids xAOD::ShallowAuxContainer::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 208 of file ShallowAuxContainer.h.

◆ ATLAS_THREAD_SAFE [3/3]

bool m_auxidsValid xAOD::ShallowAuxContainer::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 209 of file ShallowAuxContainer.h.

◆ m_locked

bool xAOD::ShallowAuxContainer::m_locked
private

Flag keeping track of whether this object is locked or not.

Definition at line 191 of file ShallowAuxContainer.h.

◆ m_mutex

mutex_t xAOD::ShallowAuxContainer::m_mutex
mutableprivate

Definition at line 203 of file ShallowAuxContainer.h.

◆ m_name

std::string xAOD::ShallowAuxContainer::m_name
private

Name of the container in memory. Set externally.

Definition at line 212 of file ShallowAuxContainer.h.

◆ m_ownsStore

bool xAOD::ShallowAuxContainer::m_ownsStore
private

Flag deciding if the object owns the dynamic store or not.

Definition at line 189 of file ShallowAuxContainer.h.

◆ m_parentIO

const SG::IAuxStoreIO* xAOD::ShallowAuxContainer::m_parentIO
private

Optional pointer to the IO interface of the parent object.

Definition at line 196 of file ShallowAuxContainer.h.

◆ m_parentLink

DataLink< SG::IConstAuxStore > xAOD::ShallowAuxContainer::m_parentLink
private

Link to the parent object.

Definition at line 194 of file ShallowAuxContainer.h.

◆ m_selection

AuxSelection xAOD::ShallowAuxContainer::m_selection
private

Dynamic attributes selection implementation.

Definition at line 182 of file ShallowAuxContainer.h.

◆ m_shallowIO

bool xAOD::ShallowAuxContainer::m_shallowIO
private

Flag for whether to do "shallow IO" or not.

Definition at line 198 of file ShallowAuxContainer.h.

◆ m_store

SG::IAuxStore* xAOD::ShallowAuxContainer::m_store
private

Internal dynamic auxiliary store object.

Definition at line 185 of file ShallowAuxContainer.h.

◆ m_storeIO

SG::IAuxStoreIO* xAOD::ShallowAuxContainer::m_storeIO
private

The IO interface to the internal auxiliary store.

Definition at line 187 of file ShallowAuxContainer.h.

◆ supportsThinning

constexpr bool SG::IAuxStore::supportsThinning = true
staticconstexprinherited

Mark that this type supports thinning operations.

See AthContainers/supportsThinning.h and AthenaPoolCnvSvc/T_AthenaPoolCnv.h. Helps guide which pool converter template will be used. If false, the default pool converter will be used rather than the aux store-specific one. Ordinary xAOD type should not touch this, but may be overridden in a derived class to handle certain special cases.

Definition at line 199 of file IAuxStore.h.


The documentation for this class was generated from the following files:
SG::AuxTypeRegistry::getFactory
const IAuxTypeVectorFactory * getFactory(const std::type_info &ti, const std::type_info &ti_alloc)
Return the vector factory for a given vector element type.
Definition: AuxTypeRegistry.cxx:1110
SGTest::store
TestStore store
Definition: TestStore.cxx:23
SG::IConstAuxStore::getData
virtual const void * getData(SG::auxid_t auxid) const =0
Return the data vector for one aux data item.
SG::IConstAuxStore::lockDecoration
virtual void lockDecoration(SG::auxid_t auxid)=0
Lock a decoration.
fitman.sz
sz
Definition: fitman.py:527
get_generator_info.result
result
Definition: get_generator_info.py:21
CxxUtils::ConcurrentBitset::count
bit_t count() const
Count the number of 1 bits in the set.
SG::IConstAuxStore::getVector
virtual const IAuxTypeVector * getVector(SG::auxid_t auxid) const =0
Return vector interface for one aux data item.
L1CaloPhase1Monitoring.standalone
standalone
Definition: L1CaloPhase1Monitoring.py:112
SG::AuxTypeRegistry::instance
static AuxTypeRegistry & instance()
Return the singleton registry instance.
Definition: AuxTypeRegistry.cxx:639
xAOD::ShallowAuxContainer::parent
const DataLink< SG::IConstAuxStore > & parent() const
Get the parent store.
Definition: ShallowAuxContainer.cxx:117
SG::AuxTypeRegistry::getName
std::string getName(SG::auxid_t auxid) const
Return the name of an aux data item.
Definition: AuxTypeRegistry.cxx:881
SG::ExcStoreLocked
Exception — Attempted to modify auxiliary data in a locked store.
Definition: Control/AthContainers/AthContainers/exceptions.h:183
xAOD::ShallowAuxContainer::getVector
virtual const SG::IAuxTypeVector * getVector(SG::auxid_t auxid) const override final
Return vector interface for one aux data item.
Definition: ShallowAuxContainer.cxx:196
xAOD::ShallowAuxContainer::guard_t
AthContainers_detail::lock_guard< mutex_t > guard_t
Definition: ShallowAuxContainer.h:202
SG::AuxTypeRegistry::getAllocType
const std::type_info * getAllocType(SG::auxid_t auxid) const
Return the type of the vector allocator.
Definition: AuxTypeRegistry.cxx:964
athena.value
value
Definition: athena.py:124
xAOD::ShallowAuxContainer::name
const char * name() const
Get the name of the container instance.
Definition: ShallowAuxContainer.cxx:595
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
xAOD::ShallowAuxContainer::m_selection
AuxSelection m_selection
Dynamic attributes selection implementation.
Definition: ShallowAuxContainer.h:182
xAOD::ShallowAuxContainer::m_shallowIO
bool m_shallowIO
Flag for whether to do "shallow IO" or not.
Definition: ShallowAuxContainer.h:198
SG::IAuxStoreIO::getIOType
virtual const std::type_info * getIOType(SG::auxid_t auxid) const =0
Return the type of the data to be stored for one aux data item.
xAOD::ShallowAuxContainer::size
virtual size_t size() const override
Get the size of the container.
Definition: ShallowAuxContainer.cxx:360
ReweightUtils.message
message
Definition: ReweightUtils.py:15
SG::IConstAuxStore::size
virtual size_t size() const =0
Return the number of elements in the store.
xAOD::ShallowAuxContainer::m_ownsStore
bool m_ownsStore
Flag deciding if the object owns the dynamic store or not.
Definition: ShallowAuxContainer.h:189
SG::IAuxStoreIO
Interface providing I/O for a generic auxiliary store.
Definition: IAuxStoreIO.h:44
SG::AuxTypeRegistry
Handle mappings between names and auxid_t.
Definition: AuxTypeRegistry.h:61
xAOD::ShallowAuxContainer::m_name
std::string m_name
Name of the container in memory. Set externally.
Definition: ShallowAuxContainer.h:212
SG::AuxTypeRegistry::getType
const std::type_info * getType(SG::auxid_t auxid) const
Return the type of an aux data item.
Definition: AuxTypeRegistry.cxx:908
xAOD::ShallowAuxContainer::m_parentLink
DataLink< SG::IConstAuxStore > m_parentLink
Link to the parent object.
Definition: ShallowAuxContainer.h:194
CxxUtils::ConcurrentBitset::size
bit_t size() const
Count the number of 1 bits in the set.
SG::IConstAuxStore::clearDecorations
virtual bool clearDecorations()=0
Clear all decorations.
xAOD::ShallowAuxContainer::m_mutex
mutex_t m_mutex
Definition: ShallowAuxContainer.h:203
SG::IAuxTypeVectorFactory
Interface for factory objects that create vectors.
Definition: IAuxTypeVectorFactory.h:50
xAOD::ShallowAuxContainer::m_storeIO
SG::IAuxStoreIO * m_storeIO
The IO interface to the internal auxiliary store.
Definition: ShallowAuxContainer.h:187
python.xAODType.dummy
dummy
Definition: xAODType.py:4
SG::IConstAuxStore::getDecoration
virtual void * getDecoration(auxid_t auxid, size_t size, size_t capacity)=0
Return the data vector for one aux data decoration item.
SG::IAuxTypeVectorFactory::copy
virtual void copy(SG::auxid_t auxid, AuxVectorData &dst, size_t dst_index, const AuxVectorData &src, size_t src_index, size_t n) const =0
Copy elements between vectors.
xAOD::ShallowAuxContainer::getAuxIDs
virtual const auxid_set_t & getAuxIDs() const override
Get the types(names) of variables handled by this container.
Definition: ShallowAuxContainer.cxx:227
python.subdetectors.mmg.ids
ids
Definition: mmg.py:8
xAOD::ShallowAuxContainer::m_parentIO
const SG::IAuxStoreIO * m_parentIO
Optional pointer to the IO interface of the parent object.
Definition: ShallowAuxContainer.h:196
xAOD::ShallowAuxContainer::m_locked
bool m_locked
Flag keeping track of whether this object is locked or not.
Definition: ShallowAuxContainer.h:191
SG::IAuxStoreIO::getIOData
virtual const void * getIOData(SG::auxid_t auxid) const =0
Return a pointer to the data to be stored for one aux data item.
SG::IAuxStore::getWritableAuxIDs
virtual const SG::auxid_set_t & getWritableAuxIDs() const =0
Return a set of identifiers for writable data items in this store.
SG::IAuxStore
Interface for non-const operations on an auxiliary store.
Definition: IAuxStore.h:48
SG::AuxStoreInternal
An auxiliary data store that holds data internally.
Definition: AuxStoreInternal.h:43
python.PyAthena.v
v
Definition: PyAthena.py:154
SG::AuxVectorInterface
Make an AuxVectorData object from either a raw array or an aux store.
Definition: AuxVectorInterface.h:33
SG::IAuxStore::getData
virtual void * getData(auxid_t auxid, size_t size, size_t capacity)=0
Return the data vector for one aux data item.
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
SG::IAuxTypeVector
Abstract interface for manipulating vectors of arbitrary types.
Definition: IAuxTypeVector.h:42
SG::IConstAuxStore::getDecorIDs
virtual const SG::auxid_set_t & getDecorIDs() const =0
Return a set of identifiers for decorations in this store.
SG::IConstAuxStore::lock
virtual void lock()=0
Lock the container.
xAOD::ShallowAuxContainer::auxid_set_t
SG::auxid_set_t auxid_set_t
The aux ID set type definition.
Definition: ShallowAuxContainer.h:60
xAOD::ShallowAuxContainer::m_store
SG::IAuxStore * m_store
Internal dynamic auxiliary store object.
Definition: ShallowAuxContainer.h:185
SG::IConstAuxStore::isDecoration
virtual bool isDecoration(auxid_t auxid) const =0
Test if a particular variable is tagged as a decoration.
xAOD::AuxSelection::getSelectedAuxIDs
virtual SG::auxid_set_t getSelectedAuxIDs(const SG::auxid_set_t &fullset) const
Return which variables were selected to be written out.
Definition: AuxSelection.cxx:62
SG::IAuxStoreHolder::AST_ObjectStore
@ AST_ObjectStore
The store describes a single object.
Definition: IAuxStoreHolder.h:67
SG::IAuxStoreHolder
Interface for objects taking part in direct ROOT I/O.
Definition: IAuxStoreHolder.h:36
xAOD::ShallowAuxContainer::remakeAuxIDs
void remakeAuxIDs() const
Definition: ShallowAuxContainer.cxx:606
SG::IConstAuxStore::getAuxIDs
virtual const SG::auxid_set_t & getAuxIDs() const =0
Return a set of identifiers for existing data items in this store.
SG::IAuxStoreHolder::AST_ContainerStore
@ AST_ContainerStore
The store describes a container.
Definition: IAuxStoreHolder.h:68
CxxUtils::ConcurrentBitset::test
bool test(bit_t bit) const
Test to see if a bit is set.