MinimalEventLoopMgr.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_MINIMALEVENTLOOPMGR_H
#define GAUDIKERNEL_MINIMALEVENTLOOPMGR_H 1

#include <Gaudi/Interfaces/IAsyncEventProcessor.h>
#include <GaudiKernel/EventContext.h>
#include <GaudiKernel/IAlgExecStateSvc.h>
#include <GaudiKernel/IAlgorithm.h>
#include <GaudiKernel/IAppMgrUI.h>
#include <GaudiKernel/IEventProcessor.h>
#include <GaudiKernel/IHiveWhiteBoard.h>
#include <GaudiKernel/IIncidentListener.h>
#include <GaudiKernel/IIncidentSvc.h>
#include <GaudiKernel/Service.h>
#include <vector>

class GAUDI_API MinimalEventLoopMgr : public extends<Service, IEventProcessor> {
private:
  class AbortEventListener : public implements<IIncidentListener> {
  public:
    void handle( const Incident& i ) override {
      if ( i.type() == IncidentType::AbortEvent ) {
        abortEvent       = true;
        abortEventSource = i.source();
      }
    }

  public:
    bool abortEvent = false;
    std::string abortEventSource;
  };

public:
  typedef std::vector<SmartIF<IAlgorithm>> ListAlg;

protected:
  // Properties
  Gaudi::Property<std::vector<std::string>> m_topAlgNames{
      this, "TopAlg", {}, &MinimalEventLoopMgr::topAlgHandler, "list of top level algorithms names"};
  Gaudi::Property<std::vector<std::string>> m_outStreamNames{
      this, "OutStream", {}, &MinimalEventLoopMgr::outStreamHandler, "list of output stream names"};
  Gaudi::Property<std::string> m_outStreamType{this, "OutStreamType", "OutputStream",
                                               "[[deprecated]] default type for OutputStream instances"};
  Gaudi::Property<bool>        m_printCFExp{this, "PrintControlFlowExpression", false,
                                     "Print the control flow expression representing the content of TopAlg"};

  // enums
  enum State { OFFLINE, CONFIGURED, FINALIZED, INITIALIZED };
  SmartIF<IAppMgrUI> m_appMgrUI;
  SmartIF<IIncidentSvc> m_incidentSvc;
  SmartIF<IAlgExecStateSvc> m_aess;
  ListAlg                   m_topAlgList;
  ListAlg m_outStreamList;
  State m_state = OFFLINE;
  bool m_scheduledStop = false;
  AbortEventListener m_abortEventListener;

public:
  MinimalEventLoopMgr( const std::string& nam, ISvcLocator* svcLoc );
  MinimalEventLoopMgr( const MinimalEventLoopMgr& ) = delete;
  MinimalEventLoopMgr& operator=( const MinimalEventLoopMgr& ) = delete;

#if defined( GAUDI_V20_COMPAT ) && !defined( G21_NO_DEPRECATED )
protected:
  template <class T>
  T* releaseInterface( T* iface ) {
    if ( 0 != iface ) iface->release();
    return 0;
  }

public:
#endif

  StatusCode initialize() override;
  StatusCode start() override;
  StatusCode stop() override;
  StatusCode finalize() override;
  StatusCode reinitialize() override;
  StatusCode restart() override;
  EventContext createEventContext() override;
  StatusCode nextEvent( int maxevt ) override;
  StatusCode executeEvent( EventContext&& ctx ) override;
  StatusCode executeRun( int maxevt ) override;
  StatusCode stopRun() override;

  void topAlgHandler( Gaudi::Details::PropertyBase& p );
  StatusCode decodeTopAlgs();
  void outStreamHandler( Gaudi::Details::PropertyBase& p );
  StatusCode decodeOutStreams();

protected:
  SmartIF<IHiveWhiteBoard> m_WB;

  // number of events processed
  size_t m_nevt{0};
};
#endif // GAUDIKERNEL_MINIMALEVENTLOOPMGR_H