| # Gaudi Framework, version v22r4 |

Home |  | Generated: Fri Sep 2 2011

Public Types | Public Member Functions | Protected Types | Protected Attributes | Private Member Functions

# MinimalEventLoopMgr Class Reference

This is the default processing manager of the application manager. More...

`#include <MinimalEventLoopMgr.h>`

Inheritance diagram for MinimalEventLoopMgr:
[legend]
Collaboration diagram for MinimalEventLoopMgr:
[legend]

List of all members.

## Public Types
typedef std::list< SmartIF < IAlgorithm > > | ListAlg
| Creator friend class.
typedef std::list< IAlgorithm * > | ListAlgPtrs
typedef std::list< std::string > | ListName
typedef std::vector< std::string > | VectorName
## Public Member Functions
| MinimalEventLoopMgr (const std::string &nam, ISvcLocator *svcLoc)
| Standard Constructor.
virtual | ~MinimalEventLoopMgr ()
| Standard Destructor.
virtual StatusCode | initialize ()
| implementation of IService::initialize
virtual StatusCode | start ()
| implementation of IService::start
virtual StatusCode | stop ()
| implementation of IService::stop
virtual StatusCode | finalize ()
| implementation of IService::finalize
virtual StatusCode | reinitialize ()
| implementation of IService::reinitialize
virtual StatusCode | restart ()
| implementation of IService::restart
virtual StatusCode | nextEvent (int maxevt)
| implementation of IEventProcessor::nextEvent
virtual StatusCode | executeEvent (void *par)
| implementation of IEventProcessor::executeEvent(void* par)
virtual StatusCode | executeRun (int maxevt)
| implementation of IEventProcessor::executeRun( )
virtual StatusCode | stopRun ()
| implementation of IEventProcessor::stopRun( )
void | topAlgHandler (Property &p)
| Top algorithm List handler.
StatusCode | decodeTopAlgs ()
| decodeTopAlgNameList & topAlgNameListHandler
void | outStreamHandler (Property &p)
| Output stream List handler.
StatusCode | decodeOutStreams ()
| decodeOutStreamNameList & outStreamNameListHandler
## Protected Types
enum | State { OFFLINE, CONFIGURED, FINALIZED, INITIALIZED }
## Protected Attributes
SmartIF< IAppMgrUI > | m_appMgrUI
| Reference to the IAppMgrUI interface of the application manager.
SmartIF< IIncidentSvc > | m_incidentSvc
| Reference to the incident service.
ListAlg | m_topAlgList
| List of top level algorithms.
ListAlg | m_outStreamList
| List of output streams.
std::string | m_outStreamType
| Out Stream type.
StringArrayProperty | m_topAlgNames
| List of top level algorithms names.
StringArrayProperty | m_outStreamNames
| List of output stream names.
State | m_state
| State of the object.
bool | m_scheduledStop
| Scheduled stop of event processing.
SmartIF< IIncidentListener > | m_abortEventListener
| Instance of the incident listener waiting for AbortEvent.
bool | m_abortEvent
| Flag signalling that the event being processedhas to be aborted (skip all following top algs).
std::string | m_abortEventSource
| Source of the AbortEvent incident.
## Private Member Functions
| MinimalEventLoopMgr (const MinimalEventLoopMgr &)
| Fake copy constructor (never implemented).
MinimalEventLoopMgr & | operator= (const MinimalEventLoopMgr &)
| Fake assignment operator (never implemented).

## Detailed Description

This is the default processing manager of the application manager.

This object handles the minimal requirements needed by the application manager. It also is capable of handling a bunch of algorithms and output streams. However, they list may as well be empty.

Author:
  Markus Frank

Version:
  1.0

Definition at line 26 of file MinimalEventLoopMgr.h.

## Member Typedef Documentation

typedef std::list<SmartIF<IAlgorithm> > MinimalEventLoopMgr::ListAlg

Creator friend class.

Definition at line 30 of file MinimalEventLoopMgr.h.

typedef std::list<IAlgorithm*> MinimalEventLoopMgr::ListAlgPtrs

Definition at line 31 of file MinimalEventLoopMgr.h.

typedef std::list<std::string> MinimalEventLoopMgr::ListName

Definition at line 32 of file MinimalEventLoopMgr.h.

typedef std::vector<std::string> MinimalEventLoopMgr::VectorName

Definition at line 33 of file MinimalEventLoopMgr.h.

## Member Enumeration Documentation

enum MinimalEventLoopMgr::State`[protected]`

Enumerator:

  OFFLINE |
  CONFIGURED |
  FINALIZED |
  INITIALIZED |

Definition at line 37 of file MinimalEventLoopMgr.h.

    { OFFLINE, CONFIGURED, FINALIZED, INITIALIZED };

## Constructor & Destructor Documentation

MinimalEventLoopMgr::MinimalEventLoopMgr | ( | const std::string & | nam,
|  | ISvcLocator * | svcLoc
| ) |  |

Standard Constructor.

Definition at line 50 of file MinimalEventLoopMgr.cpp.

      : base_class(nam, svcLoc), m_appMgrUI(svcLoc)
    {
      declareProperty("TopAlg",         m_topAlgNames );
      declareProperty("OutStream",      m_outStreamNames );
      declareProperty("OutStreamType",  m_outStreamType = "OutputStream");
      m_topAlgNames.declareUpdateHandler   ( &MinimalEventLoopMgr::topAlgHandler, this );
      m_outStreamNames.declareUpdateHandler( &MinimalEventLoopMgr::outStreamHandler, this );
      m_state = OFFLINE;
      m_scheduledStop = false;
      m_abortEvent = false;
    }

MinimalEventLoopMgr::~MinimalEventLoopMgr | ( | ) | `[virtual]`

Standard Destructor.

Definition at line 66 of file MinimalEventLoopMgr.cpp.

                                                {
      m_state = OFFLINE;
    }

MinimalEventLoopMgr::MinimalEventLoopMgr | ( | const MinimalEventLoopMgr & | ) | `[private]`

Fake copy constructor (never implemented).

## Member Function Documentation

StatusCode MinimalEventLoopMgr::decodeOutStreams | ( | ) |

decodeOutStreamNameList & outStreamNameListHandler

Definition at line 539 of file MinimalEventLoopMgr.cpp.

                                                         {
      StatusCode sc = StatusCode::SUCCESS;
      if ( CONFIGURED == m_state || INITIALIZED == m_state ) {
        SmartIF<IAlgManager> algMan(serviceLocator());
        if ( algMan.isValid() )   {
          // Reset the existing Top Algorithm List
          m_outStreamList.clear();
          const std::vector<std::string>& algNames = m_outStreamNames.value( );
          for (VectorName::const_iterator it = algNames.begin(); it != algNames.end(); it++) {
            Gaudi::Utils::TypeNameString item(*it, m_outStreamType);
            DEBMSG << "Creating " << m_outStreamType <<  (*it) << endmsg;
            const bool CREATE = false;
            SmartIF<IAlgorithm> os = algMan->algorithm( item, CREATE );
            if (os.isValid()) {
              DEBMSG << "Output Stream " << item.name() << " already exists" << endmsg;
            }
            else {
              DEBMSG << "Creating Output Stream " << (*it) << endmsg;
              IAlgorithm* ios = 0;
              StatusCode sc1 = algMan->createAlgorithm( item.type(), item.name(), ios );
              if( !sc1.isSuccess() ) {
                error() << "Unable to create Output Stream " << (*it) << endmsg;
                return sc1;
              }
              os = ios; // manage reference counting
            }
            m_outStreamList.push_back( os );
          }
         return sc;
        }
        sc = StatusCode::FAILURE;
      }
      return sc;
    }

StatusCode MinimalEventLoopMgr::decodeTopAlgs | ( | ) |

decodeTopAlgNameList & topAlgNameListHandler

Definition at line 489 of file MinimalEventLoopMgr.cpp.

                                                     {
      StatusCode sc = StatusCode::SUCCESS;
      if ( CONFIGURED == m_state || INITIALIZED == m_state ) {
        SmartIF<IAlgManager> algMan(serviceLocator());
        if ( algMan.isValid())   {
          // Reset the existing Top Algorithm List
          m_topAlgList.clear( );
          const std::vector<std::string>& algNames = m_topAlgNames.value( );
          for (VectorName::const_iterator it = algNames.begin(); it != algNames.end(); it++) {
            Gaudi::Utils::TypeNameString item(*it);
            // Got the type and name. Now creating the algorithm, avoiding duplicate creation.
            std::string item_name = item.name() + getGaudiThreadIDfromName(name());
            const bool CREATE = false;
            SmartIF<IAlgorithm> alg = algMan->algorithm(item_name, CREATE);
            if (alg.isValid()) {
              DEBMSG << "Top Algorithm " << item_name << " already exists" << endmsg;
            }
            else {
              DEBMSG << "Creating Top Algorithm " << item.type() << " with name " << item_name << endmsg;
              IAlgorithm *ialg = 0;
              StatusCode sc1 = algMan->createAlgorithm(item.type(), item_name, ialg);
              if( !sc1.isSuccess() ) {
                error() << "Unable to create Top Algorithm " << item.type() << " with name " << item_name << endmsg;
                return sc1;
              }
              alg = ialg; // manage reference counting
            }
            m_topAlgList.push_back(alg);
          }
          return sc;
        }
        sc = StatusCode::FAILURE;
      }
      return sc;
    }

StatusCode MinimalEventLoopMgr::executeEvent | ( | void * | par ) | `[virtual]`

implementation of IEventProcessor::executeEvent(void* par)

Implements IEventProcessor.

Reimplemented in EventLoopMgr.

Definition at line 389 of file MinimalEventLoopMgr.cpp.

                                                                   {
      bool eventfailed = false;

      // Call the resetExecuted() method of ALL "known" algorithms
      // (before we were reseting only the topalgs)
      SmartIF<IAlgManager> algMan(serviceLocator());
      if (LIKELY(algMan.isValid())) {
        const ListAlgPtrs& allAlgs = algMan->getAlgorithms() ;
        for( ListAlgPtrs::const_iterator ialg = allAlgs.begin() ; allAlgs.end() != ialg ; ++ialg ) {
          if (LIKELY(0 != *ialg)) (*ialg)->resetExecuted();
        }
      }

      // Get the IProperty interface of the ApplicationMgr to pass it to RetCodeGuard
      const SmartIF<IProperty> appmgr(serviceLocator());
      // Call the execute() method of all top algorithms
      for (ListAlg::iterator ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
        StatusCode sc(StatusCode::FAILURE);
        try {
          if (UNLIKELY(m_abortEvent)) {
            DEBMSG << "AbortEvent incident fired by "
                   << m_abortEventSource << endmsg;
            m_abortEvent = false;
            sc.ignore();
            break;
          }
          RetCodeGuard rcg(appmgr, Gaudi::ReturnCode::UnhandledException);
          sc = (*ita)->sysExecute();
          rcg.ignore(); // disarm the guard
        } catch ( const GaudiException& Exception ) {
          fatal() << ".executeEvent(): Exception with tag=" << Exception.tag()
                  << " thrown by " << (*ita)->name() << endmsg;
          error() << Exception << endmsg;
        } catch ( const std::exception& Exception ) {
          fatal() << ".executeEvent(): Standard std::exception thrown by "
                  << (*ita)->name() << endmsg;
          error() << Exception.what()  << endmsg;
        } catch(...) {
          fatal() << ".executeEvent(): UNKNOWN Exception thrown by "
                  << (*ita)->name() << endmsg;
        }

        if (UNLIKELY(!sc.isSuccess()))  {
          warning() << "Execution of algorithm " << (*ita)->name() << " failed" << endmsg;
          eventfailed = true;
        }
      }

      // ensure that the abortEvent flag is cleared before the next event
      if (UNLIKELY(m_abortEvent)) {
        DEBMSG << "AbortEvent incident fired by " << m_abortEventSource << endmsg;
        m_abortEvent = false;
      }

      // Call the execute() method of all output streams
      for (ListAlg::iterator ito = m_outStreamList.begin(); ito != m_outStreamList.end(); ito++ ) {
        (*ito)->resetExecuted();
          StatusCode sc;
          sc = (*ito)->sysExecute();
        if (UNLIKELY(!sc.isSuccess()))  {
          warning() << "Execution of output stream " << (*ito)->name() << " failed" << endmsg;
          eventfailed = true;
        }
      }

      // Check if there was an error processing current event
      if (UNLIKELY(eventfailed)){
        error() << "Error processing event loop." << endmsg;
        return StatusCode(StatusCode::FAILURE,true);
      }
      return StatusCode(StatusCode::SUCCESS,true);
    }

StatusCode MinimalEventLoopMgr::executeRun | ( | int | maxevt ) | `[virtual]`

implementation of IEventProcessor::executeRun( )

Implements IEventProcessor.

Reimplemented in EventLoopMgr.

Definition at line 329 of file MinimalEventLoopMgr.cpp.

                                                           {
      StatusCode  sc;
      ListAlg::iterator ita;
      bool eventfailed = false;

      // Call the beginRun() method of all top algorithms
      for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
        sc = (*ita)->sysBeginRun();
        if (!sc.isSuccess()) {
          warning() << "beginRun() of algorithm " << (*ita)->name() << " failed" << endmsg;
          eventfailed = true;
        }
      }

      // Call now the nextEvent(...)
      sc = nextEvent(maxevt);
      if (!sc.isSuccess()) {
        eventfailed = true;
      }

      // Call the endRun() method of all top algorithms
      for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
        sc = (*ita)->sysEndRun();
        if (!sc.isSuccess()) {
          warning() << "endRun() of algorithm " << (*ita)->name() << " failed" << endmsg;
          eventfailed = true;
        }
      }

      if (eventfailed) {
        return StatusCode::FAILURE;
      }
      else {
        return StatusCode::SUCCESS;
      }
    }

StatusCode MinimalEventLoopMgr::finalize | ( | void | ) | `[virtual]`

implementation of IService::finalize

Reimplemented from Service.

Reimplemented in EventLoopMgr.

Definition at line 264 of file MinimalEventLoopMgr.cpp.

                                             {
      StatusCode sc = StatusCode::SUCCESS;
      StatusCode scRet = StatusCode::SUCCESS;
      // Call the finalize() method of all top algorithms
      ListAlg::iterator ita;
      for ( ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
        sc = (*ita)->sysFinalize();
        if( !sc.isSuccess() ) {
          scRet = StatusCode::FAILURE;
          warning() << "Finalization of algorithm " << (*ita)->name() << " failed" << endmsg;
        }
      }
      // Call the finalize() method of all Output streams
      for ( ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
        sc = (*ita)->sysFinalize();
        if( !sc.isSuccess() ) {
          scRet = StatusCode::FAILURE;
          warning() << "Finalization of algorithm " << (*ita)->name() << " failed" << endmsg;
        }
      }
      // release all top algorithms
      SmartIF<IAlgManager> algMan(serviceLocator());
      for ( ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
        if (algMan->removeAlgorithm(*ita).isFailure()) {
          scRet = StatusCode::FAILURE;
          warning() << "Problems removing Algorithm " << (*ita)->name() << endmsg;
        }
      }
      m_topAlgList.clear();

      // release all output streams
      for ( ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
        (*ita)->release();
      }
      m_outStreamList.clear();
      if ( sc.isSuccess() ) m_state = FINALIZED;

      m_incidentSvc->removeListener(m_abortEventListener, IncidentType::AbortEvent);
      m_abortEventListener = 0; // release

      m_incidentSvc = 0; // release
      m_appMgrUI = 0; // release

      sc = Service::finalize();

      if (sc.isFailure()) {
        scRet = StatusCode::FAILURE;
        error() << "Problems finalizing Service base class" << endmsg;
      }

      return scRet;
    }

StatusCode MinimalEventLoopMgr::initialize | ( | void | ) | `[virtual]`

implementation of IService::initialize

Reimplemented from Service.

Reimplemented in EventLoopMgr.

Definition at line 73 of file MinimalEventLoopMgr.cpp.

                                                  {

      if ( !m_appMgrUI.isValid() ) {
        return StatusCode::FAILURE;
      }

      StatusCode sc = Service::initialize();
      if ( !sc.isSuccess() )   {
        error() << "Failed to initialize Service Base class." << endmsg;
        return StatusCode::FAILURE;
      }

      SmartIF<IProperty> prpMgr(serviceLocator());
      if ( ! prpMgr.isValid() )   {
        error() << "Error retrieving AppMgr interface IProperty." << endmsg;
        return StatusCode::FAILURE;
      }
      else {
        if ( m_topAlgNames.value().size() == 0 )    {
          setProperty(prpMgr->getProperty("TopAlg")).ignore();
        }
        if ( m_outStreamNames.value().size() == 0 )   {
          setProperty(prpMgr->getProperty("OutStream")).ignore();
        }
      }

      // Get the references to the services that are needed by the ApplicationMgr itself
      m_incidentSvc = serviceLocator()->service("IncidentSvc");
      if( !m_incidentSvc.isValid() )  {
        fatal() << "Error retrieving IncidentSvc." << endmsg;
        return StatusCode::FAILURE;
      }

      m_abortEventListener = new AbortEventListener(m_abortEvent,m_abortEventSource);
      m_incidentSvc->addListener(m_abortEventListener,IncidentType::AbortEvent);

      // The state is changed at this moment to allow decodeXXXX() to do something
      m_state = INITIALIZED;

      //--------------------------------------------------------------------------------------------
      // Create output streams. Do not initialize them yet.
      // The state is updated temporarily in order to enable the handler, which
      // is also triggered by a change to the "OutputStream" Property.
      //--------------------------------------------------------------------------------------------
      sc = decodeOutStreams();
      if ( !sc.isSuccess() )    {
        error() << "Failed to initialize Output streams." << endmsg;
        m_state = CONFIGURED;
        return sc;
      }
      //--------------------------------------------------------------------------------------------
      // Create all needed Top Algorithms. Do not initialize them yet.
      // The state is updated temporarily in order to enable the handler, which
      // is also triggered by a change to the "TopAlg" Property.
      //--------------------------------------------------------------------------------------------
      sc = decodeTopAlgs();
      if ( !sc.isSuccess() )    {
        error() << "Failed to initialize Top Algorithms streams." << endmsg;
        m_state = CONFIGURED;
        return sc;
      }

      ListAlg::iterator ita;
      // Initialize all the new TopAlgs. In fact Algorithms are protected against getting
      // initialized twice.
      for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
        sc = (*ita)->sysInitialize();
        if( !sc.isSuccess() ) {
          error() << "Unable to initialize Algorithm: " << (*ita)->name() << endmsg;
          return sc;
        }
      }
      for (ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
        sc = (*ita)->sysInitialize();
        if( !sc.isSuccess() ) {
          error() << "Unable to initialize Output Stream: " << (*ita)->name() << endmsg;
          return sc;
        }
      }

      return StatusCode::SUCCESS;
    }

StatusCode MinimalEventLoopMgr::nextEvent | ( | int | maxevt ) | `[virtual]`

implementation of IEventProcessor::nextEvent

Implements IEventProcessor.

Reimplemented in EventLoopMgr.

Definition at line 320 of file MinimalEventLoopMgr.cpp.

                                                                {
      error() << "This method cannot be called on an object of type "
              << System::typeinfoName(typeid(*this)) << endmsg;
      return StatusCode::FAILURE;
    }

MinimalEventLoopMgr& MinimalEventLoopMgr::operator= | ( | const MinimalEventLoopMgr & | ) | `[private]`

Fake assignment operator (never implemented).

void MinimalEventLoopMgr::outStreamHandler | ( | Property & | p ) |

Output stream List handler.

Definition at line 528 of file MinimalEventLoopMgr.cpp.

                                                                                {
      if ( !(decodeOutStreams( )).isSuccess() ) {
        throw GaudiException("Failed to initialize output streams.",
                             "MinimalEventLoopMgr::outStreamHandler",
                             StatusCode::FAILURE);
      }
    }

StatusCode MinimalEventLoopMgr::reinitialize | ( | ) | `[virtual]`

implementation of IService::reinitialize

Reimplemented from Service.

Reimplemented in EventLoopMgr.

Definition at line 213 of file MinimalEventLoopMgr.cpp.

                                                 {
      StatusCode sc = StatusCode::SUCCESS;
      ListAlg::iterator ita;

      // Reinitialize all the TopAlgs.
      for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
        sc = (*ita)->sysReinitialize();
        if( !sc.isSuccess() ) {
          error() << "Unable to reinitialize Algorithm: " << (*ita)->name() << endmsg;
          return sc;
        }
      }
      for (ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
        sc = (*ita)->sysReinitialize();
        if( !sc.isSuccess() ) {
          error() << "Unable to reinitialize Output Stream: " << (*ita)->name() << endmsg;
          return sc;
        }
      }

      return sc;
    }

StatusCode MinimalEventLoopMgr::restart | ( | ) | `[virtual]`

implementation of IService::restart

Reimplemented from Service.

Definition at line 238 of file MinimalEventLoopMgr.cpp.

                                            {
      StatusCode sc = StatusCode::SUCCESS;
      ListAlg::iterator ita;

      // Restart all the TopAlgs.
      for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
        sc = (*ita)->sysRestart();
        if( !sc.isSuccess() ) {
          error() << "Unable to restart Algorithm: " << (*ita)->name() << endmsg;
          return sc;
        }
      }
      for (ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
        sc = (*ita)->sysRestart();
        if( !sc.isSuccess() ) {
          error() << "Unable to restart Output Stream: " << (*ita)->name() << endmsg;
          return sc;
        }
      }

      return sc;
    }

StatusCode MinimalEventLoopMgr::start | ( | ) | `[virtual]`

implementation of IService::start

Reimplemented from Service.

Definition at line 158 of file MinimalEventLoopMgr.cpp.

                                             {

      StatusCode sc = Service::start();
      if ( ! sc.isSuccess() ) return sc;

      ListAlg::iterator ita;
      // Start all the new TopAlgs. In fact Algorithms are protected against getting
      // started twice.
      for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
        sc = (*ita)->sysStart();
        if( !sc.isSuccess() ) {
          error() << "Unable to start Algorithm: " << (*ita)->name() << endmsg;
          return sc;
        }
      }
      for (ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
        sc = (*ita)->sysStart();
        if( !sc.isSuccess() ) {
          error() << "Unable to start Output Stream: " << (*ita)->name() << endmsg;
          return sc;
        }
      }
      return StatusCode::SUCCESS;
    }

StatusCode MinimalEventLoopMgr::stop | ( | ) | `[virtual]`

implementation of IService::stop

Reimplemented from Service.

Reimplemented in EventLoopMgr.

Definition at line 185 of file MinimalEventLoopMgr.cpp.

                                            {

      StatusCode sc = StatusCode::SUCCESS;

      ListAlg::iterator ita;
      // Stop all the TopAlgs. In fact Algorithms are protected against getting
      // stopped twice.
      for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
        sc = (*ita)->sysStop();
        if( !sc.isSuccess() ) {
          error() << "Unable to stop Algorithm: " << (*ita)->name() << endmsg;
          return sc;
        }
      }
      for (ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
        sc = (*ita)->sysStop();
        if( !sc.isSuccess() ) {
          error() << "Unable to stop Output Stream: " << (*ita)->name() << endmsg;
          return sc;
        }
      }

      return Service::stop();
    }

StatusCode MinimalEventLoopMgr::stopRun | ( | ) | `[virtual]`

implementation of IEventProcessor::stopRun( )

Implements IEventProcessor.

Definition at line 464 of file MinimalEventLoopMgr.cpp.

                                            {
      // Set the application return code
      SmartIF<IProperty> appmgr(serviceLocator());
      if(Gaudi::setAppReturnCode(appmgr, Gaudi::ReturnCode::ScheduledStop).isFailure()) {
        error() << "Could not set return code of the application ("
                << Gaudi::ReturnCode::ScheduledStop << ")" << endmsg;
      }
      m_scheduledStop = true;
      return StatusCode::SUCCESS;
    }

void MinimalEventLoopMgr::topAlgHandler | ( | Property & | p ) |

Top algorithm List handler.

Definition at line 478 of file MinimalEventLoopMgr.cpp.

                                                                      {
      if ( !(decodeTopAlgs( )).isSuccess() ) {
        throw GaudiException("Failed to initialize Top Algorithms streams.",
                             "MinimalEventLoopMgr::topAlgHandler",
                             StatusCode::FAILURE);
      }
    }

## Member Data Documentation

bool MinimalEventLoopMgr::m_abortEvent`[protected]`

Flag signalling that the event being processedhas to be aborted (skip all following top algs).

Definition at line 60 of file MinimalEventLoopMgr.h.

SmartIF<IIncidentListener> MinimalEventLoopMgr::m_abortEventListener`[protected]`

Instance of the incident listener waiting for AbortEvent.

Definition at line 57 of file MinimalEventLoopMgr.h.

std::string MinimalEventLoopMgr::m_abortEventSource`[protected]`

Source of the AbortEvent incident.

Definition at line 62 of file MinimalEventLoopMgr.h.

SmartIF<IAppMgrUI> MinimalEventLoopMgr::m_appMgrUI`[protected]`

Reference to the IAppMgrUI interface of the application manager.

Definition at line 39 of file MinimalEventLoopMgr.h.

SmartIF<IIncidentSvc> MinimalEventLoopMgr::m_incidentSvc`[protected]`

Reference to the incident service.

Definition at line 41 of file MinimalEventLoopMgr.h.

ListAlg MinimalEventLoopMgr::m_outStreamList`[protected]`

List of output streams.

Definition at line 45 of file MinimalEventLoopMgr.h.

StringArrayProperty MinimalEventLoopMgr::m_outStreamNames`[protected]`

List of output stream names.

Definition at line 51 of file MinimalEventLoopMgr.h.

std::string MinimalEventLoopMgr::m_outStreamType`[protected]`

Out Stream type.

Definition at line 47 of file MinimalEventLoopMgr.h.

bool MinimalEventLoopMgr::m_scheduledStop`[protected]`

Scheduled stop of event processing.

Definition at line 55 of file MinimalEventLoopMgr.h.

State MinimalEventLoopMgr::m_state`[protected]`

State of the object.

Reimplemented from Service.

Definition at line 53 of file MinimalEventLoopMgr.h.

ListAlg MinimalEventLoopMgr::m_topAlgList`[protected]`

List of top level algorithms.

Definition at line 43 of file MinimalEventLoopMgr.h.

StringArrayProperty MinimalEventLoopMgr::m_topAlgNames`[protected]`

List of top level algorithms names.

Definition at line 49 of file MinimalEventLoopMgr.h.

The documentation for this class was generated from the following files:

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v22r4/GaudiKernel/GaudiKernel/MinimalEventLoopMgr.h
- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v22r4/GaudiKernel/src/Lib/MinimalEventLoopMgr.cpp

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines