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:

Collaboration diagram for ServiceManager:

Classes
struct	ServiceItem

Public Types
typedef std::list< ServiceItem >	ListSvc
typedef GaudiUtils::Map< std::string, std::string >	MapType
Public Types inherited from extends< BASE, Interfaces >
using	base_class = extends
	Typedef to this class. More...
using	extend_interfaces_base = extend_interfaces< Interfaces...>
	Typedef to the base of this class. More...
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 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...
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< BASE, Interfaces >
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...
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 extend_interfaces< Interfaces...>
	~extend_interfaces () override=default
	Virtual destructor. More...
	~extend_interfaces () override=default
	Virtual destructor. More...

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
std::recursive_mutex	m_svcinitmutex
	Mutex to synchronize shared service initialization between threads. 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 35 of file ServiceManager.h.

Member Typedef Documentation

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

Definition at line 56 of file ServiceManager.h.

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

Definition at line 57 of file ServiceManager.h.

Constructor & Destructor Documentation

ServiceManager::ServiceManager

(

IInterface *

application

)

default creator

Definition at line 42 of file ServiceManager.cpp.

                                                     :
  base_class(application, IService::interfaceID()),
  m_appSvc(application)
{
  // Set the service locator to myself
  m_svcLocator = this;
  addRef(); // increase ref count, so we live forever...
}

ServiceManager::~ServiceManager ( )

override

virtual destructor

Definition at line 52 of file ServiceManager.cpp.

                                {
  //-- inform the orphan services that I am gone....
  for (auto& svc : m_listsvc) svc.service->setServiceManager(nullptr);
}

Member Function Documentation

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

override

implementation of ISvcManager::addService

Definition at line 100 of file ServiceManager.cpp.

{
  auto it = find(svc);
  if (it != m_listsvc.end()) {
    it->priority = prio; // if the service is already known, it is equivalent to a setPriority
    it->active = true;   // and make it active
  } else {
    m_listsvc.emplace_back(svc,prio,true);
  }
  return StatusCode::SUCCESS;
}

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

override

implementation of ISvcManager::addService

Definition at line 115 of file ServiceManager.cpp.

{
  auto it = find(typeName.name()); // try to find the service by name
  if (it == m_listsvc.end()) { // not found
    // If the service does not exist, we create it
    SmartIF<IService>& svc = createService(typeName); // WARNING: svc is now a reference to something that lives in m_listsvc
    if (!svc) return StatusCode::FAILURE;
    it = find(svc.get()); // now it is in the list because createService added it
    it->priority = prio;
    StatusCode sc = StatusCode(StatusCode::SUCCESS, true);
    if (targetFSMState() >= Gaudi::StateMachine::INITIALIZED) { // WARNING: this can trigger a recursion!!!
      sc = svc->sysInitialize();
      if (sc.isSuccess() && targetFSMState() >= Gaudi::StateMachine::RUNNING) {
        sc = svc->sysStart();
      }
    }
    if(sc.isFailure()) { // if initialization failed, remove it from the list
      error() << "Unable to initialize service \"" << typeName.name() << "\""
              << endmsg;
      m_listsvc.erase(it);
      // Note: removing it from the list + the SmartIF going out of scope should trigger the delete
      // delete svc.get();
      return sc;
    }
    // initialization successful, we can work with the service
    // Move the just initialized service to the back of the list
    // (we care more about order of initialization than of creation)
    m_listsvc.push_back(*it);
    m_listsvc.erase(it);
    it = std::prev(std::end(m_listsvc)); // last entry (the iterator was invalidated by erase)
  } else {
    // if the service is already known, it is equivalent to a setPriority
    it->priority = prio;
  }
  // 'it' is defined because either we found the service or we created it
  // Now we can activate the service
  it->active = true;   // and make it active
  return StatusCode(StatusCode::SUCCESS, true);
}

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 59 of file ServiceManager.cpp.

{
  // Check if the service is already existing
  if(existsService(typeName.name())) {
    // return an error because a service with that name already exists
    return no_service;
  }

  const std::string &name = typeName.name();
  std::string type = typeName.type();
  if (!typeName.haveType()) { // the type is not explicit
    // see we have some specific type mapping for the name
    auto it = m_maptype.find(typeName.name());
    if( it != m_maptype.end() ) {
      type = it->second; // use the declared type
    }
  }

  auto ip = type.find("__");
  if ( ip != std::string::npos) type.erase(ip,type.length());

  IService* service = Service::Factory::create(type, name, this);
  if ( !service ) {
    fatal() << "No Service factory for " << type << " available." << endmsg;
    return no_service;
  }
  // Check the compatibility of the version of the interface obtained
  if( !isValidInterface(service) ) {
    fatal() << "Incompatible interface IService version for " << type << endmsg;
    return no_service;
  }

  m_listsvc.push_back(service);
  service->setServiceManager(this);
  return m_listsvc.back().service; // DANGER: returns a reference to a SmartIF in m_listsvc, and hence does no longer allow relocations of those...
}

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

override

implementation of ISvcManager::declareSvcType

Definition at line 235 of file ServiceManager.cpp.

{
  // once we get to C++17, replace with m_maptype.insert_or_assign...
  auto p = m_maptype.emplace( svcname, svctype );
  if ( !p.second ) p.first->second = svctype;
  return StatusCode::SUCCESS;
}

void ServiceManager::dump ( ) const

private

Definition at line 511 of file ServiceManager.cpp.

                                {

  MsgStream log(msgSvc(),name());

  log << MSG::INFO << "\n"
      << "=====================  listing all services  ===================\n"
      << " prior   ref name                           active\n";

  for (const auto& svc : m_listsvc) {

    log.width(6);
    log.flags(std::ios_base::right);
    log << svc.priority << " ";
    log.width(5);
    log << svc.service->refCount() << " ";
    log.width(30);
    log.flags(std::ios_base::left);
    log << svc.service->name() << " ";
    log.width(2);
    log << svc.active << std::endl;

  }

  log << "=================================================================\n";
  log << endmsg;

}

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

override

implementation of ISvcLocation::existsService

Definition at line 208 of file ServiceManager.cpp.

{
  return find(name) != m_listsvc.end();
}

StatusCode ServiceManager::finalize ( )

override

Finalize (from INITIALIZED to CONFIGURED).

Definition at line 393 of file ServiceManager.cpp.

{
  // make sure that HistogramDataSvc and THistSvc get finalized after the
  // ToolSvc, and the FileMgr and StatusCodeSvc after that
  int pri_tool = getPriority("ToolSvc");
  if (pri_tool != 0) {
    setPriority("THistSvc",pri_tool-10).ignore();
    setPriority("ChronoStatSvc",pri_tool-20).ignore();
    setPriority("AuditorSvc",pri_tool-30).ignore();
    setPriority("NTupleSvc",pri_tool-10).ignore();
    setPriority("HistogramDataSvc",pri_tool-10).ignore();
    // Preserve the relative ordering between HistogramDataSvc and HistogramPersistencySvc
    setPriority("HistogramPersistencySvc",pri_tool-20).ignore();
    setPriority("HistorySvc",pri_tool-30).ignore();
    setPriority("FileMgr",pri_tool-40).ignore();
  }


  // get list of PostFinalize clients
  std::vector<IIncidentListener*> postFinList;
  auto p_inc = service<IIncidentSvc>("IncidentSvc",false);
  if (p_inc) {
    p_inc->getListeners(postFinList,IncidentType::SvcPostFinalize);
    p_inc.reset();
  }

  // make sure the StatusCodeSvc gets finalized really late:
  setPriority("StatusCodeSvc",-9999).ignore();

  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // dump();

  StatusCode sc(StatusCode::SUCCESS, true);
  {
    // we work on a copy to avoid to operate twice on the services created on demand
    // which are already in the correct state.
    // only act on active services
    // call finalize() for all services in reverse order
    for (const auto& svc : reverse(activeSvc(m_listsvc)) ) {
      const std::string& name = svc->name();
      // ignore the current state for the moment
      // if( Gaudi::StateMachine::INITIALIZED == svc->state() )
      DEBMSG << "Finalizing service " << name << endmsg;
      if ( !svc->sysFinalize().isSuccess() ) {
        warning() << "Finalization of service " << name << " failed" << endmsg;
        sc = StatusCode::FAILURE;
      }
    }
  }

  // call SvcPostFinalize on all clients
  if (!postFinList.empty()) {
    DEBMSG << "Will call SvcPostFinalize for " << postFinList.size() << " clients"
           << endmsg;
    Incident inc("ServiceManager", IncidentType::SvcPostFinalize);
    for (auto& itr : postFinList) itr->handle(inc);
  }

  // loop over all Active Services, removing them one by one.
  // They should be deleted because the reference counting goes to 0.
  DEBMSG << "Looping over all active services..." << endmsg;
  auto it = m_listsvc.begin();
  while (it != m_listsvc.end()) {
    DEBMSG << "---- " << it->service->name()
       << " (refCount = " << it->service->refCount() << ")"
       << endmsg;
    if (it->service->refCount() < 1) {
      warning() << "Too low reference count for " << it->service->name()
                << " (should not go below 1 at this point)" << endmsg;
      it->service->addRef();
    }
    if (it->active) {
      it = m_listsvc.erase(it);
    } else {
      ++it;
    }
  }
  return sc;
}

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

inlineprivate

Definition at line 140 of file ServiceManager.h.

                                                     {
    return std::find(m_listsvc.begin(), m_listsvc.end(), name);
  }

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

inlineprivate

Definition at line 143 of file ServiceManager.h.

                                                                 {
    return std::find(m_listsvc.begin(), m_listsvc.end(), name);
  }

ListSvc::iterator ServiceManager::find ( const IService *  ptr )

inlineprivate

Definition at line 146 of file ServiceManager.h.

                                                   {
    return std::find(m_listsvc.begin(), m_listsvc.end(), ptr);
  }

ListSvc::const_iterator ServiceManager::find ( const IService *  ptr ) const

inlineprivate

Definition at line 149 of file ServiceManager.h.

                                                               {
    return std::find(m_listsvc.begin(), m_listsvc.end(), ptr);
  }

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

override

manage priorities of services

Definition at line 478 of file ServiceManager.cpp.

                                                       {
//------------------------------------------------------------------------------
  auto it = find(name);
  return (it != m_listsvc.end()) ? it->priority: 0;
}

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

override

Return the list of Services.

Definition at line 195 of file ServiceManager.cpp.

{
  m_listOfPtrs.clear();
  std::transform( std::begin(m_listsvc), std::end(m_listsvc),
                  std::back_inserter(m_listOfPtrs),
                  [](ListSvc::const_reference i) {
                      return const_cast<IService*>(i.service.get());
  });
  return m_listOfPtrs;
}

StatusCode ServiceManager::initialize ( )

override

Initialization (from CONFIGURED to INITIALIZED).

Definition at line 246 of file ServiceManager.cpp.

{
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // which are already in the correct state.

  StatusCode sc(StatusCode::SUCCESS, true);
  // call initialize() for all services
  for (auto& it : activeSvc(m_listsvc) ) {
    const std::string& name = it->name();
    switch (it->FSMState()) {
    case Gaudi::StateMachine::INITIALIZED:
      DEBMSG << "Service " << name << " already initialized" << endmsg;
      break;
    case Gaudi::StateMachine::OFFLINE:
      DEBMSG << "Initializing service " << name << endmsg;
      sc = it->sysInitialize();
      if( !sc.isSuccess() ) {
        error() << "Unable to initialize Service: " << name << endmsg;
        return sc;
      } break;
    default:
      error() << "Service " << name
          << " not in the correct state to be initialized ("
          << it->FSMState() << ")" << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

bool ServiceManager::loopCheckEnabled ( ) const

override

Get the value of the initialization loop check flag.

Definition at line 497 of file ServiceManager.cpp.

                                            {
  return m_loopCheck;
}

const std::string& ServiceManager::name ( ) const

inlineoverride

Return the name of the manager (implementation of INamedInterface)

Definition at line 119 of file ServiceManager.h.

                                         {
    static std::string _name = "ServiceManager";
    return _name;
  }

StatusCode ServiceManager::reinitialize ( )

override

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

Definition at line 351 of file ServiceManager.cpp.

{
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // which are already in the correct state.
  // only act on active services
  StatusCode sc(StatusCode::SUCCESS, true);
  // Re-Initialize all services
  for (auto& svc : activeSvc(m_listsvc)) {
    sc = svc->sysReinitialize();
    if( !sc.isSuccess() ) {
      error() << "Unable to re-initialize Service: " << svc->name() << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

StatusCode ServiceManager::removeService ( IService *  svc )

override

implementation of ISvcManager::removeService

Definition at line 215 of file ServiceManager.cpp.

{
  auto it = find(svc);
  if (it == m_listsvc.end()) return StatusCode(StatusCode::FAILURE,true);
  m_listsvc.erase(it);
  return StatusCode(StatusCode::SUCCESS,true);
}

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

override

implementation of ISvcManager::removeService

Definition at line 225 of file ServiceManager.cpp.

{
  auto it = find(name);
  if (it == m_listsvc.end()) return StatusCode::FAILURE;
  m_listsvc.erase(it);
  return StatusCode::SUCCESS;
}

StatusCode ServiceManager::restart ( )

override

Initialization (from RUNNING to RUNNING, via INITIALIZED).

Definition at line 372 of file ServiceManager.cpp.

{
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // which are already in the correct state.
  // only act on active services
  StatusCode sc(StatusCode::SUCCESS, true);
  // Re-Start all services
  for (auto& svc : activeSvc(m_listsvc)) {
    sc = svc->sysRestart();
    if( !sc.isSuccess() ) {
      error() << "Unable to re-start Service: " << svc->name() << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

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

override

Returns a smart pointer to a service.

Definition at line 158 of file ServiceManager.cpp.

                                                                                                        {
  const std::string &name = typeName.name();

  // Acquire the RAII lock to avoid simultaneous attempts from different threads to initialize a service
  std::lock_guard<std::recursive_mutex> lck(m_svcinitmutex);

  auto it = find(name);

  if (it !=  m_listsvc.end()) {
    if (m_loopCheck &&
        (createIf && it->service->FSMState() == Gaudi::StateMachine::CONFIGURED)) {
      error()
          << "Initialization loop detected when creating service \"" << name
          << "\""
          << endmsg;
      return no_service;
    }
    return it->service;
  }

  // Service not found. The user may be interested in one of the interfaces
  // of the application manager itself
  if( name == "ApplicationMgr" ||
      name == "APPMGR" ||
      name == "" ) {
    return m_appSvc;
  }

  //last resort: we try to create the service
  if ( createIf && addService(typeName).isSuccess()){
    return find(name)->service;
  }

  return no_service;
}

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 129 of file ServiceManager.h.

                                                                                                  {
    return SmartIF<T>{service(typeName, createIf)};
  }

SmartIF<ISvcLocator>& ServiceManager::serviceLocator ( ) const

inlineoverride

Function needed by CommonMessaging.

Definition at line 63 of file ServiceManager.h.

                                                               {
    return m_svcLocator;
  }

void ServiceManager::setLoopCheckEnabled ( bool  en )

override

Set the value of the initialization loop check flag.

Definition at line 503 of file ServiceManager.cpp.

                                                {
  m_loopCheck = en;
}

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

override

Definition at line 486 of file ServiceManager.cpp.

                                                           {
//------------------------------------------------------------------------------
  auto it = find(name);
  if (it == m_listsvc.end()) return StatusCode::FAILURE;
  it->priority = prio;
  return StatusCode::SUCCESS;
}

StatusCode ServiceManager::start ( )

override

Start (from INITIALIZED to RUNNING).

Definition at line 280 of file ServiceManager.cpp.

{
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // (which are already in the correct state.
  // only act on active services
  StatusCode sc(StatusCode::SUCCESS, true);
  // call initialize() for all services
  for (auto& it : activeSvc(m_listsvc)) {
    const std::string& name = it->name();
    switch (it->FSMState()) {
    case Gaudi::StateMachine::RUNNING:
      DEBMSG << "Service " << name
          << " already started" << endmsg;
      break;
    case Gaudi::StateMachine::INITIALIZED:
      DEBMSG << "Starting service " << name << endmsg;
      sc = it->sysStart();
      if( !sc.isSuccess() ) {
        error() << "Unable to start Service: " << name << endmsg;
        return sc;
      } break;
    default:
      error() << "Service " << name
          << " not in the correct state to be started ("
          << it->FSMState() << ")" << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

StatusCode ServiceManager::stop ( )

override

Stop (from RUNNING to INITIALIZED).

Definition at line 316 of file ServiceManager.cpp.

{
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // which are already in the correct state.
  // only act on active services

  StatusCode sc(StatusCode::SUCCESS, true);
  // call stop() for all services
  for (const auto& svc : reverse(activeSvc(m_listsvc))) {
    const std::string& name = svc->name();
    switch (svc->FSMState()) {
    case Gaudi::StateMachine::INITIALIZED:
      DEBMSG << "Service " << name << " already stopped" << endmsg;
      break;
    case Gaudi::StateMachine::RUNNING:
      DEBMSG << "Stopping service " << name << endmsg;
      sc = svc->sysStop();
      if( !sc.isSuccess() ) {
        error() << "Unable to stop Service: " << name << endmsg;
        return sc;
      } break;
    default:
      DEBMSG << "Service " << name
          << " not in the correct state to be stopped ("
          << svc->FSMState() << ")" << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

SmartIF<IService> ServiceManager::m_appSvc

private

Pointer to the application IService interface.

Definition at line 172 of file ServiceManager.h.

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

private

Definition at line 177 of file ServiceManager.h.

std::list<IService*> ServiceManager::m_listOfPtrs

mutableprivate

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

Definition at line 175 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 154 of file ServiceManager.h.

bool ServiceManager::m_loopCheck = true

private

Check for service initialization loops.

Definition at line 169 of file ServiceManager.h.

MapType ServiceManager::m_maptype

private

Map of service name and service type.

Definition at line 168 of file ServiceManager.h.

std::recursive_mutex ServiceManager::m_svcinitmutex

private

Mutex to synchronize shared service initialization between threads.

Definition at line 180 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