ServiceManager Class Reference

#include <ServiceManager.h>

Inheritance diagram for ServiceManager:

[legend]

Collaboration diagram for ServiceManager:

[legend]

List of all members.

Detailed Description

The ServiceManager class is in charge of the cretion of concrete instances of Services.

The ApplicationMgr delegates the creation and bookkeeping of services to the ServiceManager. In order to be able to create services from which it is not know the concrete type it requires that the services has been declared in one of 3 possible ways: an abstract static creator function, a dynamic link library or an abstract factory reference.

Author:: Pere Mato

Definition at line 33 of file ServiceManager.h.


Public Types
typedef std::list< IService * >	ListSvc
typedef std::list< std::pair < IService *, int > >	PListSvc
typedef std::map< std::string, std::string >	MapType
typedef std::map< std::string, ISvcFactory * >	MapFactory
Public Member Functions
	ServiceManager (IInterface *iface)
	default creator
virtual	~ServiceManager ()
	virtual destructor
virtual unsigned long	addRef ()
	implementation of IInterface::addRef
virtual unsigned long	release ()
	implementation of IInterface::release
virtual StatusCode	queryInterface (const InterfaceID &iid, void **pinterface)
	implementation of IInterface::queryInterface
virtual StatusCode	getService (const std::string &name, IService *&svc)
	implementation of ISvcLocation::getService
virtual StatusCode	getService (const std::string &name, const InterfaceID &iid, IInterface *&pinterface)
	implementation of ISvcLocation::getService
virtual StatusCode	getService (const std::string &name, IService *&svc, bool createIf)
	implementation of ISvcLocation::getService
virtual const std::list < IService * > &	getServices () const
	Return the list of Services.
virtual std::list< IService * >	getActiveServices () const
virtual bool	existsService (const std::string &name) const
	implementation of ISvcLocation::existsService
virtual StatusCode	addService (IService *svc, int prio)
	implementation of ISvcManager::addService
virtual StatusCode	addService (const std::string &typ, const std::string &nam, int prio)
	implementation of ISvcManager::addService
virtual StatusCode	removeService (IService *svc)
	implementation of ISvcManager::removeService
virtual StatusCode	removeService (const std::string &nam)
	implementation of ISvcManager::removeService
virtual StatusCode	declareSvcFactory (const ISvcFactory &factory, const std::string &svctype)
	implementation of ISvcManager::declareSvcFactory
virtual StatusCode	declareSvcType (const std::string &svcname, const std::string &svctype)
	implementation of ISvcManager::declareSvcType
virtual StatusCode	createService (const std::string &svctype, const std::string &svcname, IService *&svc)
	implementation of ISvcManager::createService
virtual StatusCode	getFactory (const std::string &svctype, const ISvcFactory *&fac) const
	implementation of IAlgManager::getFactory
virtual StatusCode	initializeServices ()
	implementation of ISvcManager::initializeServices
virtual StatusCode	startServices ()
	implementation of ISvcManager::startServices
virtual StatusCode	stopServices ()
	implementation of ISvcManager::stopServices
virtual StatusCode	finalizeServices ()
	implementation of ISvcManager::finalizeServices
virtual StatusCode	reinitializeServices ()
	implementation of ISvcManager::reinitializeServices
virtual StatusCode	restartServices ()
	implementation of ISvcManager::restartServices
virtual int	getPriority (const std::string &name) const
	manage priorities of services
virtual StatusCode	setPriority (const std::string &name, int pri)
virtual bool	loopCheckEnabled () const
	Get the value of the initialization loop check flag.
virtual void	setLoopCheckEnabled (bool en)
	Set the value of the initialization loop check flag.
Private Member Functions
IMessageSvc *	msgSvc ()
	access the message service
StatusCode	makeService (const std::string &name, IService *&svc)
	create a service and initialize it
StatusCode	removeActiveService (IService *svc)
StatusCode	removeListService (IService *svc)
Private Attributes
unsigned long	m_refcount
	Reference counter.
ListSvc	m_listsvc
	List of service maintained by ServiceManager.
PListSvc	m_activesvc
	List of "active" service maintained by ServiceManager.
MapType	m_maptype
	Map of service name and service type.
MapFactory	m_mapfactory
	Map of pairs of factory reference and service name.
IInterface *	m_pOuter
	Interface hub reference (ApplicationMgr).
ISvcLocator *	m_svclocator
	Service locator.
IMessageSvc *	m_msgsvc
	Pointer to the message service if it exists.
SmartIF< IStateful >	m_statemgr
	Pointer to the state machine.
bool	m_loopCheck
	Check for service initialization loops.

Member Typedef Documentation

typedef std::list<IService*> ServiceManager::ListSvc

Definition at line 37 of file ServiceManager.h.

typedef std::list<std::pair<IService*,int> > ServiceManager::PListSvc

Definition at line 38 of file ServiceManager.h.

typedef std::map<std::string, std::string > ServiceManager::MapType

Definition at line 39 of file ServiceManager.h.

typedef std::map<std::string, ISvcFactory*> ServiceManager::MapFactory

Definition at line 40 of file ServiceManager.h.

Constructor & Destructor Documentation

ServiceManager::ServiceManager ( IInterface * iface )

default creator

Definition at line 17 of file ServiceManager.cpp.

00017                                                :
00018   m_statemgr(iface),
00019   m_loopCheck(true)
00020 {
00021   m_refcount   = 1;
00022   m_pOuter = iface;
00023   m_svclocator = (ISvcLocator*)this;
00024   m_msgsvc     = 0;
00025 }

ServiceManager::~ServiceManager ( ) [virtual]

virtual destructor

Definition at line 28 of file ServiceManager.cpp.

00028                                 {
00029   if( m_msgsvc ) m_msgsvc->release();
00030   //-- inform the orphan services that I am gone....
00031   for (ListSvc::const_iterator it = m_listsvc.begin(); it != m_listsvc.end(); it++ ) {
00032     (*it)->setServiceManager(0);
00033   }
00034 }

Member Function Documentation

unsigned long ServiceManager::addRef ( ) [virtual]

implementation of IInterface::addRef

Implements IInterface.

Definition at line 37 of file ServiceManager.cpp.

00037                                      {
00038   m_refcount++;
00039   return m_refcount;
00040 }

unsigned long ServiceManager::release ( ) [virtual]

implementation of IInterface::release

Implements IInterface.

Definition at line 43 of file ServiceManager.cpp.

00043                                       {
00044   unsigned long count = --m_refcount;
00045   if( count <= 0) {
00046     delete this;
00047   }
00048   return count;
00049 }

StatusCode ServiceManager::queryInterface	(	const InterfaceID &	iid,
		void **	pinterface
	)			`[virtual]`

implementation of IInterface::queryInterface

Implements IInterface.

Definition at line 52 of file ServiceManager.cpp.

00054 {
00055   if( iid == IID_IInterface ) {
00056     *pinterface = (IInterface*)this;
00057     addRef();
00058     return StatusCode::SUCCESS;
00059   }
00060   else if ( iid == IID_ISvcLocator ) {
00061     *pinterface = (ISvcLocator*)this;
00062     addRef();
00063     return StatusCode::SUCCESS;
00064   }
00065   else if ( iid == IID_ISvcManager ) {
00066     *pinterface = (ISvcManager*)this;
00067     addRef();
00068     return StatusCode::SUCCESS;
00069   }
00070   else {
00071     return m_pOuter->queryInterface(iid, pinterface);
00072   }
00073 }

StatusCode ServiceManager::getService	(	const std::string &	name,
		IService *&	svc
	)			`[virtual]`

implementation of ISvcLocation::getService

Implements ISvcLocator.

Definition at line 76 of file ServiceManager.cpp.

00078 {
00079   return getService(name, svc, true);
00080 }

StatusCode ServiceManager::getService	(	const std::string &	name,
		const InterfaceID &	iid,
		IInterface *&	pinterface
	)			`[virtual]`

implementation of ISvcLocation::getService

Implements ISvcLocator.

Definition at line 82 of file ServiceManager.cpp.

00085 {
00086   IService*  svc;
00087   StatusCode status = getService( name, svc, false );
00088   if( status.isSuccess() ) {
00089     // Service found. So now get the right interface
00090     status = svc->queryInterface( iid, (void**)&pinterface );
00091   }
00092   return status;
00093 }

StatusCode ServiceManager::getService	(	const std::string &	name,
		IService *&	svc,
		bool	createIf
	)			`[virtual]`

implementation of ISvcLocation::getService

Implements ISvcLocator.

Definition at line 142 of file ServiceManager.cpp.

00145 {
00146   ListItem item(nam);
00147   const std::string& name = item.name();
00148 
00149   StatusCode sc(StatusCode::FAILURE);
00150   ListSvc::iterator it(m_listsvc.begin());
00151   for (; it != m_listsvc.end(); ++it ) {
00152     if( (*it)->name() == name ) {
00153       svc = *it;
00154       break;
00155     }
00156   }
00157 
00158   if (it !=  m_listsvc.end()) {
00159     if (m_loopCheck &&
00160         (createIf && (*it)->FSMState() == Gaudi::StateMachine::CONFIGURED)) {
00161       MsgStream log(msgSvc(), "ServiceManager");
00162       log << MSG::ERROR
00163           << "Initialization loop detected when creating service \"" << name
00164           << "\""
00165           << endreq;
00166       sc = StatusCode::FAILURE;
00167     } else {
00168       sc = StatusCode::SUCCESS;
00169     }
00170   } else {
00171     // Service not found. The user may be interested in one of the interfaces
00172     // of the application manager itself
00173     if( name == "ApplicationMgr" ||
00174         name == "APPMGR" ||
00175         name == "" ) {
00176       sc = m_svclocator->queryInterface( IService::interfaceID(), (void**)&svc );
00177       if( svc ) svc->release(); // Do not increase the reference count
00178     } else if ( createIf ){
00179       //last resort: we try to create the service
00180       if ( item.name() != item.type() ) {
00181         // if we were asked for a "ServiceType/ServiceName", we pass the string
00182         // directly to makeService
00183         sc = makeService(nam, svc);
00184       } else {
00185         // the user did not specified both type and name
00186         sc = makeService(name, svc);
00187       }
00188     }
00189   }
00190 
00191   return sc;
00192 }

const std::list< IService * > & ServiceManager::getServices ( ) const [virtual]

Return the list of Services.

Implements ISvcLocator.

Definition at line 195 of file ServiceManager.cpp.

00197 {
00198   return m_listsvc;
00199 }

std::list< IService * > ServiceManager::getActiveServices ( ) const [virtual]

Definition at line 202 of file ServiceManager.cpp.

00204 {
00205   std::list<IService*> asvcs;
00206   for (PListSvc::const_iterator itr = m_activesvc.begin();
00207        itr != m_activesvc.end(); ++itr) {
00208     asvcs.push_back( itr->first );
00209   }
00210   return asvcs;
00211 }

bool ServiceManager::existsService ( const std::string & name ) const [virtual]

implementation of ISvcLocation::existsService

Implements ISvcLocator.

Definition at line 215 of file ServiceManager.cpp.

00217 {
00218   ListSvc::const_iterator it;
00219   for (it = m_listsvc.begin(); it != m_listsvc.end(); it++ ) {
00220     if( name == (*it)->name() ) {
00221       return true;
00222     }
00223   }
00224   return false;
00225 }

StatusCode ServiceManager::addService	(	IService *	svc,
		int	prio
	)			`[virtual]`

implementation of ISvcManager::addService

Implements ISvcManager.

Definition at line 228 of file ServiceManager.cpp.

00230 {
00231   PListSvc::iterator it;
00232   // remove it if already in the list
00233   removeActiveService( svc ).ignore();
00234   // insert in the right place in the list
00235   for( it = m_activesvc.begin(); it != m_activesvc.end(); it++ ) {
00236     if( (*it).second > prio )  break;
00237   }
00238   m_activesvc.insert(it, std::make_pair(svc, prio));
00239   return StatusCode::SUCCESS;
00240 }

StatusCode ServiceManager::addService	(	const std::string &	typ,
		const std::string &	nam,
		int	prio
	)			`[virtual]`

implementation of ISvcManager::addService

Implements ISvcManager.

Definition at line 243 of file ServiceManager.cpp.

00246 {
00247   StatusCode sc;
00248   IService* svc;
00249   if( existsService(name) ) {
00250     sc = getService(name, svc);
00251   } else {
00252     if( type.length() == 0 ) {
00253       // find out if name is registered with a type
00254       MapType::iterator it = m_maptype.find( name );
00255       if( it != m_maptype.end() ) {
00256         sc = createService( (*it).second, name, svc );
00257       } else {
00258         sc = createService( name, name, svc );
00259       }
00260     } else {
00261       sc = createService( type, name, svc );
00262     }
00263 
00264     if (sc.isSuccess() && m_statemgr->targetFSMState() >= Gaudi::StateMachine::INITIALIZED) {
00265       sc = svc->sysInitialize();
00266       if (sc.isSuccess() && m_statemgr->targetFSMState() >= Gaudi::StateMachine::RUNNING) {
00267         sc = svc->sysStart();
00268       }
00269     }
00270 
00271   }
00272   if( sc.isSuccess() ) {
00273     return addService( svc, prio );
00274   }
00275   else {
00276     return sc;
00277   }
00278 }

StatusCode ServiceManager::removeService ( IService * svc ) [virtual]

implementation of ISvcManager::removeService

Implements ISvcManager.

Definition at line 281 of file ServiceManager.cpp.

00283 {
00284 
00285   removeActiveService(svc).ignore();
00286   removeListService(svc).ignore();
00287 
00288   return StatusCode(StatusCode::SUCCESS,true);
00289 }

StatusCode ServiceManager::removeService ( const std::string & nam ) [virtual]

implementation of ISvcManager::removeService

Implements ISvcManager.

Definition at line 324 of file ServiceManager.cpp.

00326 {
00327   IService* svc;
00328   if( getService(nam, svc).isSuccess() ) return removeService(svc);
00329   else return StatusCode::FAILURE;
00330 }

StatusCode ServiceManager::declareSvcFactory	(	const ISvcFactory &	factory,
		const std::string &	svctype
	)			`[virtual]`

implementation of ISvcManager::declareSvcFactory

Implements ISvcManager.

Definition at line 333 of file ServiceManager.cpp.

00336 {
00337 
00338   std::pair<MapFactory::iterator, bool> p;
00339   p = m_mapfactory.insert(MapFactory::value_type( svctype, (ISvcFactory*)&factory) );
00340   if( p.second == false) {
00341     MsgStream log(msgSvc(), "ServiceManager");
00342     log << MSG::WARNING << "Service factory for type " << svctype << " already declared" << endreq;
00343     m_mapfactory.erase ( p.first );
00344     p = m_mapfactory.insert(MapFactory::value_type( svctype, (ISvcFactory*)&factory) );
00345     if( p.second == false) return StatusCode::FAILURE;
00346   }
00347   return StatusCode::SUCCESS;
00348 }

StatusCode ServiceManager::declareSvcType	(	const std::string &	svcname,
		const std::string &	svctype
	)			`[virtual]`

implementation of ISvcManager::declareSvcType

Implements ISvcManager.

Definition at line 351 of file ServiceManager.cpp.

00354 {
00355   std::pair<MapType::iterator, bool> p = m_maptype.insert(std::make_pair(svcname, svctype));
00356   if( p.second == false) {
00357     m_maptype.erase ( p.first );
00358     p = m_maptype.insert(std::make_pair(svcname, svctype) );
00359     if( p.second == false) return StatusCode::FAILURE;
00360   }
00361   return StatusCode::SUCCESS;
00362 }

StatusCode ServiceManager::createService	(	const std::string &	svctype,
		const std::string &	svcname,
		IService *&	svc
	)			`[virtual]`

implementation of ISvcManager::createService

Implements ISvcManager.

Definition at line 564 of file ServiceManager.cpp.

00568 {
00569   // Check is the service is already existing
00570   if( existsService( svcname ) ) {
00571     // return an error because a service with that name already exists
00572     return StatusCode::FAILURE;
00573   }
00574 
00575   StatusCode rc = StatusCode::FAILURE;
00576   rc.setChecked(); //hack to avoid going into infinite recursion on ~StatusCode
00577 
00578   MsgStream log(msgSvc(), "ServiceManager");
00579 
00580   service = PluginService::Create<IService*>(svctype, svcname, m_svclocator);
00581   if ( !service ) {
00582     service = PluginService::CreateWithId<IService*>(svctype, svcname, m_svclocator);
00583   }
00584 
00585   if ( service ) {
00586     m_listsvc.push_back( service );
00587     // Check the compatibility of the version of the interface obtained
00588     if( !isValidInterface(service) ) {
00589       log << MSG::FATAL << "Incompatible interface IService version for " << svctype << endreq;
00590       return StatusCode::FAILURE;
00591     }
00592     service->setServiceManager(this);
00593     return StatusCode(StatusCode::SUCCESS,true);
00594   }
00595   log << MSG::FATAL << "No Service factory for " << svctype << " available." << endreq;
00596   return StatusCode::FAILURE;
00597 }

StatusCode ServiceManager::getFactory	(	const std::string &	svctype,
		const ISvcFactory *&	fac
	)			const `[virtual]`

implementation of IAlgManager::getFactory

Access to factory by name.

Implements ISvcManager.

Definition at line 601 of file ServiceManager.cpp.

00602 {
00603   MapFactory::const_iterator itf = m_mapfactory.find( svctype );
00604   factory = (itf == m_mapfactory.end()) ? 0 : (*itf).second;
00605   return (factory==0) ? StatusCode::FAILURE : StatusCode::SUCCESS;
00606 }

StatusCode ServiceManager::initializeServices ( ) [virtual]

implementation of ISvcManager::initializeServices

Implements ISvcManager.

Definition at line 365 of file ServiceManager.cpp.

00367 {
00368   StatusCode sc;
00369   MsgStream log(msgSvc(), "ServiceManager");
00370 
00371   // call initialize() for all services
00372   for (PListSvc::iterator it = m_activesvc.begin(); it != m_activesvc.end(); it++ ) {
00373     std::string name = (*it).first->name();
00374     switch ((*it).first->FSMState()) {
00375     case Gaudi::StateMachine::INITIALIZED:
00376       log << MSG::DEBUG << "Service " << name
00377           << " already initialized" << endreq;
00378       break;
00379     case Gaudi::StateMachine::OFFLINE:
00380       log << MSG::DEBUG << "Initializing service " << name << endreq;
00381       sc = (*it).first->sysInitialize();
00382       if( !sc.isSuccess() ) {
00383         log << MSG::ERROR << "Unable to initialize Service: " << (*it).first->name() << endreq;
00384         return sc;
00385       } break;
00386     default:
00387       log << MSG::ERROR << "Service " << name
00388           << " not in the correct state to be initialized ("
00389           << (*it).first->FSMState() << ")" << endreq;
00390       return StatusCode::FAILURE;
00391     }
00392   }
00393   return StatusCode::SUCCESS;
00394 }

StatusCode ServiceManager::startServices ( ) [virtual]

implementation of ISvcManager::startServices

Implements ISvcManager.

Definition at line 397 of file ServiceManager.cpp.

00399 {
00400   StatusCode sc = StatusCode(StatusCode::FAILURE,true);
00401   MsgStream log(msgSvc(), "ServiceManager");
00402 
00403   // call initialize() for all services
00404   for (PListSvc::iterator it = m_activesvc.begin(); it != m_activesvc.end(); it++ ) {
00405     std::string name = (*it).first->name();
00406     switch ((*it).first->FSMState()) {
00407     case Gaudi::StateMachine::RUNNING:
00408       log << MSG::DEBUG << "Service " << name
00409           << " already started" << endreq;
00410       break;
00411     case Gaudi::StateMachine::INITIALIZED:
00412       log << MSG::DEBUG << "Starting service " << name << endreq;
00413       sc = (*it).first->sysStart();
00414       if( !sc.isSuccess() ) {
00415         log << MSG::ERROR << "Unable to start Service: " << (*it).first->name() << endreq;
00416         return sc;
00417       } break;
00418     default:
00419       log << MSG::ERROR << "Service " << name
00420           << " not in the correct state to be started ("
00421           << (*it).first->FSMState() << ")" << endreq;
00422       return StatusCode::FAILURE;
00423     }
00424   }
00425   return StatusCode::SUCCESS;
00426 }

StatusCode ServiceManager::stopServices ( ) [virtual]

implementation of ISvcManager::stopServices

Implements ISvcManager.

Definition at line 430 of file ServiceManager.cpp.

00432 {
00433   StatusCode sc;
00434   MsgStream log(msgSvc(), "ServiceManager");
00435 
00436   PListSvc::reverse_iterator it;
00437   // call stop() for all services
00438   for ( it = m_activesvc.rbegin(); it != m_activesvc.rend(); it++ ) {
00439     std::string name = (*it).first->name();
00440     switch ((*it).first->FSMState()) {
00441     case Gaudi::StateMachine::INITIALIZED:
00442       log << MSG::DEBUG << "Service " << name
00443           << " already stopped" << endreq;
00444       break;
00445     case Gaudi::StateMachine::RUNNING:
00446       log << MSG::DEBUG << "Stopping service " << name << endreq;
00447       sc = (*it).first->sysStop();
00448       if( !sc.isSuccess() ) {
00449         log << MSG::ERROR << "Unable to stop Service: " << (*it).first->name() << endreq;
00450         return sc;
00451       } break;
00452     default:
00453       log << MSG::ERROR << "Service " << name
00454           << " not in the correct state to be stopped ("
00455           << (*it).first->FSMState() << ")" << endreq;
00456       return StatusCode::FAILURE;
00457     }
00458   }
00459   return StatusCode::SUCCESS;
00460 }

StatusCode ServiceManager::finalizeServices ( ) [virtual]

implementation of ISvcManager::finalizeServices

Implements ISvcManager.

Definition at line 501 of file ServiceManager.cpp.

00503 {
00504   MsgStream log(msgSvc(), "ServiceManager");
00505 
00506   PListSvc::reverse_iterator its;
00507 
00508   StatusCode sc(StatusCode::SUCCESS);
00509 
00510   // make sure that HistogramDataSvc and THistSvc get finalized after the
00511   // ToolSvc, and StatusCodeSvc after that
00512   int pri_tool = getPriority("ToolSvc");
00513   if (pri_tool != 0) {
00514     setPriority("THistSvc",pri_tool-1).ignore();
00515     setPriority("ChronoStatSvc",pri_tool-2).ignore();
00516     setPriority("AuditorSvc",pri_tool-3).ignore();
00517     setPriority("HistogramDataSvc",pri_tool-1).ignore();
00518     // Preserve the relative ordering between HistogramDataSvc and HistogramPersistencySvc
00519     setPriority("HistogramPersistencySvc",pri_tool-2).ignore();
00520   }
00521 
00522   // make sure the StatusCodeSvc gets finalized really late:
00523   setPriority("StatusCodeSvc",-9999).ignore();
00524 
00525   // call finalize() for all services in reverse order
00526   for ( its = m_activesvc.rbegin(); its != m_activesvc.rend(); its++ ) {
00527     // ignore the current state for the moment
00528     // if( Gaudi::StateMachine::INITIALIZED == (*it).first->state() ) {
00529     log << MSG::DEBUG << "Finalizing service " << (*its).first->name() << endreq;
00530     if ( !((*its).first->sysFinalize()).isSuccess() ) {
00531       log << MSG::WARNING << "Finalization of service " << (*its).first->name()
00532       << " failed" << endreq;
00533       sc = StatusCode::FAILURE;
00534     }
00535   }
00536 
00537   // loop over all Active Services, removing them one by one.
00538   while (m_activesvc.size() != 0) {
00539     PListSvc::iterator its = m_activesvc.end();
00540     its --;
00541 
00543     //   for ( its = m_activesvc.rbegin(); its != m_activesvc.rend(); its++ ) {
00544     // erase from m_listsvc before releasing
00545     for ( ListSvc::iterator ll = m_listsvc.begin(); ll != m_listsvc.end(); ++ll ) {
00546       if ( (*ll)->name() == its->first->name() ) {
00547         m_listsvc.erase( ll );
00548         break;
00549       }
00550     }
00551 
00552     // this may destroy the service
00553     (*its).first->release();
00554   }
00555 
00556   // clear the list of active services
00557   m_activesvc.erase(m_activesvc.begin(), m_activesvc.end() );
00558 
00559   return sc ;
00560 }

StatusCode ServiceManager::reinitializeServices ( ) [virtual]

implementation of ISvcManager::reinitializeServices

Implements ISvcManager.

Definition at line 463 of file ServiceManager.cpp.

00465 {
00466   StatusCode sc;
00467 
00468   PListSvc::iterator it;
00469   // Re-Initialize all services
00470   for ( it = m_activesvc.begin(); it != m_activesvc.end(); it++ ) {
00471     sc = (*it).first->sysReinitialize();
00472     if( !sc.isSuccess() ) {
00473       MsgStream log(msgSvc(), "ServiceManager");
00474       log << MSG::ERROR << "Unable to re-initialize Service: " << (*it).first->name() << endreq;
00475       return StatusCode::FAILURE;
00476     }
00477   }
00478   return StatusCode::SUCCESS;
00479 }

StatusCode ServiceManager::restartServices ( ) [virtual]

implementation of ISvcManager::restartServices

Implements ISvcManager.

Definition at line 482 of file ServiceManager.cpp.

00484 {
00485   StatusCode sc;
00486 
00487   PListSvc::iterator it;
00488   // Re-Start all services
00489   for ( it = m_activesvc.begin(); it != m_activesvc.end(); it++ ) {
00490     sc = (*it).first->sysRestart();
00491     if( !sc.isSuccess() ) {
00492       MsgStream log(msgSvc(), "ServiceManager");
00493       log << MSG::ERROR << "Unable to re-start Service: " << (*it).first->name() << endreq;
00494       return StatusCode::FAILURE;
00495     }
00496   }
00497   return StatusCode::SUCCESS;
00498 }

int ServiceManager::getPriority ( const std::string & name ) const [virtual]

manage priorities of services

Implements ISvcManager.

Definition at line 622 of file ServiceManager.cpp.

00622                                                        {
00623 //------------------------------------------------------------------------------
00624 
00625   PListSvc::const_iterator it;
00626   for (it = m_activesvc.begin(); it != m_activesvc.end(); it++ ) {
00627     if ((*it).first->name() == name) {
00628       return (*it).second;
00629     }
00630   }
00631 
00632   return 0;
00633 
00634 }

StatusCode ServiceManager::setPriority	(	const std::string &	name,
		int	pri
	)			`[virtual]`

Implements ISvcManager.

Definition at line 638 of file ServiceManager.cpp.

00638                                                            {
00639 //------------------------------------------------------------------------------
00640 
00641   PListSvc::const_iterator it;
00642   for (it = m_activesvc.begin(); it != m_activesvc.end(); it++ ) {
00643     if ((*it).first->name() == name) {
00644       IService *svc = (*it).first;
00645       removeActiveService( svc ).ignore();
00646       return addService(svc,prio);
00647     }
00648   }
00649 
00650   return StatusCode::FAILURE;
00651 
00652 }

bool ServiceManager::loopCheckEnabled ( ) const [virtual]

Get the value of the initialization loop check flag.

Implements ISvcManager.

Definition at line 657 of file ServiceManager.cpp.

00657                                             {
00658   return m_loopCheck;
00659 }

void ServiceManager::setLoopCheckEnabled ( bool en ) [virtual]

Set the value of the initialization loop check flag.

Implements ISvcManager.

Definition at line 663 of file ServiceManager.cpp.

00663                                                 {
00664   m_loopCheck = en;
00665 }

IMessageSvc * ServiceManager::msgSvc ( ) [private]

access the message service

Definition at line 609 of file ServiceManager.cpp.

00611 {
00612   if( m_msgsvc == 0 ) {
00613     IService* iSvc(0);
00614     if ( (getService( "MessageSvc", iSvc, false)).isSuccess() )
00615       m_msgsvc = dynamic_cast<IMessageSvc*>(iSvc);
00616   }
00617   return m_msgsvc;
00618 }

StatusCode ServiceManager::makeService	(	const std::string &	name,
		IService *&	svc
	)			`[private]`

create a service and initialize it

Definition at line 95 of file ServiceManager.cpp.

00098 {
00099   // find out if name is registered with a type
00100   std::string name = nam;
00101   std::string type;
00102   MapType::iterator it = m_maptype.find( nam );
00103   if( it != m_maptype.end() ) {
00104     type = (*it).second;
00105   } else {
00106     // otherwise parse the name to see if it is of the format "type/name"
00107     ListItem item(name);
00108     type = item.type();
00109     name = item.name();
00110   }
00111   std::string::size_type ip;
00112   if ( (ip = type.find("__")) != std::string::npos) {
00113     type.erase(ip,type.length());
00114   }
00115   StatusCode sc = createService( type, name, svc );
00116   if( sc.isSuccess() ) {
00117     // Bring the created service to the same state in which the ApplicationMgr
00118     // will be.
00119     if (m_statemgr->targetFSMState() >= Gaudi::StateMachine::INITIALIZED) {
00120       sc = svc->sysInitialize();
00121       if (sc.isSuccess() && m_statemgr->targetFSMState() >= Gaudi::StateMachine::RUNNING) {
00122         sc = svc->sysStart();
00123       }
00124     }
00125 
00126     if( sc.isSuccess() ) {
00127       sc = addService( svc, 10);
00128     } else {
00129       MsgStream log(msgSvc(), "ServiceManager");
00130       log << MSG::ERROR << "Unable to initialize service \"" << name << "\""
00131           << endreq;
00132       removeService(svc).ignore(); //if init fails remove it from the list
00133       delete svc;
00134       svc = 0;
00135     }
00136     if (svc!= 0) svc->setServiceManager( this );
00137   }
00138   return sc;
00139 }

StatusCode ServiceManager::removeActiveService ( IService * svc ) [private]

Definition at line 292 of file ServiceManager.cpp.

00294 {
00295   PListSvc::iterator it;
00296   for (it = m_activesvc.begin(); it != m_activesvc.end(); it++ ) {
00297     if( (*it).first == svc ) {
00298       m_activesvc.erase(it);
00299       break;
00300     }
00301   }
00302 
00303   return StatusCode::SUCCESS;
00304 }

StatusCode ServiceManager::removeListService ( IService * svc ) [private]

Definition at line 307 of file ServiceManager.cpp.

00309 {
00310 
00311   ListSvc::iterator ll;
00312   for ( ll = m_listsvc.begin(); ll != m_listsvc.end(); ++ll ) {
00313     if ( (*ll) == svc  ) {
00314       m_listsvc.erase( ll );
00315       break;
00316     }
00317   }
00318 
00319   return StatusCode::SUCCESS;
00320 }

Member Data Documentation

unsigned long ServiceManager::m_refcount [private]

Reference counter.

Definition at line 113 of file ServiceManager.h.

ListSvc ServiceManager::m_listsvc [private]

List of service maintained by ServiceManager.

Definition at line 114 of file ServiceManager.h.

PListSvc ServiceManager::m_activesvc [private]

List of "active" service maintained by ServiceManager.

Definition at line 115 of file ServiceManager.h.

MapType ServiceManager::m_maptype [private]

Map of service name and service type.

Definition at line 116 of file ServiceManager.h.

MapFactory ServiceManager::m_mapfactory [private]

Map of pairs of factory reference and service name.

Definition at line 117 of file ServiceManager.h.

IInterface* ServiceManager::m_pOuter [private]

Interface hub reference (ApplicationMgr).

Definition at line 118 of file ServiceManager.h.

ISvcLocator* ServiceManager::m_svclocator [private]

Service locator.

Definition at line 119 of file ServiceManager.h.

IMessageSvc* ServiceManager::m_msgsvc [private]

Pointer to the message service if it exists.

Definition at line 120 of file ServiceManager.h.

SmartIF<IStateful> ServiceManager::m_statemgr [private]

Pointer to the state machine.

Definition at line 121 of file ServiceManager.h.

bool ServiceManager::m_loopCheck [private]

Check for service initialization loops.

Definition at line 122 of file ServiceManager.h.

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

/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r3/GaudiSvc/src/ApplicationMgr/ServiceManager.h
/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r3/GaudiSvc/src/ApplicationMgr/ServiceManager.cpp

	Gaudi Framework, version v20r3
	Generated: 24 Nov 2008

Gaudi Framework, version v20r3

ServiceManager Class Reference

Detailed Description

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation