AlgTool.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 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.                                             *
\***********************************************************************************/
#ifndef GAUDIKERNEL_ALGTOOL_H
#define GAUDIKERNEL_ALGTOOL_H
// ============================================================================
// Include files
#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 <Gaudi/PluginService.h>
 
#include "GaudiKernel/DataHandle.h"
#include "GaudiKernel/DataHandleHolderBase.h"
#include "GaudiKernel/IDataHandleHolder.h"
 
template <class T>
class DataObjectHandle;
 
class ToolHandleInfo;
 
#include <list>
#include <vector>
 
// Forward declarations
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;
 
  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;
 
  [[deprecated( "not to be called explicitly, will be removed in v36r0" )]] StatusCode setProperties() {
    if ( !serviceLocator() ) return StatusCode::FAILURE;
    bindPropertiesTo( serviceLocator()->getOptsSvc() );
    return StatusCode::SUCCESS;
  }
 
  template <class T>
  StatusCode service( std::string_view name, T*& svc, bool createIf = true ) const {
    return service_i( name, createIf, T::interfaceID(), (void**)&svc );
  }
 
  template <class T>
  StatusCode service( std::string_view type, std::string_view name, T*& svc ) const {
    return service_i( type, name, T::interfaceID(), reinterpret_cast<void**>( &svc ) );
  }
 
  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, std::string toolTypeAndName, bool createIf = true ) {
 
    StatusCode sc = handle.initialize( toolTypeAndName, handle.isPublic() ? nullptr : this, createIf );
    if ( UNLIKELY( !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 ( 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;
    }
  }
 
  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_auditInit{this, "AuditTools", false, "[[deprecated]] unused"};
  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; 
 
  StatusCode service_i( std::string_view algName, bool createIf, const InterfaceID& iid, void** ppSvc ) const;
  StatusCode service_i( std::string_view svcType, std::string_view svcName, const InterfaceID& iid, void** ppS ) const;
 
  Gaudi::StateMachine::State m_state       = Gaudi::StateMachine::CONFIGURED; 
  Gaudi::StateMachine::State m_targetState = Gaudi::StateMachine::CONFIGURED; 
};
 
#endif // GAUDIKERNEL_ALGTOOL_H