ISvcManager.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_ISVCMANAGER_H
#define GAUDIKERNEL_ISVCMANAGER_H

// Include files
#include "GaudiKernel/IComponentManager.h"
#include "GaudiKernel/SmartIF.h"
#include "GaudiKernel/TypeNameString.h"
#include <string>

// Forward class declaration
#if defined(GAUDI_V20_COMPAT) || (!defined(GAUDI_V22_API) || defined(G22_NEW_SVCLOCATOR))
class ISvcFactory;
#include "GaudiKernel/IService.h"
#else
class IService;
#endif
class ISvcLocator;

class GAUDI_API ISvcManager: virtual public IComponentManager {
public:
  DeclareInterfaceID(ISvcManager,4,0);

  static const int DEFAULT_SVC_PRIORITY = 100;

  virtual StatusCode addService( IService* svc, int prio = DEFAULT_SVC_PRIORITY) = 0;

#if !defined(GAUDI_V22_API) || defined(G22_NEW_SVCLOCATOR)

  virtual StatusCode addService( const std::string& typ, const std::string& nam, int prio ){
    return addService(Gaudi::Utils::TypeNameString(nam,typ), prio);
  }
#endif

  virtual StatusCode addService( const Gaudi::Utils::TypeNameString& nametype, int prio = DEFAULT_SVC_PRIORITY) = 0;

  virtual StatusCode removeService( IService* svc ) = 0;

  virtual StatusCode removeService( const std::string& nam ) = 0;

#if !defined(GAUDI_V22_API) || defined(G22_NEW_SVCLOCATOR)

  virtual StatusCode declareSvcFactory( const ISvcFactory& /*factory*/,
                                        const std::string& /*svctype*/ ) {
    // This function is never used.
    return StatusCode::FAILURE;
  }
#endif

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

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

#if !defined(GAUDI_V22_API) || defined(G22_NEW_SVCLOCATOR)

  virtual StatusCode createService( const std::string& svctype,
                                    const std::string& svcname,
                                    IService*& svc ){
    SmartIF<IService> s = createService(svctype + "/" + svcname);
    svc = s.get();
    if (svc) {
      svc->addRef(); // Needed to maintain the correct reference counting.
      return StatusCode::SUCCESS;
    }
    return StatusCode::FAILURE;
  }

  virtual StatusCode getFactory(    const std::string& /*svc_type*/,
                                    const ISvcFactory*& /*fac*/) const {
    // This function is never used.
    return StatusCode::FAILURE;
  }

  virtual StatusCode initializeServices() { return initialize(); }

  virtual StatusCode startServices() { return start(); }

  virtual StatusCode stopServices() { return stop(); }

  virtual StatusCode finalizeServices() { return finalize(); }

  virtual StatusCode reinitializeServices() { return reinitialize(); }

  virtual StatusCode restartServices() { return restart(); }
#endif

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

  virtual bool loopCheckEnabled() const = 0;
  virtual void setLoopCheckEnabled(bool en = true) = 0;

};

#endif  // GAUDIKERNEL_ISVCMANAGER_H