ActiveStoreSvc.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#include "StoreGate/ActiveStoreSvc.h"
#include "StoreGate/StoreGateSvc.h"
#include "AthenaKernel/errorcheck.h"
#include "AthenaKernel/StoreID.h"
 
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ISvcLocator.h"
 
using namespace SG;
 
ActiveStoreSvc::ActiveStoreSvc(const std::string& name,ISvcLocator* svc) : 
  Service(name,svc),
  m_storeName()
{
  declareProperty("StoreName", m_storeName=StoreID::storeName(StoreID::EVENT_STORE));
}
 
 
ActiveStoreSvc::~ActiveStoreSvc()  
{}
 
StatusCode ActiveStoreSvc::initialize()    {
 
  CHECK( Service::initialize() );
 
  msg() << MSG::VERBOSE << "Initializing " << name() << endmsg;
 
  SmartIF<StoreGateSvc> storeGate{service(m_storeName, /*createIf*/true)};
  CHECK( storeGate.isValid() );
  storeGate->makeCurrent();
 
  return StatusCode::SUCCESS;
}
 
void ActiveStoreSvc::setStore(StoreGateSvc *s) {
  s->makeCurrent();
}
 
DataProxy* 
ActiveStoreSvc::proxy(const void* const pTransient) const {
  return activeStore()->proxy(pTransient);
}
 
DataProxy* 
ActiveStoreSvc::proxy(const CLID& id, const std::string& key) const { 
  return activeStore()->proxy(id,key);
}
 
SG::DataProxy* ActiveStoreSvc::proxy_exact (SG::sgkey_t sgkey) const
{
  return activeStore()->proxy_exact (sgkey);
}
 
std::vector<const SG::DataProxy*>
ActiveStoreSvc::proxies() const {
  return activeStore()->proxies();
}
 
 
StatusCode ActiveStoreSvc::addToStore (CLID id, SG::DataProxy* proxy)
{
  return activeStore()->addToStore (id, proxy);
}
 
 
SG::DataProxy*
ActiveStoreSvc::recordObject (SG::DataObjectSharedPtr<DataObject> obj,
                              const std::string& key,
                              bool allowMods,
                              bool returnExisting)
{
  return activeStore()->recordObject (obj, key, allowMods, returnExisting);
}
 
 
sgkey_t ActiveStoreSvc::stringToKey (const std::string& str, CLID clid)
{
  return activeStore()->stringToKey (str, clid);
}
 
 
const std::string* ActiveStoreSvc::keyToString (sgkey_t key) const
{
  return activeStore()->keyToString (key);
}
 
 
const std::string* ActiveStoreSvc::keyToString (sgkey_t key,
                                                CLID& clid) const
{
  return activeStore()->keyToString (key, clid);
}
 
 
void ActiveStoreSvc::registerKey (sgkey_t key,
                                  const std::string& str,
                                  CLID clid)
{
  return activeStore()->registerKey (key, str, clid);
}
 
 
const InterfaceID& ActiveStoreSvc::interfaceID() { 
  static const InterfaceID IDActiveStoreSvc("ActiveStoreSvc", 1, 0);
  return IDActiveStoreSvc; 
}
StatusCode ActiveStoreSvc::queryInterface(const InterfaceID& riid, void** ppvInterface) 
{
  if ( interfaceID().versionMatch(riid) )    {
    *ppvInterface = (ActiveStoreSvc*)this;
  }
  else if ( IProxyDict::interfaceID().versionMatch(riid) )    {
    *ppvInterface = (IProxyDict*)this;
  }
  else  {
    // Interface is not directly available: try out a base class
    return Service::queryInterface(riid, ppvInterface);
  }
  addRef();
  return StatusCode::SUCCESS;
}
 
 
StoreGateSvc* ActiveStoreSvc::activeStoreOOL() const
{
  return StoreGateSvc::currentStoreGate();
}