AthenaOutputStreamTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENAOUTPUTSTREAMTOOL_H
#define ATHENAOUTPUTSTREAMTOOL_H
 
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/ServiceHandle.h"
 
#include "AthenaKernel/IAthenaOutputStreamTool.h"
#include "AthenaBaseComps/AthAlgTool.h"
#include "PersistentDataModel/AthenaAttributeList.h"
 
#include <string>
#include <map>
#include <regex>
 
class IClassIDSvc;
class IDecisionSvc;
class StoreGateSvc;
class DataHeader;
namespace SG {
   class IFolder;
}

class AthenaOutputStreamTool : public extends<::AthAlgTool, IAthenaOutputStreamTool> {
public:
   AthenaOutputStreamTool(const std::string& type,
       const std::string& name,
       const IInterface* parent);

   virtual StatusCode initialize() override;

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

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

   StatusCode commitOutput(bool doCommit = false) override;

   StatusCode finalizeOutput() override;

   typedef std::pair<std::string, std::string> TypeKeyPair;
   typedef std::vector<TypeKeyPair>            TypeKeyPairs;
   virtual StatusCode streamObjects(const TypeKeyPairs& typeKeys, const std::string& outputName = "") override;

   typedef std::vector<DataObject*> DataObjectVec;
   virtual StatusCode streamObjects(const DataObjectVec& dataObjects, const std::string& outputName = "") override;
 
   virtual StatusCode getInputItemList(SG::IFolder* m_p2BWrittenFromTool) override;
 
private:
   StatusCode connectServices();
   void propagateProvenance( const DataHeader& src_dh );
 
private:
   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 = \"\""};
   //SG::WriteHandleKey<AthenaAttributeList>  m_attrListWrite{this, "AttributeListWrite", "", "optional key for AttributeList to be written as part of the DataHeader: default = <AttributeListKey>+\"Decisions\""};
   std::string  m_attrListWrite{""};
 
   ServiceHandle<StoreGateSvc>   m_store{ this, "Store", "StoreGateSvc/DetectorStore", "Pointer to the data store"};
   ServiceHandle<IConversionSvc> m_conversionSvc{ this, "ConversionService", "AthenaPoolCnvSvc" };
   ServiceHandle<IClassIDSvc>    m_clidSvc;
   ServiceHandle<IDecisionSvc>   m_decSvc;
   DataHeader*          m_dataHeader{nullptr};
   bool                 m_connectionOpen{false};

   bool                 m_extendProvenanceRecord{false};
   std::string          m_keepProvenancesStr;
   std::regex           m_keepProvenancesRE;
   std::map<std::string, bool>  m_keepProvenanceMatch;

   std::set<std::string> m_skippedItems;
};
 
#endif