OutputStream.h

Go to the documentation of this file.

#ifndef GAUDISVC_PERSISTENCYSVC_OUTPUTSTREAM_H
#define GAUDISVC_PERSISTENCYSVC_OUTPUTSTREAM_H

// Required for inheritance
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/IDataSelector.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/Property.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 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