The Gaudi Framework  master (f5098d57)
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
AlgTool.cpp
Go to the documentation of this file.
1 /***********************************************************************************\
2 * (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
3 * *
4 * This software is distributed under the terms of the Apache version 2 licence, *
5 * copied verbatim in the file "LICENSE". *
6 * *
7 * In applying this licence, CERN does not waive the privileges and immunities *
8 * granted to it by virtue of its status as an Intergovernmental Organization *
9 * or submit itself to any jurisdiction. *
10 \***********************************************************************************/
11 // Include files
12 #include <GaudiKernel/AlgTool.h>
16 
17 #include <Gaudi/Algorithm.h>
18 #include <Gaudi/Auditor.h>
21 #include <GaudiKernel/Guards.h>
22 #include <GaudiKernel/Service.h>
24 #include <GaudiKernel/System.h>
25 #include <GaudiKernel/ToolHandle.h>
26 
27 //------------------------------------------------------------------------------
28 namespace {
29  template <typename FUN>
30  StatusCode attempt( AlgTool& tool, const char* label, FUN&& fun ) {
31  try {
32  return fun();
33  } catch ( const GaudiException& Exception ) {
34  MsgStream log( tool.msgSvc(), tool.name() + "." + label );
35  log << MSG::FATAL << " Exception with tag=" << Exception.tag() << " is caught" << endmsg;
36  log << MSG::ERROR << Exception << endmsg;
37  } catch ( const std::exception& Exception ) {
38  MsgStream log( tool.msgSvc(), tool.name() + "." + label );
39  log << MSG::FATAL << " Standard std::exception is caught" << endmsg;
40  log << MSG::ERROR << Exception.what() << endmsg;
41  } catch ( ... ) {
42  MsgStream log( tool.msgSvc(), tool.name() + "." + label );
43  log << MSG::FATAL << "UNKNOWN Exception is caught" << endmsg;
44  }
45  return StatusCode::FAILURE;
46  }
47 } // namespace
48 
49 //------------------------------------------------------------------------------
50 StatusCode AlgTool::queryInterface( const InterfaceID& riid, void** ppvi )
51 //------------------------------------------------------------------------------
52 {
53  if ( !ppvi ) { return StatusCode::FAILURE; } // RETURN
54  StatusCode sc = base_class::queryInterface( riid, ppvi );
55  if ( sc.isSuccess() ) return sc;
56  auto i = std::find_if( std::begin( m_interfaceList ), std::end( m_interfaceList ),
57  [&]( const std::pair<InterfaceID, void*>& item ) { return item.first.versionMatch( riid ); } );
58  if ( i == std::end( m_interfaceList ) ) {
59  *ppvi = nullptr;
60  return Status::NO_INTERFACE; // RETURN
61  }
62  *ppvi = i->second;
63  addRef();
64  return StatusCode::SUCCESS; // RETURN
65 }
66 //------------------------------------------------------------------------------
67 const std::string& AlgTool::name() const
68 //------------------------------------------------------------------------------
69 {
70  return m_name;
71 }
72 
73 //------------------------------------------------------------------------------
74 const std::string& AlgTool::type() const
75 //------------------------------------------------------------------------------
76 {
77  return m_type;
78 }
79 
80 //------------------------------------------------------------------------------
82 //------------------------------------------------------------------------------
83 {
84  return m_parent;
85 }
86 
87 //------------------------------------------------------------------------------
89 //------------------------------------------------------------------------------
90 {
91  return m_svcLocator;
92 }
93 
94 // ============================================================================
95 // accessor to event service service
96 // ============================================================================
98  if ( !m_evtSvc ) {
99  m_evtSvc = service( "EventDataSvc", true );
100  if ( !m_evtSvc ) { throw GaudiException( "Service [EventDataSvc] not found", name(), StatusCode::FAILURE ); }
101  }
102  return m_evtSvc.get();
103 }
104 //------------------------------------------------------------------------------
106 //------------------------------------------------------------------------------
107 {
108  if ( !m_ptoolSvc ) {
109  m_ptoolSvc = service( "ToolSvc", true );
110  if ( !m_ptoolSvc ) { throw GaudiException( "Service [ToolSvc] not found", name(), StatusCode::FAILURE ); }
111  }
112  return m_ptoolSvc.get();
113 }
114 
115 //------------------------------------------------------------------------------
116 AlgTool::AlgTool( std::string type, std::string name, const IInterface* parent )
117  //------------------------------------------------------------------------------
118  : m_type( std::move( type ) ), m_name( std::move( name ) ), m_parent( parent ) {
119  addRef(); // Initial count set to 1
120 
121  IInterface* _p = const_cast<IInterface*>( parent );
122 
123  if ( Gaudi::Algorithm* _alg = dynamic_cast<Gaudi::Algorithm*>( _p ) ) {
124  m_svcLocator = _alg->serviceLocator();
125  } else if ( Service* _svc = dynamic_cast<Service*>( _p ) ) {
126  m_svcLocator = _svc->serviceLocator();
127  } else if ( AlgTool* _too = dynamic_cast<AlgTool*>( _p ) ) {
128  m_svcLocator = _too->serviceLocator();
129  } else if ( Gaudi::Auditor* _aud = dynamic_cast<Gaudi::Auditor*>( _p ) ) {
130  m_svcLocator = _aud->serviceLocator();
131  } else {
132  throw GaudiException( "Failure to create tool '" + m_type + "/" + m_name + "': illegal parent type '" +
133  System::typeinfoName( typeid( *_p ) ) + "'",
134  "AlgTool", StatusCode::FAILURE );
135  }
136 
137  // inherit output level from parent
138  // get the "OutputLevel" property from parent
139  if ( SmartIF<IProperty> pprop( _p ); pprop && pprop->hasProperty( "OutputLevel" ) ) {
140  m_outputLevel.assign( pprop->getProperty( "OutputLevel" ) );
141  }
142 
143  // Auditor monitoring properties
144  // Initialize the default value from ApplicationMgr AuditAlgorithms
145  Gaudi::Property<bool> audit( "AuditTools", false );
146  // note that here we need that the service locator is already defined
147  if ( auto appMgr = serviceLocator()->service<IProperty>( "ApplicationMgr" ) ) {
148  appMgr->getProperty( &audit ).ignore();
149  }
150 
151  m_auditorInitialize = audit;
152  m_auditorStart = audit;
153  m_auditorStop = audit;
154  m_auditorFinalize = audit;
155  m_auditorReinitialize = audit;
156  m_auditorRestart = audit;
157 }
158 
159 //-----------------------------------------------------------------------------
161  //-----------------------------------------------------------------------------
162  return attempt( *this, "sysInitialize", [&]() {
165  // check if we want to audit the initialize
167  StatusCode sc = initialize();
168  if ( !sc ) return sc;
169 
172 
173  // check for explicit circular data dependencies in declared handles
175  for ( auto& h : outputHandles() ) {
176  if ( !h->objKey().empty() ) out.emplace( h->fullKey() );
177  }
178  for ( auto& h : inputHandles() ) {
179  if ( !h->objKey().empty() && out.find( h->fullKey() ) != out.end() ) {
180  error() << "Explicit circular data dependency found for id " << h->fullKey() << endmsg;
181  sc = StatusCode::FAILURE;
182  }
183  }
184 
185  if ( !sc ) return sc;
186 
187  // visit all sub-tools, build full set
189  acceptDHVisitor( &avis );
190 
191  // initialize handles
192  initDataHandleHolder(); // this should 'freeze' the handle configuration.
193 
194  return sc;
195  } );
196 }
197 //------------------------------------------------------------------------------
199 //------------------------------------------------------------------------------
200 {
201  // For the time being there is nothing to be done here.
202  // Setting the properties is done by the ToolSvc calling setProperties()
203  // explicitly.
204  return StatusCode::SUCCESS;
205 }
206 
207 //-----------------------------------------------------------------------------
209  //-----------------------------------------------------------------------------
210  return attempt( *this, "sysStart", [&]() {
213  // check if we want to audit the initialize
215  StatusCode sc = start();
216  if ( sc.isSuccess() ) m_state = m_targetState;
217  return sc;
218  } );
219 }
220 
221 //------------------------------------------------------------------------------
223 //------------------------------------------------------------------------------
224 {
225  // For the time being there is nothing to be done here.
226  return StatusCode::SUCCESS;
227 }
228 
229 //-----------------------------------------------------------------------------
231  //-----------------------------------------------------------------------------
232  return attempt( *this, "sysStop", [&]() {
235  // check if we want to audit the initialize
237  StatusCode sc = stop();
238  if ( sc.isSuccess() ) m_state = m_targetState;
239  return sc;
240  } );
241 }
242 
243 //------------------------------------------------------------------------------
245 //------------------------------------------------------------------------------
246 {
247  // For the time being there is nothing to be done here.
248  return StatusCode::SUCCESS;
249 }
250 
251 //-----------------------------------------------------------------------------
253  //-----------------------------------------------------------------------------
254  return attempt( *this, "sysFinalize", [&]() {
257  // check if we want to audit the initialize
259  StatusCode sc = finalize();
260  if ( sc.isSuccess() ) m_state = m_targetState;
261  return sc;
262  } );
263 }
264 //------------------------------------------------------------------------------
266 //------------------------------------------------------------------------------
267 {
268  // For the time being there is nothing to be done here.
269  return StatusCode::SUCCESS;
270 }
271 
272 //-----------------------------------------------------------------------------
274  //-----------------------------------------------------------------------------
275 
276  // Check that the current status is the correct one.
278  error() << "sysReinitialize(): cannot reinitialize tool not initialized" << endmsg;
279  return StatusCode::FAILURE;
280  }
281 
282  return attempt( *this, "SysReinitialize()", [&]() {
284  // check if we want to audit the initialize
286  return reinitialize();
287  } );
288 }
289 
290 //------------------------------------------------------------------------------
292 //------------------------------------------------------------------------------
293 {
294  /* @TODO
295  * MCl 2008-10-23: the implementation of reinitialize as finalize+initialize
296  * is causing too many problems
297  *
298  // Default implementation is finalize+initialize
299  StatusCode sc = finalize();
300  if (sc.isFailure()) {
301  error() << "reinitialize(): cannot be finalized" << endmsg;
302  return sc;
303  }
304  sc = initialize();
305  if (sc.isFailure()) {
306  error() << "reinitialize(): cannot be initialized" << endmsg;
307  return sc;
308  }
309  */
310  return StatusCode::SUCCESS;
311 }
312 
313 //-----------------------------------------------------------------------------
315  //-----------------------------------------------------------------------------
316 
317  // Check that the current status is the correct one.
319  error() << "sysRestart(): cannot reinitialize tool not started" << endmsg;
320  return StatusCode::FAILURE;
321  }
322 
323  return attempt( *this, "sysRestart", [&]() {
326  // check if we want to audit the initialize
328  return restart();
329  } );
330 }
331 
332 //------------------------------------------------------------------------------
334 //------------------------------------------------------------------------------
335 {
336  // Default implementation is stop+start
337  StatusCode sc = stop();
338  if ( sc.isFailure() ) {
339  error() << "restart(): cannot be stopped" << endmsg;
340  return sc;
341  }
342  sc = start();
343  if ( sc.isFailure() ) {
344  error() << "restart(): cannot be started" << endmsg;
345  return sc;
346  }
347  return StatusCode::SUCCESS;
348 }
349 
350 //------------------------------------------------------------------------------
352 //------------------------------------------------------------------------------
353 {
354  if ( m_pMonitorSvc ) { m_pMonitorSvc->undeclareAll( this ); }
355 }
356 
358  auto init_one = [&]( BaseToolHandle* th ) {
359  if ( !th->isEnabled() ) {
360  if ( msgLevel( MSG::DEBUG ) && !th->typeAndName().empty() )
361  debug() << "ToolHandle " << th->typeAndName() << " not used" << endmsg;
362  return;
363  }
364  if ( !th->get() ) {
365  auto sc = th->retrieve();
366  if ( sc.isFailure() ) {
367  throw GaudiException( "Failed to retrieve tool " + th->typeAndName(), this->name(), StatusCode::FAILURE );
368  }
369  }
370  auto* tool = th->get();
371  if ( msgLevel( MSG::DEBUG ) )
372  debug() << "Adding " << ( th->isPublic() ? "public" : "private" ) << " ToolHandle tool " << tool->name() << " ("
373  << tool->type() << ")" << endmsg;
374  m_tools.push_back( tool );
375  };
376 
377  for ( auto thArr : m_toolHandleArrays ) {
378  if ( msgLevel( MSG::DEBUG ) )
379  debug() << "Registering all Tools in ToolHandleArray " << thArr->propertyName() << endmsg;
380  // Iterate over its tools:
381  for ( auto toolHandle : thArr->getBaseArray() ) {
382  // Try to cast it into a BaseToolHandle pointer:
383  BaseToolHandle* bth = dynamic_cast<BaseToolHandle*>( toolHandle );
384  if ( bth ) {
385  init_one( bth );
386  } else {
387  error() << "Error retrieving Tool " << toolHandle->typeAndName() << " in ToolHandleArray "
388  << thArr->propertyName() << ". Not registered" << endmsg;
389  }
390  }
391  }
392 
393  for ( BaseToolHandle* th : m_toolHandles ) init_one( th );
394 
395  m_toolHandlesInit = true;
396 }
397 
398 const std::vector<IAlgTool*>& AlgTool::tools() const {
400 
401  return m_tools;
402 }
403 
404 std::vector<IAlgTool*>& AlgTool::tools() {
406 
407  return m_tools;
408 }
409 
410 //------------------------------------------------------------------------------
411 SmartIF<IService> AlgTool::service( std::string_view name, const bool createIf, const bool quiet ) const {
412  const ServiceLocatorHelper helper( *serviceLocator(), *this );
413  return helper.service( name, quiet, createIf );
414 }
415 
416 //-----------------------------------------------------------------------------
418  //---------------------------------------------------------------------------
419  if ( !m_pAuditorSvc ) {
420  m_pAuditorSvc = service( "AuditorSvc", true );
421  if ( !m_pAuditorSvc ) { throw GaudiException( "Service [AuditorSvc] not found", name(), StatusCode::FAILURE ); }
422  }
423  return m_pAuditorSvc.get();
424 }
425 
426 //-----------------------------------------------------------------------------
428  //-----------------------------------------------------------------------------
429  vis->visit( this );
430 
431  for ( auto tool : tools() ) vis->visit( dynamic_cast<AlgTool*>( tool ) );
432 }
ServiceLocatorHelper::service
SmartIF< IService > service(std::string_view name, const bool quiet=false, const bool createIf=true) const
Definition: ServiceLocatorHelper.cpp:50
MSG::DEBUG
@ DEBUG
Definition: IMessageSvc.h:25
AlgTool::m_auditorFinalize
Gaudi::Property< bool > m_auditorFinalize
Definition: AlgTool.h:314
Gaudi::IAuditor::Start
static constexpr std::string Start
Definition: IAuditor.h:49
AlgTool::m_auditorRestart
Gaudi::Property< bool > m_auditorRestart
Definition: AlgTool.h:316
AlgTool::m_pMonitorSvc
SmartIF< IMonitorSvc > m_pMonitorSvc
Online Monitoring Service.
Definition: AlgTool.h:296
Gaudi.Configuration.log
log
Definition: Configuration.py:28
AlgTool::m_toolHandles
std::vector< BaseToolHandle * > m_toolHandles
Definition: AlgTool.h:320
AlgTool::sysFinalize
StatusCode sysFinalize() override
Finalize AlgTool.
Definition: AlgTool.cpp:252
AlgTool::m_state
Gaudi::StateMachine::State m_state
flag indicating whether ToolHandle tools have been added to m_tools
Definition: AlgTool.h:324
StatusCode::isSuccess
bool isSuccess() const
Definition: StatusCode.h:315
GaudiPartProp.decorators.std
std
Definition: decorators.py:32
AlgTool::m_updateDataHandles
std::unique_ptr< IDataHandleVisitor > m_updateDataHandles
Hook for for derived classes to provide a custom visitor for data handles.
Definition: AlgTool.h:233
AlgTool::m_toolHandlesInit
bool m_toolHandlesInit
Definition: AlgTool.h:322
System.h
AlgTool::m_auditorStop
Gaudi::Property< bool > m_auditorStop
Definition: AlgTool.h:313
AlgTool::m_auditorReinitialize
Gaudi::Property< bool > m_auditorReinitialize
Definition: AlgTool.h:315
GaudiException.h
AlgTool::parent
const IInterface * parent() const override
Retrieve parent of the sub-algtool.
Definition: AlgTool.cpp:81
Gaudi::StateMachine::FINALIZE
@ FINALIZE
Definition: StateMachine.h:38
AlgTool::m_svcLocator
SmartIF< ISvcLocator > m_svcLocator
Pointer to Service Locator service.
Definition: AlgTool.h:293
AlgTool::restart
StatusCode restart() override
Definition: AlgTool.cpp:333
AlgTool::AlgTool
AlgTool(std::string type, std::string name, const IInterface *parent)
Standard Constructor.
Definition: AlgTool.cpp:116
GaudiException
Definition: GaudiException.h:32
Gaudi::IAuditor::Finalize
static constexpr std::string Finalize
Definition: IAuditor.h:53
AlgTool::m_evtSvc
SmartIF< IDataProviderSvc > m_evtSvc
Event data service.
Definition: AlgTool.h:294
AlgTool::m_auditorInitialize
Gaudi::Property< bool > m_auditorInitialize
Definition: AlgTool.h:311
AlgTool::type
const std::string & type() const override
Retrieve type (concrete class) of the sub-algtool.
Definition: AlgTool.cpp:74
AlgTool::reinitialize
StatusCode reinitialize() override
Definition: AlgTool.cpp:291
DataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > > >::outputHandles
std::vector< Gaudi::DataHandle * > outputHandles() const override
Definition: DataHandleHolderBase.h:41
AlgTool::acceptDHVisitor
void acceptDHVisitor(IDataHandleVisitor *) const override
Definition: AlgTool.cpp:427
Gaudi::Property::assign
bool assign(const Details::PropertyBase &source) override
get the value from another property
Definition: Property.h:368
System::typeinfoName
GAUDI_API const std::string typeinfoName(const std::type_info &)
Get platform independent information about the class type.
Definition: System.cpp:315
AlgTool::m_tools
std::vector< IAlgTool * > m_tools
Definition: AlgTool.h:319
AlgTool::sysInitialize
StatusCode sysInitialize() override
Initialize AlgTool.
Definition: AlgTool.cpp:160
AlgTool::initialize
StatusCode initialize() override
Definition: AlgTool.cpp:198
AlgTool::m_targetState
Gaudi::StateMachine::State m_targetState
state of the Tool
Definition: AlgTool.h:325
AlgTool::sysReinitialize
StatusCode sysReinitialize() override
Initialize AlgTool.
Definition: AlgTool.cpp:273
DHHVisitor
Definition: DataHandleHolderVisitor.h:21
IMessageSvc.h
CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > >::msgLevel
MSG::Level msgLevel() const
get the cached level (originally extracted from the embedded MsgStream)
Definition: CommonMessaging.h:148
AlgTool::auditorSvc
IAuditorSvc * auditorSvc() const
Access the auditor service.
Definition: AlgTool.cpp:417
AlgTool::FSMState
Gaudi::StateMachine::State FSMState() const override
Definition: AlgTool.h:90
AlgTool::name
const std::string & name() const override
Retrieve full identifying name of the concrete tool object.
Definition: AlgTool.cpp:67
Service
Definition: Service.h:46
DataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > > >::m_outputDataObjs
DataObjIDColl m_outputDataObjs
Definition: DataHandleHolderBase.h:98
Gaudi::Guards::AuditorGuard
Definition: Guards.h:204
Gaudi::StateMachine::INITIALIZE
@ INITIALIZE
Definition: StateMachine.h:35
AlgTool::m_parent
const IInterface * m_parent
AlgTool parent.
Definition: AlgTool.h:291
bug_34121.tool
tool
Definition: bug_34121.py:18
Gaudi::Utils::begin
AttribStringParser::Iterator begin(const AttribStringParser &parser)
Definition: AttribStringParser.h:136
AlgTool::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Retrieve pointer to service locator.
Definition: AlgTool.cpp:88
DataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > > >::initDataHandleHolder
void initDataHandleHolder()
initializes all handles - called by the sysInitialize method of any descendant of this
Definition: DataHandleHolderBase.h:94
StatusCode
Definition: StatusCode.h:65
Gaudi::IAuditor::ReStart
static constexpr std::string ReStart
Definition: IAuditor.h:50
Gaudi::Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:90
AlgSequencer.h
h
Definition: AlgSequencer.py:31
AlgTool::m_type
std::string m_type
AlgTool type (concrete class name)
Definition: AlgTool.h:289
Gaudi::IAuditor::ReInitialize
static constexpr std::string ReInitialize
Definition: IAuditor.h:48
DataHandleHolderVisitor.h
DataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > > >::m_inputDataObjs
DataObjIDColl m_inputDataObjs
Definition: DataHandleHolderBase.h:98
ServiceLocatorHelper
an helper to share the implementation of service() among the various kernel base classes
Definition: ServiceLocatorHelper.h:27
AlgTool::sysStop
StatusCode sysStop() override
Stop AlgTool.
Definition: AlgTool.cpp:230
AlgTool::m_ptoolSvc
SmartIF< IToolSvc > m_ptoolSvc
Tool service.
Definition: AlgTool.h:295
AlgTool::m_toolHandleArrays
std::vector< GaudiHandleArrayBase * > m_toolHandleArrays
Definition: AlgTool.h:321
Algorithm.h
SmartIF< ISvcLocator >
AlgTool::sysRestart
StatusCode sysRestart() override
Start AlgTool.
Definition: AlgTool.cpp:314
DataObjIDColl
std::unordered_set< DataObjID, DataObjID_Hasher > DataObjIDColl
Definition: DataObjID.h:123
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:202
AlgTool::toolSvc
IToolSvc * toolSvc() const
The standard ToolSvc service, Return a pointer to the service if present.
Definition: AlgTool.cpp:105
Gaudi::StateMachine::RUNNING
@ RUNNING
Definition: StateMachine.h:26
MsgStream
Definition: MsgStream.h:33
MSG::FATAL
@ FATAL
Definition: IMessageSvc.h:25
IDataHandleVisitor
Definition: IDataHandleHolder.h:46
Gaudi::IAuditor::Stop
static constexpr std::string Stop
Definition: IAuditor.h:52
Service.h
DataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > > >::inputHandles
std::vector< Gaudi::DataHandle * > inputHandles() const override
Definition: DataHandleHolderBase.h:38
Gaudi::StateMachine::ChangeState
State GAUDI_API ChangeState(const Transition transition, const State state)
Function to get the new state according to the required transition, checking if the transition is all...
Definition: StateMachine.cpp:19
StatusCode::isFailure
bool isFailure() const
Definition: StatusCode.h:130
AlgTool::m_interfaceList
InterfaceList m_interfaceList
Interface list.
Definition: AlgTool.h:299
gaudirun.type
type
Definition: gaudirun.py:160
ConditionsStallTest.name
name
Definition: ConditionsStallTest.py:77
StatusCode::SUCCESS
constexpr static const auto SUCCESS
Definition: StatusCode.h:100
AlgTool::service
StatusCode service(std::string_view name, T *&svc, bool createIf=true) const
Access a service by name, creating it if it doesn't already exist.
Definition: AlgTool.h:137
IAuditorSvc
The interface implemented by the IAuditorSvc base class.
Definition: IAuditorSvc.h:24
AlgTool
Definition: AlgTool.h:62
BaseToolHandle
Definition: ToolHandle.h:84
SmartIF::get
TYPE * get() const
Get interface pointer.
Definition: SmartIF.h:86
AlgTool::evtSvc
IDataProviderSvc * evtSvc() const
accessor to event service service
Definition: AlgTool.cpp:97
AlgTool::tools
const std::vector< IAlgTool * > & tools() const
Definition: AlgTool.cpp:398
ServiceLocatorHelper.h
AlgTool::queryInterface
StatusCode queryInterface(const InterfaceID &riid, void **ppvUnknown) override
Query for a given interface.
Definition: AlgTool.cpp:50
ToolHandle.h
Gaudi::StateMachine::INITIALIZED
@ INITIALIZED
Definition: StateMachine.h:25
MSG::ERROR
@ ERROR
Definition: IMessageSvc.h:25
IInterface
Definition: IInterface.h:239
Gaudi::StateMachine::START
@ START
Definition: StateMachine.h:36
AlgTool::sysStart
StatusCode sysStart() override
Start AlgTool.
Definition: AlgTool.cpp:208
AlgTool::m_name
const std::string m_name
AlgTool full name.
Definition: AlgTool.h:290
Gaudi::IAuditor::Initialize
static constexpr std::string Initialize
Definition: IAuditor.h:47
AlgTool::m_pAuditorSvc
SmartIF< IAuditorSvc > m_pAuditorSvc
Auditor Service.
Definition: AlgTool.h:297
AlgTool.h
IDataProviderSvc
Definition: IDataProviderSvc.h:53
InterfaceID
Definition: IInterface.h:39
IOTest.end
end
Definition: IOTest.py:125
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition: StatusCode.h:101
Guards.h
Gaudi::Auditor
Base class from which all concrete auditor classes should be derived.
Definition: Auditor.h:33
ISvcLocator.h
Gaudi::Details::Property::ParsingErrorPolicy::Exception
@ Exception
AlgTool::stop
StatusCode stop() override
Definition: AlgTool.cpp:244
AlgTool::m_outputLevel
Gaudi::Property< int > m_outputLevel
Definition: AlgTool.h:303
IToolSvc
Definition: IToolSvc.h:29
AlgTool::~AlgTool
~AlgTool() override
Definition: AlgTool.cpp:351
IOTest.appMgr
appMgr
Definition: IOTest.py:105
AlgTool::m_auditorStart
Gaudi::Property< bool > m_auditorStart
Definition: AlgTool.h:312
Gaudi::Property< bool >
IDataManagerSvc.h
AlgTool::start
StatusCode start() override
Definition: AlgTool.cpp:222
Gaudi::StateMachine::STOP
@ STOP
Definition: StateMachine.h:37
IDataHandleVisitor::visit
virtual void visit(const IDataHandleHolder *)=0
AlgTool::initToolHandles
void initToolHandles() const
Definition: AlgTool.cpp:357
Gaudi::Functional::details::out
OptOut && out
Definition: details.h:196
Auditor.h
AlgTool::finalize
StatusCode finalize() override
Definition: AlgTool.cpp:265