IOVSvc Class Reference

#include <IOVSvc.h>

Inheritance diagram for IOVSvc:

Collaboration diagram for IOVSvc:

Public Member Functions
	IOVSvc (const std::string &name, ISvcLocator *svc)
virtual StatusCode	initialize () override
virtual StatusCode	reinitialize () override
virtual StatusCode	createIOVTool (const std::string &storeName) override
virtual std::vector< std::string >	getStoreNames () const override
virtual StatusCode	setRange (const CLID &clid, const std::string &key, IOVRange &) override
	Update Range from dB.
virtual StatusCode	setRange (const CLID &clid, const std::string &key, IOVRange &io, const std::string &storeName) override
virtual StatusCode	getRange (const CLID &clid, const std::string &key, IOVRange &io) const override
virtual StatusCode	regProxy (SG::DataProxy *proxy, const std::string &key, const std::string &storeName) override
	Subscribe method for DataProxy. key StoreGate key.
virtual StatusCode	replaceProxy (SG::DataProxy *pOld, SG::DataProxy *pNew, const std::string &storeName) override
	replace a registered DataProxy with a new version
virtual StatusCode	regProxy (const CLID &clid, const std::string &key, const std::string &storeName) override
	Another way to subscribe.
virtual StatusCode	deregProxy (SG::DataProxy *proxy) override
	Deregister a DataProxy with the service.
virtual StatusCode	deregProxy (const CLID &clid, const std::string &key) override
	Deregister a DataProxy with the service.
virtual StatusCode	getRangeFromDB (const CLID &clid, const std::string &key, IOVRange &range, std::string &tag, std::unique_ptr< IOpaqueAddress > &ioa, const EventIDBase &now) const override
	Get IOVRange from db for current event.
virtual StatusCode	getRangeFromDB (const CLID &clid, const std::string &key, const IOVTime &time, IOVRange &range, std::string &tag, std::unique_ptr< IOpaqueAddress > &ioa) const override
	Get IOVRange from db for a particular event.
virtual StatusCode	setRangeInDB (const CLID &clid, const std::string &key, const IOVRange &range, const std::string &tag) override
	Set a particular IOVRange in db (and memory)
virtual StatusCode	dropObjectFromDB (const CLID &clid, const std::string &key, const std::string &storeName) override
	Drop the associated object from the db and trigger reload.
virtual StatusCode	preLoadTAD (const SG::TransientAddress *, const std::string &storeName) override
	supply a list of TADs whose proxies will be preloaded
virtual StatusCode	preLoadDataTAD (const SG::TransientAddress *, const std::string &storeName) override
	supply a list of TADs whose data will be preloaded
virtual void	resetAllProxies () override
virtual void	ignoreProxy (const CLID &clid, const std::string &key, const std::string &storeName) override
	ignore proxy
virtual StatusCode	createCondObj (CondContBase *, const DataObjID &, const EventIDBase &) override

Private Member Functions
StatusCode	createIOVTool (const std::string &storeName, IIOVSvcTool *&tool)
IIOVSvcTool *	getTool (const std::string &storeName, bool createIF=true)
IIOVSvcTool *	getTool (const CLID &clid, const std::string &key) const
IIOVSvcTool *	getTool (SG::DataProxy *proxy) const
std::string	fullProxyName (const SG::DataProxy *proxy) const
std::string	fullProxyName (const CLID &clid, const std::string &key) const

Private Attributes
Gaudi::Property< bool >	m_preLoadRanges {this, "preLoadRanges", false}
Gaudi::Property< bool >	m_preLoadData {this, "preLoadData", false}
Gaudi::Property< bool >	m_partialPreLoadData {this, "partialPreloadData", true}
Gaudi::Property< bool >	m_preLoadExtensibleFolders {this, "preLoadExtensibleFolders", true}
Gaudi::Property< bool >	m_sortKeys {this, "sortKeys", true}
Gaudi::Property< bool >	m_forceReset {this, "forceResetAtBeginRun", false}
Gaudi::Property< std::string >	m_updateInterval {this, "updateInterval", "Event"}
ServiceHandle< IToolSvc >	p_toolSvc
ServiceHandle< IClassIDSvc >	p_CLIDSvc
ServiceHandle< StoreGateSvc >	p_sgs
ServiceHandle< StoreGateSvc >	p_detStore
ServiceHandle< ICondSvc >	p_condSvc
std::map< std::string, IIOVSvcTool * >	m_toolMap
std::recursive_mutex	m_lock

Detailed Description

Definition at line 45 of file IOVSvc.h.

Constructor & Destructor Documentation

IOVSvc()

IOVSvc::IOVSvc	(	const std::string &	name,
		ISvcLocator *	svc )

Definition at line 65 of file IOVSvc.cxx.

  : base_class( name, svc ), 
    p_toolSvc("ToolSvc",name),
    p_CLIDSvc("ClassIDSvc",name),
    p_sgs("StoreGateSvc",name),
    p_detStore("StoreGateSvc/DetectorStore",name),
    p_condSvc("CondSvc",name)
{
}

Member Function Documentation

createCondObj()

StatusCode IOVSvc::createCondObj ( CondContBase * ccb, const DataObjID & id, const EventIDBase & now )

overridevirtual

Definition at line 650 of file IOVSvc.cxx.

                                              {
  
  ATH_MSG_DEBUG("createCondObj:  id: " << id << "  t: " << now << "  valid: "
                << ccb->valid(now));
 
  if (ccb->valid(now)) {
    if (msgLvl(MSG::DEBUG)) {
      EventIDRange r;
      ccb->range(now,r);
      ATH_MSG_DEBUG( "  range " << r << " for " << id 
                     << " is still valid at " << now );
    }
    return StatusCode::SUCCESS;
  }
 
  IOVTime t(now.run_number(), now.lumi_block(),
            now.time_stamp()*1000000000LL + now.time_stamp_ns_offset());
 
  // remove storename from key
  std::string sgKey = id.key();
  auto sep = sgKey.find('+');
  if (sep != std::string::npos) {
    sgKey.erase(0,sep+1);
  }
  
  std::unique_ptr<IOpaqueAddress> ioa;
  std::string tag;
  IOVRange range;
  if (getRangeFromDB(id.clid(), sgKey, t, range, tag, ioa).isFailure()) {
    ATH_MSG_ERROR( "unable to get range from db for time "  << t << " clid "
                   << id.clid() << " " << sgKey );
    return StatusCode::FAILURE;
  }
     
  //In case the conditons-container is a 'mixed' type, we need both run/lb and time-stamps in the range. 
  //Assume infinite IOV in the other dimension 
  EventIDRange eidRange(range);   
  if (ccb->keyType()==CondContBase::KeyType::MIXED) { 
    eidRange=EventIDRange::intersect(IOVInfiniteRange::infiniteMixed(),eidRange);    
  } 
  ATH_MSG_DEBUG( " new range for ID " << id << " : " << range 
                 << " IOA: " << ioa.get());
 
  // If the start of the new range matches the start of the last range, then
  // extend the last range rather than trying to insert a new range.
  // This can happen when a folder is tagged as `extensible' in IOVDbSvc.
  EventIDRange r;
  if (ccb->range (eidRange.start(), r) &&
      eventIDMatch (r.start(), eidRange.start()))
  {
    if (ccb->extendLastRange (eidRange).isSuccess()) {
      return StatusCode::SUCCESS;
    }
  }
 
  if (ccb->proxy() == nullptr) {
    // nb. We don't want to be holding the IOVSvc lock here,
    // as SGImplSvc can call to IOVSvc with the store lock held.
    SG::DataProxy* dp = p_detStore->proxy (id.clid(), sgKey);
    ATH_MSG_DEBUG( " found DataProxy " << dp << " for " << id );
    ccb->setProxy(dp);
  }
 
  // this will talk to the IOVDbSvc, get current run/event from EventInfo 
  // object, load
  SG::DataProxy* dp = ccb->proxy();
  DataObject* dobj = nullptr;
  void* v = nullptr;
 
  if (dp->store()->createObj(dp->loader(), ioa.get(), dobj).isFailure()) {
    ATH_MSG_ERROR(" could not create a new DataObject ");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_DEBUG(" created new obj at " << dobj );
 
    v = SG::Storable_cast(dobj, id.clid());
  }
 
  // Free the DataBucket that was created along with the object we read.
  if (DataBucketBase* dbb = dynamic_cast<DataBucketBase*> (dobj)) {
    dbb->relinquish();
    delete dobj;
    dobj = nullptr;
  }
 
  // Some data objects may be reference counted by the address.
  // CondCont will take ownership of the object, but doesn't
  // do refcounting.  We'll have gotten a reference via the Storable_cast
  // above, so it should be ok ... unless CondCont deletes
  // the new object immediately instead of inserting.
  // In that case, when we delete the address, it will
  // follow an invalid pointer.  So be sure to delete
  // the address before the object is added to CondCont.
  ioa.reset();
 
  // DataObject *d2 = static_cast<DataObject*>(v);
  
  ATH_MSG_DEBUG( " SG::Storable_cast to obj: " << v );
 
  StatusCode sc = ccb->typelessInsert (eidRange, v);
  if (!sc.isSuccess()) {
    ATH_MSG_ERROR("unable to insert Object at " << v << " into CondCont " 
                  << ccb->id() << " for range " << eidRange );
    return StatusCode::FAILURE;
  }
  else if (CondContBase::Category::isOverlap (sc)) {
    // Disable this for now... IOVDbSvc can sometimes produce overlapping
    // ranges.
    //ATH_MSG_ERROR ("IOV range overlap.");
    //return StatusCode::FAILURE;
  }
 
  return sc;
 
}

createIOVTool() [1/2]

StatusCode IOVSvc::createIOVTool ( const std::string & storeName )

overridevirtual

Definition at line 529 of file IOVSvc.cxx.

{
  IIOVSvcTool* ist = nullptr;
  return createIOVTool (storeName, ist);
}

createIOVTool() [2/2]

StatusCode IOVSvc::createIOVTool ( const std::string & storeName, IIOVSvcTool *& tool )

private

Definition at line 490 of file IOVSvc.cxx.

                                                                     {
 
  std::string store(storeName);
  std::string toolName("IOVSvcTool");
  if (storeName == "default") {
    store = defaultStore;
  }
  else {
    // Append the store name if not default
    toolName += '_';
    toolName += store;
  }
 
  ATH_MSG_DEBUG( "Creating " << toolName << " associated with store \"" << store
                 << "\""  );
 
  const auto itr = m_toolMap.find( store );
  if ( itr == m_toolMap.end() ) {
    ist = nullptr;
    if (p_toolSvc->retrieveTool( "IOVSvcTool/" + toolName, ist, this ).isFailure()) {
      ATH_MSG_ERROR( "Unable to create IOVSvcTool associated with store \"" 
                     << store << "\""  );
      return StatusCode::FAILURE;
    } else {
      m_toolMap[ store ] = ist;
      ist->setStoreName( store );
      return StatusCode::SUCCESS;
    }
  } else {
    ATH_MSG_INFO( "an IOVSvcTool already exists associated with store \"" 
                  << store << "\""  );
    ist = itr->second;
    return StatusCode::SUCCESS;
  }
 
}

deregProxy() [1/2]

StatusCode IOVSvc::deregProxy ( const CLID & clid, const std::string & key )

overridevirtual

Deregister a DataProxy with the service.

Definition at line 190 of file IOVSvc.cxx.

                                                           {
 
  std::scoped_lock lock(m_lock);
  IIOVSvcTool *ist = getTool( clid, key );
  if (ist == nullptr) {
    ATH_MSG_ERROR( "deregProxy: no IOVSvcTool found for proxy " 
                   << fullProxyName(clid,key) );
    return StatusCode::FAILURE; 
  }
 
  return ist->deregProxy( clid, key );
 
}

deregProxy() [2/2]

StatusCode IOVSvc::deregProxy ( SG::DataProxy * proxy )

overridevirtual

Deregister a DataProxy with the service.

Definition at line 170 of file IOVSvc.cxx.

                                       {
 
  std::scoped_lock lock(m_lock);
  IIOVSvcTool *ist = getTool( proxy );
  if (ist == nullptr) {
    ATH_MSG_ERROR( "deregProxy: no IOVSvcTool found for proxy "
          << fullProxyName( proxy ) );
    return StatusCode::FAILURE;
  }
 
  return ist->deregProxy( proxy );
 
}

dropObjectFromDB()

StatusCode IOVSvc::dropObjectFromDB ( const CLID & clid, const std::string & key, const std::string & storeName )

overridevirtual

Drop the associated object from the db and trigger reload.

Definition at line 351 of file IOVSvc.cxx.

                                                     {
 
  std::scoped_lock lock(m_lock);
 
  IIOVSvcTool *ist = getTool( clid, key );
  if (ist == nullptr) {
    ATH_MSG_ERROR( "dropObjectFromDB: no IOVSvcTool associated with store "
                   << storeName << " and failed to create one."  );
    return StatusCode::FAILURE;
  }
 
  SG::DataProxy* proxy = p_detStore->proxy(clid, key);
  if (proxy == nullptr) {
    ATH_MSG_DEBUG("Proxy for (clid: " << clid << " key: " << key << ") in store " << storeName
                  << " does not exist. Cannot drop associated object.");
    return StatusCode::SUCCESS;
  }
 
  // Set IOV in the past to trigger reload on next range check
  IOVRange iovr(IOVTime(0, 0), IOVTime(0, 0));
  ATH_CHECK( ist->setRange(clid, key, iovr) );
 
  IIOVDbSvc *iovDB = dynamic_cast<IIOVDbSvc*>(proxy->provider());
  if (iovDB != nullptr) {
    ATH_MSG_DEBUG("Dropping " << key << "via IOVDBSvc");
    ATH_CHECK( iovDB->dropObject(key, /*resetCache=*/true) );
  } else {
    ATH_MSG_ERROR("dropObjectFromDB: Provider for " << key << " is not an IIOVDbSvc.");
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

fullProxyName() [1/2]

std::string IOVSvc::fullProxyName ( const CLID & clid, const std::string & key ) const

private

Definition at line 602 of file IOVSvc.cxx.

                                                                    {
 
  std::string fullname, tname;
  if (p_CLIDSvc->getTypeNameOfID( clid, tname ).isFailure()) {
    fullname = "[";
    fullname += std::to_string(clid);
    fullname += '/';
    fullname += key;
    fullname += ']';
  } else {
    fullname = "[";
    fullname += tname;
    fullname += ':';
    fullname += std::to_string(clid);
    fullname += '/';
    fullname += key;
    fullname += ']';
  }
 
  return fullname;
}

fullProxyName() [2/2]

std::string IOVSvc::fullProxyName ( const SG::DataProxy * proxy ) const

private

Definition at line 593 of file IOVSvc.cxx.

                                                   {
 
  return fullProxyName(dp->clID(), dp->name());
 
}

getRange()

StatusCode IOVSvc::getRange ( const CLID & clid, const std::string & key, IOVRange & io ) const

overridevirtual

Definition at line 390 of file IOVSvc.cxx.

                                      {
 
  IIOVSvcTool *ist = getTool( clid, key );
  if (ist == nullptr) {
    ATH_MSG_ERROR( "getRange: proxy for " << fullProxyName(clid,key)
                   << " not registered"  );
    return StatusCode::FAILURE;
  } else {
    return ist->getRange( clid, key, iov );
  }
 
}

getRangeFromDB() [1/2]

StatusCode IOVSvc::getRangeFromDB ( const CLID & clid, const std::string & key, const IOVTime & time, IOVRange & range, std::string & tag, std::unique_ptr< IOpaqueAddress > & ioa ) const

overridevirtual

Get IOVRange from db for a particular event.

Definition at line 437 of file IOVSvc.cxx.

                                                                 {
 
  std::scoped_lock lock(m_lock);
 
  IIOVSvcTool *ist = getTool( clid, key );
  if (ist == nullptr) {
    ATH_MSG_ERROR( "getRangeFromDB: proxy for "
                   << fullProxyName(clid, key) << " not registered"  );
    return StatusCode::FAILURE;
  } else {
    return ist->getRangeFromDB( clid, key, time, range, tag, ioa );
  }
 
}

getRangeFromDB() [2/2]

StatusCode IOVSvc::getRangeFromDB ( const CLID & clid, const std::string & key, IOVRange & range, std::string & tag, std::unique_ptr< IOpaqueAddress > & ioa, const EventIDBase & now ) const

overridevirtual

Get IOVRange from db for current event.

Definition at line 407 of file IOVSvc.cxx.

                                                     {
 
  std::scoped_lock lock(m_lock);
 
  IIOVSvcTool *ist = getTool( clid, key );
  if (ist == nullptr) {
    ATH_MSG_ERROR( "getRangeFromDB: proxy for " 
                   << fullProxyName(clid,key) << " not registered"  );
    return StatusCode::FAILURE;
  } else {
    
    uint32_t event = now.lumi_block();
    uint32_t run   = now.run_number();
    IOVTime curTime;
    curTime.setRunEvent(run,event);
    // get ns timestamp from event
    curTime.setTimestamp(1000000000L*static_cast<uint64_t>(now.time_stamp()) + now.time_stamp_ns_offset());
 
 
    return ist->getRangeFromDB( clid, key, range, tag, ioa, curTime );
  }
 
}

getStoreNames()

std::vector< std::string > IOVSvc::getStoreNames ( ) const

overridevirtual

Definition at line 627 of file IOVSvc.cxx.

                            {
 
  auto keys = m_toolMap | std::views::keys;
  return std::vector<std::string>(keys.begin(), keys.end());
 
}

getTool() [1/3]

IIOVSvcTool * IOVSvc::getTool ( const CLID & clid, const std::string & key ) const

private

Definition at line 578 of file IOVSvc.cxx.

                                                              {
 
  for (const auto& [name, ist] : m_toolMap) {
    if (ist->holdsProxy( clid, key )) {
      return ist;
    }
  }
 
  return nullptr;
 
}

getTool() [2/3]

IIOVSvcTool * IOVSvc::getTool ( const std::string & storeName, bool createIF = true )

private

Definition at line 539 of file IOVSvc.cxx.

                                                           {
 
  const std::string store = (storeName=="default" ? defaultStore : storeName);
 
  const auto itr = m_toolMap.find( store );
  IIOVSvcTool *ist = nullptr;
  if ( itr == m_toolMap.end() ) {
    ATH_MSG_INFO( "No IOVSvcTool associated with store \"" << store
                  << "\""  );
 
    if (createIF) {
      createIOVTool(store, ist).ignore();
    }
 
  } else {
    ist = itr->second;
  }
 
  return ist;
}

getTool() [3/3]

IIOVSvcTool * IOVSvc::getTool ( SG::DataProxy * proxy ) const

private

Definition at line 563 of file IOVSvc.cxx.

                                          {
 
  for (const auto& [name, ist] : m_toolMap) {
    if (ist->holdsProxy( proxy )) {
      return ist;
    }
  }
 
  return nullptr;
 
}

ignoreProxy()

void IOVSvc::ignoreProxy ( const CLID & clid, const std::string & key, const std::string & storeName )

overridevirtual

ignore proxy

Definition at line 210 of file IOVSvc.cxx.

                                                  {
 
  IIOVSvcTool *ist = getTool( storeName );
  if (ist == nullptr) {
    ATH_MSG_ERROR( "ignoreProxy: no IOVSvcTool found for store " 
                   << storeName << " and failed to create one" );
    return;
  }
 
  return ist->ignoreProxy( clid, key );
}

initialize()

StatusCode IOVSvc::initialize ( )

overridevirtual

Definition at line 77 of file IOVSvc.cxx.

                              {
 
  msg().setLevel( m_outputLevel.value() );
  ATH_MSG_DEBUG( "Initializing IOVSvc" );
 
  ATH_CHECK( p_sgs.retrieve() );
  ATH_CHECK( p_detStore.retrieve() );
  ATH_CHECK( p_condSvc.retrieve() );
 
  return StatusCode::SUCCESS;
}

preLoadDataTAD()

StatusCode IOVSvc::preLoadDataTAD ( const SG::TransientAddress * tad, const std::string & storeName )

overridevirtual

supply a list of TADs whose data will be preloaded

add to a set of TADs that who's data will be preLoaded

Definition at line 273 of file IOVSvc.cxx.

                                                     {
 
  IIOVSvcTool *ist = getTool( storeName );
  if (ist == nullptr) {
    ATH_MSG_ERROR( "preLoadDataTAD: no IOVSvcTool associated with store \""
                   << storeName << "\" and failed to create one."  );
    return StatusCode::FAILURE;
  } else {
    return ist->preLoadDataTAD( tad );
  }
 
}

preLoadTAD()

StatusCode IOVSvc::preLoadTAD ( const SG::TransientAddress * tad, const std::string & storeName )

overridevirtual

supply a list of TADs whose proxies will be preloaded

add to a set of TADs that will be registered at start of first event

Definition at line 252 of file IOVSvc.cxx.

                                                 {
 
 
  IIOVSvcTool *ist = getTool( storeName );
  if (ist == nullptr) {
    ATH_MSG_ERROR( "preLoadTAD: no IOVSvcTool associated with store \""
                   << storeName << "\" and failed to create one."  );
    return StatusCode::FAILURE;
  } else {
    return ist->preLoadTAD( tad );
  }
 
}

regProxy() [1/2]

StatusCode IOVSvc::regProxy ( const CLID & clid, const std::string & key, const std::string & storeName )

overridevirtual

Another way to subscribe.

Register a DataProxy with the service.

Definition at line 132 of file IOVSvc.cxx.

                                               {
 
  std::scoped_lock lock(m_lock);
  IIOVSvcTool *ist = getTool( storeName );
  if (ist == nullptr) {
    ATH_MSG_ERROR( "regProxy: no IOVSvcTool associated with store \"" 
                   << storeName << "\" and failed to create one."  );
    return (StatusCode::FAILURE);
  }
 
  IIOVSvcTool *ist2 = getTool( clid, key );
  if (ist2 != nullptr) {
    if (ist2 != ist) {
      ATH_MSG_ERROR( "regProxy: when registering proxy for "
                     << fullProxyName(clid,key)
                     << " with store " << storeName
                     << ", it is already registered with store \"" 
                     << ist2->getStoreName() << "\""  );
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_DEBUG( "regProxy: proxy for " << fullProxyName(clid,key)
                     << " already registered with store \"" << storeName << "\""
                     );
      return StatusCode::SUCCESS;
    }
  }
 
  return ist->regProxy( clid, key );
 
}

regProxy() [2/2]

StatusCode IOVSvc::regProxy ( SG::DataProxy * proxy, const std::string & key, const std::string & storeName )

overridevirtual

Subscribe method for DataProxy. key StoreGate key.

Register a DataProxy with the service.

Definition at line 95 of file IOVSvc.cxx.

                                               {
 
  std::scoped_lock lock(m_lock);
  IIOVSvcTool *ist = getTool( storeName );
  if (ist == nullptr) {
    ATH_MSG_ERROR( "regProxy: no IOVSvcTool associated with store \"" 
                   << storeName << "\" and failed to create one"  );
    return (StatusCode::FAILURE);
  }
 
  IIOVSvcTool *ist2 = getTool( proxy );
  if (ist2 != nullptr) {
    if (ist2 != ist) {
      ATH_MSG_ERROR( "regProxy: when registering proxy for " 
                     << fullProxyName(proxy) << " with store \"" << storeName
                     << "\", it is already registered with store \"" 
                     << ist2->getStoreName() << "\""  );
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_DEBUG( "regProxy: proxy for " << fullProxyName(proxy)
                     << " already registered with store \"" << storeName << "\""
                     );
      return StatusCode::SUCCESS;
    }
  }
 
  return ist->regProxy( proxy, key );
 
}

reinitialize()

StatusCode IOVSvc::reinitialize ( )

overridevirtual

Definition at line 475 of file IOVSvc.cxx.

{
  StatusCode sc;
  for (const auto& [name, ist] : m_toolMap) {
    sc &= ist->reinitialize();
  }
  return sc;
 
}

replaceProxy()

StatusCode IOVSvc::replaceProxy ( SG::DataProxy * pOld, SG::DataProxy * pNew, const std::string & storeName )

overridevirtual

replace a registered DataProxy with a new version

Replace a registered DataProxy with a new version.

Definition at line 230 of file IOVSvc.cxx.

                                                   {
 
  StatusCode sc(StatusCode::FAILURE);
  IIOVSvcTool *ist = getTool( storeName );
  if (ist != nullptr) {
    sc = ist->replaceProxy(pOld, pNew);
  } else {
    ATH_MSG_ERROR( "regProxy: no IOVSvcTool associated with store \"" 
                   << storeName << "\" and failed to create one."  );
  } 
  return sc;
}

resetAllProxies()

void IOVSvc::resetAllProxies ( )

overridevirtual

Definition at line 637 of file IOVSvc.cxx.

                        {
 
  for (auto& [name, ist] : m_toolMap) {
    ATH_MSG_DEBUG( "resetting all proxies for store \""
                   << ist->getStoreName() << "\""  );
    ist->resetAllProxies();
  }
 
}

setRange() [1/2]

StatusCode IOVSvc::setRange ( const CLID & clid, const std::string & key, IOVRange & iovr )

overridevirtual

Update Range from dB.

Definition at line 290 of file IOVSvc.cxx.

                                 {
 
  std::scoped_lock lock(m_lock);
 
  IIOVSvcTool *ist = getTool( clid, key );
  if (ist == nullptr) {
 
    // FIXME - this should be eliminated once the IOVDbSvc is set up to 
    // use store names. There should be no default store for setRange
 
    ATH_MSG_WARNING( "setRange(CLID,key,range) for unregistered proxies "
                     << "is deprecated - you need to specify a store! "
                     << "This will be an ERROR soon!" );
 
    return setRange(clid,key,iovr, defaultStore );
 
  } else {
    return ist->setRange( clid, key, iovr );
  }
 
}

setRange() [2/2]

StatusCode IOVSvc::setRange ( const CLID & clid, const std::string & key, IOVRange & io, const std::string & storeName )

overridevirtual

Definition at line 316 of file IOVSvc.cxx.

                                                             {
 
  std::scoped_lock lock(m_lock);
 
  IIOVSvcTool *ist = getTool( storeName );
  if (ist == nullptr) {
    ATH_MSG_ERROR( "setRange: no IOVSvcTool associated with store \""
                   << storeName << "\" and failed to create one."  );
    return StatusCode::FAILURE;
  }
 
  IIOVSvcTool *ist2 = getTool( clid, key );
  if (ist2 == nullptr) {
    ATH_MSG_INFO( "setRange: proxy for " << fullProxyName(clid,key)
                  << " not registered with store \"" << storeName << "\". Doing it now"
                  );
    if (ist->regProxy(clid, key).isFailure()) {
      return StatusCode::FAILURE;
    }
  } else if (ist2 != ist) {
    ATH_MSG_INFO( "setRange: when registering proxy (clid: " 
                  << clid << " key: " << key << ") with store \"" << storeName
                  << "\" --> already registered with store \"" << ist2->getStoreName()
                  << "\""  );
    return StatusCode::FAILURE;
  }
 
  return ist->setRange( clid, key, iovr );
 
}

setRangeInDB()

StatusCode IOVSvc::setRangeInDB ( const CLID & clid, const std::string & key, const IOVRange & range, const std::string & tag )

overridevirtual

Set a particular IOVRange in db (and memory)

Definition at line 458 of file IOVSvc.cxx.

                                                                  {
  
  IIOVSvcTool *ist = getTool( clid, key );
  if (ist == nullptr) {
    ATH_MSG_ERROR( "setRangeInDB: proxy for "
                   << fullProxyName(clid,key) << " not registered"  );
    return StatusCode::FAILURE;
  } else {
    return ist->setRangeInDB( clid, key, range, tag );
  }
 
}

Member Data Documentation

m_forceReset

Gaudi::Property<bool> IOVSvc::m_forceReset {this, "forceResetAtBeginRun", false}

private

Definition at line 141 of file IOVSvc.h.

{this, "forceResetAtBeginRun", false};

m_lock

std::recursive_mutex IOVSvc::m_lock

mutableprivate

Definition at line 153 of file IOVSvc.h.

m_partialPreLoadData

Gaudi::Property<bool> IOVSvc::m_partialPreLoadData {this, "partialPreloadData", true}

private

Definition at line 138 of file IOVSvc.h.

{this, "partialPreloadData", true};

m_preLoadData

Gaudi::Property<bool> IOVSvc::m_preLoadData {this, "preLoadData", false}

private

Definition at line 137 of file IOVSvc.h.

{this, "preLoadData", false};

m_preLoadExtensibleFolders

Gaudi::Property<bool> IOVSvc::m_preLoadExtensibleFolders {this, "preLoadExtensibleFolders", true}

private

Definition at line 139 of file IOVSvc.h.

{this, "preLoadExtensibleFolders", true};

m_preLoadRanges

Gaudi::Property<bool> IOVSvc::m_preLoadRanges {this, "preLoadRanges", false}

private

Definition at line 136 of file IOVSvc.h.

{this, "preLoadRanges", false};

m_sortKeys

Gaudi::Property<bool> IOVSvc::m_sortKeys {this, "sortKeys", true}

private

Definition at line 140 of file IOVSvc.h.

{this, "sortKeys", true};

m_toolMap

std::map< std::string, IIOVSvcTool* > IOVSvc::m_toolMap

private

Definition at line 149 of file IOVSvc.h.

m_updateInterval

Gaudi::Property<std::string> IOVSvc::m_updateInterval {this, "updateInterval", "Event"}

private

Definition at line 142 of file IOVSvc.h.

{this, "updateInterval", "Event"};

p_CLIDSvc

ServiceHandle<IClassIDSvc> IOVSvc::p_CLIDSvc

private

Definition at line 145 of file IOVSvc.h.

p_condSvc

ServiceHandle<ICondSvc> IOVSvc::p_condSvc

private

Definition at line 147 of file IOVSvc.h.

p_detStore

ServiceHandle<StoreGateSvc> IOVSvc::p_detStore

private

Definition at line 146 of file IOVSvc.h.

p_sgs

ServiceHandle<StoreGateSvc> IOVSvc::p_sgs

private

Definition at line 146 of file IOVSvc.h.

p_toolSvc

ServiceHandle<IToolSvc> IOVSvc::p_toolSvc

private

Definition at line 144 of file IOVSvc.h.

---

The documentation for this class was generated from the following files:

• IOVSvc.h
• IOVSvc.cxx