ActiveStoreSvc.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 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;
using namespace std;
 
ActiveStoreSvc::ActiveStoreSvc(const std::string& name,ISvcLocator* svc) : 
  Service(name,svc),
  p_activeStore(0),
  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;
 
  const bool CREATEIF(true);
  CHECK(  service(m_storeName, p_activeStore, CREATEIF) );
  p_activeStore->makeCurrent();
  return StatusCode::SUCCESS;
}
 
void ActiveStoreSvc::setStore(StoreGateSvc *s) {
  // Now unconditional because the actual active store is thread_local
  p_activeStore = s; // honestly, probably not necessary any more
  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);
}
 
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();
}