AuxContainerBase.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef XAODCORE_AUXCONTAINERBASE_H
#define XAODCORE_AUXCONTAINERBASE_H
 
// STL include(s):
#include <vector>
#include <string>
#include <memory>
 
// EDM include(s):
#include "AthContainersInterfaces/IAuxStore.h"
#include "AthContainersInterfaces/IAuxStoreIO.h"
#include "AthContainersInterfaces/IAuxStoreHolder.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/tools/threading.h"
#include "AthContainers/PackedContainer.h"
#include "CxxUtils/CachedPointer.h"
#include "CxxUtils/checker_macros.h"
#ifndef XAOD_STANDALONE
#   include "AthenaKernel/ILockable.h"
#endif // not XAOD_STANDALONE
 
// Local include(s):
#include "xAODCore/AuxSelection.h"
 
// Forward declaration(s):
namespace SG {
   class IAuxTypeVector;
}
class xAODAuxContainerBaseCnv;
namespace std { namespace pmr {
class memory_resource;
}}
 
namespace xAOD {
 
   class AuxContainerBase : public SG::IAuxStore,
                            public SG::IAuxStoreIO,
                            public SG::IAuxStoreHolder
#ifndef XAOD_STANDALONE
                          , public ILockable
#endif // not XAOD_STANDALONE
   {
 
   public:
      typedef SG::auxid_t auxid_t;
      typedef SG::auxid_set_t auxid_set_t;
 
      AuxContainerBase( bool allowDynamicVars = true );
      AuxContainerBase( std::pmr::memory_resource* memResource,
                        bool allowDynamicVars = true );
      AuxContainerBase( const AuxContainerBase& parent );
      AuxContainerBase( SG::IAuxStore* store,
                        std::pmr::memory_resource* memResource = nullptr );
      ~AuxContainerBase();
 
      AuxContainerBase& operator=( const AuxContainerBase& rhs );
 
 
      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; }
 
      std::pmr::memory_resource* memResource();
 
 
 
      virtual const void* getData( auxid_t auxid ) const override;
 
      virtual const auxid_set_t& getAuxIDs() 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 const SG::IAuxTypeVector* linkedVector (SG::auxid_t auxid) const 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 bool setOption( auxid_t id, const SG::AuxDataOption& option ) override;
 
      virtual SG::IAuxTypeVector* linkedVector (SG::auxid_t auxid) 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 SG::auxid_set_t getSelectedAuxIDs() const override;
 
 
 
      const char* name() const;
      void setName( const char* name );
 
 
      template <class T, class ALLOC = std::allocator<T> >
      using AuxVariable_t = std::vector<T, ALLOC>;
      template <class T, class ALLOC = std::allocator<T> >
      using LinkedVariable_t = AuxVariable_t<T, ALLOC>;
 
      template< typename T, typename ALLOC >
      auxid_t getAuxID( const std::string& name,
                        std::vector< T, ALLOC >& /*vec*/,
                        SG::AuxVarFlags flags =
                        SG::AuxVarFlags::None,
                        const SG::auxid_t linkedVariable = SG::null_auxid );
      template< typename T >
      auxid_t getAuxID( const std::string& name,
                        SG::PackedContainer< T >& /*vec*/,
                        SG::AuxVarFlags flags =
                        SG::AuxVarFlags::None,
                        const SG::auxid_t linkedVariable = SG::null_auxid );
      template< typename T, typename ALLOC >
      void regAuxVar( auxid_t auxid, const std::string& name,
                      std::vector< T, ALLOC >& vec );
 
      template< typename T >
      void regAuxVar( auxid_t auxid, const std::string& name,
                      SG::PackedContainer< T >& vec );
 
   private:
      friend class ::xAODAuxContainerBaseCnv;
 
      template< typename ELT, typename CONT >
      void regAuxVar1( auxid_t auxid, const std::string& name,
                       CONT& vec );
 
      auxid_set_t m_auxids;
      std::vector< SG::IAuxTypeVector* > m_vecs;
 
      SG::IAuxStore* m_store;
      SG::IAuxStoreIO* m_storeIO;
      bool m_ownsStore;
      bool m_locked;
 
      typedef AthContainers_detail::mutex mutex_t;
      typedef AthContainers_detail::lock_guard< mutex_t > guard_t;
      mutable mutex_t m_mutex;
 
      std::string m_name;
 
      mutable CxxUtils::CachedPointer<std::pmr::memory_resource> m_memResource ATLAS_THREAD_SAFE;
 
   }; // class AuxContainerBase
 
} // namespace xAOD
 
// Declare a class ID for the class:
#include "xAODCore/CLASS_DEF.h"
CLASS_DEF( xAOD::AuxContainerBase, 1225080690, 3 )
 
// Describe the inheritance of the class:
#include "xAODCore/BaseInfo.h"
SG_BASES3( xAOD::AuxContainerBase, SG::IAuxStore, SG::IAuxStoreIO,
           SG::IAuxStoreHolder );
 
// Include the template implementation:
#include "AuxContainerBase.icc"
 
#endif // XAODCORE_AUXCONTAINERBASE_H