StoreGateSvc.h

Go to the documentation of this file.

/* -*- C++ -*- */
 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef STOREGATE_STOREGATESVC_H
#define STOREGATE_STOREGATESVC_H
 
//FIXME the CLASS_DEF header is not needed here but was added to work around
//bad include statements in client code: when using CLASS_DEF put the
//include below in your header file!
#include "AthenaKernel/CLASS_DEF.h"
 
#include "GaudiKernel/Service.h"
#include "GaudiKernel/SmartIF.h"
#include "AthenaKernel/IProxyDict.h"
 
#include "AthenaKernel/IHiveStore.h"
#include "AthenaKernel/IHiveStoreMgr.h"
#include "CxxUtils/RefCountedPtr.h"
#include "StoreGate/tools/SGImplSvc.h"
#include "StoreGate/SGHiveEventSlot.h"
 
#include <GaudiKernel/ClassID.h>        // for CLID
#include <GaudiKernel/IMessageSvc.h>    // for Level
#include "Gaudi/Property.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/DataObjID.h"
#include "GaudiKernel/IAlgContextSvc.h"
 
#include <cstddef>                     // for size_t
#include <list>
#include <memory>                     
#include <mutex>                       
#include <string>
#include <sys/types.h>                  // for off_t
#include <vector>                       
#include <type_traits>
 
#include "AthenaKernel/StoreID.h"
#include "AthenaKernel/DefaultKey.h"
#include "AthAllocators/Arena.h"
 
#include <SGTools/StringPool.h> 
#include "SGTools/ProxyMap.h" /* for SG::ConstProxyIterator */
 
// includes used in StoreGateSvc.icc
#include "GaudiKernel/IClassIDSvc.h"
#include "AthenaKernel/IResetable.h"
#include "AthenaKernel/IIOVSvc.h"
#include "StoreGate/SGIterator.h"
#include "StoreGate/DataHandle.h"
#include "StoreGate/SGWPtr.h"
#include "StoreGate/SGObjectWithVersion.h"
#include "CxxUtils/checker_macros.h"
 
#include "GaudiKernel/IIncidentListener.h"
 
#include "StoreGate/constraints/KeyConcept.h"
 
//forward declarations
namespace SG {
  class DataProxy;
  class TransientAddress;
  struct RemapImpl;
  class TestHiveStoreSvc;
  class HiveMgrSvc; 
}
namespace xAODMaker {
  class AuxStoreWrapper;
}
 
class DataObject;
class IConversionSvc;
class IIncidentSvc;
class IProxyProviderSvc;
class IHistorySvc;
 
// python forward
struct _object; typedef _object PyObject;
class StoreGateSvc;
namespace AthenaInternal {
  PyObject* recordObjectToStore(StoreGateSvc*,PyObject*,PyObject*,bool,bool,bool);
  void py_sg_clearProxyPayload(StoreGateSvc* self, SG::DataProxy*);
}
namespace SG {
  class NoAuxStore;
}
 
//friends...
class AthenaOutputStream;
class IOVDbSvc;
class IOVSvcTool;
class PileUpMergeSvc;
namespace SG {
  class VarHandleBase; 
}

class StoreGateSvc : public extends<Service,
                                    IProxyDict,
                                    IHiveStore,
                                    IHiveStoreMgr,
                                    IIncidentListener>
{
 
public:

  
 
  template <typename T, typename TKEY, typename... ARGS>
  SG::WPtr<T> create(const TKEY& key, ARGS... constructorArgs);



  template <typename T, typename TKEY> 
  StatusCode record(T* p2BRegistered, const TKEY& key);

  template <typename T, typename TKEY> 
  StatusCode record(const T* p2BRegistered, const TKEY& key);
 

  template <typename T, typename TKEY> 
  StatusCode record(T* p2BRegistered, const TKEY& key, 
                    bool allowMods, bool resetOnly=true, bool noHist=false);

  template <typename T, typename TKEY> 
  StatusCode record(std::unique_ptr<T> pUnique, const TKEY& key);

  template <typename T, typename TKEY> 
  StatusCode record(std::unique_ptr<const T> pUnique, const TKEY& key);

  template <typename T, typename TKEY> 
  StatusCode record(std::unique_ptr<T> pUnique, const TKEY& key, 
                    bool allowMods, bool resetOnly=true, bool noHist=false);




  template <typename T> 
  StatusCode retrieve(const T*& ptr) const;

  template <typename T>
  StatusCode retrieve(T*& ptr) const;

  template <typename T>
  T* retrieve () const;

  template <typename T>
  T* tryRetrieve () const;
  template <typename T>
  const T* tryConstRetrieve() const;

  template <typename T, typename TKEY> 
  StatusCode retrieve(const T*& ptr, const TKEY& key) const requires KeyConcept<TKEY>;

  template <typename T>
  StatusCode retrieve(const T*& ptr, const std::string& key) const;
 

  template <typename T, typename TKEY>
  StatusCode retrieve(T*& ptr, const TKEY& key) const  requires KeyConcept<TKEY>;

  template <typename T>
  StatusCode retrieve(T*& ptr, const std::string& key) const;
 

  template <typename T, class TKEY>
  T* retrieve (const TKEY& key) const;

  template <typename T, class TKEY>
  T* tryRetrieve (const TKEY& key) const requires KeyConcept<TKEY>;
  template <typename T, class TKEY>
  const T* tryConstRetrieve(const TKEY& key) const requires KeyConcept<TKEY>;
 
 

  template <typename T> 
  StatusCode retrieve(SG::ConstIterator<T>& begin, 
                      SG::ConstIterator<T>& end) const;

  template <typename T, typename TKEY> 
  bool contains(const TKEY& key) const;

  template <typename T, typename TKEY> 
  StatusCode bind ATLAS_NOT_THREAD_SAFE (const DataHandle<T>& handle, const TKEY& key);




  template <typename T, typename TKEY> 
  StatusCode overwrite(T* p2BRegistered, const TKEY& key);

  template <typename T, typename TKEY> 
  StatusCode overwrite(T* p2BRegistered, const TKEY& key, 
                       bool allowMods, bool noHist=false);
 

  template <typename T, typename TKEY> 
  StatusCode overwrite(std::unique_ptr<T> pUnique, const TKEY& key, 
                       bool allowMods, bool noHist=false);

  template <typename T, typename TKEY> 
  StatusCode overwrite(std::unique_ptr<T> pUnique, const TKEY& key);

  StatusCode recordAddress(const std::string& skey,
                           CxxUtils::RefCountedPtr<IOpaqueAddress> pAddress,
                           bool clearAddressFlag=true);
  StatusCode recordAddress(CxxUtils::RefCountedPtr<IOpaqueAddress> pAddress,
                           bool clearAddressFlag=true);

  template <typename T, typename TLINK> 
  StatusCode symLink (const T* p2BRegistered, TLINK* p2BLinked );

  template <typename T, typename TLINK> 
  StatusCode symLink (const T* p2BRegistered, const TLINK* p2BLinked );

  template <KeyConcept TKEY> 
  StatusCode symLink (const CLID id, const TKEY& key, const CLID linkid);

  template <typename T, typename TKEY, typename AKEY>
  StatusCode setAlias(const T* p2BAliased, const TKEY& key, const AKEY& aliasKey) requires KeyConcept<TKEY> && KeyConcept<AKEY>;

  template <typename T, typename AKEY>
  StatusCode setAlias(const T* p2BAliased, const AKEY& aliasKey) requires KeyConcept<AKEY>;

  StatusCode setAlias(SG::DataProxy* proxy, const std::string& aliasKey);

  StatusCode setConst(const void* pointer);

  template <typename T>
  StatusCode remove(const T* pObject);

  template <typename T>          
  StatusCode removeDataAndProxy(const T* pObject);

  bool transientSwap( const CLID& id,
                      const std::string& keyA, const std::string& keyB );




  template <typename T, class TKEY>
  StatusCode retrieveHighestVersion(SG::ObjectWithVersion<T>& dobjWithVersion, 
                                    const TKEY& requestedKey) const;

  //FIXME using a vector exposes ObjectWithVersion definition and hence
  //FIXME VersionedKey.h. Should try an iface like
  //FIXME  retrieveAllVersions(const TKEY& requestedKey,
  //FIXME                      ObjectWithVersion<T>& begin,
  //FIXME                      ObjectWithVersion<T>& end)
  template <typename T, class TKEY>
  StatusCode
  retrieveAllVersions(std::list< SG::ObjectWithVersion<T> >& allVersions,
                      const TKEY& requestedKey) const;
 
  

  template <typename T>
  std::unique_ptr<T> retrieveUniquePrivateCopy (const std::string& key);

  template<typename TKEY>
  CLID clid( const TKEY& key ) const;

  template<typename TKEY>
  std::vector<CLID> clids( const TKEY& key ) const;  

  template <typename T>
  int typeCount() const;

  int typeCount(const CLID& id) const;

  template <typename TKEY>
  bool contains(const CLID& id, const TKEY& key) const;
 

  template <typename T, typename TKEY> 
  bool transientContains(const TKEY& key) const;

  template <typename TKEY>
  bool transientContains(const CLID& id, const TKEY& key) const;

  std::string dump() const;

  void setStoreID(StoreID::type id);
  StoreID::type storeID() const;
 

  template <typename T>
  void
  keys(std::vector<std::string>& vkeys, 
       bool includeAlias = false, bool onlyValid = true) const;
 
  void
  keys(const CLID& id, std::vector<std::string>& vkeys, 
       bool includeAlias = false, bool onlyValid = true) const;

 

  // FIXME pointer to unsafe impl exposed 
  virtual ::IProxyDict* hiveProxyDict() override final {
    return StoreGateSvc::currentStore();
  }

  static StoreGateSvc* currentStoreGate();
 



  virtual StatusCode clearStore(bool forceRemove=false) override final;

  virtual void commitNewDataObjects() override final;

  static void setSlot(SG::HiveEventSlot* pSlot);
 

  void setDefaultStore(SGImplSvc* pStore);                    
 


 
  template <typename H, typename TKEY>
  StatusCode regHandle ATLAS_NOT_THREAD_SAFE ( const DataHandle<H>& handle, const TKEY& key );

  template <typename H, typename TKEY>
  StatusCode regHandle( DataHandle<H>& handle, const TKEY& key);



  virtual SG::DataProxy* proxy(const void* const pTransient) const override final;

  virtual SG::DataProxy* proxy(const CLID& id) const final;

  virtual SG::DataProxy* proxy(const CLID& id, const std::string& key) const override final;
  SG::DataProxy* proxy(const CLID& id, const char* key) const;

  virtual StatusCode addToStore (CLID id, SG::DataProxy* proxy) override final;

  virtual
  SG::DataProxy* recordObject (SG::DataObjectSharedPtr<DataObject> obj,
                               const std::string& key,
                               bool allowMods,
                               bool returnExisting) override final;
 

  virtual SG::DataProxy* proxy_exact (SG::sgkey_t sgkey) const override final;
    




  virtual SG::DataProxy* proxy(const CLID& id, bool checkValid) const final;
  virtual SG::DataProxy* proxy(const CLID& id, const std::string& key, bool checkValid) const final;
  virtual SG::DataProxy* proxy(const CLID& id, const char* key, bool checkValid) const final
  { return this->proxy(id, std::string(key), checkValid); }

  virtual std::vector<const SG::DataProxy*> proxies() const override final;

  std::vector<CLID> clids() const;

  SG::DataProxy* transientProxy(const CLID& id, const std::string& key) const;

  DataObject* accessData(const CLID& id) const;
  DataObject* accessData(const CLID& id, const std::string& key) const;

  void setProxyProviderSvc(IProxyProviderSvc* pPPSvc);
  IProxyProviderSvc* proxyProviderSvc();
 

  virtual SG::SourceID sourceID (const std::string& key = "EventSelector") const override;
 


 
  typedef IStringPool::sgkey_t sgkey_t;

  virtual
  sgkey_t stringToKey (const std::string& str, CLID clid) override final;

  virtual
  const std::string* keyToString (sgkey_t key) const override final;

  virtual
  const std::string* keyToString (sgkey_t key, CLID& clid) const override final;

  virtual
  void registerKey (sgkey_t key,
                    const std::string& str,
                    CLID clidid) override final;



 

  template <class TKEY>
  void remap (CLID clid,
              const TKEY& source,
              const TKEY& target,
              off_t index_offset);
 

  void remap_impl (sgkey_t source,
                   sgkey_t target,
                   off_t index_offset);
 

  virtual bool tryELRemap (sgkey_t sgkey_in, size_t index_in,
                           sgkey_t& sgkey_out, size_t& index_out) override final;



  StoreGateSvc(const std::string& name, ISvcLocator* svc);
  virtual ~StoreGateSvc() override;


  virtual StatusCode initialize() override;
  virtual StatusCode stop() override;
  virtual StatusCode finalize() override;


  virtual void handle(const Incident&) override final;  
  StatusCode loadEventProxies();
 

  virtual
  StatusCode createObj (IConverter* cvt,
                        IOpaqueAddress* addr,
                        DataObject*& refpObject) override;

  void makeCurrent();
 
 
private:

  ServiceHandle<IProxyProviderSvc> m_pPPSHandle{this, "ProxyProviderSvc", "ProxyProviderSvc"};
  ServiceHandle<IIncidentSvc> m_incSvc{this, "IncidentSvc", "IncidentSvc"};
  ServiceHandle<IAlgContextSvc> m_algContextSvc{this, "AlgContextSvc", "AlgContextSvc"};
  Gaudi::Property<bool> m_DumpStore{this, "Dump", false, "Dump contents at EndEvent"};
  Gaudi::Property<bool> m_ActivateHistory{this, "ActivateHistory", false, "record DataObjects history"};
  Gaudi::Property<bool> m_DumpArena{this, "DumpArena", false, "Dump Arena usage stats"};

  StoreID::type m_storeID;
 
  SmartIF<SGImplSvc> m_defaultStore;
 
  friend class SG::TestHiveStoreSvc;
  static SG::HiveEventSlot* currentSlot();
 
  friend class SG::HiveMgrSvc;
  SGImplSvc* currentStore() const;
 

  friend class AthenaOutputStream;
  StatusCode proxyRange(const CLID& id,
                        SG::ConstProxyIterator& beg,
                        SG::ConstProxyIterator& end) const; 

  friend class xAODMaker::AuxStoreWrapper;
  void releaseObject(const CLID& id, const std::string& key);
 

  friend class PileUpMergeSvc;
  friend class IOVDbSvc;
  friend class IOVSvcTool;
  friend
  void
  AthenaInternal::py_sg_clearProxyPayload(StoreGateSvc*, SG::DataProxy*);

  void clearProxyPayload(SG::DataProxy*);

  friend class SG::VarHandleBase;
  friend 
  PyObject* 
  AthenaInternal::recordObjectToStore(StoreGateSvc*,PyObject*,PyObject*,bool,bool,bool);
  StatusCode typeless_record( DataObject* obj, const std::string& key,
                              const void* const raw_ptr,
                              bool allowMods, bool resetOnly=true,
                              bool noHist=false );
  StatusCode typeless_overwrite( const CLID& id,
                                 DataObject* obj, const std::string& key,
                                 const void* const raw_ptr,
                                 bool allowMods,
                                 bool noHist=false,
                                 const std::type_info* tinfo=0);
 
  // Helper for record.
  template <typename T, typename TKEY> 
  StatusCode record1(DataObject* obj, T* pObject, const TKEY& key, 
                     bool allowMods, bool resetOnly=true, bool noHist=false) requires KeyConcept<TKEY>;
 
  // Helper for overwrite.
  template <typename T, typename TKEY> 
  StatusCode overwrite1(DataObject* obj, T* pObject, const TKEY& key, 
                        bool allowMods, bool noHist=false) requires KeyConcept<TKEY>;
 
  bool isSymLinked(const CLID& linkID, SG::DataProxy* dp);
 
  StatusCode addSymLink(const CLID& linkid, SG::DataProxy* dp);
 
  StatusCode addAlias(const std::string& aliasKey, SG::DataProxy* dp);

  std::string createKey(const CLID& dataID);

  SG::DataProxy* setupProxy(const CLID& dataID, 
                            const std::string& gK, 
                            DataObject* pDObj,
                            bool allowMods,
                            bool resetOnly);

  void recycle(DataObject* pBadDObj);  
  void emptyTrash();                   
  
  StatusCode removeProxy(SG::DataProxy* proxy, const void* pTrans, 
                         bool forceRemove=false);
  StatusCode t2pRegister(const void* const pTrans, SG::DataProxy* const pPers);
  void t2pRemove(const void* const pTrans);

  void msg_update_handler(Gaudi::Details::PropertyBase& outputLevel);

  void addAutoSymLinks (const std::string& key, CLID clid, SG::DataProxy* dp,
                        const std::type_info* tinfo,
                        bool warn_nobib = true);
 
  struct BadListItem
    : public DataObjID
  {
  public:
    BadListItem (CLID clid, const std::string& key, const std::string& algo)
      : DataObjID (clid, key), m_algo (algo)
    {}
    std::string m_algo;
  };
  typedef std::unordered_set<BadListItem, DataObjID_Hasher> BadItemList;

  // Thread-safe, since they're protected by m_badMutex.
  mutable BadItemList m_badRetrieves ATLAS_THREAD_SAFE;
  mutable BadItemList m_badRecords   ATLAS_THREAD_SAFE;

  typedef std::mutex mutex_t;
  typedef std::lock_guard<mutex_t> lock_t;
  mutable mutex_t m_badMutex;
 

  void rememberBadRetrieve (CLID clid, const std::string& key) const;
 

  void rememberBadRecord (CLID clid, const std::string& key) const;
 

  void rememberBad (BadItemList& bad,
                    CLID clid,
                    const std::string& key) const;
 

  void printBadList (const BadItemList& bad,
                     const std::string& what) const;
 

  template <class DOBJ>
  bool associateAux (DOBJ*,
                     const std::string& key,
                     bool ignoreMissing=true) const;
  template <class DOBJ>
  bool associateAux (const DOBJ*,
                     const std::string& key,
                     bool ignoreMissing=true) const;
 
  template <class DOBJ, class AUXSTORE>
  bool associateAux_impl(DOBJ* ptr,
                         const std::string& key,
                         const AUXSTORE*) const;
  template <class DOBJ>
  bool associateAux_impl(DOBJ* /*ptr*/,
                         const std::string& /*key*/,
                         const SG::NoAuxStore*) const;
  
 
private:
  StoreGateSvc (const StoreGateSvc&);
  StoreGateSvc& operator= (const StoreGateSvc&);
};
 

void SG_dump (StoreGateSvc* sg);
void SG_dump (StoreGateSvc* sg, const char* fname);
 
 
#include "StoreGate/StoreGateSvc.icc"
 
 
//- PyGate: StoreGate access from python -------------------------------------
template< class T >
struct PyGate {
  // default object retrieval
  static const T* retrieve( StoreGateSvc* psg ) {
    const T* obj = 0;
    if ( StatusCode::SUCCESS == psg->retrieve( obj ) )
      return obj;
    return 0;
  }
 
  // object retrieval with string key
  static const T* retrieve( StoreGateSvc* psg, const std::string& key ) {
    const T* obj = 0;
    if ( StatusCode::SUCCESS == psg->retrieve( obj, key ) )
      return obj;
    return 0;
  }
};
 
#endif // STOREGATE_STOREGATESVC_H