ServiceManager.h

Go to the documentation of this file.

// $Id: ServiceManager.h,v 1.9 2008/11/10 15:29:09 marcocle Exp $
#ifndef GAUDISVC_ServiceManager_H
#define GAUDISVC_ServiceManager_H

// Include files
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/ISvcManager.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IStateful.h"
#include "GaudiKernel/SmartIF.h"
#include "GaudiKernel/ComponentManager.h"
#include "GaudiKernel/Map.h"
#include <string>
#include <list>
#include <map>
#include <algorithm>
#include "boost/thread.hpp"

// Forward declarations
class IService;
class ISvcFactory;
class IMessageSvc;
class Property;

class ServiceManager : public extends2<ComponentManager, ISvcManager, ISvcLocator>{
public:

  struct ServiceItem {
    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 {
    return m_svcLocator;
  }

  virtual ~ServiceManager();

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

  virtual bool existsService(const std::string& name) const;

  virtual StatusCode addService(IService* svc, int prio = 10);
  virtual StatusCode addService(const Gaudi::Utils::TypeNameString& typeName, int prio = 10);
  virtual StatusCode removeService(IService* svc);
  virtual StatusCode removeService(const std::string& name);

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

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

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

  virtual StatusCode reinitialize();
  virtual StatusCode restart();

  virtual int getPriority(const std::string& name) const;
  virtual StatusCode setPriority(const std::string& name, int pri);

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

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

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

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

private:

  inline ListSvc::iterator find(const std::string &name) {
    return std::find(m_listsvc.begin(), m_listsvc.end(), name);
  }
  inline ListSvc::const_iterator find(const std::string &name) const {
    return std::find(m_listsvc.begin(), m_listsvc.end(), name);
  }
  inline ListSvc::iterator find(const IService *ptr) {
    return std::find(m_listsvc.begin(), m_listsvc.end(), ptr);
  }
  inline ListSvc::const_iterator find(const IService *ptr) const {
    return std::find(m_listsvc.begin(), m_listsvc.end(), ptr);
  }

private:
  ListSvc       m_listsvc;     
  MapType       m_maptype;     
  bool          m_loopCheck;   

  SmartIF<IService> m_appSvc;

  mutable std::list<IService*> m_listOfPtrs;

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

  boost::recursive_mutex  m_svcinitmutex;
};
#endif  // GAUDISVC_ServiceManager_H