AlgTool.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_ALGTOOL_H
#define GAUDIKERNEL_ALGTOOL_H
// ============================================================================
// Include files
#include "GaudiKernel/IAlgTool.h"
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/IService.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IToolSvc.h"
#include "GaudiKernel/PropertyMgr.h"
#include "GaudiKernel/IAuditorSvc.h"
#include "GaudiKernel/IMonitorSvc.h"
#include "GaudiKernel/IStateful.h"
#include <Gaudi/PluginService.h>
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/CommonMessaging.h"

#include "GaudiKernel/IDataHandleHolder.h"
#include "GaudiKernel/DataHandle.h"

template<class T>
class DataObjectHandle;

class ToolHandleInfo;

#include <vector>
#include <list>

// Forward declarations

class GAUDI_API AlgTool: public CommonMessaging<implements<IAlgTool,
                                                           IDataHandleHolder,
                                                           IProperty,
                                                           IStateful>> {
public:
#ifndef __REFLEX__
  typedef Gaudi::PluginService::Factory<IAlgTool*,
                                        const std::string&,
                                        const std::string&,
                                        const IInterface*> Factory;
#endif

  StatusCode queryInterface(const InterfaceID& riid, void** ppvUnknown) override;

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

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

  const IInterface*  parent() 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; }
  StatusCode reinitialize() override;
  StatusCode restart() override;
  Gaudi::StateMachine::State FSMState() const override { return m_state; }
  Gaudi::StateMachine::State targetFSMState() const override { return m_targetState; }

  StatusCode sysInitialize() override;

  StatusCode sysStart() override;

  StatusCode sysStop() override;

  StatusCode sysFinalize() override;

  StatusCode sysReinitialize() override;

  StatusCode sysRestart() override;

  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;

  inline PropertyMgr * getPropertyMgr() const { return m_propertyMgr; }

public:

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


  AlgTool( const std::string& type,
           const std::string& name,
           const IInterface* parent);

  SmartIF<ISvcLocator>& serviceLocator()  const override;

  ISvcLocator* svcLoc()  const { return serviceLocator() ; }

  IDataProviderSvc*    evtSvc    () const ;

  IToolSvc* toolSvc() const;

  StatusCode setProperties();

  template <class T>
  StatusCode service
  ( const std::string& name, T*& svc, bool createIf = true ) const {
    return service_i(name, createIf, T::interfaceID(), (void**)&svc);
  }

  template <class T>
  StatusCode service( const std::string& type, const std::string& name, T*& svc) const {
    return service_i(type, name, T::interfaceID(), (void**)&svc);
  }

  SmartIF<IService> service(const std::string& name, const bool createIf = true, const bool quiet = false) const;

  template <typename T>
  SmartIF<T> service(const std::string& name, const bool createIf = true, const bool quiet = false) const
  { return SmartIF<T>( service(name,createIf,quiet) ); }

protected:
  template <typename I>
  void declareInterface( I* i ) { m_interfaceList.emplace_back( I::interfaceID(), i ); }
public:
  // ==========================================================================
  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>
    
    Property* declareProperty(const std::string& name,
                              ToolHandle<T>& hndl,
                              const std::string& doc = "none" ) const {
    
    AlgTool* a = const_cast<AlgTool*>(this);
    a->declareTool(hndl).ignore();
    
    return m_propertyMgr->declareProperty(name, hndl, doc);
    
  }
  
  template<class T>
    StatusCode declareTool(ToolHandle<T> &handle,
                           std::string toolTypeAndName = "",
                           bool createIf = true) {
    if (handle.isPublic()) {
      return declarePublicTool(handle, toolTypeAndName, createIf);
    } else {
      return declarePrivateTool(handle, toolTypeAndName, createIf);
    }
  }

  // ==========================================================================
  // declare ToolHandleArrays to the AlgTool  
  template <class T>
    Property* declareProperty(const std::string& name,
                              ToolHandleArray<T>& hndlArr,
                              const std::string& doc = "none" ) const {
    m_toolHandleArrays.push_back( &hndlArr );    
    return m_propertyMgr->declareProperty(name, hndlArr, doc);
  }

 protected:
  virtual void declareInput(Gaudi::DataHandle* im) override {
    m_inputHandles.push_back(im);
  }

  virtual void declareOutput(Gaudi::DataHandle* im) override {
    m_outputHandles.push_back(im);
        }
 public:

  virtual std::vector<Gaudi::DataHandle*> inputHandles() const override {
    return m_inputHandles; }
  virtual std::vector<Gaudi::DataHandle*> outputHandles() const override {
    return m_outputHandles; }

  virtual const DataObjIDColl& extraInputDeps() const override {
    return m_extInputDataObjs;
  }
  virtual const DataObjIDColl& extraOutputDeps() const override {
    return m_extOutputDataObjs;
    }


  virtual void acceptDHVisitor(IDataHandleVisitor*) const override;

  DataObjIDColl inputDataObjs() const { return m_inputDataObjs; }
  DataObjIDColl outputDataObjs() const { return m_outputDataObjs; }

  void commitHandles() override;


 private:
  std::vector<Gaudi::DataHandle*> m_inputHandles, m_outputHandles;
  DataObjIDColl m_inputDataObjs, m_outputDataObjs;

  DataObjIDColl m_extInputDataObjs, m_extOutputDataObjs;

 public:



    void registerTool(IAlgTool * tool) const {
        if (UNLIKELY(msgLevel(MSG::DEBUG)))
          debug() << "Registering tool " << tool->name() << endmsg;
        m_tools.push_back(tool);
    }

    void deregisterTool(IAlgTool * tool) const {
        auto it = std::find(m_tools.begin(), m_tools.end(), tool);
        if (it != m_tools.end()) {
                if (UNLIKELY(msgLevel(MSG::DEBUG)))
              debug() << "De-Registering tool " << tool->name() << endmsg;
            m_tools.erase(it);
        } else {
                if (UNLIKELY(msgLevel(MSG::DEBUG)))
              debug() << "Could not de-register tool " << tool->name() << endmsg;
        }
    }

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

        if (toolTypeAndName == "")
      toolTypeAndName = handle.typeAndName();

        StatusCode sc = handle.initialize(toolTypeAndName, 0, createIf);
        if (UNLIKELY(!sc)) {
              throw GaudiException{"Cannot create handle for public tool " + toolTypeAndName,
                                   name(), sc};
        }

        m_toolHandles.push_back(&handle);

        return sc;
    }

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

        if (toolTypeAndName == "")
      toolTypeAndName = handle.typeAndName();

        StatusCode sc = handle.initialize(toolTypeAndName, this, createIf);
        if (UNLIKELY(!sc)) {
              throw GaudiException{"Cannot create handle for private tool " + toolTypeAndName,
                                   name(), sc};
        }

        m_toolHandles.push_back(&handle);

        return sc;
    }

    const std::vector<IAlgTool *> & tools() const;

protected:

      std::vector<IAlgTool *> & tools();

      std::unique_ptr<IDataHandleVisitor> m_updateDataHandles;

private:
   //place IAlgTools defined via ToolHandles in m_tools
   void initToolHandles() const;

public:

  // ==========================================================================
  IAuditorSvc* auditorSvc() const;

  inline IMonitorSvc* monitorSvc() const
  {
    // If not already located try to locate it without forcing a creation
    if ( !m_pMonitorSvc ) m_pMonitorSvc = service(m_monitorSvcName, false, true);
    return m_pMonitorSvc.get();
  }

  template <class T>
  void declareInfo( const std::string& name,
                    const T& var,
                    const std::string& desc ) const
  {
    IMonitorSvc* mS = monitorSvc();
    if ( mS ) mS->declareInfo(name, var, desc, this);
  }

  void declareInfo( const std::string& name,
                    const std::string& format,
                    const void* var,
                    int size,
                    const std::string& desc ) const
  {
    IMonitorSvc* mS = monitorSvc();
    if ( mS ) mS->declareInfo(name, format, var, size, desc, this);
  }

  // Standard destructor.
  ~AlgTool() override;

private:
  typedef std::list<std::pair<InterfaceID,void*> >  InterfaceList;
  IntegerProperty      m_outputLevel = MSG::NIL;      
  std::string          m_type;             
  const std::string    m_name;             
  const IInterface*    m_parent = nullptr;           
  mutable SmartIF<ISvcLocator> m_svcLocator ;       
  mutable SmartIF<IDataProviderSvc> m_evtSvc;      
  mutable SmartIF<IToolSvc> m_ptoolSvc;         
  mutable SmartIF<IMonitorSvc> m_pMonitorSvc;      
  std::string          m_monitorSvcName;   
 protected:
  SmartIF<PropertyMgr> m_propertyMgr;      
 private:
  InterfaceList        m_interfaceList;    
  std::string          m_threadID;         

  //tools used by tool
  mutable std::vector<IAlgTool *> m_tools;
  mutable std::vector<BaseToolHandle *> m_toolHandles;
  mutable std::vector<GaudiHandleArrayBase*> m_toolHandleArrays;
  mutable bool m_toolHandlesInit = false;  

  StatusCode service_i(const std::string& algName,
                       bool createIf,
                       const InterfaceID& iid,
                       void** ppSvc) const;
  StatusCode service_i(const std::string& svcType,
                       const std::string& svcName,
                       const InterfaceID& iid,
                       void** ppS) const;

  mutable SmartIF<IAuditorSvc> m_pAuditorSvc; 

  BooleanProperty m_auditInit = false;
  bool         m_auditorInitialize = false;
  bool         m_auditorStart = false;     
  bool         m_auditorStop = false;      
  bool         m_auditorFinalize = false;  
  bool         m_auditorReinitialize = false;
  bool         m_auditorRestart = false;     

  Gaudi::StateMachine::State m_state = Gaudi::StateMachine::CONFIGURED ;            
  Gaudi::StateMachine::State m_targetState = Gaudi::StateMachine::CONFIGURED ;      
};


#ifndef GAUDI_NEW_PLUGIN_SERVICE
template <class T>
struct ToolFactory {
  template <typename S, typename... Args>
  static typename S::ReturnType create(Args&&... args) {
    return new T(std::forward<Args>(args)...);
  }
};

// Macros to declare component factories
#define DECLARE_TOOL_FACTORY(x) \
  DECLARE_FACTORY_WITH_CREATOR(x, ToolFactory< x >, AlgTool::Factory)
#define DECLARE_NAMESPACE_TOOL_FACTORY(n, x) \
    DECLARE_TOOL_FACTORY(n::x)

#else

// Macros to declare component factories
#define DECLARE_TOOL_FACTORY(x)              DECLARE_COMPONENT(x)
#define DECLARE_NAMESPACE_TOOL_FACTORY(n,x)  DECLARE_COMPONENT(n::x)

#endif


#endif // GAUDIKERNEL_ALGTOOL_H