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"
#include "OutputStreamAgent.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<Algorithm*, Items>      AlgDependentItems;
  typedef std::map<std::string, ItemNames> AlgDependentItemNames;

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", {}, "names of Algorithms that this stream accepts"};
  Gaudi::Property<std::vector<std::string>> m_requireNames{
      this, "RequireAlgs", {}, "names of Algorithms that this stream requires"};
  Gaudi::Property<std::vector<std::string>> m_vetoNames{
      this, "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";
  std::unique_ptr<OutputStreamAgent> m_agent;
  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<Algorithm*> m_acceptAlgs;
  std::vector<Algorithm*> m_requireAlgs;
  std::vector<Algorithm*> m_vetoAlgs;

public:
  OutputStream( const std::string& name, ISvcLocator* pSvcLocator );
  virtual ~OutputStream() = default;

protected:
  StatusCode decodeAcceptAlgs();
  void acceptAlgsHandler( Gaudi::Details::PropertyBase& theProp );
  StatusCode decodeRequireAlgs();
  void requireAlgsHandler( Gaudi::Details::PropertyBase& theProp );
  StatusCode decodeVetoAlgs();
  void vetoAlgsHandler( Gaudi::Details::PropertyBase& theProp );
  Algorithm* decodeAlgorithm( const std::string& theName );
  StatusCode decodeAlgorithms( Gaudi::Property<std::vector<std::string>>& theNames, std::vector<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; }
};

#endif // GAUDISVC_PERSISTENCYSVC_OUTPUTSTREAM_H