IOVRegistrationSvc Class Reference

Properties: More...

#include <IOVRegistrationSvc.h>

Inheritance diagram for IOVRegistrationSvc:

Collaboration diagram for IOVRegistrationSvc:

Public Member Functions
	IOVRegistrationSvc (const std::string &name, ISvcLocator *svc)
virtual	~IOVRegistrationSvc ()
virtual const InterfaceID &	type () const
	Service type.
virtual StatusCode	registerIOV (std::string_view typeName) const
	Register IOV DB for an object given its typeName - run/LB numbers interval or times interval and tag are taken from JobOptions Choice between run/LB and timestamp given in JobOptions.
virtual StatusCode	registerIOV (std::string_view typeName, std::string_view tag) const
	Register IOV DB for an object given its typeName - run/LB numbers interval or times interval taken from JobOptions tag is specified Choice between run/LB and timestamp given in JobOptions.
virtual StatusCode	registerIOV (std::string_view typeName, std::string_view key, std::string_view tag) const
	Register IOV DB for an object given its typeName and its key run/LB numbers interval or times interval and tag are taken from JobOptions Choice between run/LB and timestamp given in JobOptions.
virtual StatusCode	registerIOV (std::string_view typeName, std::string_view tag, unsigned int beginRun, unsigned int endRun, unsigned int beginLB, unsigned int endLB) const
	Register IOV DB for an object given its typeName, tag and run/LB numbers interval.
virtual StatusCode	registerIOV (std::string_view typeName, std::string_view tag, uint64_t beginTime, uint64_t endTime) const
	Register IOV DB for an object given its typeName, tag and times interval.
virtual StatusCode	registerIOV (std::string_view typeName, std::string_view key, std::string_view tag, unsigned int beginRun, unsigned int endRun, unsigned int beginLB, unsigned int endLB) const
	Register IOV DB for an object given its typeName, key, tag and run/LB numbers interval.
virtual StatusCode	registerIOV (std::string_view typeName, std::string_view key, std::string_view tag, uint64_t beginTime, uint64_t endTime) const
	Register IOV DB for an object given its typeName, key, tag and times interval.
virtual StatusCode	registerIOV (std::string_view typeName, std::string_view key, std::string_view folder, std::string_view tag, unsigned int beginRun, unsigned int endRun, unsigned int beginLB, unsigned int endLB) const
	Register IOV DB for an object given its typeName, key, folder, tag and run/LB numbers interval.
virtual StatusCode	registerIOV (std::string_view typeName, std::string_view key, std::string_view folder, std::string_view tag, uint64_t beginTime, uint64_t endTime) const
	Register IOV DB for an object given its typeName, key, folder, tag and times interval.
virtual StatusCode	initialize ()
	Initialize AlgTool.
virtual StatusCode	finalize ()
	Finalize AlgTool.

Private Member Functions
StatusCode	registerIOV (std::string_view typeName, std::string_view key, std::string_view folder, std::string_view tag, const IOVTime &begin, const IOVTime &end) const
StatusCode	registerIOVCOOL (std::string_view typeName, std::string_view key, std::string_view folderName, std::string_view tag, const IOVTime &begin, const IOVTime &end) const
cool::StorageType::TypeId	coralToCoolType (const std::string &parname, const std::string &coralName) const
StatusCode	getStringAddress (const CLID &clid, const std::string &key, std::string &saddr) const
uint64_t	timeToNano (const unsigned long int timesec) const
virtual StatusCode	buildDescription (std::string_view identifier, std::string_view value, std::string &description) const
	Build the folder description field add in front of the description the value with identifier-markups.
StatusCode	splitAddress (const std::string &address, std::string &address_header, std::string &address_data) const
	Split address in its header and data parts.

Private Attributes
Gaudi::Property< bool >	m_recreateFolders {this, "RecreateFolders", false}
Gaudi::Property< unsigned int >	m_beginRun {this, "BeginRun", IOVTime::MINRUN}
Gaudi::Property< unsigned int >	m_endRun {this, "EndRun", IOVTime::MAXRUN}
Gaudi::Property< unsigned int >	m_beginLB {this, "BeginLB", IOVTime::MINEVENT}
Gaudi::Property< unsigned int >	m_endLB {this, "EndLB", IOVTime::MAXEVENT}
Gaudi::Property< unsigned long >	m_beginTime {this, "BeginTime", IOVTime::MINTIMESTAMP}
Gaudi::Property< unsigned long >	m_endTime {this, "EndTime", IOVTime::MAXEVENT}
Gaudi::Property< std::string >	m_tag {this, "IOVDbTag", ""}
Gaudi::Property< bool >	m_timeStamp {this, "IOVDbTimeStamp", false}
Gaudi::Property< std::string >	m_tagDescription {this, "TagDescription", "Athena IOVRegistrationSvc"}
Gaudi::Property< bool >	m_writeKeyInfo {this, "writeKeyInfo", true}
Gaudi::Property< bool >	m_userTags {this, "userTags", true}
Gaudi::Property< bool >	m_userTagsUH {this, "userTagsUpdateHead", false}
Gaudi::Property< bool >	m_svFolder {this, "SVFolder", false}
Gaudi::Property< bool >	m_payloadTable {this, "PayloadTable", false}
Gaudi::Property< bool >	m_forceGlobalIOV {this, "UseGlobalIOVForCollections", false}
Gaudi::Property< std::vector< std::string > >	m_overrideName {this, "OverrideNames", {}}
Gaudi::Property< std::vector< std::string > >	m_overrideType {this, "OverrideTypes", {}}
ServiceHandle< IIOVCondDbSvc >	m_iov_db
ServiceHandle< StoreGateSvc >	m_detStore
ServiceHandle< IAddressCreator >	m_persSvc
ServiceHandle< IClassIDSvc >	m_clidSvc

Friends
class	SvcFactory< IOVRegistrationSvc >

Detailed Description

Properties:

• RecreateFolder:

    flag to force the recreation of the requested folder

• BeginRun:

          Begin run number

• EndRun:

            End run number

• BeginLB:

        Begin LB number

• EndLB:

          End LB number

• BeginTime:

         Begin time (ns)

• EndTime:

           End time (ns)

• IOVDbTag:

          the tag to be used

• IOVDbTimeStamp:

    the flag for time versus run-LB use

Definition at line 49 of file IOVRegistrationSvc.h.

Constructor & Destructor Documentation

IOVRegistrationSvc()

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

Definition at line 45 of file IOVRegistrationSvc.cxx.

    : 
    base_class( name, svc ),
    m_iov_db  ( "IOVDbSvc",            name ),
    m_detStore( "DetectorStore",       name ),
    m_persSvc ( "EventPersistencySvc", name ),
    m_clidSvc ( "ClassIDSvc",          name )
{
 
}

~IOVRegistrationSvc()

IOVRegistrationSvc::~IOVRegistrationSvc ( )

virtual

Definition at line 57 of file IOVRegistrationSvc.cxx.

{}

Member Function Documentation

buildDescription()

StatusCode IOVRegistrationSvc::buildDescription ( std::string_view identifier, std::string_view value, std::string & description ) const

privatevirtual

Build the folder description field add in front of the description the value with identifier-markups.

Definition at line 1124 of file IOVRegistrationSvc.cxx.

                                                                        {
  // this routine was originally in IOVDbSvc, moved here as only client
  // buids an XML fragment of form <identifier>value</identifier>
  if (identifier.empty() || value.empty()) {
    ATH_MSG_ERROR ("Identifier or value is null.");
    return StatusCode::FAILURE;
  }
  //note: appending instead of prepending would have been more efficient (to be explored)
  std::string fragment;
  fragment.reserve(identifier.size() * 2 + value.size() + 5);
  fragment.append("<");
  fragment.append(identifier);
  fragment.append(">");
  fragment.append(value);
  fragment.append("</");
  fragment.append(identifier);
  fragment.append(">");
  description.insert(0, fragment);
  return StatusCode::SUCCESS;
}

coralToCoolType()

cool::StorageType::TypeId IOVRegistrationSvc::coralToCoolType ( const std::string & parname, const std::string & coralName ) const

private

Definition at line 1072 of file IOVRegistrationSvc.cxx.

                                                              {
  // map coral type onto corresponding COOL storage type
  std::string coralType=coralName;
  // check for any overrides
  for (unsigned int i=0;i<m_overrideType.size();++i) {
    if (m_overrideName[i]==parname) {
      coralType=m_overrideType[i];
      ATH_MSG_INFO ("Override default type for attribute " << 
                    parname << " - use " << coralType);
    }
  }
  // FIXME to include all CORAL/COOL types
  // give both the names of CORAL types, and COOL types which may get specified
  // as overrides
  if (coralType=="bool") return cool::StorageType::Bool;
  if (coralType=="UChar" || coralType=="unsigned char") return cool::StorageType::UChar;
  if (coralType=="Int16") return cool::StorageType::Int16;
  if (coralType=="UInt16") return cool::StorageType::UInt16;
  if (coralType=="Int32" || coralType=="int") return cool::StorageType::Int32;
  if (coralType=="UInt32" || coralType=="unsigned int") return cool::StorageType::UInt32;
  if (coralType=="UInt63" || coralType=="unsigned long long") return cool::StorageType::UInt63;
  if (coralType=="Int64" || coralType=="long long") return cool::StorageType::Int64;
  if (coralType=="Float" || coralType=="float") return cool::StorageType::Float;
  if (coralType=="Double" || coralType=="double") return cool::StorageType::Double;
  if (coralType=="String255") return cool::StorageType::String255;
  if (coralType=="String4k" || coralType=="string") return cool::StorageType::String4k;
  if (coralType=="String64k") return cool::StorageType::String64k;
  if (coralType=="String16M") return cool::StorageType::String16M;
  if (coralType=="blob" || coralType=="Blob64k") 
    return cool::StorageType::Blob64k;
  if (coralType=="Blob16M") return cool::StorageType::Blob16M;
 
  // if we get here, mapping is undefined
  ATH_MSG_FATAL ("No COOL mapping defined for CORAL type " << coralName);
  throw std::exception();
}

finalize()

StatusCode IOVRegistrationSvc::finalize ( )

virtual

Finalize AlgTool.

Definition at line 141 of file IOVRegistrationSvc.cxx.

{
    return StatusCode::SUCCESS;
}

getStringAddress()

StatusCode IOVRegistrationSvc::getStringAddress ( const CLID & clid, const std::string & key, std::string & saddr ) const

private

initialize()

StatusCode IOVRegistrationSvc::initialize ( )

virtual

Initialize AlgTool.

Definition at line 68 of file IOVRegistrationSvc.cxx.

{
    ATH_MSG_DEBUG ("in initialize()");
 
    StatusCode sc = AthService::initialize();
    if ( sc.isFailure() ) {
      ATH_MSG_ERROR ("Unable to call base initialize method");
      return StatusCode::FAILURE;
    }
 
    // locate the conditions store ptr to it.
    sc = m_detStore.retrieve();
    if (!sc.isSuccess() || 0 == m_detStore)  {
       ATH_MSG_ERROR ("Could not find ConditionStore");
       return StatusCode::FAILURE;
    }
 
    // Get the IOVDbSvc
    sc = m_iov_db.retrieve();
    if ( sc.isFailure() ) {
      ATH_MSG_ERROR ("Unable to get the IOVDbSvc");
      return StatusCode::FAILURE;
    }
 
    // Get the persistency mgr for conversion of IOpaqueAddress to
    // string
    sc = m_persSvc.retrieve(); 
    if ( sc != StatusCode::SUCCESS ) {
        ATH_MSG_ERROR (" Cannot get IAddressCreator interface of the EventPersistencySvc ");
    return sc ;
    }
    ATH_MSG_DEBUG ("Found PersistencySvc ");
 
    
    // Get the ClassIDSvc - to get typename for clid
    sc = m_clidSvc.retrieve(); 
    if (sc != StatusCode::SUCCESS ) {
        ATH_MSG_ERROR (" Cannot get IClassIDSvc interface of the CLIDSvc " );
    return sc ;
    }
    ATH_MSG_DEBUG ("Found CLIDSvc ");
 
 
    ATH_MSG_DEBUG ("Properties ");
    ATH_MSG_DEBUG ("RecreateFolders " <<  m_recreateFolders);
    if (m_timeStamp)
      {
    ATH_MSG_DEBUG ("BeginTime      " <<  m_beginTime);
    ATH_MSG_DEBUG ("EndTime        " <<  m_endTime);
      }
    else
      {
    ATH_MSG_DEBUG ("BeginRun        " <<  m_beginRun);
    ATH_MSG_DEBUG ("EndRun          " <<  m_endRun);
    ATH_MSG_DEBUG ("BeginLB      " <<  m_beginLB);
    ATH_MSG_DEBUG ("EndLB        " <<  m_endLB);
      }
    ATH_MSG_DEBUG ("IOVDbTag        " <<  m_tag);
 
    // check consistency of override specification, if any
    if (m_overrideName.size()!=m_overrideType.size()) {
      ATH_MSG_FATAL ("Inconsistent settings of OverrideNames and OverrideTypes parameters");
      return StatusCode::FAILURE;
    }
    for (unsigned int i=0;i<m_overrideName.size();++i)
      ATH_MSG_INFO ("Attributes with name " << m_overrideName[i] <<
                    " will be stored as COOL type " << m_overrideType[i]);
    return StatusCode::SUCCESS;
 
}

registerIOV() [1/10]

StatusCode IOVRegistrationSvc::registerIOV ( std::string_view typeName ) const

virtual

Register IOV DB for an object given its typeName - run/LB numbers interval or times interval and tag are taken from JobOptions Choice between run/LB and timestamp given in JobOptions.

Definition at line 148 of file IOVRegistrationSvc.cxx.

{
  std::string key = "";
  
  if (m_timeStamp)
    {
      IOVTime start;
      start.setTimestamp(timeToNano(m_beginTime));
      IOVTime stop ;
      stop.setTimestamp(timeToNano(m_endTime));
 
      return ( registerIOV( typeName,
            key,key,
            m_tag.value(),
            start, 
            stop) );
    }
  else
    {
      IOVTime start;
      start.setRunEvent( (unsigned long)m_beginRun, (unsigned long)m_beginLB );
      IOVTime stop;
      stop.setRunEvent ( (unsigned long)m_endRun,   (unsigned long)m_endLB );
 
      return ( registerIOV( typeName,
            key,key,
            m_tag.value(),
            start, 
            stop) );
    }
}

registerIOV() [2/10]

StatusCode IOVRegistrationSvc::registerIOV ( std::string_view typeName, std::string_view key, std::string_view folder, std::string_view tag, const IOVTime & begin, const IOVTime & end ) const

private

Definition at line 384 of file IOVRegistrationSvc.cxx.

{
    // Register the conditions objects in the IOV database with
    // start/stop as the time interval
 
 
    msg() << MSG::DEBUG <<" in registerIOV()" 
          << " typename: "     << typeName << " - tag: " << tag;
    if (spec_key.empty())
      {
    msg() << " key: *empty* " << endmsg;
      }
    else
      {
    msg() << " spec_key " << spec_key << endmsg;
      }
    msg() << " - begin time: "   << start
          << " - end time: "     << stop
          << endmsg;
  
    // Check validity of start/stop
    if(start.isBoth() || stop.isBoth() || 
       start.isTimestamp() != stop.isTimestamp() ||
       start.isRunEvent() != stop.isRunEvent()) {
        ATH_MSG_ERROR ("Incorrect start/stop: " 
                       << " isBoth: " << start.isBoth() << ":" << stop.isBoth() 
                       << " isTimestamp: " << start.isTimestamp() << ":" << stop.isTimestamp() 
                       << " isRunEvent: " << start.isRunEvent() << ":" << stop.isRunEvent());
    return( StatusCode::FAILURE);
    }
    
    return registerIOVCOOL( typeName,
                spec_key,
                folder,
                tag,
                start, 
                stop );
}

registerIOV() [3/10]

StatusCode IOVRegistrationSvc::registerIOV ( std::string_view typeName, std::string_view key, std::string_view folder, std::string_view tag, uint64_t beginTime, uint64_t endTime ) const

virtual

Register IOV DB for an object given its typeName, key, folder, tag and times interval.

Definition at line 358 of file IOVRegistrationSvc.cxx.

{
  IOVTime start;
  start.setTimestamp( beginTime );
  IOVTime stop;
  stop.setTimestamp ( endTime );
 
  return ( registerIOV( typeName,
            key,
                    folder,
            tag,
            start, 
            stop) );
}

registerIOV() [4/10]

StatusCode IOVRegistrationSvc::registerIOV ( std::string_view typeName, std::string_view key, std::string_view folder, std::string_view tag, unsigned int beginRun, unsigned int endRun, unsigned int beginLB, unsigned int endLB ) const

virtual

Register IOV DB for an object given its typeName, key, folder, tag and run/LB numbers interval.

Definition at line 334 of file IOVRegistrationSvc.cxx.

{
  IOVTime start;
  start.setRunEvent( (unsigned long)beginRun, (unsigned long)beginLB );
  IOVTime stop;
  stop.setRunEvent ( (unsigned long)endRun,   (unsigned long)endLB );
 
  return ( registerIOV( typeName,
            key,
            folder,
            tag,
            start, 
            stop) );
}

registerIOV() [5/10]

StatusCode IOVRegistrationSvc::registerIOV ( std::string_view typeName, std::string_view key, std::string_view tag ) const

virtual

Register IOV DB for an object given its typeName and its key run/LB numbers interval or times interval and tag are taken from JobOptions Choice between run/LB and timestamp given in JobOptions.

Definition at line 216 of file IOVRegistrationSvc.cxx.

{
  if (m_timeStamp)
    {
      IOVTime start;
      start.setTimestamp( timeToNano(m_beginTime) );
      IOVTime stop ;
      stop.setTimestamp ( timeToNano(m_endTime) );   
          
      return ( registerIOV( typeName,
            key,key,
            tag,
            start, 
            stop) );
    }
  else
    {
      IOVTime start;
      start.setRunEvent( (unsigned long)m_beginRun, (unsigned long)m_beginLB );
      IOVTime stop;
      stop.setRunEvent ( (unsigned long)m_endRun,   (unsigned long)m_endLB );
      
      return ( registerIOV( typeName,
            key,key,
            tag,
            start, 
            stop) );
    }
}

registerIOV() [6/10]

StatusCode IOVRegistrationSvc::registerIOV ( std::string_view typeName, std::string_view key, std::string_view tag, uint64_t beginTime, uint64_t endTime ) const

virtual

Register IOV DB for an object given its typeName, key, tag and times interval.

Definition at line 314 of file IOVRegistrationSvc.cxx.

{
  IOVTime start;
  start.setTimestamp( beginTime );
  IOVTime stop;
  stop.setTimestamp ( endTime );
 
  return ( registerIOV( typeName,
                key,key,
            tag,
            start, 
            stop) );
}

registerIOV() [7/10]

StatusCode IOVRegistrationSvc::registerIOV ( std::string_view typeName, std::string_view key, std::string_view tag, unsigned int beginRun, unsigned int endRun, unsigned int beginLB, unsigned int endLB ) const

virtual

Register IOV DB for an object given its typeName, key, tag and run/LB numbers interval.

Definition at line 292 of file IOVRegistrationSvc.cxx.

{
  IOVTime start;
  start.setRunEvent( (unsigned long)beginRun, (unsigned long)beginLB );
  IOVTime stop;
  stop.setRunEvent ( (unsigned long)endRun,   (unsigned long)endLB );
 
  return ( registerIOV( typeName,
            key,key,
            tag,
            start, 
            stop) );
}

registerIOV() [8/10]

StatusCode IOVRegistrationSvc::registerIOV ( std::string_view typeName, std::string_view tag ) const

virtual

Register IOV DB for an object given its typeName - run/LB numbers interval or times interval taken from JobOptions tag is specified Choice between run/LB and timestamp given in JobOptions.

Definition at line 182 of file IOVRegistrationSvc.cxx.

{
  std::string key = "";
  
  if (m_timeStamp)
    {
      IOVTime start;
      start.setTimestamp( timeToNano(m_beginTime) );
      IOVTime stop ;
      stop.setTimestamp ( timeToNano(m_endTime) );   
          
      return ( registerIOV( typeName,
            key,key,
            tag,
            start, 
            stop) );
    }
  else
    {
      IOVTime start;
      start.setRunEvent( (unsigned long)m_beginRun, (unsigned long)m_beginLB );
      IOVTime stop;
      stop.setRunEvent ( (unsigned long)m_endRun,   (unsigned long)m_endLB );
      
      return ( registerIOV( typeName,
            key,key,
            tag,
            start, 
            stop) );
    }
}

registerIOV() [9/10]

StatusCode IOVRegistrationSvc::registerIOV ( std::string_view typeName, std::string_view tag, uint64_t beginTime, uint64_t endTime ) const

virtual

Register IOV DB for an object given its typeName, tag and times interval.

Definition at line 271 of file IOVRegistrationSvc.cxx.

{
  IOVTime start;
  start.setTimestamp( beginTime );
  IOVTime stop;
  stop.setTimestamp ( endTime );
 
  std::string key = "";
  
  return ( registerIOV( typeName,
            key,key,
            tag,
            start, 
            stop) );
}

registerIOV() [10/10]

StatusCode IOVRegistrationSvc::registerIOV ( std::string_view typeName, std::string_view tag, unsigned int beginRun, unsigned int endRun, unsigned int beginLB, unsigned int endLB ) const

virtual

Register IOV DB for an object given its typeName, tag and run/LB numbers interval.

Definition at line 249 of file IOVRegistrationSvc.cxx.

{
  IOVTime start;
  start.setRunEvent( (unsigned long)beginRun, (unsigned long)beginLB );
  IOVTime stop;
  stop.setRunEvent ( (unsigned long)endRun,   (unsigned long)endLB );
  std::string key = "";
  
  return ( registerIOV( typeName,
            key,key,
            tag,
            start, 
            stop) );
}

registerIOVCOOL()

StatusCode IOVRegistrationSvc::registerIOVCOOL ( std::string_view typeName, std::string_view key, std::string_view folderName, std::string_view tag, const IOVTime & begin, const IOVTime & end ) const

private

Definition at line 432 of file IOVRegistrationSvc.cxx.

{
    // Register the conditions objects in the IOV database with
    // start/stop as the time interval
 
    std::string tagStr{tag}; //for cool interfaces
    ATH_MSG_DEBUG (" in registerIOVCOOL()" );
  
 
    // Find the clid for type name from the CLIDSvc
    CLID clid;
    //goes to GaudiKernel ClassIDSvc, interface is std::string
    StatusCode sc = m_clidSvc->getIDOfTypeName(std::string{typeName}, clid);
    if (sc.isFailure()) {
        ATH_MSG_ERROR ("Could not get clid for typeName " << typeName);
    return( StatusCode::FAILURE);
    }
 
    try {
 
    // There are two possible states:
    //   1) The DataObject is stored elsewhere and we store in the
    //      IOVDb only a stringified ref to the object, or
    //   2) The DataObject is an AthenaAttributeList or a
    //      CondAttrListCollection and then we store it directly into
    //      the IOVDb. 
    //
    //   The second case is detected either with the type name,
    //   for AthenaAttributeList or CondAttrListCollection, or by
    //   checking the real type of the IOA - i.e. if it is a
    //   CondAttrListCollAddress then a CondAttrListCollection may
    //   have been filled with pool refs stored in it.
 
    bool storeRef          = true;
    bool storeAttrListColl = false;
    bool needSGaddr=false;
    if ("AthenaAttributeList" == typeName) {
      storeRef = false;
      needSGaddr=false;
    }
    if ("CondAttrListCollection" == typeName) {
        storeRef           = false;
        storeAttrListColl  = true;
        needSGaddr=false;
    }
    // (See after retrieval of the IOA for a final check of the
    // type of storage.)
 
    // Get IOpaqueAddress, key and symlinks for each data object
    // from StoreGate
    IOpaqueAddress* addr=0;
    std::string key{spec_key}; 
    std::vector<CLID> symlinks;
    SG::DataProxy* proxy;
    if (key.empty()) {
        // Get IOpaqueAddress and key for each data object from
        // StoreGate
        proxy = m_detStore->proxy(clid);
        if (!proxy) {
          ATH_MSG_ERROR ("Could not get proxy for clid " << clid);
          return( StatusCode::FAILURE);
        }
        
        // Get key to be used for folder name
        key = proxy->name();
        // get proxy address - this will fail if object not streamed out
        // but this can be recovered later for inline data
        addr = proxy->address();
    } else {
        // Get IOpaqueAddress for each data object from StoreGate
        proxy = m_detStore->proxy(clid, key);
        if (!proxy) {
          ATH_MSG_ERROR ("Could not get proxy for clid " << clid << " and key " << key);
          return( StatusCode::FAILURE );
        }
        // get proxy address - this will fail if object not streamed out
        // but this can be recovered later for inline data
        addr = proxy->address();
    }
    std::string saddr;
    if (addr) {
      // Get symlinks, if any
          symlinks = proxy->transientID();
          auto it = std::find (symlinks.begin(), symlinks.end(), clid);
          if (it != symlinks.end()) {
            symlinks.erase (it);
          }
 
      // Check whether the IOA is a CondAttrListCollAddress - if so
      // we will store a CondAttrListCollection
      CondAttrListCollAddress* collAddr = dynamic_cast<CondAttrListCollAddress*>(addr);
      if (collAddr) {
        storeRef           = false;
        storeAttrListColl  = true;
      }
      // Convert IOpaqueAddress to string via the persistency
      // service. We then store the string address in the IOV DB
      sc = m_persSvc->convertAddress(addr, saddr);   
      if (sc.isFailure()) {
        ATH_MSG_WARNING ("Could not get string from IOpaqueAddress for clid " << clid
                         << " is BAD_STORAGE_TYPE: " << (sc == IConversionSvc::Status::BAD_STORAGE_TYPE));
      return( StatusCode::FAILURE);
      }
      ATH_MSG_DEBUG ("String address = \"" << saddr << "\"");
    } else {
      // if no addr was found, object has not been streamed out
      // this is OK providing we do not need the addr later
      // i.e. plain CondAttrListCollection or AthenaAttributeList
      if (needSGaddr) {
        ATH_MSG_ERROR ("Could not get address for clid " << clid);
        return( StatusCode::FAILURE );
      } else {
        ATH_MSG_DEBUG ("Faking address for " << typeName);
        // fake the saddr contents 
        if ("AthenaAttributeList" == typeName) {
          saddr="<address_header service_type=\"256\" clid=\"40774348\" /> POOLContainer_AthenaAttributeList][CLID=x";
        } else if ("CondAttrListCollection" == typeName) {
          saddr="<address_header service_type=\"256\" clid=\"1238547719\" /> POOLContainer_CondAttrListCollection][CLID=x";
        } else {
          ATH_MSG_ERROR ("Cannot fake stringaddress for typename "
                             << typeName);
        }
      }
    }
 
    ATH_MSG_DEBUG ("Storing ref: " << storeRef 
                       << " Storing AttrListCollection: " << storeAttrListColl);
 
    // Set folder name - in the present case this is defined
    // to be the key 
    // RJH - unless a non-null folder is given on input
    std::string local_folder;
    if (""==folderName) {
      local_folder = key;
    } else {
      local_folder=folderName;
    }
    ATH_MSG_DEBUG ("Using folder name " << local_folder);
      
    // Get COOL database in update mode (false == readOnly flag)
    cool::IDatabasePtr db = m_iov_db->getDatabase(false); 
    if (!db) {
            ATH_MSG_ERROR ("Could not get pointer to COOL db ");
        return(StatusCode::FAILURE);       
    }
    // get some information about the database connection for later checks
    const cool::DatabaseId& dbid=db->databaseId();
    // look for direct connection to production accounts
    bool dbidprod=(dbid.find("oracle")!=std::string::npos && (
               dbid.find("ATLAS_COOLONL_")!=std::string::npos ||
               dbid.find("ATLAS_COOLOFL_")!=std::string::npos ||
               dbid.find("ATLAS_COOL_")!=std::string::npos));
    // look for use of writer account ('_W' in connection string)
    bool dbidwriter=(dbid.find("oracle")!=std::string::npos && 
             dbid.find("_W")!=std::string::npos);
    ATH_MSG_DEBUG ("Identified prod/writer " << dbidprod << dbidwriter);
    // do not allow write accesss to production servers
    if (dbidprod) {
      ATH_MSG_FATAL ("Direct update of production Oracle servers from Athena is FORBIDDEN");
      ATH_MSG_FATAL ("Please write to SQLite file and then merge with AtlCoolMerge.py");
      return StatusCode::FAILURE;
    }
    
    // For AthenaAttributeList/CondAttrListCollection, save a pointer to the object
    const AthenaAttributeList*    attrList     = 0;
    const CondAttrListCollection* attrListColl = 0;
 
    if (!storeRef) {
        if ("CondAttrListCollection"==typeName) {
          if (StatusCode::SUCCESS!=m_detStore->
          retrieve(attrListColl,key)) {
                ATH_MSG_ERROR ("Could not find CondAttrListCollecton for "
                               << key);
        return StatusCode::FAILURE;
          }
        } else if (storeAttrListColl) {
          // have to go through SG proxy, as it is a collection of POOLref
          if (addr) {
        CondAttrListCollAddress* attrAddr = dynamic_cast<CondAttrListCollAddress*>(addr);
        if (attrAddr) {
            // Successful cast
            attrListColl = attrAddr->attrListColl();
            ATH_MSG_DEBUG ("Set attr list coll ptr ");
            ATH_MSG_DEBUG ("addr, attrAddr, coll " 
                                   << addr << " " << attrAddr << " " << attrListColl);
        } else {
          ATH_MSG_ERROR ("Could not extract ptr for CondAttrListCollAddress ");
          return StatusCode::FAILURE;
        }
          } else {
        ATH_MSG_ERROR ("Cannot write out collection of POOLref without streaming them first" );
        return StatusCode::FAILURE;
          }
        } else {
          // Just AttrList - get directly from Storegate
          if (StatusCode::SUCCESS!=m_detStore->retrieve(attrList,key)) {
        ATH_MSG_ERROR ("Could not find AthenaAttributeList for "
                               << key);
        return StatusCode::FAILURE;
          }
        }
        
    }
 
 
    ATH_MSG_DEBUG ("Set attr list coll ptr " << attrListColl);
 
    // Save folder pointer
    cool::IFolderPtr folder;
 
    // Create folders if required - a job option allows on to
    // delete existing folders and then recreate them
 
    bool createFolders = false;
 
    if(db->existsFolder(local_folder)) {
 
        if (m_recreateFolders) {
            // do not allow this action on production schema or with writer
            if (dbidprod || dbidwriter) {
          ATH_MSG_FATAL ("Apparent attempt to delete folder on production COOL schema " << dbid);
          return StatusCode::FAILURE;
            }
        
        ATH_MSG_DEBUG (" Deleting existing COOL Folder " << local_folder);
        db->dropNode( local_folder ); 
        createFolders = true;
        }
        else {
        // Get folder
                ATH_MSG_DEBUG ("COOL Folder " << local_folder << " exists");
        folder = db->getFolder(local_folder);
        }
 
    }
    else {
            ATH_MSG_DEBUG ("COOL Folder " << local_folder 
                           << " does not exist - must create it");
        createFolders = true;
    }
        
    // Split the string address into header and data parts
    std::string address_header;
    std::string address_data;
 
    sc = splitAddress(saddr,address_header,address_data);
    if (sc.isFailure()) {
            ATH_MSG_ERROR ("Could not split address: "
                           << "addr: " << saddr << "\n"
                           << "hdr:  " << address_header << "\n"
                           << "data  " << address_data);
        return( StatusCode::FAILURE);
    }
    msg() << MSG::DEBUG <<"split address: " << saddr << endmsg
              << "  hdr:  " << address_header << endmsg
              << "  data: " << address_data << endmsg;
                
 
    if(createFolders) {
        // first make sure not using writer account -if so abort
        if (dbidwriter) {
          ATH_MSG_FATAL ("Apparent attempt to create folder using writer account, dbID is: " << dbid);
          return StatusCode::FAILURE;
        }
 
        // We store extra information in the folder description. 
        // This info is:
        //   typeName       - required information
        //   symlinks       - the extra StoreGate keys, if any
        //   key            - optional, only needed if key != folder name
        //   timeStamp      - either run-lumi (default) or time
        //   address_header - added by convention
        //
        //
        // The convention is that the address_header is stored
        // in the description, and the IOV interval data
        // payload is just the pool reference in string form.
        // The address_header and address_data can be obtained
        // from the string address returned from the
        // persistency service, using splitAddress
 
        std::string mergedNames;
 
        sc = buildDescription( "typeName", typeName,
                         mergedNames );
        if (sc.isFailure()) {
                ATH_MSG_ERROR ("Could not merge towards merged description: "
                               << "typeName: " << typeName);
        return( StatusCode::FAILURE);
        }
        
        sc = buildDescription( "addrHeader", address_header,
                         mergedNames );
        if (sc.isFailure()) {
                ATH_MSG_ERROR ("Could not merge towards merged description: "
                               << "addrHeader: " << address_header);
        return( StatusCode::FAILURE);
        }
        // RJH - if key is not same as folder, and we want the read-back
        // objects to end up in the TDS with the given Storegate key rather
        // than the folder name, need to set the <key> attribute
        // a jobOption WriteKeyInfo=FALSE disables this, in case you have
        // created objects with the 'wrong' SG key and want the key
        // on read-back to correspond to the folder name
        if (local_folder!=key && m_writeKeyInfo) {
          sc=buildDescription("key",key,mergedNames);
          if (sc.isFailure()) {
        ATH_MSG_ERROR ("Could not merge towards merged description: "
                               << "key: " << key);
        return( StatusCode::FAILURE);
          }
        }
 
        // Add in symlink types
        if (!symlinks.empty()) {
        std::string symlinkTypes;
        for (unsigned int i = 0; i < symlinks.size(); ++i) {
            std::string type;
            sc = m_clidSvc->getTypeNameOfID(symlinks[i], type);
            if (sc.isFailure()) {
                        ATH_MSG_ERROR ("Could not get type name for symlink clid "
                                       << symlinks[i]);
            return( StatusCode::FAILURE);
            }
            else {
                        ATH_MSG_DEBUG ("adding symlink: clid, type  " 
                                       << symlinks[i] << " " << type);
            }
            if (symlinkTypes.size()) symlinkTypes += ':';
            symlinkTypes += type;
        }
        sc=buildDescription("symlinks", symlinkTypes, mergedNames);
        if (sc.isFailure()) {
                  msg() << MSG::ERROR <<"Could not merge symlinks to merged description: "
            << "symlink types: ";
            for (unsigned int i = 0; i < symlinkTypes.size(); ++i) {
                      msg() << MSG::ERROR << symlinkTypes[i] << " ";
            }
            msg() << MSG::ERROR << endmsg;
            return( StatusCode::FAILURE);
        }
        else {
                  ATH_MSG_DEBUG ("symlinks, merged names " 
                                 << symlinkTypes << " " << mergedNames);
        }
        }
 
        // Type of time is defined by start/stop
 
        // Some checks on the times:
        if (!start.isValid() || 
        !stop.isValid()  || 
        start.isTimestamp() != stop.isTimestamp() || 
        start.isRunEvent() != stop.isRunEvent()) {
                ATH_MSG_ERROR ("Invalid times: start isValid/isTimeStamp/isRunEvent "
                               << "addrHeader: " << address_header
                               << start.isValid() << " " << start.isTimestamp() << " " 
                               << start.isRunEvent());
                ATH_MSG_ERROR ("Invalid times: stop isValid/isTimeStamp/isRunEvent "
                               << "addrHeader: " << address_header
                               << stop.isValid() << " " << stop.isTimestamp() << " " 
                               << stop.isRunEvent());
        return( StatusCode::FAILURE);
        }
        bool isTimeStamp = false;
        if (start.isTimestamp()) isTimeStamp = true;
 
        if (isTimeStamp)
          {
        sc = buildDescription( "timeStamp", "time",
                         mergedNames );
          }
        else
          {
        sc = buildDescription( "timeStamp", "run-lumi",
                         mergedNames );
          }
        if (sc.isFailure()) { 
                ATH_MSG_ERROR ("Could not merge timeStamp flag towards merged description. ");
        return( StatusCode::FAILURE);
        }
        // add <named/> for channels with names
        if (storeAttrListColl && attrListColl!=0 && 
        attrListColl->name_size()>0) mergedNames+="<named/>";
        
        ATH_MSG_DEBUG (" create folder " << local_folder 
                           << " with description " << mergedNames);
 
        // Create folder 
 
            ATH_MSG_DEBUG ("Set attr list coll ptr " << attrListColl);
 
        cool::RecordSpecification payloadSpec;
        if (storeRef) {
        // Folder with refs only:
        // Payload specification - contains just a string
            // assuming POOL refs will not be longer than 4000 chars
        payloadSpec.extend("PoolRef",cool::StorageType::String4k);
        }
        else {
        // Store AttributeList or a collection of AttributeLists
            const coral::AttributeList* atr4spec=0;
        if (storeAttrListColl) {
 
            // Folder with CondAttrListCollection itself
            // Get the attribute spec from the first element in the collection
            if (0 == attrListColl) {
                        ATH_MSG_ERROR ("attrListColl not found. ");
            return( StatusCode::FAILURE);
            }
        
            if (0 == attrListColl->size()) {
                        ATH_MSG_ERROR ("attrListColl is empty. ");
            return( StatusCode::FAILURE);
            }
            // FIXME
                    ATH_MSG_DEBUG ("Size of AttrList collection" <<
                                   attrListColl->size());
 
                    atr4spec=&((*attrListColl->begin()).second);
        } else {
            // folder with simple AttributeList
            atr4spec=attrList;
                    ATH_MSG_DEBUG ("In simple atrlist branch");
        }
                ATH_MSG_DEBUG ("Pointer to atrList is " << atr4spec);
        // construct COOL specification
        for (coral::AttributeList::const_iterator itr=
               atr4spec->begin();itr!=atr4spec->end();++itr) {
          // extend specification with appropriate COOL type
          // giving opportunity to override default choice
          payloadSpec.extend(itr->specification().name(),
                    coralToCoolType(itr->specification().name(),
                    itr->specification().typeName()));
        }
        }
        // create folder
        cool::FolderVersioning::Mode version=
          cool::FolderVersioning::MULTI_VERSION;
        if (m_svFolder) {
          version=cool::FolderVersioning::SINGLE_VERSION;
              ATH_MSG_INFO ("Creating single version folder for "
                            << local_folder);
        }
        if (m_payloadTable)
              ATH_MSG_INFO ("Creating separate payload table for "
                            << local_folder);
        cool::FolderSpecification folderSpec(version,payloadSpec,cool::PayloadMode::SEPARATEPAYLOAD);
        folder = db->createFolder(local_folder,folderSpec,
                  mergedNames,true); 
            ATH_MSG_DEBUG ("Creation of CondDBFolder " << 
                           local_folder << " done");
 
        // create channels if needed - only for CondAttrListColl with names
        if (storeAttrListColl && attrListColl!=0 && 
        attrListColl->name_size()>0) {
              ATH_MSG_DEBUG ("Naming " << attrListColl->name_size() <<
                             " channels in " << local_folder);
          for (CondAttrListCollection::name_const_iterator nitr=
             attrListColl->name_begin();
           nitr!=attrListColl->name_end();++nitr) {
        folder->createChannel(nitr->first,nitr->second);
          }
        }
    }
        
    // Print out stop/start ONLY for non-collections - collections
    // have a per-channel start/stop
    if (storeAttrListColl) {
            ATH_MSG_DEBUG (" Global Start/stop time: "
                           << start << " " << stop << " Note: will be ignored for channels with differnt IOVs " );
    }
    else {
            ATH_MSG_DEBUG (" Start/stop time " << start << " " << stop << " ");
    }
 
    // Convert IOVTime to ValidityKey
    cool::ValidityKey ivStart = start.re_time();
    cool::ValidityKey ivStop  = stop.re_time();
    if(start.isTimestamp()) {
        ivStart = start.timestamp();
        ivStop  = stop.timestamp();
    }
 
    // get record specification of folder
            
    const cool::RecordSpecification& rspec=folder->payloadSpecification();
 
    if (storeAttrListColl) {
        //
        // Need to store multiple channels
        //
        //  The policy for the IOV of each channel is to use the
        //  channel IOV already stored in the collection, if it is
        //  there. If it is not there, then use the global IOV. 
        //
        if (storeRef) {
        // Should NOT get here for a collection, signal error
                ATH_MSG_ERROR ("Trying to store a ref for a CondAttrListCollection. ");
        return( StatusCode::FAILURE);
        }
 
        ATH_MSG_DEBUG (" --> Storing Object( " << start << ", " << stop 
                           << ", " << tag << " )");
        ATH_MSG_DEBUG (" -->   address: " << address_data);
        // Loop over collection
        CondAttrListCollection::const_iterator first = attrListColl->begin();
        CondAttrListCollection::const_iterator last  = attrListColl->end();
        for (; first != last; ++first) {
 
        // Copy from retrieved attribute list
        const coral::AttributeList& payload = (*first).second;
        // Get channel id
        CondAttrListCollection::ChanNum chanNum = (*first).first;
 
        // Check whether to use already stored IOV, or the
        // global IOV
        cool::ValidityKey ivStart1 = ivStart;
        cool::ValidityKey ivStop1  = ivStop;
        CondAttrListCollection::iov_const_iterator iovIt = attrListColl->chanIOVPair(chanNum);
        std::ostringstream attr;
        payload.toOutputStream( attr );
        ATH_MSG_DEBUG (" --> ChanNum: " << chanNum << " Payload: " << attr.str());
        if (!m_forceGlobalIOV && iovIt != attrListColl->iov_end()) {
            const IOVRange& range = (*iovIt).second;
            if(range.start().isTimestamp()) {
            ivStart1 = range.start().timestamp();
            ivStop1  = range.stop().timestamp();
            }
            else {
            ivStart1 = range.start().re_time();
            ivStop1  = range.stop().re_time();
            }
            ATH_MSG_DEBUG (" --> Start/stop time " 
                                   << range.start() << " " << range.stop() << " ");
        }
        else {
                  ATH_MSG_DEBUG (" --> Start/stop time " 
                                 << start << " " << stop << " ");
        }
        
        // Store address in folder with interval
        cool::Record record(rspec,payload);
        if (m_userTags && tag!="") {
              ATH_MSG_DEBUG ("Object stored with user tag " << tag );
          folder->storeObject( ivStart1, ivStop1, record, chanNum, tagStr,!m_userTagsUH);
        } else {
          folder->storeObject( ivStart1, 
                                       ivStop1,
                                       record,
                                       chanNum);
        }
        }
    }
    else {
        // Store a single channel
        cool::Record record(rspec);
        if (storeRef) {
          // PayLoad is ONLY the ref
          record["PoolRef"].setValue<std::string>(address_data);
        }
        else {
          // Copy from retrieved attribute list
          record=cool::Record(rspec,*attrList);
        }
 
        // Store address in folder with interval
        if (m_userTags && !tag.empty()) {
          ATH_MSG_DEBUG ("Object stored with user tag " << tag );
          folder->storeObject( ivStart, 
                                   ivStop,
                                   record,0,tagStr,!m_userTagsUH);
        } else {
          folder->storeObject( ivStart, 
                                   ivStop,
                                   record,0);
        }
          
        ATH_MSG_DEBUG (" --> Stored Object( " << start << ", " << stop 
                           << ", " << tag << " )");
        ATH_MSG_DEBUG (" -->   address: " << address_data);
    }
    
    ATH_MSG_DEBUG (" storeData OK ");
          
    // Now tag the folder if required
    if (!m_userTags) {
      if ("" == tag) {
              ATH_MSG_DEBUG (" tag is empty - folder is not being tagged ");
      }
      else {
            ATH_MSG_INFO (" Tagging HEAD of folder " << local_folder << 
                          " with tag " << tag);
        try { 
          folder->tagCurrentHead(tagStr,m_tagDescription);
        }
        catch ( cool::TagExists& e) {
              ATH_MSG_INFO ("Tag " << tag << 
                            " exists - attempt to delete tag and retag HEAD");
          // first check this tag is really defined in THIS folder
              std::vector<std::string> taglist=folder->listTags();
          if (find(taglist.begin(),taglist.end(),tag)==
          taglist.end()) {
                  ATH_MSG_ERROR ("Tag is defined in another folder - tag names must be global");
          } else if (folder->existsUserTag(tagStr)) {
        // this is a COOL user tag, in which case user
            // is trying to mix user and HEAD tags, not allowed in COOL1.3
        ATH_MSG_ERROR ("Tag " << tag << 
                               " is already USER tag - cannot mix tagging modes");
          } else {
            try {
              folder->deleteTag(tagStr);
                  folder->tagCurrentHead(tagStr,m_tagDescription);
              ATH_MSG_INFO ("Delete and retag succeeded");
            }
            catch ( cool::TagNotFound& e) {
              ATH_MSG_ERROR ("Delete and retag HEAD failed");
            }
          }
        }
      }
    }
    return StatusCode::SUCCESS;
    }
    
    catch (std::exception& e) {
        ATH_MSG_ERROR ("*** COOL  exception caught: " << e.what() );
        // << "\n"
        //      << "***   error code: " << e.code() 
    return StatusCode::FAILURE;
    }
 
    //return StatusCode::SUCCESS;
}

splitAddress()

StatusCode IOVRegistrationSvc::splitAddress ( const std::string & address, std::string & address_header, std::string & address_data ) const

private

Split address in its header and data parts.

Definition at line 1147 of file IOVRegistrationSvc.cxx.

                                                                  {
  // this routine was originally in IOVDbSvc, moved here as only client
  // Deals with address of form
  // <address_header service_type="256" clid="1238547719" /> POOLContainer_CondAttrListCollection][CLID=x
  // return header as part up to and including />, trailer as rest
 
  std::string::size_type p1=address.find(" />");
  if (p1!=std::string::npos) {
    address_header=address.substr(0,p1+3);
    address_data=address.substr(p1+4);
    return StatusCode::SUCCESS;
  } else {
    return StatusCode::FAILURE;
  }
}

timeToNano()

uint64_t IOVRegistrationSvc::timeToNano ( const unsigned long int timesec ) const

private

Definition at line 1113 of file IOVRegistrationSvc.cxx.

{
  // convert time specified in seconds to ns used by COOL
  // use the magic value MAXEVENT to signal full range
  if (timesec==IOVTime::MAXEVENT) {
    return IOVTime::MAXTIMESTAMP;
  } else {
    return static_cast<uint64_t>(timesec)*1000000000;
  }
}

type()

const InterfaceID & IOVRegistrationSvc::type ( ) const

virtual

Service type.

Definition at line 60 of file IOVRegistrationSvc.cxx.

{ 
    return IIOVRegistrationSvc::interfaceID();
}

Friends And Related Symbol Documentation

SvcFactory< IOVRegistrationSvc >

friend class SvcFactory< IOVRegistrationSvc >

friend

Definition at line 138 of file IOVRegistrationSvc.h.

Member Data Documentation

m_beginLB

Gaudi::Property<unsigned int> IOVRegistrationSvc::m_beginLB {this, "BeginLB", IOVTime::MINEVENT}

private

Definition at line 183 of file IOVRegistrationSvc.h.

{this, "BeginLB", IOVTime::MINEVENT};

m_beginRun

Gaudi::Property<unsigned int> IOVRegistrationSvc::m_beginRun {this, "BeginRun", IOVTime::MINRUN}

private

Definition at line 181 of file IOVRegistrationSvc.h.

{this, "BeginRun", IOVTime::MINRUN};

m_beginTime

Gaudi::Property<unsigned long> IOVRegistrationSvc::m_beginTime {this, "BeginTime", IOVTime::MINTIMESTAMP}

private

Definition at line 186 of file IOVRegistrationSvc.h.

{this, "BeginTime", IOVTime::MINTIMESTAMP};

m_clidSvc

ServiceHandle<IClassIDSvc> IOVRegistrationSvc::m_clidSvc

private

Definition at line 204 of file IOVRegistrationSvc.h.

m_detStore

ServiceHandle<StoreGateSvc> IOVRegistrationSvc::m_detStore

private

Definition at line 202 of file IOVRegistrationSvc.h.

m_endLB

Gaudi::Property<unsigned int> IOVRegistrationSvc::m_endLB {this, "EndLB", IOVTime::MAXEVENT}

private

Definition at line 184 of file IOVRegistrationSvc.h.

{this, "EndLB", IOVTime::MAXEVENT};

m_endRun

Gaudi::Property<unsigned int> IOVRegistrationSvc::m_endRun {this, "EndRun", IOVTime::MAXRUN}

private

Definition at line 182 of file IOVRegistrationSvc.h.

{this, "EndRun", IOVTime::MAXRUN};

m_endTime

Gaudi::Property<unsigned long> IOVRegistrationSvc::m_endTime {this, "EndTime", IOVTime::MAXEVENT}

private

Definition at line 187 of file IOVRegistrationSvc.h.

{this, "EndTime", IOVTime::MAXEVENT}; // as the time parameter is only 32bit

m_forceGlobalIOV

Gaudi::Property<bool> IOVRegistrationSvc::m_forceGlobalIOV {this, "UseGlobalIOVForCollections", false}

private

Definition at line 197 of file IOVRegistrationSvc.h.

{this, "UseGlobalIOVForCollections", false};

m_iov_db

ServiceHandle<IIOVCondDbSvc> IOVRegistrationSvc::m_iov_db

private

Definition at line 201 of file IOVRegistrationSvc.h.

m_overrideName

Gaudi::Property<std::vector<std::string> > IOVRegistrationSvc::m_overrideName {this, "OverrideNames", {}}

private

Definition at line 198 of file IOVRegistrationSvc.h.

{this, "OverrideNames", {}};

m_overrideType

Gaudi::Property<std::vector<std::string> > IOVRegistrationSvc::m_overrideType {this, "OverrideTypes", {}}

private

Definition at line 199 of file IOVRegistrationSvc.h.

{this, "OverrideTypes", {}};

m_payloadTable

Gaudi::Property<bool> IOVRegistrationSvc::m_payloadTable {this, "PayloadTable", false}

private

Definition at line 196 of file IOVRegistrationSvc.h.

{this, "PayloadTable", false};

m_persSvc

ServiceHandle<IAddressCreator> IOVRegistrationSvc::m_persSvc

private

Definition at line 203 of file IOVRegistrationSvc.h.

m_recreateFolders

Gaudi::Property<bool> IOVRegistrationSvc::m_recreateFolders {this, "RecreateFolders", false}

private

Definition at line 180 of file IOVRegistrationSvc.h.

{this, "RecreateFolders", false};

m_svFolder

Gaudi::Property<bool> IOVRegistrationSvc::m_svFolder {this, "SVFolder", false}

private

Definition at line 195 of file IOVRegistrationSvc.h.

{this, "SVFolder", false};

m_tag

Gaudi::Property<std::string> IOVRegistrationSvc::m_tag {this, "IOVDbTag", ""}

private

Definition at line 189 of file IOVRegistrationSvc.h.

{this, "IOVDbTag", ""};

m_tagDescription

Gaudi::Property<std::string> IOVRegistrationSvc::m_tagDescription {this, "TagDescription", "Athena IOVRegistrationSvc"}

private

Definition at line 191 of file IOVRegistrationSvc.h.

{this, "TagDescription", "Athena IOVRegistrationSvc"};

m_timeStamp

Gaudi::Property<bool> IOVRegistrationSvc::m_timeStamp {this, "IOVDbTimeStamp", false}

private

Definition at line 190 of file IOVRegistrationSvc.h.

{this, "IOVDbTimeStamp", false};

m_userTags

Gaudi::Property<bool> IOVRegistrationSvc::m_userTags {this, "userTags", true}

private

Definition at line 193 of file IOVRegistrationSvc.h.

{this, "userTags", true};

m_userTagsUH

Gaudi::Property<bool> IOVRegistrationSvc::m_userTagsUH {this, "userTagsUpdateHead", false}

private

Definition at line 194 of file IOVRegistrationSvc.h.

{this, "userTagsUpdateHead", false};

m_writeKeyInfo

Gaudi::Property<bool> IOVRegistrationSvc::m_writeKeyInfo {this, "writeKeyInfo", true}

private

Definition at line 192 of file IOVRegistrationSvc.h.

{this, "writeKeyInfo", true};

---

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

• IOVRegistrationSvc.h
• IOVRegistrationSvc.cxx