SGImplSvc.h

Go to the documentation of this file.

/* -*- C++ -*- */
 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef STOREGATE_SGIMPLSVC_H
#define STOREGATE_SGIMPLSVC_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"
 
//base classes
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/Service.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/IConverter.h"
#include "AthenaKernel/IProxyDict.h"
 
#include <GaudiKernel/ClassID.h>        // for CLID
#include <GaudiKernel/IInterface.h>     // for InterfaceID
#include <GaudiKernel/IMessageSvc.h>    // for Level
#include "GaudiKernel/MsgStream.h"
#include "Gaudi/Property.h"
#include "GaudiKernel/StatusCode.h"
 
#include "GaudiKernel/DataObjID.h"
 
#include <cstddef>                     // for size_t
#include <list>
#include <memory>                     
#include <string>
#include <sys/types.h>                  // for off_t
#include <vector>                       
#include <thread>
 
#include "AthenaKernel/StoreID.h"
#include "AthenaKernel/IProxyProviderSvc.h"
#include "AthenaKernel/IHiveStoreMgr.h"
#include "AthenaKernel/DefaultKey.h"
#include "CxxUtils/RefCountedPtr.h"
 
#include <SGTools/StringPool.h> 
#include "SGTools/ProxyMap.h" /* for SG::ConstProxyIterator */
 
 
// includes used in SGImplSvc.icc
#include "GaudiKernel/IClassIDSvc.h"
#include "AthenaKernel/IResetable.h"
#include "AthenaKernel/IIOVSvc.h"
#include "StoreGate/SGIterator.h"
#include "StoreGate/SGWPtr.h"
#include "AthAllocators/Arena.h"
 
#include "GaudiKernel/IIncidentSvc.h"
 
//forward declarations
namespace SG {
  class DataProxy;
  class TransientAddress;
  struct RemapImpl;
  class AuxVectorBase;
  class AuxElement;
  class DataStore;
}
 
class DataObject;
class IConversionSvc;
class Incident;
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 ActiveStoreSvc;
namespace SG { 
  class VarHandleBase; 
}

class SGImplSvc final : public extends<Service,
                                       IProxyDict,
                                       IHiveStoreMgr,
                                       IIncidentListener>
{
 
public:
  SGImplSvc (const SGImplSvc&) = delete;
  SGImplSvc& operator= (const SGImplSvc&) = delete;
 



  StatusCode retrieve (CLID clid,
                       SG::detail::IteratorBase& cibegin, 
                       SG::detail::IteratorBase& ciend) const;
 




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

  StatusCode symLink (const CLID id, const std::string& key, const CLID linkid);

  StatusCode setAlias(const void* p2BAliased, const std::string& aliasKey);

  StatusCode setConst(const void* pointer);

  StatusCode remove(const void* pObject);

  StatusCode removeDataAndProxy(const void* pObject);




  CLID clid( const std::string& key ) const;

  bool contains(const CLID id, const std::string& key) const;
 

  bool transientContains(const CLID id, const std::string& key) const;

  std::string dump() const;

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

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

  virtual ::IProxyDict* hiveProxyDict() override final {
    return this;
  }

 
  using IProxyDict::proxy;

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

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

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

  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;
    




  SG::DataProxy* proxy(const CLID& id, bool checkValid) const;
  SG::DataProxy* proxy(const CLID& id, const std::string& key, bool checkValid) const;
  SG::DataProxy* proxy(const CLID& id, const char* key, bool checkValid) const
  { 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;
 

  bool mergeStringPool (const SGImplSvc& other);
 



 

  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;



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


  virtual StatusCode initialize() override final;
  virtual StatusCode reinitialize() override final;
  virtual StatusCode start() override final;
  virtual StatusCode stop() override final;
  virtual StatusCode finalize() override final;
 



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



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

  virtual void commitNewDataObjects() override final;
 

  void setSlotNumber (int slot, int numSlots);
 

  virtual void boundHandle (IResetable* handle) override final;
 

  virtual void unboundHandle (IResetable* handle) override final;
 

  // Const methods: 

  virtual
  StatusCode createObj (IConverter* cvt,
                        IOpaqueAddress* addr,
                        DataObject*& refpObject) override;
 
                     
private:
 
  StatusCode record_HistObj(const CLID& id, const std::string& key,
                            const std::string& store, bool allowMods, 
                            bool resetOnly=true);
 
 
  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);
 
  StatusCode typeless_record( DataObject* obj, const std::string& key,
                              const void* const raw_ptr,
                              bool allowMods, bool resetOnly,
                              bool noHist,
                              const std::type_info* tinfo);
  StatusCode typeless_record( DataObject* obj, const std::string& key,
                              const void* const raw_ptr,
                              bool allowMods, bool resetOnly,
                              bool noHist,
                              const std::type_info* tinfo,
                              SG::DataProxy** proxy_ret,
                              bool noOverwrite);

  SG::DataProxy* record_impl( DataObject* obj, const std::string& key,
                              const void* const raw_ptr,
                              bool allowMods, bool resetOnly, bool allowOverwrite,
                              const std::type_info* tinfo);
 
                          
  void releaseObject(const CLID& id, const std::string& key);

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

  SG::DataProxy* locatePersistent(const SG::TransientAddress* tAddr,
                                  bool checkValid = false) const;
 
  friend class StoreGateSvc;
  friend class SG::VarHandleBase;                                                      
 
  SG::DataStore* store();
  const SG::DataStore* store() const;
 
  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);
 
  bool associateAux_impl (SG::AuxVectorBase* ptr,
                          const std::string& key,
                          CLID auxclid) const;
 
  bool associateAux_impl (SG::AuxElement* ptr,
                          const std::string& key,
                          CLID auxclid) const;

  void addAutoSymLinks (const std::string& key, CLID clid, SG::DataProxy* dp,
                        const std::type_info* tinfo,
                        bool warn_nobib = true);
 
  friend class ActiveStoreSvc;
  void makeCurrent();
 
  ServiceHandle<IClassIDSvc> m_pCLIDSvc;
  ServiceHandle<IConversionSvc> m_pDataLoader;
 
  ServiceHandle<IProxyProviderSvc> m_pPPSHandle;
  // Has to be separate from handle due to setProxyProviderSvc() interface.
  // Can we get rid of that?
  IProxyProviderSvc* m_pPPS;
 
  ServiceHandle<IHistorySvc> m_pHistorySvc;
 
  SG::DataStore* m_pStore;             
  std::list<DataObject*> m_trash;    
 
  ServiceHandle<IIncidentSvc> m_pIncSvc; 
  bool m_DumpStore; 
  bool m_ActivateHistory; 
  bool m_DumpArena; 
 
  //  typedef std::list<std::string> StrList; 
  StringArrayProperty m_folderNameList; 

  ServiceHandle<IIOVSvc> m_pIOVSvc;
 
  bool m_storeLoaded;  
 
  SG::StringPool m_stringpool;
 
  SG::RemapImpl* m_remap_impl;

  SG::Arena m_arena;

  int m_slotNumber;

  int m_numSlots;

  std::map<std::thread::id, std::vector<IResetable*> > m_newBoundHandles;
 
  typedef std::recursive_mutex mutex_t;
  typedef std::lock_guard<mutex_t> lock_t;
  mutable mutex_t m_mutex;
  mutable mutex_t m_remapMutex;
  mutable mutex_t m_stringPoolMutex;
};
 

void SG_dump (SGImplSvc* sg);
void SG_dump (SGImplSvc* sg, const char* fname);
 
 
#include "StoreGate/tools/SGImplSvc.icc"
 
#endif // STOREGATE_SGIMPLSVC_H