---

MinimalEventLoopMgr.cpp

Go to the documentation of this file.

//===================================================================
//      MinimalEventLoopMgr.cpp
//--------------------------------------------------------------------
//
//      Package    : MinimalEventLoopMgr ( The LHCb Offline System)
//
//  Description: implementation of the Application's batch mode handler
//
//      Author     : M.Frank
//  History    :
// +---------+----------------------------------------------+---------
// |    Date |                 Comment                      | Who     
// +---------+----------------------------------------------+---------
// | 29/10/98| Initial version                              | MF
// +---------+----------------------------------------------+---------
//
//====================================================================
#define  GAUDISVC_MINIMALEVENTLOOPMGR_CPP

#include "GaudiKernel/SmartIF.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/IAlgorithm.h"
#include "GaudiKernel/IAlgManager.h"

#include "MinimalEventLoopMgr.h"
#include "ListItem.h"

// Instantiation of a static factory class used by clients to create instances of this service
static SvcFactory<MinimalEventLoopMgr> s_MinimalEventLoopMgrFactory;
const ISvcFactory& MinimalEventLoopMgrFactory = s_MinimalEventLoopMgrFactory;

// Standard Constructor
MinimalEventLoopMgr::MinimalEventLoopMgr(const std::string& nam, ISvcLocator* svcLoc)
: Service(nam, svcLoc)
{
  declareProperty("TopAlg",         m_topAlgNames );
  declareProperty("OutStream",      m_outStreamNames );
  m_topAlgNames.declareUpdateHandler   ( &MinimalEventLoopMgr::topAlgHandler, this );
  m_outStreamNames.declareUpdateHandler( &MinimalEventLoopMgr::outStreamHandler, this );
  svcLoc->queryInterface(IID_IAppMgrUI, (void**)&m_appMgrUI);
  m_state = OFFLINE;
}

// Standard Destructor
MinimalEventLoopMgr::~MinimalEventLoopMgr()   {
  m_state = OFFLINE;
}

// implementation of IInterface: queryInterface
StatusCode MinimalEventLoopMgr::queryInterface(const InterfaceID& riid, void** ppvInterface)   {
  if ( riid == IID_IAppMgrUI )  {
    *ppvInterface = (IAppMgrUI*)this;
  }
  else if ( riid == IID_IEventProcessor )  {
    *ppvInterface = (IEventProcessor*)this;
  }
  else  {
    return Service::queryInterface(riid, ppvInterface);
  }
  addRef();
  return StatusCode::SUCCESS;
}

// implementation of IAppMgrUI::run
StatusCode MinimalEventLoopMgr::run()   {
  return StatusCode::FAILURE;
}

// implementation of IAppMgrUI::configure
StatusCode MinimalEventLoopMgr::configure()   {
  if ( 0 != m_appMgrUI )    {
    StatusCode sc = Service::initialize();
    if ( sc.isSuccess() )   {
      MsgStream log(msgSvc(), name());
      SmartIF<IProperty> prpMgr(IID_IProperty, serviceLocator());
      if ( prpMgr.isValid() )   {
        if ( m_topAlgNames.value().size() == 0 )    {
          setProperty(prpMgr->getProperty("TopAlg"));
        }
        if ( m_outStreamNames.value().size() == 0 )   {
          setProperty(prpMgr->getProperty("OutStream"));
        }
        m_state = CONFIGURED;
        return StatusCode::SUCCESS;
      }
      log << MSG::ERROR << "Error retrieving AppMgr interface IProperty." << endreq;
      return StatusCode::FAILURE;
    }
    return sc;
  }
  return StatusCode::FAILURE;
}

// implementation of IAppMgrUI::initalize
StatusCode MinimalEventLoopMgr::initialize()    {
  MsgStream log(msgSvc(), name());
  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.
  //--------------------------------------------------------------------------------------------
  StatusCode sc = decodeOutStreams();
  if ( !sc.isSuccess() )    {
    log << MSG::ERROR << "Failed to initialize Output streams." << endreq;
    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() )    {
    log << MSG::ERROR << "Failed to initialize Top Algorithms streams." << endreq;
    m_state = CONFIGURED;
    return sc;
  }
  return sc;
}

// implementation of IAppMgrUI::initalize
StatusCode MinimalEventLoopMgr::finalize()    {
  MsgStream log( msgSvc(), name() );
  StatusCode sc = 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() ) {
      log << MSG::WARNING << "Finalization of algorithm " << (*ita)->name() << " failed" << endreq;
    }
  }
  //--------------------------------------------------------------------------------------------
  // Call the finalize() method of all Output streams
  //--------------------------------------------------------------------------------------------
  for ( ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
    sc = (*ita)->sysFinalize();
    if( !sc.isSuccess() ) {
      log << MSG::WARNING << "Finalization of algorithm " << (*ita)->name() << " failed" << endreq;
    }
  }
  //--------------------------------------------------------------------------------------------
  // release all top algorithms
  //--------------------------------------------------------------------------------------------
  for ( ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
    (*ita)->release();
  }
  m_topAlgList.erase(m_topAlgList.begin(), m_topAlgList.end() );

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

// implementation of IAppMgrUI::terminate
StatusCode MinimalEventLoopMgr::terminate()   {
  m_appMgrUI = releaseInterface(m_appMgrUI);
  return Service::finalize();
}

// implementation of IAppMgrUI::nextEvent
StatusCode MinimalEventLoopMgr::nextEvent(int /* maxevt */)   {
  MsgStream log(msgSvc(), name());
  log << MSG::ERROR << "This method cannot be called on an object of type " 
      << System::typeinfoName(typeid(*this)) << endreq;
  return StatusCode::FAILURE;
}

// implementation of IAppMgrUI::state: current state of the application manager
const std::string& MinimalEventLoopMgr::state() const   {
  return m_appMgrUI->state();
}

// implemenation of IEventProcessor::executeEvent(void* par)
StatusCode MinimalEventLoopMgr::executeEvent(void* /* par */)    {
  bool eventfailed = false;
  StatusCode sc;
  //--------------------------------------------------------------------------------------------
  // Call the execute() method of all top algorithms
  //--------------------------------------------------------------------------------------------
  for (ListAlg::iterator ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
    (*ita)->resetExecuted();
    sc = (*ita)->sysExecute();
    if( !sc.isSuccess() )  {
      MsgStream log( msgSvc(), name() );
      log << MSG::WARNING << "Execution of algorithm " << (*ita)->name() << " failed" << endreq;
      eventfailed = true;
    }
  }
  //--------------------------------------------------------------------------------------------
  // Call the execute() method of all output streams
  //--------------------------------------------------------------------------------------------
  for (ListAlg::iterator ito = m_outStreamList.begin(); ito != m_outStreamList.end(); ito++ ) {
    (*ito)->resetExecuted();
    sc = (*ito)->sysExecute();
    if( !sc.isSuccess() )  {
      MsgStream log( msgSvc(), name() );
      log << MSG::WARNING << "Execution of output stream " << (*ito)->name() << " failed" << endreq;
      eventfailed = true;
    }
  }
  //--------------------------------------------------------------------------------------------
  // Check if there was an error processing current event
  //--------------------------------------------------------------------------------------------
  if( eventfailed ){
    MsgStream log( msgSvc(), name() );
    log << MSG::ERROR << "Error processing event loop." << endreq;
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

//============================================================================================
// Top algorithm List handler
//============================================================================================
void MinimalEventLoopMgr::topAlgHandler( Property& /* theProp */ )              {
  decodeTopAlgs( );
}

//============================================================================================
// decodeTopAlgNameList & topAlgNameListHandler
//============================================================================================
StatusCode MinimalEventLoopMgr::decodeTopAlgs()    {
  StatusCode result = StatusCode::SUCCESS;
  if ( CONFIGURED == m_state || INITIALIZED == m_state ) {
    SmartIF<IAlgManager> algMan(IID_IAlgManager, serviceLocator());
    MsgStream log(msgSvc(), name());
    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++) {
        ListItem item(*it);
        // Got the type and name. Now creating the algorithm, avoiding duplicate creation.
        IAlgorithm* ialg;
        result = algMan->getAlgorithm( item.name(), ialg );
        if ( result.isSuccess( ) ) {
          log << MSG::DEBUG << "Top Algorithm " << item.name() << " already exists" << endreq;
        } 
        else {
          log << MSG::DEBUG << "Creating Top Algorithm " << item.type() << endreq;
          result = algMan->createAlgorithm( item.type(), item.name(), ialg );
          if( result.isFailure() ) {
            log << MSG::ERROR << "Unable to create Top Algorithm " << item.type() << endreq;
            return result;
          }
        }
        m_topAlgList.push_back(ialg);
      }
      if ( INITIALIZED == m_state ) {
        // Initialize the new list of Algorihms. Note that existing Algorithms
        // are protected against multiple initialization attempts.
        for (ListAlg::iterator ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
          result = (*ita)->sysInitialize();
          if( result.isFailure() ) {
            log << MSG::ERROR << "Unable to initialize Algorithm: " << (*ita)->name() << endreq;
            return result;
          }
        }
      }
      return result;
    }
    result = StatusCode::FAILURE;
  }
  return result;
}

//============================================================================================
// Output stream List handler
//============================================================================================
void MinimalEventLoopMgr::outStreamHandler( Property& /* theProp */ )           {
  decodeOutStreams( );
}

//============================================================================================
// decodeOutStreamNameList & outStreamNameListHandler
//============================================================================================
StatusCode MinimalEventLoopMgr::decodeOutStreams( )    {
  StatusCode result = StatusCode::SUCCESS;
  if ( CONFIGURED == m_state || INITIALIZED == m_state ) {
    MsgStream log(msgSvc(), name());
    SmartIF<IAlgManager> algMan(IID_IAlgManager, 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++) {
        ListItem item(*it, "OutputStream");
        IAlgorithm* ios;
        log << MSG::DEBUG << "Creating OutputStream " << (*it) << endreq;
        result = algMan->getAlgorithm( item.name(), ios );
        if ( result.isSuccess( ) ) {
          log << MSG::DEBUG << "Output Stream " << item.name() << " already exists" << endreq;
        } 
        else {
          log << MSG::DEBUG << "Creating Output Stream " << (*it) << endreq;
          result = algMan->createAlgorithm( item.type(), item.name(), ios );
          if( result.isFailure( ) )    {
            log << MSG::ERROR << "Unable to create Output Stream " << (*it) << endreq;
            return result;
          }
        }
        m_outStreamList.push_back( ios );
      }
      if ( INITIALIZED == m_state ) {
        // Initialize the new list of Output Streams. Note that existing Output Streams
        // are protected against multiple initialization attempts.
        for (ListAlg::iterator ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
          result = (*ita)->sysInitialize();
          if( result.isFailure() ) {
            log << MSG::ERROR << "Unable to initialize Output Stream: " << (*ita)->name() << endreq;
            return result;
          }
        }
      }
      return result;
    }
    result = StatusCode::FAILURE;
  }
  return result;
}

---