AthenaOutputStreamTool Class Reference

This is the implementation of IAthenaOutputStreamTool. More...

#include <AthenaOutputStreamTool.h>

Inheritance diagram for AthenaOutputStreamTool:

Collaboration diagram for AthenaOutputStreamTool:

Public Types
typedef std::pair< std::string, std::string >	TypeKeyPair
	Stream out objects. More...
typedef std::vector< TypeKeyPair >	TypeKeyPairs
typedef std::vector< DataObject * >	DataObjectVec
	Stream out a vector of objects Must convert to DataObject, e.g. More...

Public Member Functions
	AthenaOutputStreamTool (const std::string &type, const std::string &name, const IInterface *parent)
	Standard AlgTool Constructor. More...
virtual StatusCode	initialize () override
	AthAlgTool Interface method implementations: More...
StatusCode	connectServices (const std::string &dataStore, const std::string &cnvSvc, bool extendProvenenceRecord) override
	Specify which data store and conversion service to use and whether to extend provenance Only use if one wants to override jobOptions. More...
StatusCode	connectOutput (const std::string &outputName="") override
	Connect to the output stream Must connectOutput BEFORE streaming Only specify "outputName" if one wants to override jobOptions. More...
StatusCode	commitOutput (bool doCommit=false) override
	Commit the output stream after having streamed out objects Must commitOutput AFTER streaming. More...
StatusCode	finalizeOutput () override
	Finalize the output stream after the last commit, e.g. More...
virtual StatusCode	streamObjects (const TypeKeyPairs &typeKeys, const std::string &outputName="") override
virtual StatusCode	streamObjects (const DataObjectVec &dataObjects, const std::string &outputName="") override
virtual StatusCode	getInputItemList (SG::IFolder *m_p2BWrittenFromTool) override

Private Member Functions
StatusCode	connectServices ()
	Do the real connection to services. More...
void	propagateProvenance (const DataHeader &src_dh)
	copy provenance records when creating new DataHeaders More...

Private Attributes
StringProperty	m_outputName { this, "OutputFile", "", "name of the output db name"}
StringProperty	m_dataHeaderKey { this, "DataHeaderKey", "", "name of the data header key: defaults to tool name"}
StringProperty	m_processTag { this, "ProcessingTag", "", "tag of processing stage: defaults to SG key of DataHeader (Stream name)"}
StringProperty	m_outputCollection { this, "OutputCollection", "", "custom container name prefix for DataHeader: default = "" (will result in \"POOLContainer_\")"}
StringProperty	m_containerPrefix { this, "PoolContainerPrefix", "", "prefix for top level POOL container: default = \"CollectionTree\""}
StringProperty	m_containerNameHint { this, "TopLevelContainerName", "0", "naming hint policy for top level POOL container: default = \"0\""}
StringProperty	m_metaDataOutputCollection { this, "MetaDataOutputCollection", "", "custom container name prefix for MetaDataHeader: default = "" (will result in \"MetaDataHdr\")"}
StringProperty	m_metaDataContainerPrefix { this, "MetaDataPoolContainerPrefix", "", "prefix for top level MetaData container: default = "" (will result in \"MetaData\")"}
StringProperty	m_branchNameHint { this, "SubLevelBranchName", "0", "naming hint policy for POOL branching: default = \"0\"" }
BooleanProperty	m_extend { this, "SaveDecisions", false, "Set to true to add streaming decisions to an attributeList"}
std::string	m_outputAttributes
std::string	m_metaDataOutputAttributes
SG::ReadHandleKey< AthenaAttributeList >	m_attrListKey {this, "AttributeListKey", "", "optional key for AttributeList to be written as part of the DataHeader: default = \"\""}
std::string	m_attrListWrite {""}
ServiceHandle< StoreGateSvc >	m_store { this, "Store", "StoreGateSvc/DetectorStore", "Pointer to the data store"}
ServiceHandle< IConversionSvc >	m_conversionSvc { this, "ConversionService", "AthenaPoolCnvSvc" }
	Keep reference to the data conversion service. More...
ServiceHandle< IClassIDSvc >	m_clidSvc
	Ref to ClassIDSvc to convert type name to clid. More...
ServiceHandle< IDecisionSvc >	m_decSvc
	Ref to DecisionSvc. More...
DataHeader *	m_dataHeader {nullptr}
	Current DataHeader for streamed objects. More...
bool	m_connectionOpen {false}
	Flag to tell whether connectOutput has been called. More...
bool	m_extendProvenanceRecord {false}
	Flag as to whether to extend provenance via the DataHeader. More...
std::string	m_keepProvenancesStr
	RegEx string to match provenance tags to keep in the output DataHeader. Retrieved from an OutputStream property. More...
std::regex	m_keepProvenancesRE
	RegEx pattern created from m_keepProvenancesStr. More...
std::map< std::string, bool >	m_keepProvenanceMatch
	Cache provenance RegEx matching result in a map. More...
std::set< std::string >	m_skippedItems
	set of skipped item keys, because of missing CLID More...

Detailed Description

This is the implementation of IAthenaOutputStreamTool.

Definition at line 33 of file AthenaOutputStreamTool.h.

Member Typedef Documentation

DataObjectVec

typedef std::vector<DataObject*> AthenaOutputStreamTool::DataObjectVec

Stream out a vector of objects Must convert to DataObject, e.g.

#include "AthenaKernel/StorableConversions.h" T* obj = xxx; DataObject* dataObject = SG::asStorable(obj);

Definition at line 75 of file AthenaOutputStreamTool.h.

TypeKeyPair

typedef std::pair<std::string, std::string> AthenaOutputStreamTool::TypeKeyPair

Stream out objects.

Provide vector of typeName/key pairs. If key is empty, assumes only one object and this will fail if there is more than one

Definition at line 66 of file AthenaOutputStreamTool.h.

TypeKeyPairs

typedef std::vector<TypeKeyPair> AthenaOutputStreamTool::TypeKeyPairs

Definition at line 67 of file AthenaOutputStreamTool.h.

Constructor & Destructor Documentation

AthenaOutputStreamTool()

AthenaOutputStreamTool::AthenaOutputStreamTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Standard AlgTool Constructor.

Constructor.

Definition at line 43 of file AthenaOutputStreamTool.cxx.

                                  : base_class(type, name, parent),
    m_clidSvc("ClassIDSvc", name),
    m_decSvc("DecisionSvc/DecisionSvc", name) {
}

Member Function Documentation

commitOutput()

StatusCode AthenaOutputStreamTool::commitOutput ( bool  doCommit = false )

override

Commit the output stream after having streamed out objects Must commitOutput AFTER streaming.

Definition at line 338 of file AthenaOutputStreamTool.cxx.

                                                             {
   ATH_MSG_DEBUG("In commitOutput");
   // Connect the output file to the service
   if (m_conversionSvc->commitOutput(m_outputName.value(), doCommit).isFailure()) {
      ATH_MSG_ERROR("Unable to commit output " << m_outputName.value());
      return(StatusCode::FAILURE);
   }
   // Set flag that connection is closed
   m_connectionOpen = false;
   return(StatusCode::SUCCESS);
}

connectOutput()

StatusCode AthenaOutputStreamTool::connectOutput ( const std::string &  outputName = "" )

override

Connect to the output stream Must connectOutput BEFORE streaming Only specify "outputName" if one wants to override jobOptions.

Definition at line 159 of file AthenaOutputStreamTool.cxx.

                                                                            {
   ATH_MSG_DEBUG("In connectOutput " << outputName);
 
   // Use arg if not empty, save the output name
   if (!outputName.empty()) {
      m_outputName.setValue(outputName);
   }
   if (m_outputName.value().empty()) {
      ATH_MSG_ERROR("No OutputName provided");
      return(StatusCode::FAILURE);
   }
   // Connect services if not already available
   if (m_store == 0 || m_conversionSvc == 0) {
     ATH_CHECK( connectServices() );
   }
   // Connect the output file to the service
   if (m_conversionSvc->connectOutput(m_outputName.value()).isFailure()) {
      ATH_MSG_ERROR("Unable to connect output " << m_outputName.value());
      return(StatusCode::FAILURE);
   } else {
      ATH_MSG_DEBUG("Connected to " << m_outputName.value());
   }
 
   // Remove DataHeader with same key if it exists
   if (m_store->contains<DataHeader>(m_dataHeaderKey)) {
      const DataHeader* preDh = nullptr;
      if (m_store->retrieve(preDh, m_dataHeaderKey).isSuccess()) {
         if (m_store->removeDataAndProxy(preDh).isFailure()) {
            ATH_MSG_ERROR("Unable to get proxy for the DataHeader with key " << m_dataHeaderKey);
            return(StatusCode::FAILURE);
         }
         ATH_MSG_DEBUG("Released DataHeader with key " << m_dataHeaderKey);
      }
   }
 
   // Create new DataHeader
   m_dataHeader = new DataHeader();
   m_dataHeader->setProcessTag(m_processTag);
 
   // Retrieve all existing DataHeaders from StoreGate
   const DataHeader* dh = nullptr;
   std::vector<std::string> dhKeys;
   m_store->keys<DataHeader>(dhKeys);
   for (const std::string& dhKey : dhKeys) {
      bool primaryDH = false;
      if (!m_store->transientContains<DataHeader>(dhKey)) {
         if (dhKey == "EventSelector") primaryDH = true;
         ATH_MSG_DEBUG("No transientContains DataHeader with key " << dhKey);
      }
      if (m_store->retrieve(dh, dhKey).isFailure()) {
         ATH_MSG_DEBUG("Unable to retrieve the DataHeader with key " << dhKey);
      }
      if (dh->isInput() || hasInputAlias(*m_store->proxy(dh)) || primaryDH) {
         propagateProvenance( *dh );
      }
   }
 
   // Attach the attribute list to the DataHeader if requested
   if (!m_attrListKey.key().empty() && m_store->storeID() == StoreID::EVENT_STORE) {
      auto attrListHandle = SG::makeHandle(m_attrListKey);
      if (!attrListHandle.isValid()) {
         ATH_MSG_WARNING("Unable to retrieve AttributeList with key " << m_attrListKey);
      } else {
         m_dataHeader->setAttributeList(attrListHandle.cptr());
         if (m_extend) {  // Add streaming decisions
            ATH_MSG_DEBUG("Adding stream decisions to " << m_attrListWrite);
            // Look for attribute list created for mini-EventInfo
            const AthenaAttributeList* attlist(attrListHandle.cptr());
 
            // Build new attribute list for modification
            AthenaAttributeList* newone = new AthenaAttributeList(attlist->specification());
            newone->copyData(*attlist);
 
            // Now loop over stream definitions and add decisions
            auto streams = m_decSvc->getStreams();
            for (auto it  = streams.begin();
                      it != streams.end(); ++it) {
               newone->extend(*it,"bool");
               (*newone)[*it].data<bool>() = m_decSvc->isEventAccepted(*it,Gaudi::Hive::currentContext());
               ATH_MSG_DEBUG("Added stream decision for " << *it << " to " << m_attrListKey);
            }
            // record new attribute list with old key + suffix
            const AthenaAttributeList* attrList2 = nullptr;
            if (!m_store->contains<AthenaAttributeList>(m_attrListWrite)) {
               if (m_store->record(newone,m_attrListWrite).isFailure()) {
                  ATH_MSG_ERROR("Unable to record att list " << m_attrListWrite);
               }
            } else {
               ATH_MSG_DEBUG("Decisions already added by a different stream");
            }
            if (m_store->retrieve(attrList2,m_attrListWrite).isFailure()) {
               ATH_MSG_ERROR("Unable to record att list " << m_attrListWrite);
            } else {
               m_dataHeader->setAttributeList(attrList2);
            }
/*
            SG::WriteHandle<AthenaAttributeList> attrWrite(m_attrListWrite);
            std::unique_ptr<AthenaAttributeList> uptr = std::make_unique<AthenaAttributeList>(*newone);
            if ( attrWrite.record(std::move(uptr)).isFailure() ) {
               ATH_MSG_ERROR("Unable to record att list " << m_attrListWrite);
            } else {
               ATH_MSG_DEBUG("Decisions already added by a different stream");
            }
*/
            //m_dataHeader->setAttributeList(newone);
         }    // list extend check
      }       // list retrieve check
   }          // list property check
 
   // Record DataHeader in StoreGate
   SG::WriteHandle<DataHeader> wh(m_dataHeaderKey, m_store->name());
   if (wh.record(std::unique_ptr<DataHeader>(m_dataHeader)).isFailure()) {
      ATH_MSG_ERROR("Unable to record DataHeader with key " << m_dataHeaderKey);
      return(StatusCode::FAILURE);
   } else {
      ATH_MSG_DEBUG("Recorded DataHeader with key " << m_dataHeaderKey);
   }
   m_dataHeader->setStatus(DataHeader::Output);
   // Set flag that connection is open
   m_connectionOpen = true;
   return(StatusCode::SUCCESS);
}

connectServices() [1/2]

StatusCode AthenaOutputStreamTool::connectServices ( )

private

Do the real connection to services.

Definition at line 150 of file AthenaOutputStreamTool.cxx.

                                                   {
   // Find the data store
   if (m_store.retrieve().isFailure() || m_store == 0) {
      ATH_MSG_ERROR("Could not locate " << m_store.typeAndName() << " store");
      return(StatusCode::FAILURE);
   }
   return(StatusCode::SUCCESS);
}

connectServices() [2/2]

StatusCode AthenaOutputStreamTool::connectServices ( const std::string &  dataStore, const std::string &  cnvSvc, bool  extendProvenenceRecord  )

override

Specify which data store and conversion service to use and whether to extend provenance Only use if one wants to override jobOptions.

Definition at line 116 of file AthenaOutputStreamTool.cxx.

                                 {
   // Release old data store
   if (m_store.isValid()) {
      if (m_store.release().isFailure()) {
         ATH_MSG_ERROR("Could not release " << m_store.typeAndName() << " store");
      }
   }
   m_store = ServiceHandle<StoreGateSvc>(dataStore, this->name());
   if (cnvSvc != m_conversionSvc.type() && cnvSvc != "EventPersistencySvc") {
      if (m_conversionSvc.release().isFailure()) {
         ATH_MSG_ERROR("Could not release " << m_conversionSvc.type());
      }
      m_conversionSvc = ServiceHandle<IConversionSvc>(cnvSvc, this->name());
      if (m_conversionSvc.retrieve().isFailure() || m_conversionSvc == 0) {
         ATH_MSG_ERROR("Could not locate " << m_conversionSvc.type());
         return(StatusCode::FAILURE);
      }
   }
   m_extendProvenanceRecord = extendProvenenceRecord;
   auto pprop = dynamic_cast<const IProperty*>(parent());
   if (not pprop){
     ATH_MSG_ERROR("'parent' could not be cast to IProperty");
     return(StatusCode::FAILURE);
   }
   auto keep = dynamic_cast<const StringProperty&>( pprop->getProperty("KeepProvenanceTagsRegEx") );
   m_keepProvenancesStr = keep.value();
   // create RegEx pattern from the property value, specify extended grammar
   m_keepProvenancesRE = std::regex(m_keepProvenancesStr, std::regex::extended);
 
   return(connectServices());
}

finalizeOutput()

StatusCode AthenaOutputStreamTool::finalizeOutput ( )

override

Finalize the output stream after the last commit, e.g.

in finalize

Definition at line 350 of file AthenaOutputStreamTool.cxx.

                                                  {
   AthCnvSvc* athConversionSvc = dynamic_cast<AthCnvSvc*>(m_conversionSvc.get());
   if (athConversionSvc != 0) {
      if (athConversionSvc->disconnectOutput(m_outputName.value()).isFailure()) {
         ATH_MSG_ERROR("Unable to finalize output " << m_outputName.value());
         return(StatusCode::FAILURE);
      }
   }
   return(StatusCode::SUCCESS);
}

getInputItemList()

StatusCode AthenaOutputStreamTool::getInputItemList ( SG::IFolder *  m_p2BWrittenFromTool )

overridevirtual

Definition at line 533 of file AthenaOutputStreamTool.cxx.

                                                                                 {
   const std::string hltKey = "HLTAutoKey";
   SG::ConstIterator<DataHeader> beg;
   SG::ConstIterator<DataHeader> ending;
   if (m_store->retrieve(beg, ending).isFailure() || beg == ending) {
      ATH_MSG_DEBUG("No DataHeaders present in StoreGate");
   } else {
      for ( ; beg != ending; ++beg) {
         if (m_store->transientContains<DataHeader>(beg.key()) && beg->isInput()) {
            for (std::vector<DataHeaderElement>::const_iterator it = beg->begin(), itLast = beg->end();
                it != itLast; ++it) {
               // Only insert the primary clid, not the ones for the symlinks!
               CLID clid = it->getPrimaryClassID();
               if (clid != ClassID_traits<DataHeader>::ID()) {
                  //check the typename is known ... we make an exception if the key contains 'Aux.' ... aux containers may not have their keys known yet in some cases
                  //see https://its.cern.ch/jira/browse/ATLASG-59 for the solution
                  std::string typeName;
                  if (m_clidSvc->getTypeNameOfID(clid, typeName).isFailure() && it->getKey().find("Aux.") == std::string::npos) {
                     if (m_skippedItems.find(it->getKey()) == m_skippedItems.end()) {
                        ATH_MSG_WARNING("Skipping " << it->getKey() << " with unknown clid " << clid << " . Further warnings for this item are suppressed" );
                        m_skippedItems.insert(it->getKey());
                     }
                     continue;
                  }
                  ATH_MSG_DEBUG("Adding " << typeName << "#" << it->getKey() << " (clid " << clid << ") to itemlist");
                  const std::string keyName = it->getKey();
                  if (keyName.size() > 10 && keyName.compare(0, 10,hltKey)==0) {
                     p2BWrittenFromTool->add(clid, hltKey + "*").ignore();
                  } else if (keyName.size() > 10 && keyName.compare(keyName.size() - 10, 10, hltKey)==0) {
                     p2BWrittenFromTool->add(clid, "*" + hltKey).ignore();
                  } else {
                     p2BWrittenFromTool->add(clid, keyName).ignore();
                  }
               }
            }
         }
      }
   }
   ATH_MSG_DEBUG("Adding DataHeader for stream " << name());
   return(StatusCode::SUCCESS);
}

initialize()

StatusCode AthenaOutputStreamTool::initialize ( )

overridevirtual

AthAlgTool Interface method implementations:

Definition at line 50 of file AthenaOutputStreamTool.cxx.

                                              {
   ATH_MSG_INFO("Initializing " << name());
 
   ATH_CHECK( m_clidSvc.retrieve() );
   ATH_CHECK( m_conversionSvc.retrieve() );
 
   // Autoconfigure
   if (m_dataHeaderKey.empty()) {
      m_dataHeaderKey.setValue(name());
      // Remove "ToolSvc." from m_dataHeaderKey.
      if (m_dataHeaderKey.value().starts_with( "ToolSvc.")) {
         m_dataHeaderKey.setValue(m_dataHeaderKey.value().substr(8));
         // Remove "Tool" from m_dataHeaderKey.
         if (m_dataHeaderKey.value().find("Tool") == m_dataHeaderKey.size() - 4) {
            m_dataHeaderKey.setValue(m_dataHeaderKey.value().substr(0, m_dataHeaderKey.size() - 4));
         }
      } else {
         const INamedInterface* parentAlg = dynamic_cast<const INamedInterface*>(parent());
         if (parentAlg != 0) {
            m_dataHeaderKey.setValue(parentAlg->name());
         }
      }
   }
   if (m_processTag.empty()) {
      m_processTag.setValue(m_dataHeaderKey);
   }
 
   { // handle the AttrKey overwrite
     const std::string keyword = "[AttributeListKey=";
     std::string::size_type pos = m_outputName.value().find(keyword);
     if( (pos != std::string::npos) ) {
       ATH_MSG_INFO("The AttrListKey will be overwritten/set by the value from the OutputName: " << m_outputName);
       const std::string attrListKey = m_outputName.value().substr(pos + keyword.size(),
                                   m_outputName.value().find(']', pos + keyword.size()) - pos - keyword.size());
       m_attrListKey = attrListKey;
     }
   }
   if ( ! m_attrListKey.key().empty() ) {
     ATH_CHECK(m_attrListKey.initialize());
     m_attrListWrite = m_attrListKey.key() + "Decisions";
     //ATH_CHECK(m_attrListWrite.initialize());
   }
 
   if (!m_outputCollection.value().empty()) {
      m_outputAttributes += "[OutputCollection=" + m_outputCollection.value() + "]";
   }
   if (!m_containerPrefix.value().empty()) {
      m_outputAttributes += "[PoolContainerPrefix=" + m_containerPrefix.value() + "]";
   }
   if (m_containerNameHint.value() != "0") {
      m_outputAttributes += "[TopLevelContainerName=" + m_containerNameHint.value() + "]";
   }
   if (m_branchNameHint.value() != "0") {
      m_outputAttributes += "[SubLevelBranchName=" + m_branchNameHint.value() + "]";
   }
   if (!m_metaDataOutputCollection.value().empty()) {
      m_metaDataOutputAttributes += "[OutputCollection=" + m_metaDataOutputCollection.value() + "]";
   }
   if (!m_metaDataContainerPrefix.value().empty()) {
      m_metaDataOutputAttributes += "[PoolContainerPrefix=" + m_metaDataContainerPrefix.value() + "]";
   }
 
   if (m_extend) ATH_CHECK(m_decSvc.retrieve());
   return(StatusCode::SUCCESS);
}

propagateProvenance()

void AthenaOutputStreamTool::propagateProvenance ( const DataHeader &  src_dh )

private

copy provenance records when creating new DataHeaders

Definition at line 283 of file AthenaOutputStreamTool.cxx.

{
   // keep track of provenance entries inserted into the new DataHeader
   std::set<std::string> insertedTags{};
   // Add DataHeader token to the new DataHeader
   if (m_extendProvenanceRecord) {
      std::string pTag;
      std::unique_ptr<SG::TransientAddress> dhTransAddr;
      for (const DataHeaderElement& dhe : src_dh) {
         if (dhe.getPrimaryClassID() == ClassID_traits<DataHeader>::ID()) {
            pTag = dhe.getKey();
            dhTransAddr.reset( dhe.getAddress(0) );
         }
      }
      // Update dhTransAddr to handle fast merged files.
      if( auto dhProxy=m_store->proxy(&src_dh); dhProxy && dhProxy->address() ) {
         DataHeaderElement dhe(dhProxy, dhProxy->address(), pTag);
         m_dataHeader->insertProvenance(dhe);
         insertedTags.insert(std::move(pTag));
      }
      else if( dhTransAddr ) {
         DataHeaderElement dhe(dhTransAddr.get(), dhTransAddr->address(), pTag);
         m_dataHeader->insertProvenance(dhe);
         insertedTags.insert(std::move(pTag));
      }
   }
 
   // empty regexpr means do not keep any provenance
   if( !m_keepProvenancesStr.empty() ) {
      // Each stream tag is written only once in the provenance record
      // In files where there are multiple entries per stream tag
      // the record is in reverse, i.e., the latest appears first.
      // Therefore, only keep the first entry if there are multiple
      // matches so that we retain the latest one.
      for(auto iter=src_dh.beginProvenance(), iEnd=src_dh.endProvenance(); iter != iEnd; ++iter) {
         const auto & currentKey = (*iter).getKey();
         if( insertedTags.insert(currentKey).second ) {
            // first prov with that tag. Now check if we want to keep that tag
            bool keep = false;
            auto it =  m_keepProvenanceMatch.find( currentKey );
            if( it != m_keepProvenanceMatch.end() ) {
               keep = it->second;
            } else {
               keep = std::regex_search(currentKey, m_keepProvenancesRE);
               m_keepProvenanceMatch[currentKey] = keep;
            }
            if( keep ) {
               m_dataHeader->insertProvenance(*iter);
            }
         }
      }
   }
}

streamObjects() [1/2]

StatusCode AthenaOutputStreamTool::streamObjects ( const DataObjectVec &  dataObjects, const std::string &  outputName = ""  )

overridevirtual

Definition at line 422 of file AthenaOutputStreamTool.cxx.

                                                                                                              {
   // Check that a connection has been opened
   if (!m_connectionOpen) {
      ATH_MSG_ERROR("Connection NOT open. Please open a connection before streaming out objects.");
      return(StatusCode::FAILURE);
   }
   // Connect the output file to the service
   std::string outputConnectionString = outputName;
   const std::string defaultMetaDataString = "[OutputCollection=MetaDataHdr][PoolContainerPrefix=MetaData]";
   if (std::string::size_type mpos = outputConnectionString.find(defaultMetaDataString); mpos!=std::string::npos) {
     // If we're in here we're writing MetaData
     // Now let's see if we should be overwriting the MetaData attributes
     // For the time-being this happens when we're writing MetaData in the augmentation mode
     if (!m_metaDataOutputAttributes.empty()) {
       // Note: This won't work quite right if only one attribute is set though!
       outputConnectionString.replace(mpos, defaultMetaDataString.length(), m_metaDataOutputAttributes);
     }
   }
   for (std::string::size_type pos = m_outputAttributes.find('['); pos != std::string::npos; pos = m_outputAttributes.find('[', ++pos)) {
      if (outputConnectionString.find(m_outputAttributes.substr(pos, m_outputAttributes.find('=', pos) + 1 - pos)) == std::string::npos) {
         outputConnectionString += m_outputAttributes.substr(pos, m_outputAttributes.find(']', pos) + 1 - pos);
      }
   }
 
   // Check that the DataHeader is still valid
   DataObject* dataHeaderObj = m_store->accessData(ClassID_traits<DataHeader>::ID(), m_dataHeaderKey);
   std::map<DataObject*, IOpaqueAddress*> written;
   for (DataObject* dobj : dataObjects) {
      // Do not write the DataHeader via the explicit list
      if (dobj->clID() == ClassID_traits<DataHeader>::ID()) {
         ATH_MSG_DEBUG("Explicit request to write DataHeader: " << dobj->name() << " - skipping it.");
      // Do not stream out same object twice
      } else if (written.find(dobj) != written.end()) {
         // Print warning and skip
         ATH_MSG_DEBUG("Trying to write DataObject twice (clid/key): " << dobj->clID() << " " << dobj->name());
         ATH_MSG_DEBUG("    Skipping this one.");
      } else {
         // Write object
         IOpaqueAddress* addr = new TokenAddress(0, dobj->clID(), outputConnectionString);
         addr->addRef();
         if (m_conversionSvc->createRep(dobj, addr).isSuccess()) {
            written.insert(std::pair<DataObject*, IOpaqueAddress*>(dobj, addr));
         } else {
            ATH_MSG_ERROR("Could not create Rep for DataObject (clid/key):" << dobj->clID() << " " << dobj->name());
            return(StatusCode::FAILURE);
         }
      }
   }
   // End of loop over DataObjects, write DataHeader
   if ((m_conversionSvc.type() == "AthenaPoolCnvSvc" || m_conversionSvc.type() == "AthenaPoolSharedIOCnvSvc") && dataHeaderObj != nullptr) {
      IOpaqueAddress* addr = new TokenAddress(0, dataHeaderObj->clID(), outputConnectionString);
      addr->addRef();
      if (m_conversionSvc->createRep(dataHeaderObj, addr).isSuccess()) {
         written.insert(std::pair<DataObject*, IOpaqueAddress*>(dataHeaderObj, addr));
      } else {
         ATH_MSG_ERROR("Could not create Rep for DataHeader");
         return(StatusCode::FAILURE);
      }
   }
   for (DataObject* dobj : dataObjects) {
      // call fillRepRefs of persistency service
      SG::DataProxy* proxy = dynamic_cast<SG::DataProxy*>(dobj->registry());
      if (proxy != nullptr && written.find(dobj) != written.end()) {
         IOpaqueAddress* addr(written.find(dobj)->second);
         if ((m_conversionSvc->fillRepRefs(addr, dobj)).isSuccess()) {
            if (dobj->clID() != 1 || addr->par()[0] != "\n") {
               if (dobj->clID() != ClassID_traits<DataHeader>::ID()) {
                  m_dataHeader->insert(proxy, addr);
               } else {
                  m_dataHeader->insert(proxy, addr, m_processTag);
               }
               if (proxy->address() == nullptr) {
                  proxy->setAddress(addr);
               }
               addr->release();
            }
         } else {
            ATH_MSG_ERROR("Could not fill Object Refs for DataObject (clid/key):" << dobj->clID() << " " << dobj->name());
            return(StatusCode::FAILURE);
         }
      } else {
         ATH_MSG_WARNING("Could cast DataObject " << dobj->clID() << " " << dobj->name());
      }
   }
   m_dataHeader->addHash(&*m_store);
   if ((m_conversionSvc.type() == "AthenaPoolCnvSvc" || m_conversionSvc.type() == "AthenaPoolSharedIOCnvSvc") && dataHeaderObj != nullptr) {
      // End of DataObjects, fill refs for DataHeader
      SG::DataProxy* proxy = dynamic_cast<SG::DataProxy*>(dataHeaderObj->registry());
      if (proxy != nullptr && written.find(dataHeaderObj) != written.end()) {
         IOpaqueAddress* addr(written.find(dataHeaderObj)->second);
         if ((m_conversionSvc->fillRepRefs(addr, dataHeaderObj)).isSuccess()) {
            if (dataHeaderObj->clID() != 1 || addr->par()[0] != "\n") {
               if (dataHeaderObj->clID() != ClassID_traits<DataHeader>::ID()) {
                  m_dataHeader->insert(proxy, addr);
               } else {
                  m_dataHeader->insert(proxy, addr, m_processTag);
               }
               addr->release();
            }
         } else {
            ATH_MSG_ERROR("Could not fill Object Refs for DataHeader");
            return(StatusCode::FAILURE);
         }
      } else {
         ATH_MSG_ERROR("Could not cast DataHeader");
         return(StatusCode::FAILURE);
      }
   }
   return(StatusCode::SUCCESS);
}

streamObjects() [2/2]

StatusCode AthenaOutputStreamTool::streamObjects ( const TypeKeyPairs &  typeKeys, const std::string &  outputName = ""  )

overridevirtual

Definition at line 361 of file AthenaOutputStreamTool.cxx.

                                                                                                          {
   ATH_MSG_DEBUG("In streamObjects");
   // Check that a connection has been opened
   if (!m_connectionOpen) {
      ATH_MSG_ERROR("Connection NOT open. Please open a connection before streaming out objects.");
      return(StatusCode::FAILURE);
   }
   // Use arg if not empty, save the output name
   if (!outputName.empty()) {
      m_outputName.setValue(outputName);
   }
   if (m_outputName.value().empty()) {
      ATH_MSG_ERROR("No OutputName provided");
      return(StatusCode::FAILURE);
   }
   // Now iterate over the type/key pairs and stream out each object
   std::vector<DataObject*> dataObjects;
   for (TypeKeyPairs::const_iterator first = typeKeys.begin(), last = typeKeys.end();
       first != last; ++first) {
      const std::string& type = (*first).first;
      const std::string& key  = (*first).second;
      // Find the clid for type name from the CLIDSvc
      CLID clid;
      if (m_clidSvc->getIDOfTypeName(type, clid).isFailure()) {
         ATH_MSG_ERROR("Could not get clid for typeName " << type);
         return(StatusCode::FAILURE);
      }
      DataObject* dObj = 0;
      // Two options: no key or explicit key
      if (key.empty()) {
         ATH_MSG_DEBUG("Get data object with no key");
         // Get DataObject without key
         dObj = m_store->accessData(clid);
      } else {
         ATH_MSG_DEBUG("Get data object with key");
         // Get DataObjects with key
         dObj = m_store->accessData(clid, key);
      }
      if (dObj == 0) {
         // No object - print warning and return
         ATH_MSG_DEBUG("No object found for type " << type << " key " << key);
         return(StatusCode::SUCCESS);
      } else {
         ATH_MSG_DEBUG("Found object for type " << type << " key " << key);
      }
      // Save the dObj
      dataObjects.push_back(dObj);
   }
   // Stream out objects
   if (dataObjects.size() == 0) {
      ATH_MSG_DEBUG("No data objects found");
      return(StatusCode::SUCCESS);
   }
   StatusCode status = streamObjects(dataObjects, m_outputName.value());
   if (!status.isSuccess()) {
      ATH_MSG_ERROR("Could not stream out objects");
      return(status);
   }
   return(StatusCode::SUCCESS);
}

Member Data Documentation

m_attrListKey

SG::ReadHandleKey<AthenaAttributeList> AthenaOutputStreamTool::m_attrListKey {this, "AttributeListKey", "", "optional key for AttributeList to be written as part of the DataHeader: default = \"\""}

private

Definition at line 100 of file AthenaOutputStreamTool.h.

m_attrListWrite

std::string AthenaOutputStreamTool::m_attrListWrite {""}

private

Definition at line 102 of file AthenaOutputStreamTool.h.

m_branchNameHint

StringProperty AthenaOutputStreamTool::m_branchNameHint { this, "SubLevelBranchName", "0", "naming hint policy for POOL branching: default = \"0\"" }

private

Definition at line 95 of file AthenaOutputStreamTool.h.

m_clidSvc

ServiceHandle<IClassIDSvc> AthenaOutputStreamTool::m_clidSvc

private

Ref to ClassIDSvc to convert type name to clid.

Definition at line 108 of file AthenaOutputStreamTool.h.

m_connectionOpen

bool AthenaOutputStreamTool::m_connectionOpen {false}

private

Flag to tell whether connectOutput has been called.

Definition at line 114 of file AthenaOutputStreamTool.h.

m_containerNameHint

StringProperty AthenaOutputStreamTool::m_containerNameHint { this, "TopLevelContainerName", "0", "naming hint policy for top level POOL container: default = \"0\""}

private

Definition at line 92 of file AthenaOutputStreamTool.h.

m_containerPrefix

StringProperty AthenaOutputStreamTool::m_containerPrefix { this, "PoolContainerPrefix", "", "prefix for top level POOL container: default = \"CollectionTree\""}

private

Definition at line 91 of file AthenaOutputStreamTool.h.

m_conversionSvc

ServiceHandle<IConversionSvc> AthenaOutputStreamTool::m_conversionSvc { this, "ConversionService", "AthenaPoolCnvSvc" }

private

Keep reference to the data conversion service.

Definition at line 106 of file AthenaOutputStreamTool.h.

m_dataHeader

DataHeader* AthenaOutputStreamTool::m_dataHeader {nullptr}

private

Current DataHeader for streamed objects.

Definition at line 112 of file AthenaOutputStreamTool.h.

m_dataHeaderKey

StringProperty AthenaOutputStreamTool::m_dataHeaderKey { this, "DataHeaderKey", "", "name of the data header key: defaults to tool name"}

private

Definition at line 88 of file AthenaOutputStreamTool.h.

m_decSvc

ServiceHandle<IDecisionSvc> AthenaOutputStreamTool::m_decSvc

private

Ref to DecisionSvc.

Definition at line 110 of file AthenaOutputStreamTool.h.

m_extend

BooleanProperty AthenaOutputStreamTool::m_extend { this, "SaveDecisions", false, "Set to true to add streaming decisions to an attributeList"}

private

Definition at line 96 of file AthenaOutputStreamTool.h.

m_extendProvenanceRecord

bool AthenaOutputStreamTool::m_extendProvenanceRecord {false}

private

Flag as to whether to extend provenance via the DataHeader.

Definition at line 117 of file AthenaOutputStreamTool.h.

m_keepProvenanceMatch

std::map<std::string, bool> AthenaOutputStreamTool::m_keepProvenanceMatch

private

Cache provenance RegEx matching result in a map.

Definition at line 123 of file AthenaOutputStreamTool.h.

m_keepProvenancesRE

std::regex AthenaOutputStreamTool::m_keepProvenancesRE

private

RegEx pattern created from m_keepProvenancesStr.

Definition at line 121 of file AthenaOutputStreamTool.h.

m_keepProvenancesStr

std::string AthenaOutputStreamTool::m_keepProvenancesStr

private

RegEx string to match provenance tags to keep in the output DataHeader. Retrieved from an OutputStream property.

Definition at line 119 of file AthenaOutputStreamTool.h.

m_metaDataContainerPrefix

StringProperty AthenaOutputStreamTool::m_metaDataContainerPrefix { this, "MetaDataPoolContainerPrefix", "", "prefix for top level MetaData container: default = "" (will result in \"MetaData\")"}

private

Definition at line 94 of file AthenaOutputStreamTool.h.

m_metaDataOutputAttributes

std::string AthenaOutputStreamTool::m_metaDataOutputAttributes

private

Definition at line 99 of file AthenaOutputStreamTool.h.

m_metaDataOutputCollection

StringProperty AthenaOutputStreamTool::m_metaDataOutputCollection { this, "MetaDataOutputCollection", "", "custom container name prefix for MetaDataHeader: default = "" (will result in \"MetaDataHdr\")"}

private

Definition at line 93 of file AthenaOutputStreamTool.h.

m_outputAttributes

std::string AthenaOutputStreamTool::m_outputAttributes

private

Definition at line 98 of file AthenaOutputStreamTool.h.

m_outputCollection

StringProperty AthenaOutputStreamTool::m_outputCollection { this, "OutputCollection", "", "custom container name prefix for DataHeader: default = "" (will result in \"POOLContainer_\")"}

private

Definition at line 90 of file AthenaOutputStreamTool.h.

m_outputName

StringProperty AthenaOutputStreamTool::m_outputName { this, "OutputFile", "", "name of the output db name"}

private

Definition at line 87 of file AthenaOutputStreamTool.h.

m_processTag

StringProperty AthenaOutputStreamTool::m_processTag { this, "ProcessingTag", "", "tag of processing stage: defaults to SG key of DataHeader (Stream name)"}

private

Definition at line 89 of file AthenaOutputStreamTool.h.

m_skippedItems

std::set<std::string> AthenaOutputStreamTool::m_skippedItems

private

set of skipped item keys, because of missing CLID

Definition at line 126 of file AthenaOutputStreamTool.h.

m_store

ServiceHandle<StoreGateSvc> AthenaOutputStreamTool::m_store { this, "Store", "StoreGateSvc/DetectorStore", "Pointer to the data store"}

private

Definition at line 104 of file AthenaOutputStreamTool.h.

---

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

• AthenaOutputStreamTool.h
• AthenaOutputStreamTool.cxx