include/Gaudi/Algorithm.h

0001 /***********************************************************************************\
0002 * (c) Copyright 1998-2024 CERN for the benefit of the LHCb and ATLAS collaborations *
0003 *                                                                                   *
0004 * This software is distributed under the terms of the Apache version 2 licence,     *
0005 * copied verbatim in the file "LICENSE".                                            *
0006 *                                                                                   *
0007 * In applying this licence, CERN does not waive the privileges and immunities       *
0008 * granted to it by virtue of its status as an Intergovernmental Organization        *
0009 * or submit itself to any jurisdiction.                                             *
0010 \***********************************************************************************/
0011 #pragma once
0012 // ============================================================================
0013 // Include files
0014 // ============================================================================
0015 #include <GaudiKernel/IAlgorithm.h>
0016 #include <GaudiKernel/IMessageSvc.h>
0017 #include <GaudiKernel/IProperty.h>
0018 #include <GaudiKernel/IService.h>
0019 #include <GaudiKernel/IStateful.h>
0020 #include <GaudiKernel/ISvcLocator.h>
0021 #include <GaudiKernel/ITimelineSvc.h>
0022
0023 #include <string>
0024 #include <vector>
0025
0026 // Extra include files (forward declarations should be sufficient)
0027 #include <Gaudi/PluginService.h>
0028 #include <Gaudi/Property.h>
0029 #include <GaudiKernel/CommonMessaging.h>
0030 #include <GaudiKernel/DataObjID.h> // must be include before Property.h, which is included in PropertyHolder.h
0031 #include <GaudiKernel/IAlgContextSvc.h>
0032 #include <GaudiKernel/IAuditorSvc.h>
0033 #include <GaudiKernel/IChronoStatSvc.h>
0034 #include <GaudiKernel/IConversionSvc.h>
0035 #include <GaudiKernel/IDataProviderSvc.h>
0036 #include <GaudiKernel/IExceptionSvc.h>
0037 #include <GaudiKernel/IHistogramSvc.h>
0038 #include <GaudiKernel/IHiveWhiteBoard.h>
0039 #include <GaudiKernel/IMonitorSvc.h>
0040 #include <GaudiKernel/INTupleSvc.h>
0041 #include <GaudiKernel/IRndmGenSvc.h>
0042 #include <GaudiKernel/IToolSvc.h>
0043 #include <GaudiKernel/PropertyHolder.h>
0044 #include <GaudiKernel/System.h>
0045 #include <GaudiKernel/ToolHandle.h>
0046
0047 // For concurrency
0048 #include <GaudiKernel/DataHandle.h>
0049 #include <GaudiKernel/DataHandleHolderBase.h>
0050 #include <GaudiKernel/EventContext.h>
0051 #include <GaudiKernel/IAlgExecStateSvc.h>
0052
0053 class IAlgTool;
0054 class ToolHandleInfo;
0055 class AlgorithmManager;
0056
0057 #ifndef PACKAGE_VERSION
0058 #  define PACKAGE_VERSION "unknown"
0059 #endif
0060 namespace Gaudi {
0061   namespace Details {
0062     bool getDefaultAuditorValue( ISvcLocator* loc );
0063   }
0064
0065   /** Base class from which all concrete algorithm classes should
0066    *  be derived.
0067    *
0068    *  In order for a concrete algorithm class to do anything
0069    *  useful the methods initialize(), execute() and finalize()
0070    *  should be overridden.
0071    *
0072    *  The base class provides utility methods for accessing
0073    *  standard services (event data service etc.); for declaring
0074    *  properties which may be configured by the job options
0075    *  service; and for creating sub algorithms.
0076    *  The only base class functionality which may be used in the
0077    *  constructor of a concrete algorithm is the declaration of
0078    *  member variables as properties. All other functionality,
0079    *  i.e. the use of services and the creation of sub-algorithms,
0080    *  may be used only in initialize() and afterwards (see the
0081    *  Gaudi user guide).
0082    *
0083    *  @author Paul Maley
0084    *  @author Pere Mato
0085    *  @author David Quarrie
0086    *  @date   1998
0087    */
0088   class GAUDI_API Algorithm
0089       : public DataHandleHolderBase<
0090             PropertyHolder<CommonMessaging<implements<IAlgorithm, IDataHandleHolder, IProperty, IStateful>>>> {
0091   public:
0092 #ifndef __REFLEX__
0093     typedef Gaudi::PluginService::Factory<IAlgorithm*( const std::string&, ISvcLocator* )> Factory;
0094 #endif
0095     friend AlgorithmManager;
0096
0097     /** Constructor
0098      *  @param name    The algorithm object's name
0099      *  @param svcloc  A pointer to a service location service
0100      */
0101     Algorithm( std::string name, ISvcLocator* svcloc, std::string version = PACKAGE_VERSION )
0102         : m_name( std::move( name ) )
0103         , m_version( std::move( version ) ) // incremented by AlgResourcePool
0104         , m_pSvcLocator( svcloc ) {}
0105
0106     /** Reinitialization method invoked by the framework. This method is responsible
0107      *  for any reinitialization required by the framework itself.
0108      *  It will in turn invoke the reinitialize() method of the derived algorithm,
0109      * and of any sub-algorithms which it creates.
0110      */
0111     StatusCode sysStart() override;
0112
0113     /** Initialization method invoked by the framework. This method is responsible
0114      *  for any bookkeeping of initialization required by the framework itself.
0115      *  It will in turn invoke the initialize() method of the derived algorithm,
0116      * and of any sub-algorithms which it creates.
0117      */
0118     StatusCode sysInitialize() override;
0119
0120     /** Reinitialization method invoked by the framework. This method is responsible
0121      *  for any reinitialization required by the framework itself.
0122      *  It will in turn invoke the reinitialize() method of the derived algorithm,
0123      * and of any sub-algorithms which it creates.
0124      */
0125     StatusCode sysReinitialize() override;
0126
0127     /** Restart method invoked by the framework.
0128         It will in turn invoke the restart() method of the derived algorithm,
0129         and of any sub-algorithms which it creates.
0130     */
0131     StatusCode sysRestart() override;
0132
0133     /** The actions to be performed by the algorithm on an event. This method is
0134      * invoked once per event for top level algorithms by the application
0135      *  manager.
0136      *  This method invokes execute() method.
0137      *  For sub-algorithms either the sysExecute() method or execute() method
0138      *  must be EXPLICITLY invoked by  the parent algorithm.
0139      */
0140     StatusCode sysExecute( const EventContext& ctx ) override;
0141
0142     /** System stop. This method invokes the stop() method of a concrete
0143         algorithm and the stop() methods of all of that algorithm's sub algorithms.
0144     */
0145     StatusCode sysStop() override;
0146
0147     /** System finalization. This method invokes the finalize() method of a
0148      *  concrete algorithm and the finalize() methods of all of that algorithm's
0149      *  sub algorithms.
0150      */
0151     StatusCode sysFinalize() override;
0152
0153     /** The identifying name of the algorithm object. This is the name of a
0154      *  particular instantiation of an algorithm object as opposed to the name
0155      *  of the algorithm itself, e.g. "LinearTrackFit" may be the name of a
0156      *  concrete algorithm class,
0157      *  whereas "ApproxTrackFit" and "BestTrackFit" may be two instantiations
0158      *  of the class configured to find tracks with different fit criteria.
0159      */
0160     const std::string&      name() const override;
0161     const Gaudi::StringKey& nameKey() const override;
0162
0163     /** The type of the algorithm object.
0164      */
0165     const std::string& type() const override { return m_type; }
0166     void setType( std::string type ) override { m_type = std::move( type ); } // BH, TODO: move to proper place
0167
0168     const std::string& version() const override;
0169
0170     unsigned int index() const override;
0171
0172     /// Dummy implementation of IStateful::configure() method
0173     StatusCode configure() override { return StatusCode::SUCCESS; }
0174     /// Dummy implementation of IStateful::terminate() method
0175     StatusCode terminate() override { return StatusCode::SUCCESS; }
0176
0177     /// the default (empty) implementation of IStateful::initialize() method
0178     StatusCode initialize() override { return StatusCode::SUCCESS; }
0179     /// the default (empty) implementation of IStateful::start() method
0180     StatusCode start() override { return StatusCode::SUCCESS; }
0181     /// the default (empty) implementation of IStateful::stop() method
0182     StatusCode stop() override { return StatusCode::SUCCESS; }
0183     /// the default (empty) implementation of IStateful::finalize() method
0184     StatusCode finalize() override { return StatusCode::SUCCESS; }
0185     /// the default (empty) implementation of IStateful::reinitialize() method
0186     StatusCode reinitialize() override;
0187     /// the default (empty) implementation of IStateful::restart() method
0188     StatusCode restart() override;
0189     /// returns the current state of the algorithm
0190     Gaudi::StateMachine::State FSMState() const override { return m_state; }
0191     /// returns the state the algorithm will be in after the ongoing transition
0192     Gaudi::StateMachine::State targetFSMState() const override { return m_targetState; }
0193
0194     /// Is this algorithm enabled or disabled?
0195     bool isEnabled() const override;
0196
0197     /// Are we a Sequence?
0198     bool isSequence() const override { return false; }
0199
0200     /// Get the number of failures of the algorithm.
0201     unsigned int errorCount() const;
0202
0203     /// Access a service by name, creating it if it doesn't already exist.
0204     template <class T>
0205     [[deprecated( "use service<T>(name, createIf) -> SmartIF<T>" )]] StatusCode
0206     service( std::string_view name, T*& psvc, bool createIf = true ) const {
0207       return service_i( name, createIf, T::interfaceID(), (void**)&psvc );
0208     }
0209
0210     /// Access a service by name and type, creating it if it doesn't already exist.
0211     template <class T>
0212     [[deprecated( "use service<T>(name, createIf) -> SmartIF<T>" )]] StatusCode
0213     service( std::string_view svcType, std::string_view svcName, T*& psvc ) const {
0214       return service_i( svcType, svcName, T::interfaceID(), reinterpret_cast<void**>( &psvc ) );
0215     }
0216
0217     /// Return a pointer to the service identified by name (or "type/name")
0218     SmartIF<IService> service( std::string_view name, const bool createIf = true, const bool quiet = false ) const;
0219
0220     template <class T>
0221     SmartIF<T> service( std::string_view name, bool createIf = true, bool quiet = false ) const {
0222       return service( name, createIf, quiet ).as<T>();
0223     }
0224
0225     /** The standard auditor service.May not be invoked before sysInitialize()
0226      *  has been invoked.
0227      */
0228     SmartIF<IAuditorSvc>& auditorSvc() const;
0229
0230     /** The standard Chrono & Stat service,
0231      *  Return a pointer to the service if present
0232      */
0233     SmartIF<IChronoStatSvc>& chronoSvc() const;
0234
0235     /** The standard detector data service.
0236      *  May not be invoked before sysInitialize() has been invoked.
0237      */
0238     SmartIF<IDataProviderSvc>& detSvc() const;
0239
0240     /** The standard detector data persistency conversion service.
0241      *  May not be invoked before sysInitialize() has been invoked.
0242      */
0243     SmartIF<IConversionSvc>& detCnvSvc() const;
0244
0245     /** The standard event data service.
0246      *  May not be invoked before sysInitialize() has been invoked.
0247      */
0248     SmartIF<IDataProviderSvc>& eventSvc() const;
0249     /// shortcut for  method eventSvc
0250     SmartIF<IDataProviderSvc>& evtSvc() const { return eventSvc(); }
0251
0252     /** The standard event data persistency conversion service.
0253      *  May not be invoked before sysInitialize() has been invoked.
0254      */
0255     SmartIF<IConversionSvc>& eventCnvSvc() const;
0256
0257     /** The standard histogram service.
0258      *  May not be invoked before sysInitialize() has been invoked.
0259      */
0260     SmartIF<IHistogramSvc>& histoSvc() const;
0261
0262     /** The standard N tuple service.
0263      *  Returns a pointer to the N tuple service if present.
0264      */
0265     SmartIF<INTupleSvc>& ntupleSvc() const;
0266
0267     /** The standard RandomGen service,
0268      *  Return a pointer to the service if present
0269      */
0270     SmartIF<IRndmGenSvc>& randSvc() const;
0271
0272     /// The standard ToolSvc service, Return a pointer to the service if present
0273     SmartIF<IToolSvc>& toolSvc() const;
0274
0275     /// Get the exception Service
0276     SmartIF<IExceptionSvc>& exceptionSvc() const;
0277
0278     /// get Algorithm Context Service
0279     SmartIF<IAlgContextSvc>& contextSvc() const;
0280
0281     SmartIF<ITimelineSvc>& timelineSvc() const;
0282
0283     /** The standard service locator.
0284      *  Returns a pointer to the service locator service.
0285      *  This service may be used by an algorithm to request
0286      *  any services it requires in addition to those provided by default.
0287      */
0288     SmartIF<ISvcLocator>& serviceLocator() const override;
0289     /// shortcut for method serviceLocator
0290     SmartIF<ISvcLocator>& svcLoc() const { return serviceLocator(); }
0291
0292     SmartIF<IHiveWhiteBoard>& whiteboard() const;
0293
0294     SmartIF<IAlgExecStateSvc>& algExecStateSvc() const;
0295
0296     /// register for Algorithm Context Service?
0297     bool registerContext() const { return m_registerContext; }
0298
0299     // ==========================================================================
0300     using PropertyHolderImpl::declareProperty;
0301
0302     // declare Tools to the Algorithms
0303     template <class T>
0304     Gaudi::Details::PropertyBase* declareProperty( const std::string& name, ToolHandle<T>& hndl,
0305                                                    const std::string& doc = "none" ) {
0306       this->declareTool( hndl, hndl.typeAndName() ).ignore();
0307       return PropertyHolderImpl::declareProperty( name, hndl, doc );
0308     }
0309
0310     // ==========================================================================
0311     // declare ToolHandleArrays to the Algorithms
0312
0313     template <class T>
0314     Gaudi::Details::PropertyBase* declareProperty( const std::string& name, ToolHandleArray<T>& hndlArr,
0315                                                    const std::string& doc = "none" ) {
0316       addToolsArray( hndlArr );
0317       return PropertyHolderImpl::declareProperty( name, hndlArr, doc );
0318     }
0319
0320     // ==========================================================================
0321     /** @brief Access the monitor service
0322      *
0323      *   @attention Note that this method will return a NULL pointer if no monitor service is
0324      *              configured to be present. You must take this possibility into account when
0325      *              using the pointer
0326      *   @return Pointer to the Monitor service
0327      *   @retval NULL No monitor service is present
0328      *   @retval non-NULL A monitor service is present and available to be used
0329      */
0330     SmartIF<IMonitorSvc>& monitorSvc() const {
0331       // If not already located try to locate it without forcing a creation
0332       if ( !m_pMonitorSvc ) {
0333         m_pMonitorSvc = service( m_monitorSvcName, false, true ); // do not create and be quiet
0334       }
0335       return m_pMonitorSvc;
0336     }
0337
0338     /** Declare monitoring information
0339         @param name Monitoring information name known to the external system
0340         @param var  Monitoring Listener address (the item to monitor...)
0341         @param desc Textual description of the information being monitored
0342     */
0343     template <class T>
0344     void declareInfo( const std::string& name, const T& var, const std::string& desc ) const {
0345       IMonitorSvc* mS = monitorSvc().get();
0346       if ( mS ) mS->declareInfo( name, var, desc, this );
0347     }
0348
0349     /** Declare monitoring information (special case)
0350         @param name Monitoring information name known to the external system
0351         @param format Format information
0352         @param var  Monitoring Listener address
0353         @param size Monitoring Listener address size
0354         @param desc Textual description of the information being monitored
0355     */
0356     void declareInfo( const std::string& name, const std::string& format, const void* var, int size,
0357                       const std::string& desc ) const {
0358       IMonitorSvc* mS = monitorSvc().get();
0359       if ( mS ) mS->declareInfo( name, format, var, size, desc, this );
0360     }
0361
0362   public:
0363     void acceptDHVisitor( IDataHandleVisitor* ) const override;
0364
0365     void registerTool( IAlgTool* tool ) const;
0366     void deregisterTool( IAlgTool* tool ) const;
0367
0368     template <class T>
0369     StatusCode declareTool( ToolHandle<T>& handle, bool createIf = true ) {
0370       return this->declareTool( handle, handle.typeAndName(), createIf );
0371     }
0372
0373     template <class T>
0374     StatusCode declareTool( ToolHandle<T>& handle, const std::string& toolTypeAndName, bool createIf = true ) {
0375
0376       StatusCode sc = handle.initialize( toolTypeAndName, handle.isPublic() ? nullptr : this, createIf );
0377       if ( !sc ) {
0378         throw GaudiException{ std::string{ "Cannot create handle for " } +
0379                                   ( handle.isPublic() ? "public" : "private" ) + " tool " + toolTypeAndName,
0380                               name(), sc };
0381       }
0382
0383       m_toolHandles.push_back( &handle );
0384
0385       return sc;
0386     }
0387
0388     template <class T>
0389     void addToolsArray( ToolHandleArray<T>& hndlArr ) {
0390       m_toolHandleArrays.push_back( &hndlArr );
0391     }
0392
0393     const std::vector<IAlgTool*>& tools() const;
0394
0395     // Return the asynchronous flag
0396     bool isAsynchronous() const { return m_asynchronous; }
0397     // Set the asynchronous flag
0398     void setAsynchronous( bool value ) { m_asynchronous = value; }
0399
0400   protected:
0401     std::vector<IAlgTool*>& tools();
0402
0403     // // adds declared in- and outputs of subAlgorithms to own DOHs
0404     //  void addSubAlgorithmDataObjectHandles();
0405
0406   private:
0407     // place IAlgTools defined via ToolHandles in m_tools
0408     void initToolHandles() const;
0409
0410   public:
0411     // /// Specifies the clonability of the algorithm
0412     // bool isClonable() const override { return false; }
0413
0414     /// Return the cardinality
0415     unsigned int cardinality() const override { return m_cardinality; }
0416
0417     const std::vector<std::string>& neededResources() const override { return m_neededResources; }
0418
0419   protected:
0420     /// Has the Algorithm already been initialized?
0421     bool isInitialized() const override { return Gaudi::StateMachine::INITIALIZED == m_state; }
0422
0423     /// Has the Algorithm already been finalized?
0424     bool isFinalized() const override { return Gaudi::StateMachine::CONFIGURED == m_state; }
0425
0426     /// set instantiation index of Alg
0427     void setIndex( const unsigned int& idx ) override;
0428
0429   public:
0430     /// reference to AlgExecState of Alg
0431     AlgExecState& execState( const EventContext& ctx ) const override;
0432
0433     /// Produce string represention of the control flow expression.
0434     std::ostream& toControlFlowExpression( std::ostream& os ) const override;
0435
0436   private:
0437     unsigned int maxErrors() const { return m_errorMax; }
0438
0439   protected:
0440     bool isReEntrant() const override { return true; }
0441
0442   private:
0443     Gaudi::StringKey m_name;      ///< Algorithm's name for identification
0444     std::string      m_type;      ///< Algorithm's type
0445     std::string      m_version;   ///< Algorithm's version
0446     unsigned int     m_index = 0; ///< Algorithm's index
0447
0448     // tools used by algorithm
0449     mutable std::vector<IAlgTool*>             m_tools;
0450     mutable std::vector<BaseToolHandle*>       m_toolHandles;
0451     mutable std::vector<GaudiHandleArrayBase*> m_toolHandleArrays;
0452
0453   private:
0454     template <typename IFace>
0455     SmartIF<IFace>& get_svc_( SmartIF<IFace>& p, const char* service_name ) const;
0456
0457     mutable SmartIF<IMessageSvc>      m_MS;          ///< Message service
0458     mutable SmartIF<IDataProviderSvc> m_EDS;         ///< Event data service
0459     mutable SmartIF<IHiveWhiteBoard>  m_WB;          ///< Event data service (whiteboard)
0460     mutable SmartIF<IConversionSvc>   m_ECS;         ///< Event conversion service
0461     mutable SmartIF<IDataProviderSvc> m_DDS;         ///< Detector data service
0462     mutable SmartIF<IConversionSvc>   m_DCS;         ///< Detector conversion service
0463     mutable SmartIF<IHistogramSvc>    m_HDS;         ///< Histogram data service
0464     mutable SmartIF<INTupleSvc>       m_NTS;         ///< N tuple service
0465     mutable SmartIF<IChronoStatSvc>   m_CSS;         ///< Chrono & Stat Service
0466     mutable SmartIF<IRndmGenSvc>      m_RGS;         ///< Random Number Generator Service
0467     mutable SmartIF<IExceptionSvc>    m_EXS;         ///< Exception Handler Service
0468     mutable SmartIF<IAuditorSvc>      m_pAuditorSvc; ///< Auditor Service
0469     mutable SmartIF<IToolSvc>         m_ptoolSvc;    ///< ToolSvc Service
0470     mutable SmartIF<IMonitorSvc>      m_pMonitorSvc; ///< Online Monitoring Service
0471     mutable SmartIF<IAlgContextSvc>   m_contextSvc;  ///< Algorithm Context Service
0472
0473     mutable SmartIF<ITimelineSvc>     m_timelineSvc; ///< Timeline Service
0474     mutable SmartIF<IAlgExecStateSvc> m_aess;        ///< Alg execution state mgr
0475
0476     SmartIF<ISvcLocator> m_pSvcLocator; ///< Pointer to service locator service
0477
0478   protected:
0479     /// Hook for for derived classes to provide a custom visitor for data handles.
0480     std::unique_ptr<IDataHandleVisitor> m_updateDataHandles;
0481
0482   private:
0483     // Properties
0484     Gaudi::Property<int> m_outputLevel{
0485         this, "OutputLevel", MSG::NIL,
0486         [this]( Gaudi::Details::PropertyBase& ) { this->updateMsgStreamOutputLevel( this->m_outputLevel ); },
0487         "output level" };
0488     Gaudi::Property<bool> m_isEnabled{ this, "Enable", true, "should the algorithm be executed or not" };
0489
0490     Gaudi::Property<unsigned int> m_errorMax{ this, "ErrorMax", 1, "[[deprecated]] max number of errors" };
0491
0492     Gaudi::Property<bool> m_auditInit{ this, "AuditAlgorithms", Details::getDefaultAuditorValue( m_pSvcLocator ),
0493                                        "[[deprecated]] unused" };
0494     Gaudi::Property<bool> m_auditorInitialize{ this, "AuditInitialize", m_auditInit.value(),
0495                                                "trigger auditor on initialize()" };
0496     Gaudi::Property<bool> m_auditorReinitialize{ this, "AuditReinitialize", m_auditInit.value(),
0497                                                  "trigger auditor on reinitialize()" };
0498     Gaudi::Property<bool> m_auditorRestart{ this, "AuditRestart", m_auditInit.value(), "trigger auditor on restart()" };
0499     Gaudi::Property<bool> m_auditorExecute{ this, "AuditExecute", m_auditInit.value(), "trigger auditor on execute()" };
0500     Gaudi::Property<bool> m_auditorFinalize{ this, "AuditFinalize", m_auditInit.value(),
0501                                              "trigger auditor on finalize()" };
0502     Gaudi::Property<bool> m_auditorStart{ this, "AuditStart", m_auditInit.value(), "trigger auditor on start()" };
0503     Gaudi::Property<bool> m_auditorStop{ this, "AuditStop", m_auditInit.value(), "trigger auditor on stop()" };
0504
0505     Gaudi::Property<bool> m_doTimeline{ this, "Timeline", true, "send events to TimelineSvc" };
0506
0507     Gaudi::Property<std::string> m_monitorSvcName{ this, "MonitorService", "MonitorSvc",
0508                                                    "name to use for Monitor Service" };
0509
0510     Gaudi::Property<bool> m_registerContext{ this, "RegisterForContextService", false,
0511                                              "flag to enforce the registration for Algorithm Context Service" };
0512
0513     Gaudi::Property<int>                      m_cardinality{ this, "Cardinality", 0,
0514                                         "how many clones to create - 0 means algo is reentrant" };
0515     Gaudi::Property<std::vector<std::string>> m_neededResources{
0516         this, "NeededResources", {}, "named resources needed during event looping" };
0517
0518     Gaudi::Property<bool> m_asynchronous{ this, "Asynchronous", false,
0519                                           "whether algorithm is asynchronous and uses Boost Fiber to suspend "
0520                                           "while offloaded code is running." };
0521     // The default should be changed to "false" for v29
0522     Gaudi::Property<bool> m_filterCircDeps{ this, "FilterCircularDependencies", true,
0523                                             "filter out circular data dependencies" };
0524
0525     mutable bool m_toolHandlesInit = false; /// flag indicating whether ToolHandle tools have been added to m_tools
0526
0527     Gaudi::StateMachine::State m_state       = Gaudi::StateMachine::CONFIGURED; ///< Algorithm has been initialized flag
0528     Gaudi::StateMachine::State m_targetState = Gaudi::StateMachine::CONFIGURED; ///< Algorithm has been initialized flag
0529
0530     /// implementation of legacy service method
0531     [[deprecated]] StatusCode service_i( std::string_view svcName, bool createIf, const InterfaceID& iid,
0532                                          void** ppSvc ) const;
0533     [[deprecated]] StatusCode service_i( std::string_view svcType, std::string_view svcName, const InterfaceID& iid,
0534                                          void** ppSvc ) const;
0535
0536     /// delete copy constructor: NO COPY ALLOWED
0537     Algorithm( const Algorithm& ) = delete;
0538
0539     /// delete assignment operator: NO ASSIGNMENT ALLOWED
0540     Algorithm& operator=( const Algorithm& ) = delete;
0541   };
0542 } // namespace Gaudi