ServiceManager.h

Go to the documentation of this file.

#ifndef GAUDISVC_ServiceManager_H
#define GAUDISVC_ServiceManager_H

// Include files
#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 "boost/thread.hpp"
#include <algorithm>
#include <list>
#include <memory>
#include <string>
#include <vector>

// Forward declarations
class IService;
class IMessageSvc;

class ServiceManager : public extends<ComponentManager, ISvcManager, ISvcLocator>
{
public:
  struct ServiceItem final {
    ServiceItem( IService* s, long p = 0, bool act = false ) : service( s ), priority( p ), active( act ) {}
    SmartIF<IService> service;
    long priority;
    bool active;
    inline bool operator==( const std::string& name ) const { return service->name() == name; }
    inline bool operator==( const IService* ptr ) const { return service.get() == ptr; }
    inline bool operator<( const ServiceItem& rhs ) const { return priority < rhs.priority; }
  };

  // typedefs and classes
  typedef std::list<ServiceItem> ListSvc;
  typedef GaudiUtils::Map<std::string, std::string> MapType;

  ServiceManager( IInterface* application );

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

  ~ServiceManager() override;

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

  bool existsService( const std::string& 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( const std::string& name ) override;

  StatusCode declareSvcType( const std::string& svcname, const 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( const std::string& name ) const override;
  StatusCode setPriority( const std::string& 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 )};
  }

#if !defined( GAUDI_V22_API ) || defined( G22_NEW_SVCLOCATOR )
  using ISvcManager::createService;
  using ISvcManager::addService;
#endif

  void outputLevelUpdate() override;

private:
  inline ListSvc::iterator find( const std::string& name )
  {
    boost::lock_guard<boost::recursive_mutex> lck( m_gLock );
    return std::find( m_listsvc.begin(), m_listsvc.end(), name );
  }
  inline ListSvc::const_iterator find( const std::string& name ) const
  {
    boost::lock_guard<boost::recursive_mutex> lck( m_gLock );
    return std::find( m_listsvc.begin(), m_listsvc.end(), name );
  }
  inline ListSvc::iterator find( const IService* ptr )
  {
    boost::lock_guard<boost::recursive_mutex> lck( m_gLock );
    return std::find( m_listsvc.begin(), m_listsvc.end(), ptr );
  }
  inline ListSvc::const_iterator find( const IService* ptr ) const
  {
    boost::lock_guard<boost::recursive_mutex> lck( 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;

  typedef boost::recursive_mutex Mutex_t;
  typedef boost::lock_guard<Mutex_t> LockGuard_t;

  mutable Mutex_t m_gLock;
  mutable std::map<std::string, std::unique_ptr<Mutex_t>> m_lockMap;

private:
  void dump() const;
};
#endif // GAUDISVC_ServiceManager_H