| # Gaudi Framework, version v21r10p1 |

Home |  | Generated: 29 Jul 2010

# MinimalEventLoopMgr.cpp

Go to the documentation of this file.

    00001 // $Id: MinimalEventLoopMgr.cpp,v 1.7 2008/07/15 12:48:18 marcocle Exp $
    00002 #define  GAUDIKERNEL_MINIMALEVENTLOOPMGR_CPP
    00003
    00004 #include "GaudiKernel/SmartIF.h"
    00005 #include "GaudiKernel/MsgStream.h"
    00006 #include "GaudiKernel/IAlgorithm.h"
    00007 #include "GaudiKernel/IAlgManager.h"
    00008 #include "GaudiKernel/TypeNameString.h"
    00009 #include "GaudiKernel/GaudiException.h"
    00010 #include "GaudiKernel/ThreadGaudi.h"
    00011 #include "GaudiKernel/Incident.h"
    00012 #include "GaudiKernel/IIncidentListener.h"
    00013 #include "GaudiKernel/IIncidentSvc.h"
    00014
    00015 #include "GaudiKernel/MinimalEventLoopMgr.h"
    00016
    00017 namespace {
    00018   class AbortEventListener: public implements1<IIncidentListener> {
    00019   public:
    00020     AbortEventListener(bool &flag, std::string &source):m_flag(flag),
    00021                                                         m_source(source){
    00022       addRef(); // Initial count set to 1
    00023     }
    00024     virtual ~AbortEventListener() {}
    00026     virtual void handle(const Incident& i) {
    00027       if (i.type() == IncidentType::AbortEvent) {
    00028         m_flag = true;
    00029         m_source = i.source();
    00030       }
    00031     }
    00032
    00033   private:
    00035     bool &m_flag;
    00037     std::string &m_source;
    00038   };
    00039 }
    00040
    00041 //--------------------------------------------------------------------------------------------
    00042 // Standard Constructor
    00043 //--------------------------------------------------------------------------------------------
    00044 MinimalEventLoopMgr::MinimalEventLoopMgr(const std::string& nam, ISvcLocator* svcLoc)
    00045   : base_class(nam, svcLoc), m_appMgrUI(svcLoc)
    00046 {
    00047   declareProperty("TopAlg",         m_topAlgNames );
    00048   declareProperty("OutStream",      m_outStreamNames );
    00049   declareProperty("OutStreamType",  m_outStreamType = "OutputStream");
    00050   m_topAlgNames.declareUpdateHandler   ( &MinimalEventLoopMgr::topAlgHandler, this );
    00051   m_outStreamNames.declareUpdateHandler( &MinimalEventLoopMgr::outStreamHandler, this );
    00052   m_state = OFFLINE;
    00053   m_scheduledStop = false;
    00054   m_abortEvent = false;
    00055 }
    00056
    00057 //--------------------------------------------------------------------------------------------
    00058 // Standard Destructor
    00059 //--------------------------------------------------------------------------------------------
    00060 MinimalEventLoopMgr::~MinimalEventLoopMgr()   {
    00061   m_state = OFFLINE;
    00062 }
    00063
    00064 //--------------------------------------------------------------------------------------------
    00065 // implementation of IAppMgrUI::initialize
    00066 //--------------------------------------------------------------------------------------------
    00067 StatusCode MinimalEventLoopMgr::initialize()    {
    00068
    00069   MsgStream log(msgSvc(), name());
    00070
    00071   if ( !m_appMgrUI.isValid() ) {
    00072     return StatusCode::FAILURE;
    00073   }
    00074
    00075   StatusCode sc = Service::initialize();
    00076   if ( !sc.isSuccess() )   {
    00077     log << MSG::ERROR << "Failed to initialize Service Base class." << endmsg;
    00078     return StatusCode::FAILURE;
    00079   }
    00080
    00081   SmartIF<IProperty> prpMgr(serviceLocator());
    00082   if ( ! prpMgr.isValid() )   {
    00083     log << MSG::ERROR << "Error retrieving AppMgr interface IProperty." << endmsg;
    00084     return StatusCode::FAILURE;
    00085   }
    00086   else {
    00087     if ( m_topAlgNames.value().size() == 0 )    {
    00088       setProperty(prpMgr->getProperty("TopAlg")).ignore();
    00089     }
    00090     if ( m_outStreamNames.value().size() == 0 )   {
    00091       setProperty(prpMgr->getProperty("OutStream")).ignore();
    00092     }
    00093   }
    00094
    00095   // Get the references to the services that are needed by the ApplicationMgr itself
    00096   m_incidentSvc = serviceLocator()->service("IncidentSvc");
    00097   if( !m_incidentSvc.isValid() )  {
    00098     log << MSG::FATAL << "Error retrieving IncidentSvc." << endmsg;
    00099     return StatusCode::FAILURE;
    00100   }
    00101
    00102   m_abortEventListener = new AbortEventListener(m_abortEvent,m_abortEventSource);
    00103   m_incidentSvc->addListener(m_abortEventListener,IncidentType::AbortEvent);
    00104
    00105   // The state is changed at this moment to allow decodeXXXX() to do something
    00106   m_state = INITIALIZED;
    00107
    00108   //--------------------------------------------------------------------------------------------
    00109   // Create output streams. Do not initialize them yet.
    00110   // The state is updated temporarily in order to enable the handler, which
    00111   // is also triggered by a change to the "OutputStream" Property.
    00112   //--------------------------------------------------------------------------------------------
    00113   sc = decodeOutStreams();
    00114   if ( !sc.isSuccess() )    {
    00115     log << MSG::ERROR << "Failed to initialize Output streams." << endmsg;
    00116     m_state = CONFIGURED;
    00117     return sc;
    00118   }
    00119   //--------------------------------------------------------------------------------------------
    00120   // Create all needed Top Algorithms. Do not initialize them yet.
    00121   // The state is updated temporarily in order to enable the handler, which
    00122   // is also triggered by a change to the "TopAlg" Property.
    00123   //--------------------------------------------------------------------------------------------
    00124   sc = decodeTopAlgs();
    00125   if ( !sc.isSuccess() )    {
    00126     log << MSG::ERROR << "Failed to initialize Top Algorithms streams." << endmsg;
    00127     m_state = CONFIGURED;
    00128     return sc;
    00129   }
    00130
    00131   ListAlg::iterator ita;
    00132   // Initialize all the new TopAlgs. In fact Algorithms are protected against getting
    00133   // initialized twice.
    00134   for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
    00135     sc = (*ita)->sysInitialize();
    00136     if( !sc.isSuccess() ) {
    00137       log << MSG::ERROR << "Unable to initialize Algorithm: " << (*ita)->name() << endmsg;
    00138       return sc;
    00139     }
    00140   }
    00141   for (ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
    00142     sc = (*ita)->sysInitialize();
    00143     if( !sc.isSuccess() ) {
    00144       log << MSG::ERROR << "Unable to initialize Output Stream: " << (*ita)->name() << endmsg;
    00145       return sc;
    00146     }
    00147   }
    00148
    00149   return StatusCode::SUCCESS;
    00150 }
    00151 //--------------------------------------------------------------------------------------------
    00152 // implementation of IAppMgrUI::start
    00153 //--------------------------------------------------------------------------------------------
    00154 StatusCode MinimalEventLoopMgr::start()    {
    00155
    00156   StatusCode sc = Service::start();
    00157   if ( ! sc.isSuccess() ) return sc;
    00158
    00159   MsgStream log(msgSvc(), name());
    00160
    00161   ListAlg::iterator ita;
    00162   // Start all the new TopAlgs. In fact Algorithms are protected against getting
    00163   // started twice.
    00164   for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
    00165     sc = (*ita)->sysStart();
    00166     if( !sc.isSuccess() ) {
    00167       log << MSG::ERROR << "Unable to start Algorithm: " << (*ita)->name() << endmsg;
    00168       return sc;
    00169     }
    00170   }
    00171   for (ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
    00172     sc = (*ita)->sysStart();
    00173     if( !sc.isSuccess() ) {
    00174       log << MSG::ERROR << "Unable to start Output Stream: " << (*ita)->name() << endmsg;
    00175       return sc;
    00176     }
    00177   }
    00178   return StatusCode::SUCCESS;
    00179 }
    00180 //--------------------------------------------------------------------------------------------
    00181 // implementation of IAppMgrUI::stop
    00182 //--------------------------------------------------------------------------------------------
    00183 StatusCode MinimalEventLoopMgr::stop()    {
    00184
    00185   StatusCode sc = StatusCode::SUCCESS;
    00186
    00187   MsgStream log(msgSvc(), name());
    00188
    00189   ListAlg::iterator ita;
    00190   // Stop all the TopAlgs. In fact Algorithms are protected against getting
    00191   // stopped twice.
    00192   for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
    00193     sc = (*ita)->sysStop();
    00194     if( !sc.isSuccess() ) {
    00195       log << MSG::ERROR << "Unable to stop Algorithm: " << (*ita)->name() << endmsg;
    00196       return sc;
    00197     }
    00198   }
    00199   for (ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
    00200     sc = (*ita)->sysStop();
    00201     if( !sc.isSuccess() ) {
    00202       log << MSG::ERROR << "Unable to stop Output Stream: " << (*ita)->name() << endmsg;
    00203       return sc;
    00204     }
    00205   }
    00206
    00207   return Service::stop();
    00208 }
    00209
    00210 //--------------------------------------------------------------------------------------------
    00211 // implementation of IService::reinitialize
    00212 //--------------------------------------------------------------------------------------------
    00213 StatusCode MinimalEventLoopMgr::reinitialize() {
    00214   MsgStream log( msgSvc(), name() );
    00215   StatusCode sc = StatusCode::SUCCESS;
    00216   ListAlg::iterator ita;
    00217
    00218   // Reinitialize all the TopAlgs.
    00219   for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
    00220     sc = (*ita)->sysReinitialize();
    00221     if( !sc.isSuccess() ) {
    00222       log << MSG::ERROR << "Unable to reinitialize Algorithm: " << (*ita)->name() << endmsg;
    00223       return sc;
    00224     }
    00225   }
    00226   for (ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
    00227     sc = (*ita)->sysReinitialize();
    00228     if( !sc.isSuccess() ) {
    00229       log << MSG::ERROR << "Unable to reinitialize Output Stream: " << (*ita)->name() << endmsg;
    00230       return sc;
    00231     }
    00232   }
    00233
    00234   return sc;
    00235 }
    00236 //--------------------------------------------------------------------------------------------
    00237 // implementation of IService::restart
    00238 //--------------------------------------------------------------------------------------------
    00239 StatusCode MinimalEventLoopMgr::restart() {
    00240   MsgStream log( msgSvc(), name() );
    00241   StatusCode sc = StatusCode::SUCCESS;
    00242   ListAlg::iterator ita;
    00243
    00244   // Restart all the TopAlgs.
    00245   for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
    00246     sc = (*ita)->sysRestart();
    00247     if( !sc.isSuccess() ) {
    00248       log << MSG::ERROR << "Unable to restart Algorithm: " << (*ita)->name() << endmsg;
    00249       return sc;
    00250     }
    00251   }
    00252   for (ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
    00253     sc = (*ita)->sysRestart();
    00254     if( !sc.isSuccess() ) {
    00255       log << MSG::ERROR << "Unable to restart Output Stream: " << (*ita)->name() << endmsg;
    00256       return sc;
    00257     }
    00258   }
    00259
    00260   return sc;
    00261 }
    00262
    00263 //--------------------------------------------------------------------------------------------
    00264 // implementation of IService::finalize
    00265 //--------------------------------------------------------------------------------------------
    00266 StatusCode MinimalEventLoopMgr::finalize()    {
    00267   MsgStream log( msgSvc(), name() );
    00268   StatusCode sc = StatusCode::SUCCESS;
    00269   StatusCode scRet = StatusCode::SUCCESS;
    00270   // Call the finalize() method of all top algorithms
    00271   ListAlg::iterator ita;
    00272   for ( ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
    00273     sc = (*ita)->sysFinalize();
    00274     if( !sc.isSuccess() ) {
    00275       scRet = StatusCode::FAILURE;
    00276       log << MSG::WARNING << "Finalization of algorithm " << (*ita)->name() << " failed" << endmsg;
    00277     }
    00278   }
    00279   // Call the finalize() method of all Output streams
    00280   for ( ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
    00281     sc = (*ita)->sysFinalize();
    00282     if( !sc.isSuccess() ) {
    00283       scRet = StatusCode::FAILURE;
    00284       log << MSG::WARNING << "Finalization of algorithm " << (*ita)->name() << " failed" << endmsg;
    00285     }
    00286   }
    00287   // release all top algorithms
    00288   SmartIF<IAlgManager> algMan(serviceLocator());
    00289   for ( ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
    00290     if (algMan->removeAlgorithm(*ita).isFailure()) {
    00291       scRet = StatusCode::FAILURE;
    00292       log << MSG::ERROR << "Problems removing Algorithm " << (*ita)->name()
    00293           << endmsg;
    00294     }
    00295   }
    00296   m_topAlgList.clear();
    00297
    00298   // release all output streams
    00299   for ( ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ita++ ) {
    00300     (*ita)->release();
    00301   }
    00302   m_outStreamList.clear();
    00303   if ( sc.isSuccess() ) m_state = FINALIZED;
    00304
    00305   m_incidentSvc->removeListener(m_abortEventListener, IncidentType::AbortEvent);
    00306   m_abortEventListener = 0; // release
    00307
    00308   m_incidentSvc = 0; // release
    00309   m_appMgrUI = 0; // release
    00310
    00311   sc = Service::finalize();
    00312
    00313   if (sc.isFailure()) {
    00314     scRet = StatusCode::FAILURE;
    00315     log << MSG::ERROR << "Problems finalizing Service base class" << endmsg;
    00316   }
    00317
    00318   return scRet;
    00319 }
    00320
    00321 //--------------------------------------------------------------------------------------------
    00322 // implementation of IAppMgrUI::nextEvent
    00323 //--------------------------------------------------------------------------------------------
    00324 StatusCode MinimalEventLoopMgr::nextEvent(int /* maxevt */)   {
    00325   MsgStream log(msgSvc(), name());
    00326   log << MSG::ERROR << "This method cannot be called on an object of type "
    00327       << System::typeinfoName(typeid(*this)) << endmsg;
    00328   return StatusCode::FAILURE;
    00329 }
    00330
    00331 //--------------------------------------------------------------------------------------------
    00332 // IEventProcessing::executeRun
    00333 //--------------------------------------------------------------------------------------------
    00334 StatusCode MinimalEventLoopMgr::executeRun( int maxevt ) {
    00335   StatusCode  sc;
    00336   MsgStream log( msgSvc(), name() );
    00337   ListAlg::iterator ita;
    00338   bool eventfailed = false;
    00339
    00340   // Call the beginRun() method of all top algorithms
    00341   for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
    00342     sc = (*ita)->sysBeginRun();
    00343     if( !sc.isSuccess() ) {
    00344       log << MSG::WARNING << "beginRun() of algorithm " << (*ita)->name() << " failed" << endmsg;
    00345       eventfailed = true;
    00346     }
    00347   }
    00348
    00349   // Call now the nextEvent(...)
    00350   sc = nextEvent(maxevt);
    00351   if( !sc.isSuccess() ) {
    00352     eventfailed = true;
    00353   }
    00354
    00355   // Call the endRun() method of all top algorithms
    00356   for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
    00357     sc = (*ita)->sysEndRun();
    00358     if( !sc.isSuccess() ) {
    00359       log << MSG::WARNING << "endRun() of algorithm " << (*ita)->name() << " failed" << endmsg;
    00360       eventfailed = true;
    00361     }
    00362   }
    00363
    00364   if( eventfailed ){
    00365     return StatusCode::FAILURE;
    00366   }
    00367   else {
    00368     return StatusCode::SUCCESS;
    00369   }
    00370 }
    00371
    00372 //--------------------------------------------------------------------------------------------
    00373 // Implementation of IEventProcessor::executeEvent(void* par)
    00374 //--------------------------------------------------------------------------------------------
    00375 StatusCode MinimalEventLoopMgr::executeEvent(void* /* par */)    {
    00376   bool eventfailed = false;
    00377
    00378   // Call the resetExecuted() method of ALL "known" algorithms
    00379   // (before we were reseting only the topalgs)
    00380   SmartIF<IAlgManager> algMan(serviceLocator());
    00381   if ( algMan.isValid() ) {
    00382     const ListAlgPtrs& allAlgs = algMan->getAlgorithms() ;
    00383     for( ListAlgPtrs::const_iterator ialg = allAlgs.begin() ; allAlgs.end() != ialg ; ++ialg ) {
    00384       if ( 0 != *ialg ) (*ialg)->resetExecuted();
    00385     }
    00386   }
    00387
    00388   // Call the execute() method of all top algorithms
    00389   for (ListAlg::iterator ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
    00390     StatusCode sc(StatusCode::FAILURE);
    00391     try {
    00392       if (m_abortEvent){
    00393         MsgStream log ( msgSvc() , name() );
    00394         log << MSG::DEBUG << "AbortEvent incident fired by "
    00395                           << m_abortEventSource << endmsg;
    00396         m_abortEvent = false;
    00397         sc.ignore();
    00398         break;
    00399       }
    00400       sc = (*ita)->sysExecute();
    00401     } catch ( const GaudiException& Exception ) {
    00402       MsgStream log ( msgSvc() , "MinimalEventLoopMgr.executeEvent()" );
    00403       log << MSG::FATAL << " Exception with tag=" << Exception.tag()
    00404           << " thrown by " << (*ita)->name() << endmsg;
    00405       log << MSG::ERROR << Exception << endmsg;
    00406     } catch ( const std::exception& Exception ) {
    00407       MsgStream log ( msgSvc() , "MinimalEventLoopMgr.executeEvent()" );
    00408       log << MSG::FATAL << " Standard std::exception thrown by "
    00409           << (*ita)->name() << endmsg;
    00410       log << MSG::ERROR << Exception.what()  << endmsg;
    00411     } catch(...) {
    00412       MsgStream log ( msgSvc() , "MinimalEventLoopMgr.executeEvent()" );
    00413       log << MSG::FATAL << "UNKNOWN Exception thrown by "
    00414           << (*ita)->name() << endmsg;
    00415     }
    00416
    00417     if( !sc.isSuccess() )  {
    00418       MsgStream log( msgSvc(), name() );
    00419       log << MSG::WARNING << "Execution of algorithm " << (*ita)->name() << " failed" << endmsg;
    00420       eventfailed = true;
    00421     }
    00422   }
    00423
    00424   // ensure that the abortEvent flag is cleared before the next event
    00425   if (m_abortEvent){
    00426     if (outputLevel() <= MSG::DEBUG) {
    00427       MsgStream log ( msgSvc() , name() );
    00428       log << MSG::DEBUG << "AbortEvent incident fired by "
    00429                         << m_abortEventSource << endmsg;
    00430     }
    00431     m_abortEvent = false;
    00432   }
    00433
    00434   // Call the execute() method of all output streams
    00435   for (ListAlg::iterator ito = m_outStreamList.begin(); ito != m_outStreamList.end(); ito++ ) {
    00436     (*ito)->resetExecuted();
    00437       StatusCode sc;
    00438       sc = (*ito)->sysExecute();
    00439     if( !sc.isSuccess() )  {
    00440       MsgStream log( msgSvc(), name() );
    00441       log << MSG::WARNING << "Execution of output stream " << (*ito)->name() << " failed" << endmsg;
    00442       eventfailed = true;
    00443     }
    00444   }
    00445
    00446   // Check if there was an error processing current event
    00447   if( eventfailed ){
    00448     MsgStream log( msgSvc(), name() );
    00449     log << MSG::ERROR << "Error processing event loop." << endmsg;
    00450     return StatusCode(StatusCode::FAILURE,true);
    00451   }
    00452   return StatusCode(StatusCode::SUCCESS,true);
    00453 }
    00454 //--------------------------------------------------------------------------------------------
    00455 // Implementation of IEventProcessor::stopRun()
    00456 //--------------------------------------------------------------------------------------------
    00457 StatusCode MinimalEventLoopMgr::stopRun() {
    00458   m_scheduledStop = true;
    00459   return StatusCode::SUCCESS;
    00460 }
    00461
    00462 //--------------------------------------------------------------------------------------------
    00463 // Top algorithm List handler
    00464 //--------------------------------------------------------------------------------------------
    00465 void MinimalEventLoopMgr::topAlgHandler( Property& /* theProp */ )  {
    00466   if ( !(decodeTopAlgs( )).isSuccess() ) {
    00467     throw GaudiException("Failed to initialize Top Algorithms streams.",
    00468                          "MinimalEventLoopMgr::topAlgHandler",
    00469                          StatusCode::FAILURE);
    00470   }
    00471 }
    00472
    00473 //--------------------------------------------------------------------------------------------
    00474 // decodeTopAlgNameList & topAlgNameListHandler
    00475 //--------------------------------------------------------------------------------------------
    00476 StatusCode MinimalEventLoopMgr::decodeTopAlgs()    {
    00477   StatusCode sc = StatusCode::SUCCESS;
    00478   if ( CONFIGURED == m_state || INITIALIZED == m_state ) {
    00479     SmartIF<IAlgManager> algMan(serviceLocator());
    00480     MsgStream log(msgSvc(), name());
    00481     if ( algMan.isValid())   {
    00482       // Reset the existing Top Algorithm List
    00483       m_topAlgList.clear( );
    00484       const std::vector<std::string>& algNames = m_topAlgNames.value( );
    00485       for (VectorName::const_iterator it = algNames.begin(); it != algNames.end(); it++) {
    00486         Gaudi::Utils::TypeNameString item(*it);
    00487         // Got the type and name. Now creating the algorithm, avoiding duplicate creation.
    00488         std::string item_name = item.name() + getGaudiThreadIDfromName(name());
    00489         const bool CREATE = false;
    00490         SmartIF<IAlgorithm> alg = algMan->algorithm(item_name, CREATE);
    00491         if (alg.isValid()) {
    00492           log << MSG::DEBUG << "Top Algorithm " << item_name << " already exists" << endmsg;
    00493         }
    00494         else {
    00495           log << MSG::DEBUG << "Creating Top Algorithm " << item.type() << " with name " << item_name << endmsg;
    00496           IAlgorithm *ialg = 0;
    00497           StatusCode sc1 = algMan->createAlgorithm(item.type(), item_name, ialg);
    00498           if( !sc1.isSuccess() ) {
    00499             log << MSG::ERROR << "Unable to create Top Algorithm " << item.type() << " with name " << item_name << endmsg;
    00500             return sc1;
    00501           }
    00502           alg = ialg; // manage reference counting
    00503         }
    00504         m_topAlgList.push_back(alg);
    00505       }
    00506       return sc;
    00507     }
    00508     sc = StatusCode::FAILURE;
    00509   }
    00510   return sc;
    00511 }
    00512
    00513 //--------------------------------------------------------------------------------------------
    00514 // Output stream List handler
    00515 //--------------------------------------------------------------------------------------------
    00516 void MinimalEventLoopMgr::outStreamHandler( Property& /* theProp */ )         {
    00517   if ( !(decodeOutStreams( )).isSuccess() ) {
    00518     throw GaudiException("Failed to initialize output streams.",
    00519                          "MinimalEventLoopMgr::outStreamHandler",
    00520                          StatusCode::FAILURE);
    00521   }
    00522 }
    00523
    00524 //--------------------------------------------------------------------------------------------
    00525 // decodeOutStreamNameList & outStreamNameListHandler
    00526 //--------------------------------------------------------------------------------------------
    00527 StatusCode MinimalEventLoopMgr::decodeOutStreams( )    {
    00528   StatusCode sc = StatusCode::SUCCESS;
    00529   if ( CONFIGURED == m_state || INITIALIZED == m_state ) {
    00530     MsgStream log(msgSvc(), name());
    00531     SmartIF<IAlgManager> algMan(serviceLocator());
    00532     if ( algMan.isValid() )   {
    00533       // Reset the existing Top Algorithm List
    00534       m_outStreamList.clear();
    00535       const std::vector<std::string>& algNames = m_outStreamNames.value( );
    00536       for (VectorName::const_iterator it = algNames.begin(); it != algNames.end(); it++) {
    00537         Gaudi::Utils::TypeNameString item(*it, m_outStreamType);
    00538         log << MSG::DEBUG << "Creating " << m_outStreamType <<  (*it) << endmsg;
    00539         const bool CREATE = false;
    00540         SmartIF<IAlgorithm> os = algMan->algorithm( item, CREATE );
    00541         if (os.isValid()) {
    00542           log << MSG::DEBUG << "Output Stream " << item.name() << " already exists" << endmsg;
    00543         }
    00544         else {
    00545           log << MSG::DEBUG << "Creating Output Stream " << (*it) << endmsg;
    00546           IAlgorithm* ios = 0;
    00547           StatusCode sc1 = algMan->createAlgorithm( item.type(), item.name(), ios );
    00548           if( !sc1.isSuccess() ) {
    00549             log << MSG::ERROR << "Unable to create Output Stream " << (*it) << endmsg;
    00550             return sc1;
    00551           }
    00552           os = ios; // manage reference counting
    00553         }
    00554         m_outStreamList.push_back( os );
    00555       }
    00556      return sc;
    00557     }
    00558     sc = StatusCode::FAILURE;
    00559   }
    00560   return sc;
    00561 }
    00562
    00563