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 "GaudiKernel/ToolHandle.h"

// ============================================================================
#include <vector>
#include <mutex>
// ============================================================================
// Forward declarations
// ============================================================================
class IMessageSvc;
class ISvcManager;
class ServiceManager;
// ============================================================================
class GAUDI_API Service: public CommonMessaging<implements<IService,
                                                           IProperty,
                                                           IStateful> > {
public:
#ifndef __REFLEX__
  typedef Gaudi::PluginService::Factory<IService*,
                                        const std::string&,
                                        ISvcLocator*> Factory;
#endif
  friend class ServiceManager;

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

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

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

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

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

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

  StatusCode setProperties();

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

  template <class T>
  StatusCode service( const std::string& name, T*& psvc, bool createIf = true ) const {
    auto  ptr = service<T>(name,createIf);
    psvc = ( ptr ? ptr.get() : nullptr );
    if (psvc) {
      psvc->addRef();
      return StatusCode::SUCCESS;
    }
    return StatusCode::FAILURE;
  }

  template <typename IFace = IService>
  SmartIF<IFace> service(const std::string& name, bool createIf = true) const {
    return ServiceLocatorHelper(*serviceLocator(), *this).
                               service<IFace>(name, !createIf, // quiet
                                              createIf);
  }

  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 ) ;
  }

    template<class T>
    StatusCode declarePrivateTool(ToolHandle<T> & handle, std::string toolTypeAndName =
            "", bool createIf = true) {

        if (toolTypeAndName == "")
            toolTypeAndName = System::typeinfoName(typeid(T));

        StatusCode sc = handle.initialize(toolTypeAndName, this, createIf);

        if (sc.isSuccess()) {
                  if (UNLIKELY(msgLevel(MSG::DEBUG)))
            debug() << "Handle for private tool" << toolTypeAndName
                    << " successfully created and stored." << endmsg;
        } else {

            error() << "Handle for private tool" << toolTypeAndName
                    << " could not be created." << endmsg;
        }

        return sc;

    }

    template<class T>
    StatusCode declarePublicTool(ToolHandle<T> & handle, std::string toolTypeAndName =
            "", bool createIf = true) {

        if (toolTypeAndName == "")
            toolTypeAndName = System::typeinfoName(typeid(T));

        StatusCode sc = handle.initialize(toolTypeAndName, 0, createIf);


        if (sc.isSuccess()) {
                  if (UNLIKELY(msgLevel(MSG::DEBUG)))
            debug() << "Handle for public tool" << toolTypeAndName
                    << " successfully created and stored." << endmsg;
        } else {

            error() << "Handle for public tool" << toolTypeAndName
                    << " could not be created." << endmsg;
        }

        return sc;

    }

  // ==========================================================================
  SmartIF<IAuditorSvc>& auditorSvc() const;

protected:
  ~Service() override;
  IntegerProperty m_outputLevel = MSG::NIL;
  Gaudi::StateMachine::State    m_state = Gaudi::StateMachine::OFFLINE;
  Gaudi::StateMachine::State    m_targetState = Gaudi::StateMachine::OFFLINE;

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

private:

  void sysInitialize_imp();
  StatusCode m_initSC;
  std::once_flag m_initFlag;

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

  void setServiceManager(ISvcManager* ism) override;

  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(std::forward<Args>(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