| The Gaudi Framework v29r0 (ff2e7097)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Classes | Public Types | Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
ServiceManager Class Reference

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

`#include <src/ApplicationMgr/ServiceManager.h>`

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

## Classes
struct | ServiceItem

## Public Types
typedef std::list< ServiceItem > | ListSvc
typedef GaudiUtils::Map< std::string, std::string > | MapType
Public Types inherited from extends< ComponentManager, ISvcManager, ISvcLocator >
using | base_class = extends
| Typedef to this class. More...
using | extend_interfaces_base = extend_interfaces< Interfaces... >
| Typedef to the base of this class. More...
Public Types inherited from CommonMessaging< implements< IComponentManager > >
using | base_class = CommonMessaging
Public Types inherited from extend_interfaces< Interfaces... >
using | ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids... >::type
| take union of the ext_iids of all Interfaces... More...

## Public Member Functions
| ServiceManager (IInterface *application)
| default creator More...
SmartIF< ISvcLocator > & | serviceLocator () const override
| Function needed by CommonMessaging. More...
| ~ServiceManager () override
| virtual destructor More...
const std::list< IService * > & | getServices () const override
| Return the list of Services. More...
bool | existsService (const std::string &name) const override
| implementation of ISvcLocation::existsService More...
StatusCode | addService (IService *svc, int prio=DEFAULT_SVC_PRIORITY) override
| implementation of ISvcManager::addService More...
StatusCode | addService (const Gaudi::Utils::TypeNameString &typeName, int prio=DEFAULT_SVC_PRIORITY) override
| implementation of ISvcManager::addService More...
StatusCode | removeService (IService *svc) override
| implementation of ISvcManager::removeService More...
StatusCode | removeService (const std::string &name) override
| implementation of ISvcManager::removeService More...
StatusCode | declareSvcType (const std::string &svcname, const std::string &svctype) override
| implementation of ISvcManager::declareSvcType More...
SmartIF< IService > & | createService (const Gaudi::Utils::TypeNameString &nametype) override
| implementation of ISvcManager::createService NOTE: as this returns a &, we must guarantee that once created, these SmartIF remain pinned in their location, thus constraining the underlying implementation... More...
StatusCode | initialize () override
| Initialization (from CONFIGURED to INITIALIZED). More...
StatusCode | start () override
| Start (from INITIALIZED to RUNNING). More...
StatusCode | stop () override
| Stop (from RUNNING to INITIALIZED). More...
StatusCode | finalize () override
| Finalize (from INITIALIZED to CONFIGURED). More...
StatusCode | reinitialize () override
| Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED). More...
StatusCode | restart () override
| Initialization (from RUNNING to RUNNING, via INITIALIZED). More...
int | getPriority (const std::string &name) const override
| manage priorities of services More...
StatusCode | setPriority (const std::string &name, int pri) override
bool | loopCheckEnabled () const override
| Get the value of the initialization loop check flag. More...
void | setLoopCheckEnabled (bool en) override
| Set the value of the initialization loop check flag. More...
const std::string & | name () const override
| Return the name of the manager (implementation of INamedInterface) More...
SmartIF< IService > & | service (const Gaudi::Utils::TypeNameString &typeName, const bool createIf=true) override
| Returns a smart pointer to a service. More...
template<typename T >
SmartIF< T > | service (const Gaudi::Utils::TypeNameString &typeName, const bool createIf=true)
| Returns a smart pointer to the requested interface of a service. More...
Public Member Functions inherited from extends< ComponentManager, ISvcManager, ISvcLocator >
void * | i_cast (const InterfaceID &tid) const override
| Implementation of IInterface::i_cast. More...
StatusCode | queryInterface (const InterfaceID &ti, void **pp) override
| Implementation of IInterface::queryInterface. More...
std::vector< std::string > | getInterfaceNames () const override
| Implementation of IInterface::getInterfaceNames. More...
| ~extends () override=default
| Virtual destructor. More...
Public Member Functions inherited from ComponentManager
| ComponentManager (IInterface *application, const InterfaceID &baseIID)
| Constructor. More...
const InterfaceID & | componentBaseInterface () const override
| Basic interface id of the managed components. More...
StatusCode | queryInterface (const InterfaceID &iid, void **pinterface) override
| Specialized queryInterface implementation. More...
SmartIF< ISvcLocator > & | serviceLocator () const override
StatusCode | configure () override
| Configuration (from OFFLINE to CONFIGURED). More...
StatusCode | initialize () override
| Initialization (from CONFIGURED to INITIALIZED). More...
StatusCode | start () override
| Start (from INITIALIZED to RUNNING). More...
StatusCode | stop () override
| Stop (from RUNNING to INITIALIZED). More...
StatusCode | finalize () override
| Finalize (from INITIALIZED to CONFIGURED). More...
StatusCode | terminate () override
| Initialization (from CONFIGURED to OFFLINE). More...
StatusCode | reinitialize () override
| Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED). More...
StatusCode | restart () override
| Initialization (from RUNNING to RUNNING, via INITIALIZED). More...
Gaudi::StateMachine::State | FSMState () const override
| Get the current state. More...
Gaudi::StateMachine::State | targetFSMState () const override
| When we are in the middle of a transition, get the state where the transition is leading us. More...
Public Member Functions inherited from CommonMessagingBase
virtual | ~CommonMessagingBase ()=default
| Virtual destructor. More...
SmartIF< IMessageSvc > & | msgSvc () const
| The standard message service. More...
MsgStream & | msgStream () const
| Return an uninitialized MsgStream. More...
MsgStream & | msgStream (const MSG::Level level) const
| Predefined configurable message stream for the efficient printouts. More...
MsgStream & | always () const
| shortcut for the method msgStream(MSG::ALWAYS) More...
MsgStream & | fatal () const
| shortcut for the method msgStream(MSG::FATAL) More...
MsgStream & | err () const
| shortcut for the method msgStream(MSG::ERROR) More...
MsgStream & | error () const
| shortcut for the method msgStream(MSG::ERROR) More...
MsgStream & | warning () const
| shortcut for the method msgStream(MSG::WARNING) More...
MsgStream & | info () const
| shortcut for the method msgStream(MSG::INFO) More...
MsgStream & | debug () const
| shortcut for the method msgStream(MSG::DEBUG) More...
MsgStream & | verbose () const
| shortcut for the method msgStream(MSG::VERBOSE) More...
MsgStream & | msg () const
| shortcut for the method msgStream(MSG::INFO) More...
MSG::Level | msgLevel () const
| get the output level from the embedded MsgStream More...
MSG::Level | outputLevel () const __attribute__((deprecated))
| Backward compatibility function for getting the output level. More...
bool | msgLevel (MSG::Level lvl) const
| get the output level from the embedded MsgStream More...
Public Member Functions inherited from extend_interfaces< Interfaces... >
| ~extend_interfaces () override=default
| Virtual destructor. More...

## Private Types
typedef boost::recursive_mutex | Mutex_t
| Mutex to synchronize shared service initialization between threads. More...
typedef boost::lock_guard< Mutex_t > | LockGuard_t

## Private Member Functions
ListSvc::iterator | find (const std::string &name)
ListSvc::const_iterator | find (const std::string &name) const
ListSvc::iterator | find (const IService *ptr)
ListSvc::const_iterator | find (const IService *ptr) const
void | dump () const

## Private Attributes
ListSvc | m_listsvc
| List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because there can be SmartIF<T>& 'out there' that refer to these specific SmarIF<T>, we unfortunately must guarantee that they never move after creation. More...
MapType | m_maptype
| Map of service name and service type. More...
bool | m_loopCheck = true
| Check for service initialization loops. More...
SmartIF< IService > | m_appSvc
| Pointer to the application IService interface. More...
std::list< IService * > | m_listOfPtrs
| List of pointers to the know services used to implement getServices() More...
GaudiUtils::Map< InterfaceID, SmartIF< IInterface > > | m_defaultImplementations
Mutex_t | m_gLock
std::map< std::string, std::unique_ptr< Mutex_t > > | m_lockMap

## Additional Inherited Members
Protected Member Functions inherited from CommonMessaging< implements< IComponentManager > >
void | updateMsgStreamOutputLevel (int level)
| Update the output level of the cached MsgStream. More...
Protected Attributes inherited from ComponentManager
SmartIF< IInterface > | m_application
| Pointer to the owner of the manager. More...
SmartIF< IStateful > | m_stateful
| Pointer to the IStateful interface of the owner. More...
InterfaceID | m_basicInterfaceId
| Basic interface id of the managed components. More...
SmartIF< ISvcLocator > | m_svcLocator
| Service locator (needed to access the MessageSvc) More...

## Detailed Description

The ServiceManager class is in charge of the creation 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 36 of file ServiceManager.h.

## Member Typedef Documentation

typedef std::list<ServiceItem> ServiceManager::ListSvc

Definition at line 50 of file ServiceManager.h.

typedef boost::lock_guard<Mutex_t> ServiceManager::LockGuard_t
| private

Definition at line 182 of file ServiceManager.h.

typedef GaudiUtils::Map<std::string, std::string> ServiceManager::MapType

Definition at line 51 of file ServiceManager.h.

typedef boost::recursive_mutex ServiceManager::Mutex_t
| private

Mutex to synchronize shared service initialization between threads.

Definition at line 181 of file ServiceManager.h.

## Constructor & Destructor Documentation

ServiceManager::ServiceManager | ( | IInterface * | application | ) |

default creator

Definition at line 45 of file ServiceManager.cpp.

46 : base_class( application, IService::interfaceID() ), m_appSvc( application )
47 {
48 // Set the service locator to myself
49 m_svcLocator = this;
50 addRef(); // increase ref count, so we live forever...
51 }
ServiceManager::m_appSvc
SmartIF< IService > m_appSvc
Pointer to the application IService interface.
Definition: ServiceManager.h:173
ComponentManager::m_svcLocator
SmartIF< ISvcLocator > m_svcLocator
Service locator (needed to access the MessageSvc)
Definition: ComponentManager.h:76
extends< ComponentManager, ISvcManager, ISvcLocator >::base_class
extends base_class
Typedef to this class.
Definition: extends.h:15

ServiceManager::~ServiceManager | ( |  | ) |
| override

virtual destructor

Definition at line 54 of file ServiceManager.cpp.

55 {
56 //-- inform the orphan services that I am gone....
57 for ( auto& svc : m_listsvc ) svc.service->setServiceManager( nullptr );
58 }
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155

## Member Function Documentation

StatusCode ServiceManager::addService | ( | IService * | svc,
|  | int | prio = `DEFAULT_SVC_PRIORITY`
| ) |  |
| override

implementation of ISvcManager::addService

Definition at line 104 of file ServiceManager.cpp.

106 {
107 ListSvc::iterator it = find( svc );
108 LockGuard_t lck( m_gLock );
109 if ( it != m_listsvc.end() ) {
110 it->priority = prio; // if the service is already known, it is equivalent to a setPriority
111 it->active = true; // and make it active
112 } else {
113 m_listsvc.emplace_back( svc, prio, true );
114 }
115 return StatusCode::SUCCESS;
116 }
StatusCode::SUCCESS
Definition: StatusCode.h:31
ServiceManager::LockGuard_t
boost::lock_guard< Mutex_t > LockGuard_t
Definition: ServiceManager.h:182
ServiceManager::m_gLock
Mutex_t m_gLock
Definition: ServiceManager.h:184
std::list::end
T end(T...args)
ServiceManager::find
ListSvc::iterator find(const std::string &name)
Definition: ServiceManager.h:133
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155
std::list::emplace_back
T emplace_back(T...args)

StatusCode ServiceManager::addService | ( | const Gaudi::Utils::TypeNameString & | typeName,
|  | int | prio = `DEFAULT_SVC_PRIORITY`
| ) |  |
| override

implementation of ISvcManager::addService

Definition at line 120 of file ServiceManager.cpp.

122 {
123 auto it = find( typeName.name() ); // try to find the service by name
124 if ( it == m_listsvc.end() ) { // not found
125 // If the service does not exist, we create it
126 SmartIF<IService>& svc =
127 createService( typeName ); // WARNING: svc is now a reference to something that lives in m_listsvc
128 if ( !svc ) return StatusCode::FAILURE;
129 it = find( svc.get() ); // now it is in the list because createService added it
130 it->priority = prio;
131 StatusCode sc = StatusCode( StatusCode::SUCCESS, true );
132 if ( targetFSMState() >= Gaudi::StateMachine::INITIALIZED ) { // WARNING: this can trigger a recursion!!!
133 sc = svc->sysInitialize();
134 if ( sc.isSuccess() && targetFSMState() >= Gaudi::StateMachine::RUNNING ) {
135 sc = svc->sysStart();
136 }
137 }
138 if ( sc.isFailure() ) { // if initialization failed, remove it from the list
139 error() << "Unable to initialize service \"" << typeName.name() << "\"" << endmsg;
140 LockGuard_t lck( m_gLock );
141 m_listsvc.erase( it );
142 // Note: removing it from the list + the SmartIF going out of scope should trigger the delete
143 // delete svc.get();
144 return sc;
145 }
146 // initialization successful, we can work with the service
147 // Move the just initialized service to the back of the list
148 // (we care more about order of initialization than of creation)
149 LockGuard_t lck( m_gLock );
150 m_listsvc.push_back( *it );
151 m_listsvc.erase( it );
152 it = std::prev( std::end( m_listsvc ) ); // last entry (the iterator was invalidated by erase)
153 } else {
154 // if the service is already known, it is equivalent to a setPriority
155 it->priority = prio;
156 }
157 // 'it' is defined because either we found the service or we created it
158 // Now we can activate the service
159 it->active = true; // and make it active
160 return StatusCode( StatusCode::SUCCESS, true );
161 }
Gaudi::StateMachine::INITIALIZED
Definition: StateMachine.h:17
StatusCode::SUCCESS
Definition: StatusCode.h:31
SmartIF< IService >
ServiceManager::LockGuard_t
boost::lock_guard< Mutex_t > LockGuard_t
Definition: ServiceManager.h:182
ServiceManager::m_gLock
Mutex_t m_gLock
Definition: ServiceManager.h:184
StatusCode::FAILURE
Definition: StatusCode.h:31
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:75
ComponentManager::targetFSMState
Gaudi::StateMachine::State targetFSMState() const override
When we are in the middle of a transition, get the state where the transition is leading us...
Definition: ComponentManager.h:63
std::list::end
T end(T...args)
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
std::prev
T prev(T...args)
SmartIF::get
TYPE * get() const
Get interface pointer.
Definition: SmartIF.h:82
IService::sysInitialize
virtual StatusCode sysInitialize()=0
Initialize Service.
std::list::push_back
T push_back(T...args)
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:111
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:28
std::list::erase
T erase(T...args)
Gaudi::StateMachine::RUNNING
Definition: StateMachine.h:18
IService::sysStart
virtual StatusCode sysStart()=0
Start Service.
ServiceManager::find
ListSvc::iterator find(const std::string &name)
Definition: ServiceManager.h:133
Gaudi::Utils::TypeNameString::name
const std::string & name() const
Definition: TypeNameString.h:40
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155
ServiceManager::createService
SmartIF< IService > & createService(const Gaudi::Utils::TypeNameString &nametype) override
implementation of ISvcManager::createService NOTE: as this returns a &, we must guarantee that once c...
Definition: ServiceManager.cpp:62
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209

SmartIF< IService > & ServiceManager::createService | ( | const Gaudi::Utils::TypeNameString & | nametype | ) |
| override

implementation of ISvcManager::createService NOTE: as this returns a &, we must guarantee that once created, these SmartIF remain pinned in their location, thus constraining the underlying implementation...

Fix-Me:
  : what does this mean?

Definition at line 62 of file ServiceManager.cpp.

64 {
65 // Check if the service is already existing
66 if ( existsService( typeName.name() ) ) {
67 // return an error because a service with that name already exists
68 return no_service;
69 }
70
71 const std::string& name = typeName.name();
72 std::string type = typeName.type();
73 if ( !typeName.haveType() ) { // the type is not explicit
74 // see we have some specific type mapping for the name
75 auto it = m_maptype.find( typeName.name() );
76 if ( it != m_maptype.end() ) {
77 type = it->second; // use the declared type
78 }
79 }
80
82 auto ip = type.find( "__" );
83 if ( ip != std::string::npos ) type.erase( ip, type.length() );
84
85 IService* service = Service::Factory::create( type, name, this );
86 if ( !service ) {
87 fatal() << "No Service factory for " << type << " available." << endmsg;
88 return no_service;
89 }
90 // Check the compatibility of the version of the interface obtained
91 if ( !isValidInterface( service ) ) {
92 fatal() << "Incompatible interface IService version for " << type << endmsg;
93 return no_service;
94 }
95
96 m_listsvc.push_back( service );
97 service->setServiceManager( this );
98 return m_listsvc.back().service; // DANGER: returns a reference to a SmartIF in m_listsvc, and hence does no longer
99 // allow relocations of those...
100 }
isValidInterface
bool isValidInterface(I *i)
Templated function that throws an exception if the version if the interface implemented by the object...
Definition: IInterface.h:374
ServiceManager::m_maptype
MapType m_maptype
Map of service name and service type.
Definition: ServiceManager.h:169
std::string
STL class.
std::list::push_back
T push_back(T...args)
ServiceManager::existsService
bool existsService(const std::string &name) const override
implementation of ISvcLocation::existsService
Definition: ServiceManager.cpp:224
GaudiUtils::Map::end
iterator end()
Definition: Map.h:134
IService
General service interface definition.
Definition: IService.h:18
gaudirun.type
type
Definition: gaudirun.py:133
std::string::erase
T erase(T...args)
ServiceManager::name
const std::string & name() const override
Return the name of the manager (implementation of INamedInterface)
Definition: ServiceManager.h:111
GaudiUtils::Map::find
iterator find(const key_type &key)
Definition: Map.h:151
std::string::find
T find(T...args)
std::string::length
T length(T...args)
std::list::back
T back(T...args)
CommonMessagingBase::fatal
MsgStream & fatal() const
shortcut for the method msgStream(MSG::FATAL)
Definition: CommonMessaging.h:105
ServiceManager::service
SmartIF< IService > & service(const Gaudi::Utils::TypeNameString &typeName, const bool createIf=true) override
Returns a smart pointer to a service.
Definition: ServiceManager.cpp:165
GaudiDict::typeName
std::string typeName(const std::type_info &typ)
Definition: Dictionary.cpp:23
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155
IService::setServiceManager
virtual void setServiceManager(ISvcManager *)=0
ServiceManager::ServiceItem::service
SmartIF< IService > service
Definition: ServiceManager.h:41
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209

StatusCode ServiceManager::declareSvcType | ( | const std::string & | svcname,
|  | const std::string & | svctype
| ) |  |
| override

implementation of ISvcManager::declareSvcType

Definition at line 251 of file ServiceManager.cpp.

253 {
254 // once we get to C++17, replace with m_maptype.insert_or_assign...
255 auto p = m_maptype.emplace( svcname, svctype );
256 if ( !p.second ) p.first->second = svctype;
257 return StatusCode::SUCCESS;
258 }
StatusCode::SUCCESS
Definition: StatusCode.h:31
ServiceManager::m_maptype
MapType m_maptype
Map of service name and service type.
Definition: ServiceManager.h:169
GaudiUtils::Map::emplace
std::pair< iterator, bool > emplace(Args &&...args)
Definition: Map.h:169

void ServiceManager::dump | ( |  | ) | const
| private

Definition at line 512 of file ServiceManager.cpp.

513 {
514
515 auto& log = info();
516 log << "\n"
517 << "===================== listing all services ===================\n"
518 << " prior ref name active\n";
519
520 for ( const auto& svc : m_listsvc ) {
521
522 log.width( 6 );
523 log.flags( std::ios_base::right );
524 log << svc.priority << " ";
525 log.width( 5 );
526 log << svc.service->refCount() << " ";
527 log.width( 30 );
528 log.flags( std::ios_base::left );
529 log << svc.service->name() << " ";
530 log.width( 2 );
531 log << svc.active << std::endl;
532 }
533
534 log << "=================================================================\n";
535 log << endmsg;
536 }
CommonMessagingBase::info
MsgStream & info() const
shortcut for the method msgStream(MSG::INFO)
Definition: CommonMessaging.h:117
std::endl
T endl(T...args)
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209
Gaudi.Configuration.log
log
Definition: Configuration.py:13

bool ServiceManager::existsService | ( | const std::string & | name | ) | const
| override

implementation of ISvcLocation::existsService

Definition at line 224 of file ServiceManager.cpp.

226 {
227 return find( name ) != m_listsvc.end();
228 }
std::list::end
T end(T...args)
ServiceManager::find
ListSvc::iterator find(const std::string &name)
Definition: ServiceManager.h:133
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155

StatusCode ServiceManager::finalize | ( |  | ) |
| override

Finalize (from INITIALIZED to CONFIGURED).

Definition at line 404 of file ServiceManager.cpp.

406 {
407 // make sure that HistogramDataSvc and THistSvc get finalized after the
408 // ToolSvc, and the FileMgr and StatusCodeSvc after that
409 int pri_tool = getPriority( "ToolSvc" );
410 if ( pri_tool != 0 ) {
411 setPriority( "THistSvc", pri_tool - 10 ).ignore();
412 setPriority( "ChronoStatSvc", pri_tool - 20 ).ignore();
413 setPriority( "AuditorSvc", pri_tool - 30 ).ignore();
414 setPriority( "NTupleSvc", pri_tool - 10 ).ignore();
415 setPriority( "HistogramDataSvc", pri_tool - 10 ).ignore();
416 // Preserve the relative ordering between HistogramDataSvc and HistogramPersistencySvc
417 setPriority( "HistogramPersistencySvc", pri_tool - 20 ).ignore();
418 setPriority( "HistorySvc", pri_tool - 30 ).ignore();
419 setPriority( "FileMgr", pri_tool - 40 ).ignore();
420 }
421
422 // get list of PostFinalize clients
423 std::vector<IIncidentListener*> postFinList;
424 auto p_inc = service<IIncidentSvc>( "IncidentSvc", false );
425 if ( p_inc ) {
426 p_inc->getListeners( postFinList, IncidentType::SvcPostFinalize );
427 p_inc.reset();
428 }
429
430 // make sure the StatusCodeSvc gets finalized really late:
431 setPriority( "StatusCodeSvc", -9999 ).ignore();
432
433 // ensure that the list is ordered by priority
434 m_listsvc.sort();
435 // dump();
436
437 StatusCode sc( StatusCode::SUCCESS, true );
438 {
439 // we work on a copy to avoid to operate twice on the services created on demand
440 // which are already in the correct state.
441 // only act on active services
442 // call finalize() for all services in reverse order
443 for ( const auto& svc : reverse( activeSvc( m_listsvc ) ) ) {
444 const std::string& name = svc->name();
445 // ignore the current state for the moment
446 // if( Gaudi::StateMachine::INITIALIZED == svc->state() )
447 DEBMSG << "Finalizing service " << name << endmsg;
448 if ( !svc->sysFinalize().isSuccess() ) {
449 warning() << "Finalization of service " << name << " failed" << endmsg;
450 sc = StatusCode::FAILURE;
451 }
452 }
453 }
454
455 // call SvcPostFinalize on all clients
456 if ( !postFinList.empty() ) {
457 DEBMSG << "Will call SvcPostFinalize for " << postFinList.size() << " clients" << endmsg;
458 Incident inc( "ServiceManager", IncidentType::SvcPostFinalize );
459 for ( auto& itr : postFinList ) itr->handle( inc );
460 }
461
462 // loop over all Active Services, removing them one by one.
463 // They should be deleted because the reference counting goes to 0.
464 DEBMSG << "Looping over all active services..." << endmsg;
465 auto it = m_listsvc.begin();
466 while ( it != m_listsvc.end() ) {
467 DEBMSG << "---- " << it->service->name() << " (refCount = " << it->service->refCount() << ")" << endmsg;
468 if ( it->service->refCount() < 1 ) {
469 warning() << "Too low reference count for " << it->service->name() << " (should not go below 1 at this point)"
470 << endmsg;
471 it->service->addRef();
472 }
473 if ( it->active ) {
474 it = m_listsvc.erase( it );
475 } else {
476 ++it;
477 }
478 }
479 return sc;
480 }
StatusCode::SUCCESS
Definition: StatusCode.h:31
std::vector::empty
T empty(T...args)
StatusCode::FAILURE
Definition: StatusCode.h:31
std::list::end
T end(T...args)
std::string
STL class.
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:114
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:28
std::list::erase
T erase(T...args)
ServiceManager::name
const std::string & name() const override
Return the name of the manager (implementation of INamedInterface)
Definition: ServiceManager.h:111
ServiceManager::getPriority
int getPriority(const std::string &name) const override
manage priorities of services
Definition: ServiceManager.cpp:483
reverse
reverse_wrapper< T > reverse(T &&iterable)
Definition: reverse.h:35
std::vector::size
T size(T...args)
std::vector
STL class.
std::list::begin
T begin(T...args)
Incident
Base class for all Incidents (computing events).
Definition: Incident.h:17
std::list::sort
T sort(T...args)
DEBMSG
#define DEBMSG
Definition: ServiceManager.cpp:23
ServiceManager::setPriority
StatusCode setPriority(const std::string &name, int pri) override
Definition: ServiceManager.cpp:491
StatusCode::ignore
void ignore() const
Definition: StatusCode.h:109
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209

ListSvc::iterator ServiceManager::find | ( | const std::string & | name | ) |
| inline private

Definition at line 133 of file ServiceManager.h.

134 {
135 boost::lock_guard<boost::recursive_mutex> lck( m_gLock );
136 return std::find( m_listsvc.begin(), m_listsvc.end(), name );
137 }
ServiceManager::m_gLock
Mutex_t m_gLock
Definition: ServiceManager.h:184
std::list::end
T end(T...args)
ServiceManager::name
const std::string & name() const override
Return the name of the manager (implementation of INamedInterface)
Definition: ServiceManager.h:111
std::find
T find(T...args)
std::list::begin
T begin(T...args)
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155

ListSvc::const_iterator ServiceManager::find | ( | const std::string & | name | ) | const
| inline private

Definition at line 138 of file ServiceManager.h.

139 {
140 boost::lock_guard<boost::recursive_mutex> lck( m_gLock );
141 return std::find( m_listsvc.begin(), m_listsvc.end(), name );
142 }
ServiceManager::m_gLock
Mutex_t m_gLock
Definition: ServiceManager.h:184
std::list::end
T end(T...args)
ServiceManager::name
const std::string & name() const override
Return the name of the manager (implementation of INamedInterface)
Definition: ServiceManager.h:111
std::find
T find(T...args)
std::list::begin
T begin(T...args)
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155

ListSvc::iterator ServiceManager::find | ( | const IService * | ptr | ) |
| inline private

Definition at line 143 of file ServiceManager.h.

144 {
145 boost::lock_guard<boost::recursive_mutex> lck( m_gLock );
146 return std::find( m_listsvc.begin(), m_listsvc.end(), ptr );
147 }
ServiceManager::m_gLock
Mutex_t m_gLock
Definition: ServiceManager.h:184
std::list::end
T end(T...args)
std::find
T find(T...args)
std::list::begin
T begin(T...args)
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155

ListSvc::const_iterator ServiceManager::find | ( | const IService * | ptr | ) | const
| inline private

Definition at line 148 of file ServiceManager.h.

149 {
150 boost::lock_guard<boost::recursive_mutex> lck( m_gLock );
151 return std::find( m_listsvc.begin(), m_listsvc.end(), ptr );
152 }
ServiceManager::m_gLock
Mutex_t m_gLock
Definition: ServiceManager.h:184
std::list::end
T end(T...args)
std::find
T find(T...args)
std::list::begin
T begin(T...args)
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155

int ServiceManager::getPriority | ( | const std::string & | name | ) | const
| override

manage priorities of services

Definition at line 483 of file ServiceManager.cpp.

484 {
485 //------------------------------------------------------------------------------
486 auto it = find( name );
487 return ( it != m_listsvc.end() ) ? it->priority : 0;
488 }
std::list::end
T end(T...args)
ServiceManager::find
ListSvc::iterator find(const std::string &name)
Definition: ServiceManager.h:133
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155

const std::list< IService * > & ServiceManager::getServices | ( |  | ) | const
| override

Return the list of Services.

Definition at line 214 of file ServiceManager.cpp.

216 {
217 m_listOfPtrs.clear();
218 std::transform( std::begin( m_listsvc ), std::end( m_listsvc ), std::back_inserter( m_listOfPtrs ),
219 []( ListSvc::const_reference i ) { return const_cast<IService*>( i.service.get() ); } );
220 return m_listOfPtrs;
221 }
ServiceManager::m_listOfPtrs
std::list< IService * > m_listOfPtrs
List of pointers to the know services used to implement getServices()
Definition: ServiceManager.h:176
std::end
T end(T...args)
IService
General service interface definition.
Definition: IService.h:18
std::list::clear
T clear(T...args)
std::begin
T begin(T...args)
std::back_inserter
T back_inserter(T...args)
std::transform
T transform(T...args)
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155

StatusCode ServiceManager::initialize | ( |  | ) |
| override

Initialization (from CONFIGURED to INITIALIZED).

Definition at line 261 of file ServiceManager.cpp.

263 {
264 // ensure that the list is ordered by priority
265 m_listsvc.sort();
266 // we work on a copy to avoid to operate twice on the services created on demand
267 // which are already in the correct state.
268
269 StatusCode sc( StatusCode::SUCCESS, true );
270 // call initialize() for all services
271 for ( auto& it : activeSvc( m_listsvc ) ) {
272 const std::string& name = it->name();
273 switch ( it->FSMState() ) {
274 case Gaudi::StateMachine::INITIALIZED:
275 DEBMSG << "Service " << name << " already initialized" << endmsg;
276 break;
277 case Gaudi::StateMachine::OFFLINE:
278 DEBMSG << "Initializing service " << name << endmsg;
279 sc = it->sysInitialize();
280 if ( !sc.isSuccess() ) {
281 error() << "Unable to initialize Service: " << name << endmsg;
282 return sc;
283 }
284 break;
285 default:
286 error() << "Service " << name << " not in the correct state to be initialized (" << it->FSMState() << ")"
287 << endmsg;
288 return StatusCode::FAILURE;
289 }
290 }
291 return StatusCode::SUCCESS;
292 }
Gaudi::StateMachine::INITIALIZED
Definition: StateMachine.h:17
StatusCode::SUCCESS
Definition: StatusCode.h:31
StatusCode::FAILURE
Definition: StatusCode.h:31
std::string
STL class.
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:111
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:28
ServiceManager::name
const std::string & name() const override
Return the name of the manager (implementation of INamedInterface)
Definition: ServiceManager.h:111
std::list::sort
T sort(T...args)
DEBMSG
#define DEBMSG
Definition: ServiceManager.cpp:23
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155
Gaudi::StateMachine::OFFLINE
Definition: StateMachine.h:15
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209

bool ServiceManager::loopCheckEnabled | ( |  | ) | const
| override

Get the value of the initialization loop check flag.

Definition at line 503 of file ServiceManager.cpp.

503 { return m_loopCheck; }
ServiceManager::m_loopCheck
bool m_loopCheck
Check for service initialization loops.
Definition: ServiceManager.h:170

const std::string& ServiceManager::name | ( |  | ) | const
| inline override

Return the name of the manager (implementation of INamedInterface)

Definition at line 111 of file ServiceManager.h.

112 {
113 static std::string _name = "ServiceManager";
114 return _name;
115 }
std::string
STL class.

StatusCode ServiceManager::reinitialize | ( |  | ) |
| override

Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED).

Definition at line 362 of file ServiceManager.cpp.

364 {
365 // ensure that the list is ordered by priority
366 m_listsvc.sort();
367 // we work on a copy to avoid to operate twice on the services created on demand
368 // which are already in the correct state.
369 // only act on active services
370 StatusCode sc( StatusCode::SUCCESS, true );
371 // Re-Initialize all services
372 for ( auto& svc : activeSvc( m_listsvc ) ) {
373 sc = svc->sysReinitialize();
374 if ( !sc.isSuccess() ) {
375 error() << "Unable to re-initialize Service: " << svc->name() << endmsg;
376 return StatusCode::FAILURE;
377 }
378 }
379 return StatusCode::SUCCESS;
380 }
StatusCode::SUCCESS
Definition: StatusCode.h:31
StatusCode::FAILURE
Definition: StatusCode.h:31
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:111
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:28
std::list::sort
T sort(T...args)
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209

StatusCode ServiceManager::removeService | ( | IService * | svc | ) |
| override

implementation of ISvcManager::removeService

Definition at line 231 of file ServiceManager.cpp.

233 {
234 auto it = find( svc );
235 if ( it == m_listsvc.end() ) return StatusCode( StatusCode::FAILURE, true );
236 m_listsvc.erase( it );
237 return StatusCode( StatusCode::SUCCESS, true );
238 }
StatusCode::SUCCESS
Definition: StatusCode.h:31
StatusCode::FAILURE
Definition: StatusCode.h:31
std::list::end
T end(T...args)
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:28
std::list::erase
T erase(T...args)
ServiceManager::find
ListSvc::iterator find(const std::string &name)
Definition: ServiceManager.h:133
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155

StatusCode ServiceManager::removeService | ( | const std::string & | name | ) |
| override

implementation of ISvcManager::removeService

Definition at line 241 of file ServiceManager.cpp.

243 {
244 auto it = find( name );
245 if ( it == m_listsvc.end() ) return StatusCode::FAILURE;
246 m_listsvc.erase( it );
247 return StatusCode::SUCCESS;
248 }
StatusCode::SUCCESS
Definition: StatusCode.h:31
StatusCode::FAILURE
Definition: StatusCode.h:31
std::list::end
T end(T...args)
std::list::erase
T erase(T...args)
ServiceManager::find
ListSvc::iterator find(const std::string &name)
Definition: ServiceManager.h:133
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155

StatusCode ServiceManager::restart | ( |  | ) |
| override

Initialization (from RUNNING to RUNNING, via INITIALIZED).

Definition at line 383 of file ServiceManager.cpp.

385 {
386 // ensure that the list is ordered by priority
387 m_listsvc.sort();
388 // we work on a copy to avoid to operate twice on the services created on demand
389 // which are already in the correct state.
390 // only act on active services
391 StatusCode sc( StatusCode::SUCCESS, true );
392 // Re-Start all services
393 for ( auto& svc : activeSvc( m_listsvc ) ) {
394 sc = svc->sysRestart();
395 if ( !sc.isSuccess() ) {
396 error() << "Unable to re-start Service: " << svc->name() << endmsg;
397 return StatusCode::FAILURE;
398 }
399 }
400 return StatusCode::SUCCESS;
401 }
StatusCode::SUCCESS
Definition: StatusCode.h:31
StatusCode::FAILURE
Definition: StatusCode.h:31
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:111
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:28
std::list::sort
T sort(T...args)
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209

SmartIF< IService > & ServiceManager::service | ( | const Gaudi::Utils::TypeNameString & | typeName,
|  | const bool | createIf = `true`
| ) |  |
| override

Returns a smart pointer to a service.

Definition at line 165 of file ServiceManager.cpp.

166 {
167 const std::string& name = typeName.name();
168
169 // Acquire the RAII lock to avoid simultaneous attempts from different threads to initialize a service
170
171 Mutex_t* imut;
172 {
173 // get the global lock, then extract/create the service specific mutex
174 // then release global lock
175
176 LockGuard_t lk( m_gLock );
177 auto mit = m_lockMap.find( name );
178 if ( mit == m_lockMap.end() ) {
179 mit = m_lockMap.emplace( name, std::unique_ptr<Mutex_t>( new Mutex_t ) ).first;
180 }
181 imut = mit->second.get();
182 }
183
184 {
185 // now we have the service specific lock on the above mutex
186 LockGuard_t lk2( *imut );
187
188 auto it = find( name );
189
190 if ( it != m_listsvc.end() ) {
191 if ( m_loopCheck && ( createIf && it->service->FSMState() == Gaudi::StateMachine::CONFIGURED ) ) {
192 error() << "Initialization loop detected when creating service \"" << name << "\"" << endmsg;
193 return no_service;
194 }
195 return it->service;
196 }
197
198 // Service not found. The user may be interested in one of the interfaces
199 // of the application manager itself
200 if ( name == "ApplicationMgr" || name == "APPMGR" || name == "" ) {
201 return m_appSvc;
202 }
203
204 // last resort: we try to create the service
205 if ( createIf && addService( typeName ).isSuccess() ) {
206 return find( name )->service;
207 }
208
209 return no_service;
210 }
211 }
ServiceManager::m_appSvc
SmartIF< IService > m_appSvc
Pointer to the application IService interface.
Definition: ServiceManager.h:173
ServiceManager::LockGuard_t
boost::lock_guard< Mutex_t > LockGuard_t
Definition: ServiceManager.h:182
ServiceManager::m_gLock
Mutex_t m_gLock
Definition: ServiceManager.h:184
Gaudi::StateMachine::CONFIGURED
Definition: StateMachine.h:16
ServiceManager::m_loopCheck
bool m_loopCheck
Check for service initialization loops.
Definition: ServiceManager.h:170
ServiceManager::Mutex_t
boost::recursive_mutex Mutex_t
Mutex to synchronize shared service initialization between threads.
Definition: ServiceManager.h:181
std::map::end
T end(T...args)
std::string
STL class.
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:111
ServiceManager::name
const std::string & name() const override
Return the name of the manager (implementation of INamedInterface)
Definition: ServiceManager.h:111
ServiceManager::m_lockMap
std::map< std::string, std::unique_ptr< Mutex_t > > m_lockMap
Definition: ServiceManager.h:185
std::unique_ptr::get
T get(T...args)
std::map::find
T find(T...args)
std::unique_ptr< Mutex_t >
std::map::emplace
T emplace(T...args)
ServiceManager::find
ListSvc::iterator find(const std::string &name)
Definition: ServiceManager.h:133
Gaudi::Utils::TypeNameString::name
const std::string & name() const
Definition: TypeNameString.h:40
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209
ServiceManager::addService
StatusCode addService(IService *svc, int prio=DEFAULT_SVC_PRIORITY) override
implementation of ISvcManager::addService
Definition: ServiceManager.cpp:104
template<typename T >

SmartIF<T> ServiceManager::service | ( | const Gaudi::Utils::TypeNameString & | typeName,
|  | const bool | createIf = `true`
| ) |  |
| inline

Returns a smart pointer to the requested interface of a service.

Definition at line 122 of file ServiceManager.h.

123 {
124 return SmartIF<T>{service( typeName, createIf )};
125 }
SmartIF
Small smart pointer class with automatic reference counting for IInterface.
Definition: IConverter.h:15
ServiceManager::service
SmartIF< IService > & service(const Gaudi::Utils::TypeNameString &typeName, const bool createIf=true) override
Returns a smart pointer to a service.
Definition: ServiceManager.cpp:165

SmartIF<ISvcLocator>& ServiceManager::serviceLocator | ( |  | ) | const
| inline override

Function needed by CommonMessaging.

Definition at line 57 of file ServiceManager.h.

57 { return m_svcLocator; }
ComponentManager::m_svcLocator
SmartIF< ISvcLocator > m_svcLocator
Service locator (needed to access the MessageSvc)
Definition: ComponentManager.h:76

void ServiceManager::setLoopCheckEnabled | ( | bool | en | ) |
| override

Set the value of the initialization loop check flag.

Definition at line 507 of file ServiceManager.cpp.

507 { m_loopCheck = en; }
ServiceManager::m_loopCheck
bool m_loopCheck
Check for service initialization loops.
Definition: ServiceManager.h:170

StatusCode ServiceManager::setPriority | ( | const std::string & | name,
|  | int | pri
| ) |  |
| override

Definition at line 491 of file ServiceManager.cpp.

492 {
493 //------------------------------------------------------------------------------
494 auto it = find( name );
495 if ( it == m_listsvc.end() ) return StatusCode::FAILURE;
496 it->priority = prio;
497 return StatusCode::SUCCESS;
498 }
StatusCode::SUCCESS
Definition: StatusCode.h:31
StatusCode::FAILURE
Definition: StatusCode.h:31
std::list::end
T end(T...args)
ServiceManager::find
ListSvc::iterator find(const std::string &name)
Definition: ServiceManager.h:133
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155

StatusCode ServiceManager::start | ( |  | ) |
| override

Start (from INITIALIZED to RUNNING).

Definition at line 295 of file ServiceManager.cpp.

297 {
298 // ensure that the list is ordered by priority
299 m_listsvc.sort();
300 // we work on a copy to avoid to operate twice on the services created on demand
301 // (which are already in the correct state.
302 // only act on active services
303 StatusCode sc( StatusCode::SUCCESS, true );
304 // call initialize() for all services
305 for ( auto& it : activeSvc( m_listsvc ) ) {
306 const std::string& name = it->name();
307 switch ( it->FSMState() ) {
308 case Gaudi::StateMachine::RUNNING:
309 DEBMSG << "Service " << name << " already started" << endmsg;
310 break;
311 case Gaudi::StateMachine::INITIALIZED:
312 DEBMSG << "Starting service " << name << endmsg;
313 sc = it->sysStart();
314 if ( !sc.isSuccess() ) {
315 error() << "Unable to start Service: " << name << endmsg;
316 return sc;
317 }
318 break;
319 default:
320 error() << "Service " << name << " not in the correct state to be started (" << it->FSMState() << ")" << endmsg;
321 return StatusCode::FAILURE;
322 }
323 }
324 return StatusCode::SUCCESS;
325 }
Gaudi::StateMachine::INITIALIZED
Definition: StateMachine.h:17
StatusCode::SUCCESS
Definition: StatusCode.h:31
StatusCode::FAILURE
Definition: StatusCode.h:31
std::string
STL class.
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:111
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:28
ServiceManager::name
const std::string & name() const override
Return the name of the manager (implementation of INamedInterface)
Definition: ServiceManager.h:111
Gaudi::StateMachine::RUNNING
Definition: StateMachine.h:18
std::list::sort
T sort(T...args)
DEBMSG
#define DEBMSG
Definition: ServiceManager.cpp:23
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209

StatusCode ServiceManager::stop | ( |  | ) |
| override

Stop (from RUNNING to INITIALIZED).

Definition at line 328 of file ServiceManager.cpp.

330 {
331 // ensure that the list is ordered by priority
332 m_listsvc.sort();
333 // we work on a copy to avoid to operate twice on the services created on demand
334 // which are already in the correct state.
335 // only act on active services
336
337 StatusCode sc( StatusCode::SUCCESS, true );
338 // call stop() for all services
339 for ( const auto& svc : reverse( activeSvc( m_listsvc ) ) ) {
340 const std::string& name = svc->name();
341 switch ( svc->FSMState() ) {
342 case Gaudi::StateMachine::INITIALIZED:
343 DEBMSG << "Service " << name << " already stopped" << endmsg;
344 break;
345 case Gaudi::StateMachine::RUNNING:
346 DEBMSG << "Stopping service " << name << endmsg;
347 sc = svc->sysStop();
348 if ( !sc.isSuccess() ) {
349 error() << "Unable to stop Service: " << name << endmsg;
350 return sc;
351 }
352 break;
353 default:
354 DEBMSG << "Service " << name << " not in the correct state to be stopped (" << svc->FSMState() << ")" << endmsg;
355 return StatusCode::FAILURE;
356 }
357 }
358 return StatusCode::SUCCESS;
359 }
Gaudi::StateMachine::INITIALIZED
Definition: StateMachine.h:17
StatusCode::SUCCESS
Definition: StatusCode.h:31
StatusCode::FAILURE
Definition: StatusCode.h:31
std::string
STL class.
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:111
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:28
ServiceManager::name
const std::string & name() const override
Return the name of the manager (implementation of INamedInterface)
Definition: ServiceManager.h:111
reverse
reverse_wrapper< T > reverse(T &&iterable)
Definition: reverse.h:35
Gaudi::StateMachine::RUNNING
Definition: StateMachine.h:18
std::list::sort
T sort(T...args)
DEBMSG
#define DEBMSG
Definition: ServiceManager.cpp:23
ServiceManager::m_listsvc
ListSvc m_listsvc
List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because...
Definition: ServiceManager.h:155
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209

## Member Data Documentation

SmartIF<IService> ServiceManager::m_appSvc
| private

Pointer to the application IService interface.

Definition at line 173 of file ServiceManager.h.

GaudiUtils::Map<InterfaceID, SmartIF<IInterface> > ServiceManager::m_defaultImplementations
| private

Definition at line 178 of file ServiceManager.h.

Mutex_t ServiceManager::m_gLock
| mutable private

Definition at line 184 of file ServiceManager.h.

std::list<IService*> ServiceManager::m_listOfPtrs
| mutable private

List of pointers to the know services used to implement getServices()

Definition at line 176 of file ServiceManager.h.

ListSvc ServiceManager::m_listsvc
| private

List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because there can be SmartIF<T>& 'out there' that refer to these specific SmarIF<T>, we unfortunately must guarantee that they never move after creation.

Hence, we cannot use a plain std::vector here, as that may cause relocation and/or swapping of SmartIF<T>'s, and then the already handed out references may refer to the wrong item.... Note that we could use an std::vector<std::unique_ptr<ServiceItem>> (sometimes known as 'stable vector') as then the individual ServiceItems would stay pinned in their original location, but that would put ServiceItem on the heap... And maybe I'm way too paranoid...

Definition at line 155 of file ServiceManager.h.

std::map<std::string, std::unique_ptr<Mutex_t> > ServiceManager::m_lockMap
| mutable private

Definition at line 185 of file ServiceManager.h.

bool ServiceManager::m_loopCheck = true
| private

Check for service initialization loops.

Definition at line 170 of file ServiceManager.h.

MapType ServiceManager::m_maptype
| private

Map of service name and service type.

Definition at line 169 of file ServiceManager.h.

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

- GaudiCoreSvc/src/ApplicationMgr/ServiceManager.h
- GaudiCoreSvc/src/ApplicationMgr/ServiceManager.cpp