---

ApplicationMgr.cpp

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiSvc/src/ApplicationMgr/ApplicationMgr.cpp,v 1.1.1.3 2001/04/18 18:32:48 tlindner Exp $

// Include files
#include "ApplicationMgr.h"
#include "ServiceFactory.h"
#include "AlgorithmFactory.h"
#include "ConverterFactory.h"
#include "ObjectManager.h"
#include "DLLClassManager.h"
#include "ListItem.h"

#include "GaudiKernel/IService.h"
#include "GaudiKernel/IRunable.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/IJobOptionsSvc.h"

#include "GaudiKernel/SmartIF.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/PropertyMgr.h"
#include "GaudiKernel/ObjectFactory.h"

static ObjectFactory<ApplicationMgr> s_factory; 
const IFactory& ApplicationMgrFactory = s_factory;

static const char* s_eventloop = "EventLoop";
static const char* s_runable   = "Runable";


// Implementation class for the Application Manager. In this way the 
// ApplicationMgr class is a fully insulated concrete class. Clients (main programs)
// will not need to re-compile if there are changes in the implementation

//============================================================================================
// Constructor 
//============================================================================================
ApplicationMgr::ApplicationMgr(IInterface*) {
  // IInterface initialization
  m_refcount = 1;
  
  // Instanciate internal services
  m_objFactory   = new ObjectManager(this);
  m_svcFactory   = new ServiceFactory(this);
  m_algFactory   = new AlgorithmFactory(this);
  m_cnvFactory   = new ConverterFactory(this);
  m_classManager = new DLLClassManager(this);
  m_propertyMgr  = new PropertyMgr();

  // Initialize two basic services: messagesvc & joboptions
  m_messageSvc        = 0;
  m_svcLocator        = (ISvcLocator*)this;
  
  m_name  = "ApplicationMgr";
  m_state = OFFLINE;
  m_stateName.push_back("Offline");
  m_stateName.push_back("Configured");
  m_stateName.push_back("Finalized");
  m_stateName.push_back("Initialized");

  m_propertyMgr->declareProperty("Go",        m_SIGo = 0 );
  m_propertyMgr->declareProperty("Exit",      m_SIExit = 0 );
  m_propertyMgr->declareProperty("Dlls",      m_dllNameList );
  m_propertyMgr->declareProperty("ExtSvc",    m_extSvcNameList );
  m_propertyMgr->declareProperty("DefSvc",    m_defServices );

  m_propertyMgr->declareProperty("TopAlg",    m_topAlgNameList );
  m_propertyMgr->declareProperty("OutStream", m_outStreamNameList );
  m_propertyMgr->declareProperty( s_runable,  m_runableType    = "AppMgrRunable");
  m_propertyMgr->declareProperty( s_eventloop,m_eventLoopMgr  = "GaudiEventLoopMgr");

  m_propertyMgr->declareProperty("HistogramPersistency", m_histPersName="NONE");

  // Declare Job Options Service properties and set default
  m_propertyMgr->declareProperty("JobOptionsType", m_jobOptionsType = "FILE");
  m_propertyMgr->declareProperty("JobOptionsPath", m_jobOptionsPath = "jobOptions.txt");
  m_propertyMgr->declareProperty("EvtMax",         m_evtMax = -1);
  m_propertyMgr->declareProperty("EvtSel",         m_evtsel );

  // Add action handlers to the appropriate properties
  m_SIGo.declareUpdateHandler  ( &ApplicationMgr::SIGoHandler         , this );
  m_SIExit.declareUpdateHandler( &ApplicationMgr::SIExitHandler       , this );
  m_topAlgNameList.declareUpdateHandler   ( &ApplicationMgr::evtLoopPropertyHandler, this );
  m_outStreamNameList.declareUpdateHandler( &ApplicationMgr::evtLoopPropertyHandler, this );
  m_extSvcNameList.declareUpdateHandler   ( &ApplicationMgr::extSvcNameListHandler   , this );
  m_dllNameList.declareUpdateHandler      ( &ApplicationMgr::dllNameListHandler      , this );
  m_processingMgr = 0;
  m_runable = 0;
}

//============================================================================================
// destructor 
//============================================================================================
ApplicationMgr::~ApplicationMgr() {
  delete m_objFactory;
  delete m_cnvFactory;
  delete m_svcFactory;
  delete m_algFactory;
  delete m_classManager;
  delete m_propertyMgr;
}

//============================================================================================
// IInterface implementation: ApplicationMgr::addRef()
//============================================================================================
unsigned long ApplicationMgr::addRef() {
  m_refcount++;
  return m_refcount;
}

//============================================================================================
// IInterface implementation: ApplicationMgr::release()
//============================================================================================
unsigned long ApplicationMgr::release() {
  long count = --m_refcount;
  if( count <= 0) {
    delete this;
  }
  return count;
}

//============================================================================================
// IInterface implementation: queryInterface::addRef()
//============================================================================================
StatusCode ApplicationMgr::queryInterface(const InterfaceID& iid, void** ppvInterface){

  if( iid == IID_IInterface ) {  
    *ppvInterface = (IInterface*)this;
  } 
  else if ( iid == IID_ISvcLocator ) { 
    *ppvInterface = (ISvcLocator*)this;
  } 
  else if ( iid == IID_IAppMgrUI ) {
    *ppvInterface = (IAppMgrUI*)this;
  } 
  else if ( iid == IID_ISvcManager ) {
    *ppvInterface = (ISvcManager*)this;
  } 
  else if ( iid == IID_IObjManager ) {
    *ppvInterface = (IObjManager*)this;
  } 
  else if ( iid == IID_IAlgManager ) {
    *ppvInterface = (IAlgManager*)this;
  } 
  else if ( iid == IID_IClassManager ) {
    *ppvInterface = (IClassManager*)this;
  } 
  else if ( iid == IID_ICnvManager ) {
    *ppvInterface = (ICnvManager*)this;
  } 
  else if ( iid == IID_IProperty ) {
    *ppvInterface = (IProperty*)this;
  } 
  else {
    return StatusCode::FAILURE;
  }
  addRef();
  return StatusCode::SUCCESS;
}

//============================================================================================
// Connect to service (Check existence; if needed, create)
//============================================================================================
IService* ApplicationMgr::i_connectService(const std::string& typ, const std::string& nam)    {
  MsgStream log(m_messageSvc, name());
  if ( 0 != m_messageSvc )  {
    log << MSG::DEBUG << "Creating service " << nam << " of type " << typ << endreq;
  }
  IService* svc = 0;
  StatusCode sc = getService(nam, svc);
  if( sc.isSuccess() ) {
    log << MSG::WARNING << "Service with name " << nam << " already existing" << endreq;
  }
  else    {
    StatusCode sc = m_svcFactory->createService( typ, nam, svc );
    if( !sc.isSuccess() ) {
      log << MSG::ERROR << "Unable to create Service " << nam << " of type " << typ << endreq;
      return 0;
    }
    m_topSvcList.push_back( svc );
  }
  return svc;
}

//============================================================================================
// ApplicationMgr::i_startup()
//============================================================================================
StatusCode ApplicationMgr::i_startup() {
  MsgStream tlog( m_messageSvc, name() );
  IService   *msgsvc = 0, *jobsvc = 0;
  IProperty* jobOptsIProp = 0;
  StatusCode  sc;

  // declare factories in current module
  m_classManager->loadModule("");
  
  // Create the Message service
  sc = m_svcFactory->createService( "MessageSvc", "MessageSvc", msgsvc );
  if( !sc.isSuccess() )  {
    tlog << MSG::FATAL << "Error creating MessageSvc" << endreq;
    return sc;
  }
  // Create the Job Options service
  sc = m_svcFactory->createService( "JobOptionsSvc", "JobOptionsSvc", jobsvc );
  if( !sc.isSuccess() )   {
    tlog << MSG::FATAL << "Error creating JobOptionsSvc" << endreq;
    return sc;
  }

  sc = m_svcLocator->service( "JobOptionsSvc", jobOptsIProp);
  if( !sc.isSuccess() )  {
    tlog << MSG::FATAL << "Error retrieving JobOptionsSvc." << endreq;
    return sc;
  }

  jobOptsIProp->setProperty( StringProperty("TYPE", m_jobOptionsType) );
  if ( 0 != getenv("JOBOPTPATH") ) { 
          jobOptsIProp->setProperty( StringProperty("PATH", getenv("JOBOPTPATH")));
  }
  else {
          jobOptsIProp->setProperty( StringProperty("PATH", m_jobOptionsPath ));
  }

  sc = jobsvc->initialize();
  if( !sc.isSuccess() )   {
    tlog << MSG::FATAL << "Error initializing JobOptionsSvc" << endreq;
    return sc;
  }
  sc = msgsvc->initialize();
  if( !sc.isSuccess() )  {
    tlog << MSG::FATAL << "Error initializing MessageSvc" << endreq;
    return sc;
  }
  return sc;
}

//============================================================================================
// IAppMgrUI implementation: ApplicationMgr::configure()
//============================================================================================
StatusCode ApplicationMgr::configure() {
  MsgStream tlog( m_messageSvc, name() );
  IJobOptionsSvc* jobOptionsSvc = 0;
  StatusCode  sc;

  if( m_state == CONFIGURED ) {
    tlog << MSG::INFO << "Already Configured" << endreq;
    return StatusCode::SUCCESS;
  } 
  else if( m_state != OFFLINE && m_state != FINALIZED ) {
    tlog << MSG::FATAL << "Invalid initial state" << endreq;
    return StatusCode::FAILURE;
  }
  else if( m_state == OFFLINE )      {
    sc = i_startup();
    if ( !sc.isSuccess() )    {
      return sc;
    }
  }

  sc = m_svcLocator->service( "MessageSvc", m_messageSvc);
  if( !sc.isSuccess() )  {
    tlog << MSG::FATAL << "Error retrieving MessageSvc." << endreq;
    return sc;
  }
  sc = m_svcLocator->service( "JobOptionsSvc", jobOptionsSvc);
  if( !sc.isSuccess() )  {
    tlog << MSG::FATAL << "Error retrieving MessageSvc." << endreq;
    return sc;
  }

  MsgStream log( m_messageSvc, name() );
  m_topSvcNameList.erase(m_topSvcNameList.begin(), m_topSvcNameList.end());
  m_defServices.erase(m_defServices.begin(), m_defServices.end());
  // Create the other known services
  m_defServices.push_back("EvtDataSvc/EventDataSvc");
  m_defServices.push_back("EvtPersistencySvc/EventPersistencySvc");
  //  The selection of the event selection is done inthe JobOptions file
  //  m_defServices.push_back("EventSelector/EventSelector");
  m_defServices.push_back("DetPersistencySvc/DetectorPersistencySvc");
  m_defServices.push_back("DetDataSvc/DetectorDataSvc");
  m_defServices.push_back("HistogramSvc/HistogramDataSvc");
  m_defServices.push_back("NTupleSvc/NTupleSvc");
  m_defServices.push_back("IncidentSvc/IncidentSvc");
  m_defServices.push_back("ToolSvc/ToolSvc");

  //  m_defServices.push_back("HbookCnv::PersSvc/HistogramPersistencySvc");
  m_defServices.push_back("ChronoStatSvc/ChronoStatSvc");
  m_defServices.push_back("RndmGenSvc/RndmGenSvc");
  m_defServices.push_back("AuditorSvc/AuditorSvc");

  // Get my own options using the Job options service
  log << MSG::DEBUG << "Getting my own properties" << endreq;
  sc = jobOptionsSvc->setMyProperties( name(), this );
  if( !sc.isSuccess() ) {
    log << MSG::WARNING << "Problems getting my properties from JobOptionsSvc" << endreq;
    return sc;
  }
  // CGL: Only load the Histogram persistency service that's required
  if ( m_histPersName == "ROOT" ) {
    m_defServices.push_back("RootHistCnv::PersSvc/HistogramPersistencySvc");
  }
  else if ( m_histPersName == "HBOOK" ) {
    m_defServices.push_back("HbookCnv::PersSvc/HistogramPersistencySvc");
  }
  else if ( m_histPersName == "NONE" ) {
  }
  else {
    log << MSG::WARNING << "Unknown Histogram Persistency Mechanism " << m_histPersName << endreq;
  }
  // Declare other Services and Algorithms by loading DLL's
  // The state is updated temporarily in order to enable the handler, which
  // is also triggered by a change to the "DLLs" Property.
  State oldState = m_state;
  m_state = CONFIGURED;
  sc = decodeDllNameList( );
  m_state = oldState;

  // Add into the list the services declared by the user
  m_topSvcNameList.insert( m_topSvcNameList.end(), m_defServices.begin(), m_defServices.end());
  
  //--------------------------------------------------------------------------------------------
  // Create the list of top Services
  //--------------------------------------------------------------------------------------------
  for ( ListName::iterator its = m_topSvcNameList.begin(); its != m_topSvcNameList.end(); its++ ) {
    ListItem item(*its);
    if ( !i_connectService(item.type(), item.name()) )    {
      return StatusCode::FAILURE;
    }
  }
  //--------------------------------------------------------------------------------------------
  // Deal with the services explicitely declared by the user.
  // The state is updated temporarily in order to enable the handler, which
  // is also triggered by a change to the "ExtSvc" Property.
  //--------------------------------------------------------------------------------------------
  oldState = m_state;
  m_state = CONFIGURED;
  sc = decodeExtSvcNameList();
  m_state = oldState;
  if ( sc.isFailure( ) ) {
    log << MSG::ERROR << "Failure during external service creation" << endreq;
    return sc;
  }
  //--------------------------------------------------------------------------------------------
  // Retrieve intrinsic services. If needed configure them.
  //--------------------------------------------------------------------------------------------
  i_connectService(m_runableType, m_runableType);
  sc = m_svcLocator->service( m_runableType, m_runable);
  if( !sc.isSuccess() )  {
    log << MSG::FATAL << "Error retrieving Runable:" << m_runableType << endreq;
    log << MSG::FATAL << "Check option ApplicationMgr." << s_runable << endreq;
    return sc;
  }
  i_connectService(m_eventLoopMgr, m_eventLoopMgr);
  sc = m_svcLocator->service( m_eventLoopMgr, m_processingMgr);
  if( !sc.isSuccess() )  {
    log << MSG::FATAL << "Error retrieving Processing manager:" << m_eventLoopMgr << endreq;
    log << MSG::FATAL << "Check option ApplicationMgr." << s_eventloop << endreq;
    log << MSG::ERROR << "Not events will be processed." << endreq;
    return sc;
  }
  sc = m_processingMgr->configure();
  if( !sc.isSuccess() )  {
    log << MSG::FATAL << "Error configuring Processing manager:" << m_eventLoopMgr << endreq;
    return sc;
  }
  log << MSG::INFO << "Application Manager Configured successfully" << endreq;
  m_state = CONFIGURED;
  return StatusCode::SUCCESS;
}

//============================================================================================
// IAppMgrUI implementation: ApplicationMgr::initialize()
//============================================================================================
StatusCode ApplicationMgr::initialize() {
  MsgStream log( m_messageSvc, name() );
  StatusCode sc;

  if( m_state == INITIALIZED ) {
    log << MSG::INFO << "Already Initialized!" << endreq;
    return StatusCode::SUCCESS;
  } 
  else if( m_state != CONFIGURED ) {
    return StatusCode::FAILURE;
  }
  //--------------------------------------------------------------------------------------------
  // Initialize the list of top Services
  //--------------------------------------------------------------------------------------------
  for (ListSvc::iterator it = m_topSvcList.begin(); it != m_topSvcList.end(); it++ ) {
    sc = (*it)->initialize();
    if( !sc.isSuccess() ) {
      log << MSG::ERROR << "Unable to initialize Service: " << (*it)->name() << endreq;
      return sc;
    }
  }
  //--------------------------------------------------------------------------------------------
  // Final steps: Inform user and change internal state 
  //--------------------------------------------------------------------------------------------
//  sc = initDetDataSvc();
//  if ( !sc.isSuccess() )  
//    return sc;
  log << MSG::INFO << "Application Manager Initialized successfully"  << endreq;
  m_state = INITIALIZED;
  return sc;
}

//============================================================================================
// IAppMgrUI implementation: ApplicationMgr::nextEvent(int)
//============================================================================================
StatusCode ApplicationMgr::nextEvent(int maxevt)    {
  if( m_state != INITIALIZED ) {
    MsgStream log( m_messageSvc, name() );
    log << MSG::FATAL << "Invalid initial state:" << state() << endreq;
    return StatusCode::FAILURE;
  }
  if ( 0 == m_processingMgr )   {
    MsgStream log( m_messageSvc, name() );
    log << MSG::FATAL << "No event processing manager specified. Check option:" << s_eventloop << endreq;
    return StatusCode::FAILURE;
  }
  return m_processingMgr->nextEvent(maxevt);
}

//============================================================================================
// IAppMgrUI implementation: ApplicationMgr::finalize()
//============================================================================================
StatusCode ApplicationMgr::finalize() {
  MsgStream log( m_messageSvc, name() );
  StatusCode sc;
  if( m_state == FINALIZED ) {
    log << MSG::INFO << "Already Finalized" << endreq;
    return StatusCode::SUCCESS;
  } 
  else if( m_state != INITIALIZED ) {
    log << MSG::FATAL << "Invalid initial state" << endreq;
    return StatusCode::FAILURE;
  }
  //--------------------------------------------------------------------------------------------
  // Call the finalize() method of all top services
  //--------------------------------------------------------------------------------------------
  ListSvc::reverse_iterator its;
  for ( its = m_topSvcList.rbegin(); its != m_topSvcList.rend(); its++ ) {
    sc = (*its)->finalize();
    if( !sc.isSuccess() ) {
      log << MSG::WARNING << "Finalization of service " << (*its)->name() << " failed" << endreq;
    }
  }
  sc = m_processingMgr->terminate();
  if( !sc.isSuccess() )  {
    log << MSG::FATAL << "Error terminating Processing manager:" << s_eventloop << endreq;
    return sc;
  }
  //--------------------------------------------------------------------------------------------
  // release all top services
  //--------------------------------------------------------------------------------------------
  for ( its = m_topSvcList.rbegin(); its != m_topSvcList.rend(); its++ ) {
    (*its)->release();
  }
  m_topSvcList.erase(m_topSvcList.begin(), m_topSvcList.end() );
  m_processingMgr = 0;

  log << MSG::INFO << "Application Manager Finalized successfully" << endreq;
  m_state = FINALIZED;
  return StatusCode::SUCCESS;
}

//============================================================================================
// IAppMgrUI implementation: ApplicationMgr::terminate()
//============================================================================================
StatusCode ApplicationMgr::terminate() {
  MsgStream log( m_messageSvc, name() );

  if( m_state == OFFLINE ) {
    log << MSG::INFO << "Already Offline" << endreq;
    return StatusCode::SUCCESS;
  } 
  else if( m_state != FINALIZED ) {
    log << MSG::FATAL << "Invalid initial state" << endreq;
    return StatusCode::FAILURE;
  }
  // release all Services
  log << MSG::INFO << "Application Manager Terminated successfully" << endreq;
  m_state = OFFLINE;
  return StatusCode::SUCCESS;
}

//============================================================================================
// IAppMgrUI implementation: ApplicationMgr::run()
//============================================================================================
StatusCode ApplicationMgr::run() {
  StatusCode sc = configure();          // configure application
  if( sc.isSuccess() ) {
    MsgStream log(m_messageSvc, name());
    sc = initialize();                  // initialize application
    if( sc.isSuccess() ) {
      if ( 0 != m_runable )    {       // loop over the events
        sc = m_runable->run();
        if( sc.isSuccess() ) {
          sc = finalize();              // finalize application  
          if( sc.isSuccess() ) {
            return terminate();         // terminate application
          }
          log << MSG::FATAL << "Application finalization failed. Ending the job." << endreq;
          terminate();
          return sc;
        }
        log << MSG::FATAL << "Application execution failed. Ending the job." << endreq;
        finalize();
        terminate();
        return sc;
      }
      finalize();
      log << MSG::FATAL << "Application has no runable object. Check option:" << s_runable << endreq;
    }
    terminate();
    log << MSG::FATAL << "Application initilization failed" << endreq;
    return sc;
  }
  MsgStream elog( m_messageSvc, name() );
  elog << MSG::FATAL << "Application configuration failed" << endreq;
  return sc;
}

//============================================================================================
// IAppMgrUI implementation: ApplicationMgr::state()
//============================================================================================
const std::string& ApplicationMgr::state() const  { 
  return m_stateName[m_state]; 
}

//============================================================================================
// IEventProcessor implementation: executeEvent(void* par)
//============================================================================================
StatusCode ApplicationMgr::executeEvent(void* par)    {
  if( m_state == INITIALIZED ) {
    SmartIF<IEventProcessor> processor(IID_IEventProcessor, m_processingMgr);
    if ( processor.isValid() )    {
      return processor->executeEvent(par);
    }
  }
  MsgStream log( m_messageSvc, name() );
  log << MSG::FATAL << "Invalid initial state:" << state() << endreq;
  return StatusCode::FAILURE;
}

// getService
StatusCode ApplicationMgr::getService( const std::string& name, IService*& svc) {
  return m_svcFactory->getService(name, svc);
}

// getService
StatusCode ApplicationMgr::getService( const std::string& name, const IID& iid, IInterface*& pinterface) {
  return m_svcFactory->getService(name, iid, pinterface);
}

// getService
StatusCode ApplicationMgr::getService( const std::string& name, IService*& svc, bool createIf) {
  return m_svcFactory->getService(name, svc, createIf);
}

// getServices
std::list<IService*>& ApplicationMgr::getServices( ) const    {
  return m_svcFactory->getServices( );
}

// existsService
bool ApplicationMgr::existsService( const std::string& name) const {
        return m_svcFactory->existsService(name);
}

// addService
StatusCode ApplicationMgr::addService( IService* svc) {
  return m_svcFactory->addService(svc);
}

// removeService
StatusCode ApplicationMgr::removeService( IService* svc) {
  return m_svcFactory->removeService(svc);
}

// declareSvcCreator
StatusCode ApplicationMgr::declareSvcCreator( ISvcManager::SvcCreator creator,
                                              const std::string& svctype ) {
  return m_svcFactory->declareSvcCreator( creator, svctype );
}

// declareSvcModule
StatusCode ApplicationMgr::declareSvcModule( const std::string& module,
                                             const std::string& svctype ) {
  return m_svcFactory->declareSvcModule( module, svctype );
}

// declareSvcFactory
StatusCode ApplicationMgr::declareSvcFactory( const ISvcFactory& factory,
                                              const std::string& svctype ) {
  return m_svcFactory->declareSvcFactory( factory, svctype );
}

// createService
StatusCode ApplicationMgr::createService( const std::string& svctype, 
                                         const std::string& svcname,
                                         IService*& svc) {
  return m_svcFactory->createService( svctype, svcname, svc );
}

// Implementation of IAppMgrUI::name
const std::string& ApplicationMgr::name() const {
  return m_name;
}

// setProperty
StatusCode ApplicationMgr::setProperty(const Property& p) {
  return m_propertyMgr->setProperty( p ); 
}
// Set the property by istream
StatusCode ApplicationMgr::setProperty( std::istream& s )   {
  return m_propertyMgr->setProperty( s ); 
}

// Set the property by std::string
StatusCode ApplicationMgr::setProperty( const std::string& n, const std::string& v )    {
  return m_propertyMgr->setProperty( n, v ); 
}

// getProperty
StatusCode ApplicationMgr::getProperty(Property* p ) const {
  return m_propertyMgr->getProperty( p ); 
}

// implementation of IProperty::getProperty
const Property& ApplicationMgr::getProperty( const std::string& name ) const{
  return m_propertyMgr->getProperty( name ); 
}

// Get the property by std::string
StatusCode ApplicationMgr::getProperty( const std::string& n, std::string& v ) const    {
  return m_propertyMgr->getProperty( n, v ); 
}

// implementation of IProperty::getProperties
const std::vector<Property*>& ApplicationMgr::getProperties( ) const {
  return m_propertyMgr->getProperties( ); 
}


// AlgManager delegates to the Algorithm factory

// getAlgorithm
StatusCode ApplicationMgr::getAlgorithm( const std::string& name, IAlgorithm*& alg) const {
  return m_algFactory->getAlgorithm(name, alg);
}

// existsAlgorithm
bool ApplicationMgr::existsAlgorithm( const std::string& name) const {
        return m_algFactory->existsAlgorithm(name);
}

// addAlgorithm
StatusCode ApplicationMgr::addAlgorithm( IAlgorithm* alg) {
  return m_algFactory->addAlgorithm(alg);
}

// removeAlgorithm
StatusCode ApplicationMgr::removeAlgorithm( IAlgorithm* alg) {
  return m_algFactory->removeAlgorithm(alg);
}

// declareAlgCreator
StatusCode ApplicationMgr::declareAlgCreator( IAlgManager::AlgCreator creator,
                                              const std::string& algtype ) {
  return m_algFactory->declareAlgCreator( creator, algtype );
}

// declareAlgModule
StatusCode ApplicationMgr::declareAlgModule( const std::string& module,
                                              const std::string& algtype ) {
  return m_algFactory->declareAlgModule( module, algtype );
}

// declareAlgFactory
StatusCode ApplicationMgr::declareAlgFactory( const IAlgFactory& factory,
                                              const std::string& algtype ) {
  return m_algFactory->declareAlgFactory( factory, algtype );
}

// createService
StatusCode ApplicationMgr::createAlgorithm( const std::string& algtype, 
                                            const std::string& algname,
                                            IAlgorithm*& alg) {
  return m_algFactory->createAlgorithm( algtype, algname, alg );
}

// getAlgorithms
std::list<IAlgorithm*>& ApplicationMgr::getAlgorithms( ) const
{
  return m_algFactory->getAlgorithms( );
}

// implementation of ICnvManager::declareCnvFactory
StatusCode ApplicationMgr::declareCnvFactory( const ICnvFactory& factory )   {
  return m_cnvFactory->declareCnvFactory(factory);
}

// implementation of ICnvManager::existsConverter
bool ApplicationMgr::existsConverter( const unsigned char repSvcType, // Converter service type 
                                      const CLID& objtype             // Converter object type
                                      ) const   {
  return m_cnvFactory->existsConverter( repSvcType, objtype);
}

// implementation of ICnvManager::factory
const ICnvFactory* ApplicationMgr::factory(   const unsigned char repSvctype, // Converter service type 
                                              const CLID& objtype             // Converter object type
                                          ) const
{
  return m_cnvFactory->factory(repSvctype, objtype);
}

// implementation of ICnvManager::begin
ICnvManager::CnvIterator ApplicationMgr::cnvBegin()    {
  return m_cnvFactory->cnvBegin();
}

// implementation of ICnvManager::end
ICnvManager::CnvIterator ApplicationMgr::cnvEnd()    {
  return m_cnvFactory->cnvEnd();
}

// implementation of IObjManager::existsObjConverter
bool ApplicationMgr::existsObjFactory(const std::string& objtype) const   {
  return m_objFactory->existsObjFactory( objtype);
}

// implementation of IObjManager::factory
const IFactory* ApplicationMgr::objFactory(const std::string& objtype) const    {
  return m_objFactory->objFactory(objtype);
}

// implementation of IObjManager::begin
IObjManager::ObjIterator ApplicationMgr::objBegin()    {
  return m_objFactory->objBegin();
}

// implementation of IObjManager::end
IObjManager::ObjIterator ApplicationMgr::objEnd()    {
  return m_objFactory->objEnd();
}

// implementation of IObjManager::declareObjFactory
StatusCode ApplicationMgr::declareObjFactory( const IFactory& factory )    {
  return m_objFactory->declareObjFactory( factory );
}

// implementation of IClassManager::declareFactory
StatusCode ApplicationMgr::declareFactory( const IFactory& factory )    {
  return m_classManager->declareFactory( factory );
}

// implementation of IClassManager::loadModule 
StatusCode ApplicationMgr::loadModule( const std::string& module ) {
  return m_classManager->loadModule( module );
}

//============================================================================================
// SI Go Handler
//============================================================================================
void ApplicationMgr::SIGoHandler( Property& ) {
  if ( 0 != m_runable )    {       // loop over the events
    m_runable->run();
    return;
  }
  MsgStream log (m_messageSvc, name());
  log << MSG::FATAL << "Application has no runable object. Check option:" << s_runable << endreq;
}

//============================================================================================
// SI Exit Handler
//============================================================================================
void ApplicationMgr::SIExitHandler( Property& ) {
  StatusCode status;
  status = finalize();
  status = terminate();
  ::exit( 0 );
}

//============================================================================================
// Handle properties of the event loop manager (Top alg/Output stream list)
//============================================================================================
void ApplicationMgr::evtLoopPropertyHandler( Property& p ) {
  if ( m_processingMgr )    {
    SmartIF<IProperty> props(IID_IProperty, m_processingMgr);
    if ( props.isValid() )    {
      props->setProperty( p );
    }
  }
}

//============================================================================================
// External Service List handler
//============================================================================================
void ApplicationMgr::extSvcNameListHandler( Property& /* theProp */ ) {
  decodeExtSvcNameList( );
}

//============================================================================================
//  decodeExtSvcNameList & extSvcNameListHandler
//============================================================================================
StatusCode ApplicationMgr::decodeExtSvcNameList( )    {
  StatusCode result = StatusCode::SUCCESS;
  if ( CONFIGURED == m_state || INITIALIZED == m_state ) {
    ListSvc extSvcList;
    MsgStream log( m_messageSvc, m_name );
    const std::vector<std::string>& theNames = m_extSvcNameList.value( );
    for (VectorName::const_iterator it = theNames.begin(); it != theNames.end(); it++) {
      ListItem item(*it);
      if ( m_svcFactory->existsService(item.name()) ) {
        log << MSG::DEBUG << "Service " << item.name() << " Already exists" << endreq;
      } 
      else {
        IService* svc = i_connectService(item.type(), item.name());
        if( !svc ) {
          return StatusCode::FAILURE;
        }
        extSvcList.push_back( svc );
      }
    }
    if ( INITIALIZED == m_state ) {
      // Initialize the new list of Services
      for (ListSvc::iterator its = extSvcList.begin(); its != extSvcList.end(); its++ ) {
        result = (*its)->initialize();
        if( result.isFailure() ) {
          log << MSG::ERROR << "Unable to initialize Service: " << (*its)->name() << endreq;
          return result;
        }
      }
    }
  }
  return result;
}

//============================================================================================
// Dll List handler
//============================================================================================
void ApplicationMgr::dllNameListHandler( Property& /* theProp */ )              {
  decodeDllNameList();
}

//============================================================================================
//  decodeDllNameList & dllNameListHandler
//============================================================================================
StatusCode ApplicationMgr::decodeDllNameList()   {
  StatusCode result = StatusCode::SUCCESS;
  if ( CONFIGURED == m_state || INITIALIZED == m_state ) {
    MsgStream log( m_messageSvc, m_name );
    log << MSG::DEBUG << "Loading declared DLL's" << endreq;
    const std::vector<std::string>& theNames = m_dllNameList.value( );
    std::vector<std::string>::const_iterator it;
    std::vector<std::string>::const_iterator itend = theNames.end( );
    for (it = theNames.begin(); it != itend; it++) {
      StatusCode status = m_classManager->loadModule( (*it) );
      if( status.isFailure() ) {
        log << MSG::WARNING << "Unable to load DLL " << (*it) << endreq;
      }
    }
  }
  return result;
}

---