AlgTool.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <Gaudi/PluginService.h>
#include <GaudiKernel/CommonMessaging.h>
#include <GaudiKernel/DataObjID.h>
#include <GaudiKernel/IAlgTool.h>
#include <GaudiKernel/IAuditorSvc.h>
#include <GaudiKernel/IDataProviderSvc.h>
#include <GaudiKernel/IMessageSvc.h>
#include <GaudiKernel/IMonitorSvc.h>
#include <GaudiKernel/IProperty.h>
#include <GaudiKernel/IService.h>
#include <GaudiKernel/IStateful.h>
#include <GaudiKernel/ISvcLocator.h>
#include <GaudiKernel/IToolSvc.h>
#include <GaudiKernel/PropertyHolder.h>
#include <GaudiKernel/ToolHandle.h>
 
#include <GaudiKernel/DataHandle.h>
#include <GaudiKernel/DataHandleHolderBase.h>
#include <GaudiKernel/IDataHandleHolder.h>
#include <list>
#include <vector>
 
template <class T>
class DataObjectHandle;
class ToolHandleInfo;
class ToolSvc;
class ToolVisitor;

class GAUDI_API AlgTool
    : public DataHandleHolderBase<
          PropertyHolder<CommonMessaging<implements<IAlgTool, IDataHandleHolder, IProperty, IStateful>>>> {
  friend ToolSvc;
  friend class ToolVisitor;
 
public:
  using Factory = Gaudi::PluginService::Factory<IAlgTool*( const std::string&, const std::string&, const IInterface* )>;

  StatusCode  queryInterface( const InterfaceID& riid, void** ppvUnknown ) override;
  void const* i_cast( const InterfaceID& riid ) const 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;
 
public:
  AlgTool( std::string type, std::string name, const IInterface* parent );

  SmartIF<ISvcLocator>& serviceLocator() const override;

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

  IDataProviderSvc* evtSvc() const;

  IToolSvc* toolSvc() const;

  SmartIF<IService> service( std::string_view name, const bool createIf = true, const bool quiet = false ) const;
 
  template <typename T>
  SmartIF<T> service( std::string_view 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:
  using PropertyHolderImpl::declareProperty;
 
  template <class T>
  Gaudi::Details::PropertyBase* declareProperty( const std::string& name, ToolHandle<T>& hndl,
                                                 const std::string& doc = "none" ) {
    this->declareTool( hndl, hndl.typeAndName() ).ignore();
    return PropertyHolderImpl::declareProperty( name, hndl, doc );
  }
 
  template <class T>
  StatusCode declareTool( ToolHandle<T>& handle, bool createIf = true ) {
    return this->declareTool( handle, handle.typeAndName(), createIf );
  }
 
  template <class T>
  StatusCode declareTool( ToolHandle<T>& handle, const std::string& toolTypeAndName, bool createIf = true ) {
 
    StatusCode sc = handle.initialize( toolTypeAndName, handle.isPublic() ? nullptr : this, createIf );
    if ( !sc ) {
      throw GaudiException{ std::string{ "Cannot create handle for " } + ( handle.isPublic() ? "public" : "private" ) +
                                " tool " + toolTypeAndName,
                            name(), sc };
    }
 
    m_toolHandles.push_back( &handle );
 
    return sc;
  }
 
  // declare ToolHandleArrays to the AlgTool
  template <class T>
  Gaudi::Details::PropertyBase* declareProperty( const std::string& name, ToolHandleArray<T>& hndlArr,
                                                 const std::string& doc = "none" ) {
    addToolsArray( hndlArr );
    return PropertyHolderImpl::declareProperty( name, hndlArr, doc );
  }
 
  template <class T>
  void addToolsArray( ToolHandleArray<T>& hndlArr ) {
    m_toolHandleArrays.push_back( &hndlArr );
  }
 
public:
  void acceptDHVisitor( IDataHandleVisitor* ) const override;
 
public:
  void registerTool( IAlgTool* tool ) const {
    if ( 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 ( msgLevel( MSG::DEBUG ) ) debug() << "De-Registering tool " << tool->name() << endmsg;
      m_tools.erase( it );
    } else {
      if ( msgLevel( MSG::DEBUG ) ) debug() << "Could not de-register tool " << tool->name() << endmsg;
    }
  }
 
  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;
 
  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; 
  mutable SmartIF<IAuditorSvc>      m_pAuditorSvc; 
 
  InterfaceList m_interfaceList; 
 
  // Properties
  // initialize output level from MessageSvc and initialize messaging (before enabling update handler)
  Gaudi::Property<int> m_outputLevel{
      this, "OutputLevel", setUpMessaging(),
      [this]( Gaudi::Details::PropertyBase& ) { this->updateMsgStreamOutputLevel( this->m_outputLevel ); },
      "output level" };
 
  Gaudi::Property<std::string> m_monitorSvcName{ this, "MonitorService", "MonitorSvc",
                                                 "name to use for Monitor Service" };
 
  Gaudi::Property<bool> m_auditorInitialize{ this, "AuditInitialize", false, "trigger auditor on initialize()" };
  Gaudi::Property<bool> m_auditorStart{ this, "AuditStart", false, "trigger auditor on start()" };
  Gaudi::Property<bool> m_auditorStop{ this, "AuditStop", false, "trigger auditor on stop()" };
  Gaudi::Property<bool> m_auditorFinalize{ this, "AuditFinalize", false, "trigger auditor on finalize()" };
  Gaudi::Property<bool> m_auditorReinitialize{ this, "AuditReinitialize", false, "trigger auditor on reinitialize()" };
  Gaudi::Property<bool> m_auditorRestart{ this, "AuditRestart", false, "trigger auditor on restart()" };
 
  // 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; 
 
  Gaudi::StateMachine::State m_state       = Gaudi::StateMachine::CONFIGURED; 
  Gaudi::StateMachine::State m_targetState = Gaudi::StateMachine::CONFIGURED; 
};