Service.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_SERVICE_H
#define GAUDIKERNEL_SERVICE_H
// ============================================================================
// Include files
// ============================================================================
#include "GaudiKernel/IService.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/ServiceLocatorHelper.h"
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/IStateful.h"
#include "GaudiKernel/PropertyMgr.h"
#include "GaudiKernel/Property.h"
#include "GaudiKernel/IAuditorSvc.h"
#include "GaudiKernel/CommonMessaging.h"
#include "GaudiKernel/SmartIF.h"
#include <Gaudi/PluginService.h>
// ============================================================================
#include <vector>
// ============================================================================
// Forward declarations
// ============================================================================
class IMessageSvc;
class ISvcManager;
class ServiceManager;
// ============================================================================
class GAUDI_API Service: public CommonMessaging<implements3<IService, IProperty, IStateful> > {
public:
#ifndef __REFLEX__
  typedef Gaudi::PluginService::Factory<IService*,
                                        const std::string&,
                                        ISvcLocator*> Factory;
#endif
  friend class ServiceManager;

  virtual unsigned long release();

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

  // State machine implementation
  virtual StatusCode configure() { return StatusCode::SUCCESS; }
  virtual StatusCode initialize();
  virtual StatusCode start();
  virtual StatusCode stop();
  virtual StatusCode finalize();
  virtual StatusCode terminate() { return StatusCode::SUCCESS; }
  virtual Gaudi::StateMachine::State FSMState() const { return m_state; }
  virtual Gaudi::StateMachine::State targetFSMState() const { return m_targetState; }
  virtual StatusCode reinitialize();
  virtual StatusCode restart();

  virtual StatusCode sysInitialize();
  virtual StatusCode sysStart();
  virtual StatusCode sysStop();
  virtual StatusCode sysFinalize();
  virtual StatusCode sysReinitialize();
  virtual StatusCode sysRestart();

  // Default implementations for ISetProperty
  virtual StatusCode setProperty(const Property& p);
  virtual StatusCode setProperty( const std::string& s );
  virtual StatusCode setProperty( const std::string& n, const std::string& v);
  virtual StatusCode getProperty(Property* p) const;
  virtual const Property& getProperty( const std::string& name) const;
  virtual StatusCode getProperty( const std::string& n, std::string& v ) const;
  virtual const std::vector<Property*>& getProperties( ) const;
  virtual bool hasProperty(const std::string& name) const;

  template <class TYPE>
  StatusCode setProperty
  ( const std::string& name  ,
    const TYPE&        value )
  { return Gaudi::Utils::setProperty ( m_propertyMgr , name , value ) ; }

  Service( const std::string& name, ISvcLocator* svcloc);
  SmartIF<ISvcLocator>& serviceLocator() const;

  StatusCode setProperties();

  template <class T>
  StatusCode service( const std::string& name, const T*& psvc, bool createIf = true ) const {
    ISvcLocator& svcLoc = *serviceLocator();
    SmartIF<T> ptr(
      ServiceLocatorHelper(svcLoc, *this).service(name, !createIf, // quiet
                                                  createIf));
    if (ptr.isValid()) {
      psvc = ptr.get();
      const_cast<T*>(psvc)->addRef();
      return StatusCode::SUCCESS;
    }
    // else
    psvc = 0;
    return StatusCode::FAILURE;
  }

  template <class T>
  StatusCode service( const std::string& name, T*& psvc, bool createIf = true ) const {
    ISvcLocator& svcLoc = *serviceLocator();
    SmartIF<T> ptr(
      ServiceLocatorHelper(svcLoc, *this).service(name, !createIf, // quiet
                                                  createIf));
    if (ptr.isValid()) {
      psvc = ptr.get();
      psvc->addRef();
      return StatusCode::SUCCESS;
    }
    // else
    psvc = 0;
    return StatusCode::FAILURE;
  }

  template <class T>
  StatusCode service( const std::string& svcType, const std::string& svcName,
              T*& psvc) const {
    return service(svcType + "/" + svcName, psvc);
  }
  // ==========================================================================
  template <class T>
  Property* declareProperty
  ( const std::string& name              ,
    T&                 property          ,
    const std::string& doc      = "none" ) const
  {
    return m_propertyMgr -> declareProperty ( name , property , doc ) ;
  }
  // ==========================================================================
  Property* declareRemoteProperty
  ( const std::string& name       ,
    IProperty*         rsvc       ,
    const std::string& rname = "" ) const
  {
    return m_propertyMgr -> declareRemoteProperty ( name , rsvc , rname ) ;
  }
  // ==========================================================================
  SmartIF<IAuditorSvc>& auditorSvc() const;

protected:
  virtual ~Service();
  IntegerProperty m_outputLevel;
  Gaudi::StateMachine::State    m_state;
  Gaudi::StateMachine::State    m_targetState;

  int  outputLevel() const { return m_outputLevel.value(); }

private:
  std::string   m_name;
  mutable SmartIF<ISvcLocator> m_svcLocator;
  SmartIF<ISvcManager>  m_svcManager;
  PropertyMgr*  m_propertyMgr;

  void setServiceManager(ISvcManager* ism);

  mutable SmartIF<IAuditorSvc>  m_pAuditorSvc;
  BooleanProperty       m_auditInit;
  bool                  m_auditorInitialize;
  bool                  m_auditorStart;
  bool                  m_auditorStop;
  bool                  m_auditorFinalize;
  bool                  m_auditorReinitialize;
  bool                  m_auditorRestart;

  void initOutputLevel(Property& prop);
};

#ifndef GAUDI_NEW_PLUGIN_SERVICE
template <class T>
class SvcFactory {
public:
#ifndef __REFLEX__
  template <typename S, typename... Args>
  static typename S::ReturnType create(Args... args) {
    return new T(args...);
  }
#endif
};

// Macros to declare component factories
#define DECLARE_SERVICE_FACTORY(x) \
  DECLARE_FACTORY_WITH_CREATOR(x, SvcFactory< x >, Service::Factory)
#define DECLARE_NAMED_SERVICE_FACTORY(x, n) \
  DECLARE_FACTORY_WITH_CREATOR_AND_ID(x, SvcFactory< x >, #n, Service::Factory)
#define DECLARE_NAMESPACE_SERVICE_FACTORY(n, x) \
  DECLARE_SERVICE_FACTORY(n::x)

#else

// macros to declare factories
#define DECLARE_SERVICE_FACTORY(x)              DECLARE_COMPONENT(x)
#define DECLARE_NAMED_SERVICE_FACTORY(x, n)     DECLARE_COMPONENT_WITH_ID(x, #n)
#define DECLARE_NAMESPACE_SERVICE_FACTORY(n, x) DECLARE_COMPONENT(n::x)

#endif

#endif // GAUDIKERNEL_SERVICE_H