OutputStream.h

Go to the documentation of this file.

// $Id: OutputStream.h,v 1.4 2010/05/20 17:07:50 marcocle Exp $
#ifndef GAUDISVC_PERSISTENCYSVC_OUTPUTSTREAM_H
#define GAUDISVC_PERSISTENCYSVC_OUTPUTSTREAM_H


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

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

// forward declarations
template <class ConcreteAlgorithm> class AlgFactory;
namespace { template <class P, class S> class Factory; }

class IIncidentSvc;
class IRegistry;
class IConversionSvc;
class IDataManagerSvc;
class OutputStreamAgent;
class DataStoreItem;

class OutputStream : public Algorithm     {
  friend class AlgFactory<OutputStream>;
  friend class Factory<OutputStream,IAlgorithm* (std::string,ISvcLocator *)>;

public:
  typedef std::vector<DataStoreItem*> Items;
  typedef std::vector<std::string>    ItemNames;
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;
  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;
  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();
protected:
  StatusCode decodeAcceptAlgs( );
  void acceptAlgsHandler( Property& theProp );
  StatusCode decodeRequireAlgs( );
  void requireAlgsHandler( Property& theProp );
  StatusCode decodeVetoAlgs( );
  void vetoAlgsHandler( Property& theProp );
  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:
        virtual StatusCode initialize();
        virtual StatusCode finalize();
        virtual StatusCode execute();
  // Connect to proper conversion service
  virtual StatusCode connectConversionSvc();
  virtual bool collect(IRegistry* dir, int level);
  virtual StatusCode collectObjects();
  void clearItems(Items& itms);
  void addItem(Items& itms, const std::string& descriptor);
  void clearSelection();
  IDataSelector* selectedObjects()    {
    return &m_objects;
  }
};

#endif // GAUDISVC_PERSISTENCYSVC_OUTPUTSTREAM_H