ShallowAuxContainer.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: ShallowAuxContainer.h 793737 2017-01-24 20:11:10Z ssnyder $
#ifndef XAODCORE_SHALLOWAUXCONTAINER_H
#define XAODCORE_SHALLOWAUXCONTAINER_H
 
// EDM include(s):
#include "AthLinks/DataLink.h"
#include "AthContainersInterfaces/IAuxStore.h"
#include "AthContainersInterfaces/IAuxStoreIO.h"
#include "AthContainersInterfaces/IAuxStoreHolder.h"
#include "AthContainers/tools/threading.h"
#include "SGCore/ILockable.h"
#include "CxxUtils/checker_macros.h"
 
// Local include(s):
#include "xAODCore/AuxSelection.h"
 
namespace xAOD {

   class ShallowAuxContainer : public SG::IAuxStore,
                               public SG::IAuxStoreIO,
                               public SG::IAuxStoreHolder,
                               public ILockable
   {
 
   public:
      typedef SG::auxid_t auxid_t;
      typedef SG::auxid_set_t auxid_set_t;

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

      ShallowAuxContainer& operator= ( const ShallowAuxContainer& rhs );

      const DataLink< SG::IConstAuxStore >& parent() const;
      void setParent( const DataLink< SG::IConstAuxStore >& link );

      bool shallowIO() const;
      void setShallowIO( bool value );


      virtual SG::IAuxStore* getStore() override;
      virtual const SG::IAuxStore* getStore() const override;
      virtual void setStore( SG::IAuxStore* store ) override;
      virtual AuxStoreType getStoreType() const override { return AST_ContainerStore; }



      virtual const void* getData( auxid_t auxid ) const override;

      virtual const SG::IAuxTypeVector* getVector (SG::auxid_t auxid) const override final;

      virtual const auxid_set_t& getAuxIDs() const override;

      virtual const auxid_set_t& getDecorIDs() const override;

      virtual bool isDecoration (auxid_t auxid) const override;

      virtual void* getDecoration (auxid_t auxid, size_t size, size_t capacity) override;
      virtual void lock() override;
      virtual bool clearDecorations() override;
      virtual size_t size() const override;
      virtual void lockDecoration (SG::auxid_t auxid) override;


      virtual void* getData( auxid_t auxid, size_t size,
                             size_t capacity ) override;

      virtual const auxid_set_t& getWritableAuxIDs() const override;

      virtual bool resize( size_t size ) override;
      virtual void reserve( size_t size ) override;
      virtual void shift( size_t pos, ptrdiff_t offs ) override;
      virtual bool insertMove (size_t pos,
                               IAuxStore& other,
                               const SG::auxid_set_t& ignore) override;



      virtual const void* getIOData( auxid_t auxid ) const override;

      virtual const std::type_info* getIOType( auxid_t auxid ) const override;

      virtual const auxid_set_t& getDynamicAuxIDs() const override;

      virtual auxid_set_t getSelectedAuxIDs() const override;



      const char* name() const;
      void setName( const char* name );

 
   private:
      void remakeAuxIDs() const;

      AuxSelection m_selection;

      SG::IAuxStore* m_store;
      SG::IAuxStoreIO* m_storeIO;
      bool m_ownsStore;
      bool m_locked;

      DataLink< SG::IConstAuxStore > m_parentLink;
      const SG::IAuxStoreIO* m_parentIO;
      bool m_shallowIO;

      typedef AthContainers_detail::recursive_mutex mutex_t;
      typedef AthContainers_detail::lock_guard<mutex_t> guard_t;
      mutable mutex_t m_mutex;
 
      // Mutable is thread-safe since we lock access, and the object
      // is a ConcurrentBitset.
      mutable auxid_set_t m_auxids ATLAS_THREAD_SAFE;
      mutable auxid_set_t m_decorids ATLAS_THREAD_SAFE;
      mutable bool m_auxidsValid ATLAS_THREAD_SAFE;

      std::string m_name;
 
   }; // class ShallowAuxContainer
 
} // namespace xAOD
 
// Declare a class ID for the class:
#include "xAODCore/CLASS_DEF.h"
CLASS_DEF( xAOD::ShallowAuxContainer, 1111823638, 1 )
 
// Describe the inheritance of the class:
#include "xAODCore/BaseInfo.h"
SG_BASES3( xAOD::ShallowAuxContainer, SG::IAuxStore, SG::IAuxStoreIO,
           SG::IAuxStoreHolder );
 
#endif // XAODCORE_SHALLOWAUXCONTAINER_H