OutputStream.h

Go to the documentation of this file.

#ifndef GAUDISVC_PERSISTENCYSVC_OUTPUTSTREAM_H
#define GAUDISVC_PERSISTENCYSVC_OUTPUTSTREAM_H

// Required for inheritance
#include "GaudiKernel/IDataSelector.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/Property.h"
#include "OutputStreamAgent.h"

// STL include files
#include <memory>
#include <vector>
#include <string>

// forward declarations
class IIncidentSvc;
class IRegistry;
class IConversionSvc;
class 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:
  SmartIF<IIncidentSvc> m_incidentSvc;
  bool                     m_doPreLoad;
  bool                     m_doPreLoadOpt;
  bool                     m_verifyItems;
  std::string              m_storeName;
  std::string              m_persName;
  std::string              m_output;
  std::string              m_outputName;
  std::string              m_outputType;
  std::unique_ptr<OutputStreamAgent> m_agent;
  SmartIF<IDataProviderSvc>        m_pDataProvider;
  SmartIF<IDataManagerSvc>         m_pDataManager;
  SmartIF<IConversionSvc>          m_pConversionSvc;
  DataStoreItem*           m_currentItem;
  ItemNames                m_itemNames;
  Items                    m_itemList;
  ItemNames                m_optItemNames;
  Items                    m_optItemList;
  AlgDependentItemNames    m_algDependentItemList;
  AlgDependentItems        m_algDependentItems;
  IDataSelector            m_objects;
  int                      m_events;
  StringArrayProperty      m_acceptNames;
  StringArrayProperty      m_requireNames;
  StringArrayProperty      m_vetoNames;
  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( Property& theProp );
  StatusCode decodeRequireAlgs();
  void requireAlgsHandler( Property& theProp );
  StatusCode decodeVetoAlgs();
  void vetoAlgsHandler( Property& theProp );
  Algorithm* decodeAlgorithm( const std::string& theName );
  StatusCode decodeAlgorithms( StringArrayProperty& theNames,
                               std::vector<Algorithm*>& theAlgs );
  bool isEventAccepted() const;
  DataStoreItem* findItem(const std::string& path);
  virtual StatusCode writeObjects();

  bool m_fireIncidents;

  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