OutputStream.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2024 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#ifndef GAUDISVC_PERSISTENCYSVC_OUTPUTSTREAM_H
#define GAUDISVC_PERSISTENCYSVC_OUTPUTSTREAM_H
 
// Required for inheritance
#include <Gaudi/Property.h>
#include <GaudiKernel/Algorithm.h>
#include <GaudiKernel/IDataSelector.h>
#include <GaudiKernel/IIncidentSvc.h>
 
// STL include files
#include <memory>
#include <string>
#include <vector>
 
// forward declarations
class IIncidentSvc;
class IRegistry;
class IConversionSvc;
struct IDataManagerSvc;
class OutputStreamAgent;
class DataStoreItem;
 
class OutputStream : public Algorithm {
public:
  typedef std::vector<DataStoreItem*>        Items;
  typedef std::vector<std::string>           ItemNames;
  typedef std::map<Gaudi::Algorithm*, Items> AlgDependentItems;
  typedef std::map<std::string, ItemNames>   AlgDependentItemNames;
 
public:
  using Algorithm::Algorithm;
 
protected:
  Gaudi::Property<ItemNames> m_itemNames{ this, "ItemList", {}, "vector of item names to be saved to this stream" };
  Gaudi::Property<ItemNames> m_optItemNames{
      this, "OptItemList", {}, "vector of optional item names to be saved to this stream" };
  Gaudi::Property<AlgDependentItemNames> m_algDependentItemList{
      this,
      "AlgDependentItemList",
      {},
      "mapping between algorithm names, and a list of items for which, if the "
      "algorithm in question accepted the event, they should be also stored" };
  Gaudi::Property<bool>                     m_doPreLoad{ this, "Preload", true,
                                     "flag indicating whether data pre-loading should be performed" };
  Gaudi::Property<bool>                     m_doPreLoadOpt{ this, "PreloadOptItems", false,
                                        "flag indicating whether optional items should be preloaded" };
  Gaudi::Property<std::string>              m_output{ this, "Output", {}, "name of the output file specification" };
  Gaudi::Property<std::string>              m_outputName{ this, "OutputFile", {}, "name of the output file" };
  Gaudi::Property<std::string>              m_storeName{ this, "EvtDataSvc", "EventDataSvc",
                                            "name of the service managing the data store" };
  Gaudi::Property<std::string>              m_persName{ this, "EvtConversionSvc", "EventPersistencySvc",
                                           "name of the persistency service capable to write data from the store" };
  Gaudi::Property<std::vector<std::string>> m_acceptNames{
      this,
      "AcceptAlgs",
      {},
      [this]( auto& ) { this->decodeAlgorithms( this->m_acceptNames, this->m_acceptAlgs ); },
      "names of Algorithms that this stream accepts" };
  Gaudi::Property<std::vector<std::string>> m_requireNames{
      this,
      "RequireAlgs",
      {},
      [this]( auto& ) { this->decodeAlgorithms( this->m_requireNames, this->m_requireAlgs ); },
      "names of Algorithms that this stream requires" };
  Gaudi::Property<std::vector<std::string>> m_vetoNames{
      this,
      "VetoAlgs",
      {},
      [this]( auto& ) { this->decodeAlgorithms( this->m_vetoNames, this->m_vetoAlgs ); },
      "names of Algorithms that this stream is vetoed by" };
  Gaudi::Property<bool> m_verifyItems{ this, "VerifyItems", true,
                                       "flag to indicate that item consistency should be checked" };
 
  bool m_fireIncidents = true;
 
  SmartIF<IIncidentSvc> m_incidentSvc;
 
  std::string m_outputType = "UPDATE";
  SmartIF<IDataProviderSvc> m_pDataProvider;
  SmartIF<IDataManagerSvc> m_pDataManager;
  SmartIF<IConversionSvc> m_pConversionSvc;
  DataStoreItem* m_currentItem;
  Items m_itemList;
  Items m_optItemList;
  AlgDependentItems m_algDependentItems;
  IDataSelector m_objects;
  int m_events;
 
  std::vector<Gaudi::Algorithm*> m_acceptAlgs;
  std::vector<Gaudi::Algorithm*> m_requireAlgs;
  std::vector<Gaudi::Algorithm*> m_vetoAlgs;
 
protected:
  Gaudi::Algorithm* decodeAlgorithm( const std::string& theName );
  void decodeAlgorithms( Gaudi::Property<std::vector<std::string>>& theNames, std::vector<Gaudi::Algorithm*>& theAlgs );
  bool isEventAccepted() const;
  DataStoreItem* findItem( const std::string& path );
  virtual StatusCode writeObjects();
 
  virtual bool hasInput() const;
 
public:
  StatusCode start() override;
  StatusCode initialize() override;
  StatusCode finalize() override;
  StatusCode execute() override;
  // Connect to proper conversion service
  virtual StatusCode connectConversionSvc();
  virtual bool collect( IRegistry* dir, int level );
  virtual StatusCode collectObjects();
  void clearSelection();
 
private:
  void clearItems( Items& itms );
  void addItem( Items& itms, const std::string& descriptor );
  IDataSelector* selectedObjects() { return &m_objects; }
 
  StatusCode collectFromSubTree( DataObject* );
};
 
#endif // GAUDISVC_PERSISTENCYSVC_OUTPUTSTREAM_H