AlgTool.h

Go to the documentation of this file.

#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 GAUDI_API AlgTool
    : public DataHandleHolderBase<
          PropertyHolder<CommonMessaging<implements<IAlgTool, IDataHandleHolder, IProperty, IStateful>>>>
{
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( const std::string& type, const std::string& name, const IInterface* parent );

  SmartIF<ISvcLocator>& serviceLocator() const override;

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

  IDataProviderSvc* evtSvc() const { return eventSvc().get(); }
  SmartIF<IDataProviderSvc>& eventSvc() const final override;

  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(), reinterpret_cast<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:
  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 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();

  DataObjIDMapping m_updateDependencies;

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

  // Set up uninitialized circular dependency handling for a certain tool
  void addUninitializedTool( AlgTool* tool );

  // Forward uninitialized circular dependencies from another tool
  void propagateUninitializedTools( AlgTool* tool );

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]( auto& ) { 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; 

  // Handling of circular tool dependencies during initialization
  std::unordered_set<AlgTool*> m_uninitializedTools;
  std::unordered_set<AlgTool*> m_toolsAwaitingInit;

  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;

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

#endif // GAUDIKERNEL_ALGTOOL_H