ServiceManager.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/ComponentManager.h>
#include <GaudiKernel/IStateful.h>
#include <GaudiKernel/ISvcLocator.h>
#include <GaudiKernel/ISvcManager.h>
#include <GaudiKernel/Kernel.h>
#include <GaudiKernel/Map.h>
#include <GaudiKernel/SmartIF.h>
#include <algorithm>
#include <list>
#include <mutex>
#include <string>
 
class IService;
class IMessageSvc;

class ServiceManager : public extends<ComponentManager, ISvcManager, ISvcLocator> {
public:
  struct ServiceItem final {
    ServiceItem( IService* s, int p = 0, bool act = false ) : service( s ), priority( p ), active( act ) {}
    SmartIF<IService> service;
    int               priority;
    bool              active;
    bool              operator==( std::string_view name ) const { return service->name() == name; }
    bool              operator==( const IService* ptr ) const { return service.get() == ptr; }
    bool              operator<( const ServiceItem& rhs ) const { return priority < rhs.priority; }
  };
 
  // typedefs and classes
  typedef std::list<ServiceItem>                          ListSvc;
  typedef std::map<std::string, std::string, std::less<>> MapType;

  ServiceManager( IInterface* application );

  inline SmartIF<ISvcLocator>& serviceLocator() const override { return m_svcLocator; }

  ~ServiceManager() override;

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

  bool existsService( std::string_view name ) const override;

  StatusCode addService( IService* svc, int prio = DEFAULT_SVC_PRIORITY ) override;
  StatusCode addService( const Gaudi::Utils::TypeNameString& typeName, int prio = DEFAULT_SVC_PRIORITY ) override;
  StatusCode removeService( IService* svc ) override;
  StatusCode removeService( std::string_view name ) override;

  StatusCode declareSvcType( std::string svcname, std::string svctype ) override;

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

  StatusCode initialize() override;
  StatusCode start() override;
  StatusCode stop() override;
  StatusCode finalize() override;

  StatusCode reinitialize() override;
  StatusCode restart() override;

  int        getPriority( std::string_view name ) const override;
  StatusCode setPriority( std::string_view name, int pri ) override;

  bool loopCheckEnabled() const override;
  void setLoopCheckEnabled( bool en ) override;

  const std::string& name() const override {
    static std::string _name = "ServiceManager";
    return _name;
  }

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

  template <typename T>
  inline SmartIF<T> service( const Gaudi::Utils::TypeNameString& typeName, const bool createIf = true ) {
    return SmartIF<T>{ service( typeName, createIf ) };
  }

  void outputLevelUpdate() override;
 
private:
  ListSvc::iterator find( std::string_view name ) {
    auto lck = std::scoped_lock{ m_gLock };
    return std::find( m_listsvc.begin(), m_listsvc.end(), name );
  }
  ListSvc::const_iterator find( std::string_view name ) const {
    auto lck = std::scoped_lock{ m_gLock };
    return std::find( m_listsvc.begin(), m_listsvc.end(), name );
  }
  ListSvc::iterator find( const IService* ptr ) {
    auto lck = std::scoped_lock{ m_gLock };
    return std::find( m_listsvc.begin(), m_listsvc.end(), ptr );
  }
  ListSvc::const_iterator find( const IService* ptr ) const {
    auto lck = std::scoped_lock{ m_gLock };
    return std::find( m_listsvc.begin(), m_listsvc.end(), ptr );
  }
 
private:
  ListSvc m_listsvc;          
  MapType m_maptype;          
  bool    m_loopCheck = true; 

  SmartIF<IService> m_appSvc;

  mutable std::list<IService*> m_listOfPtrs;
 
  GaudiUtils::Map<InterfaceID, SmartIF<IInterface>> m_defaultImplementations;

  mutable std::recursive_mutex                        m_gLock;
  mutable std::map<std::string, std::recursive_mutex> m_lockMap;
 
private:
  void dump() const;
};