ByteStreamAuxContainer_v1.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 XAODTRIGGER_VERSIONS_BYTESTREAMAUXCONTAINER_V1_H
#define XAODTRIGGER_VERSIONS_BYTESTREAMAUXCONTAINER_V1_H
 
// STL include(s):
#include <vector>
#include <map>
#include <string>
 
// EDM include(s):
#include "AthContainersInterfaces/IAuxStore.h"
#include "AthContainers/tools/threading.h"
#include "CxxUtils/checker_macros.h"
#ifndef XAOD_STANDALONE
#   include "AthenaKernel/ILockable.h"
#endif
 
// Forward declaration(s):
namespace SG {
   class IAuxTypeVector;
}
 
namespace xAOD {
 
   class ByteStreamAuxContainer_v1
     : public SG::IAuxStore
#ifndef XAOD_STANDALONE
     , public ILockable
#endif
   {
 
   public:
      typedef SG::auxid_t auxid_t;
      typedef SG::auxid_set_t auxid_set_t;
 
      ByteStreamAuxContainer_v1();
      ByteStreamAuxContainer_v1( const ByteStreamAuxContainer_v1& parent );
      virtual ~ByteStreamAuxContainer_v1();
 
      ByteStreamAuxContainer_v1&
      operator=( const ByteStreamAuxContainer_v1& rhs );
 
 
      virtual const void* getData( auxid_t auxid ) const override;
 
      virtual const SG::IAuxTypeVector* getVector( auxid_t auxid ) const override final;
 
      virtual const auxid_set_t& getAuxIDs() const override;
 
      virtual const auxid_set_t& getDecorIDs() const override;
 
      virtual void* getDecoration (auxid_t auxid, size_t size, size_t capacity) override;
 
      virtual bool isDecoration (auxid_t auxid) const override;
 
      virtual void lock() override;
 
      virtual bool clearDecorations() override;
 
      virtual void lockDecoration (SG::auxid_t auxid) override;
 
      virtual size_t size() 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;
 
 
      void reset();
 
 
      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< typename T >
      auxid_t getAuxID( const std::string& name,
                        std::vector< T >& /*vec*/,
                        SG::AuxVarFlags flags =
                        SG::AuxVarFlags::None );
      template< typename T >
      void regAuxVar( auxid_t auxid, const std::string& name,
                      std::vector< T >& vec );
 
   private:
      size_t size_noLock() const;
 
      template< typename T >
      SG::IAuxTypeVector* getVector1( auxid_t auxid,
                                      std::map< std::string, std::vector< T > >& pers,
                                      size_t size, size_t capacity, bool quiet,
                                      bool forDecor) const;
 
      SG::IAuxTypeVector* getVector1( auxid_t auxid,
                                      size_t size, size_t capacity, bool quiet,
                                      bool forDecor ) const;
 
 
      mutable std::map< std::string, std::vector< int > > m_int ATLAS_THREAD_SAFE;
      mutable std::map< std::string, std::vector< float > > m_float ATLAS_THREAD_SAFE;
      mutable std::map< std::string, std::vector< std::vector< int > > > m_vecInt ATLAS_THREAD_SAFE;
      mutable std::map< std::string, std::vector< std::vector< float > > > m_vecFloat ATLAS_THREAD_SAFE;
 
 
 
      mutable auxid_set_t m_auxids ATLAS_THREAD_SAFE;
      std::vector< SG::IAuxTypeVector* > m_staticVecs;
      mutable std::vector< SG::IAuxTypeVector* > m_dynamicVecs ATLAS_THREAD_SAFE;
      bool m_locked;
      SG::auxid_set_t m_decorations;
 
      typedef AthContainers_detail::mutex mutex_t;
      typedef AthContainers_detail::lock_guard<mutex_t> guard_t;
      mutable mutex_t m_mutex;
 
 
      std::string m_name;
 
   }; // class ByteStreamAuxContainer_v1
 
} // namespace xAOD
 
// Declare the inheritace of the container:
#include "xAODCore/BaseInfo.h"
SG_BASE( xAOD::ByteStreamAuxContainer_v1, SG::IAuxStore );
 
 
// Include the template implementation:
#include "ByteStreamAuxContainer_v1.icc"
 
#endif // XAODTRIGGER_VERSIONS_BYTESTREAMAUXCONTAINER_V1_H