| The Gaudi Framework v28r2p1 (f1a77ff4)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

AlgTool.cpp
Go to the documentation of this file.
1 // Include files
2 #include "GaudiKernel/AlgTool.h"
3 #include "GaudiKernel/IDataManagerSvc.h"
4 #include "GaudiKernel/IJobOptionsSvc.h"
5 #include "GaudiKernel/IMessageSvc.h"
6 #include "GaudiKernel/ISvcLocator.h"
7
8 #include "GaudiKernel/Algorithm.h"
9 #include "GaudiKernel/Auditor.h"
10 #include "GaudiKernel/DataHandleHolderVisitor.h"
11 #include "GaudiKernel/GaudiException.h"
12 #include "GaudiKernel/Guards.h"
13 #include "GaudiKernel/Service.h"
14 #include "GaudiKernel/ServiceLocatorHelper.h"
15 #include "GaudiKernel/System.h"
16 #include "GaudiKernel/ThreadGaudi.h"
17 #include "GaudiKernel/ToolHandle.h"
18
19 //------------------------------------------------------------------------------
20 namespace
21 {
22 template <typename FUN>
23 StatusCode attempt( AlgTool& tool, const char* label, FUN&& fun )
24 {
25 try {
26 return fun();
27 } catch ( const GaudiException& Exception ) {
28 MsgStream log( tool.msgSvc(), tool.name() + "." + label );
29 log << MSG::FATAL << " Exception with tag=" << Exception.tag() << " is caught" << endmsg;
30 log << MSG::ERROR << Exception << endmsg;
31 } catch ( const std::exception& Exception ) {
32 MsgStream log( tool.msgSvc(), tool.name() + "." + label );
33 log << MSG::FATAL << " Standard std::exception is caught" << endmsg;
34 log << MSG::ERROR << Exception.what() << endmsg;
35 } catch ( ... ) {
36 MsgStream log( tool.msgSvc(), tool.name() + "." + label );
37 log << MSG::FATAL << "UNKNOWN Exception is caught" << endmsg;
38 }
39 return StatusCode::FAILURE;
40 }
41 }
42
43 //------------------------------------------------------------------------------
44 StatusCode AlgTool::queryInterface( const InterfaceID& riid, void** ppvi )
45 //------------------------------------------------------------------------------
46 {
47 if ( !ppvi ) {
48 return StatusCode::FAILURE;
49 } // RETURN
50 StatusCode sc = base_class::queryInterface( riid, ppvi );
51 if ( sc.isSuccess() ) return sc;
52 auto i = std::find_if( std::begin( m_interfaceList ), std::end( m_interfaceList ),
53 [&]( const std::pair<InterfaceID, void*>& item ) { return item.first.versionMatch( riid ); } );
54 if ( i == std::end( m_interfaceList ) ) {
55 *ppvi = nullptr;
56 return NO_INTERFACE; // RETURN
57 }
58 *ppvi = i->second;
59 addRef();
60 return SUCCESS; // RETURN
61 }
62 //------------------------------------------------------------------------------
63 const std::string& AlgTool::name() const
64 //------------------------------------------------------------------------------
65 {
66 return m_name;
67 }
68
69 //------------------------------------------------------------------------------
70 const std::string& AlgTool::type() const
71 //------------------------------------------------------------------------------
72 {
73 return m_type;
74 }
75
76 //------------------------------------------------------------------------------
77 const IInterface* AlgTool::parent() const
78 //------------------------------------------------------------------------------
79 {
80 return m_parent;
81 }
82
83 //------------------------------------------------------------------------------
84 SmartIF<ISvcLocator>& AlgTool::serviceLocator() const
85 //------------------------------------------------------------------------------
86 {
87 return m_svcLocator;
88 }
89
90 // ============================================================================
91 // accessor to event service service
92 // ============================================================================
93 IDataProviderSvc* AlgTool::evtSvc() const
94 {
95 if ( !m_evtSvc ) {
96 m_evtSvc = service( "EventDataSvc", true );
97 if ( !m_evtSvc ) {
98 throw GaudiException( "Service [EventDataSvc] not found", name(), StatusCode::FAILURE );
99 }
100 }
101 return m_evtSvc.get();
102 }
103 //------------------------------------------------------------------------------
104 IToolSvc* AlgTool::toolSvc() const
105 //------------------------------------------------------------------------------
106 {
107 if ( !m_ptoolSvc ) {
108 m_ptoolSvc = service( "ToolSvc", true );
109 if ( !m_ptoolSvc ) {
110 throw GaudiException( "Service [ToolSvc] not found", name(), StatusCode::FAILURE );
111 }
112 }
113 return m_ptoolSvc.get();
114 }
115
116 //------------------------------------------------------------------------------
117 StatusCode AlgTool::setProperties()
118 //------------------------------------------------------------------------------
119 {
120 if ( !m_svcLocator ) return StatusCode::FAILURE;
121 auto jos = m_svcLocator->service<IJobOptionsSvc>( "JobOptionsSvc" );
122 if ( !jos ) return StatusCode::FAILURE;
123
124 // set first generic Properties
125 StatusCode sc = jos->setMyProperties( getGaudiThreadGenericName( name() ), this );
126 if ( sc.isFailure() ) return StatusCode::FAILURE;
127
128 // set specific Properties
129 if ( isGaudiThreaded( name() ) ) {
130 if ( jos->setMyProperties( name(), this ).isFailure() ) {
131 return StatusCode::FAILURE;
132 }
133 }
134 updateMsgStreamOutputLevel( m_outputLevel );
135 return StatusCode::SUCCESS;
136 }
137
138 //------------------------------------------------------------------------------
139 AlgTool::AlgTool( const std::string& type, const std::string& name, const IInterface* parent )
140 //------------------------------------------------------------------------------
141 : m_type( type ),
142 m_name( name ),
143 m_parent( parent )
144 {
145 addRef(); // Initial count set to 1
146
147 IInterface* _p = const_cast<IInterface*>( parent );
148
149 // inherit output level from parent
150 { // get the "OutputLevel" property from parent
151 SmartIF<IProperty> pprop( _p );
152 if ( pprop && pprop->hasProperty( "OutputLevel" ) ) {
153 m_outputLevel.assign( pprop->getProperty( "OutputLevel" ) );
154 }
155 }
156 m_outputLevel.declareUpdateHandler(
157 [this]( Gaudi::Details::PropertyBase& ) { this->updateMsgStreamOutputLevel( this->m_outputLevel ); } );
158
159 if ( Algorithm* _alg = dynamic_cast<Algorithm*>( _p ) ) {
160 m_svcLocator = _alg->serviceLocator();
161 m_threadID = getGaudiThreadIDfromName( _alg->name() );
162 } else if ( Service* _svc = dynamic_cast<Service*>( _p ) ) {
163 m_svcLocator = _svc->serviceLocator();
164 m_threadID = getGaudiThreadIDfromName( _svc->name() );
165 } else if ( AlgTool* _too = dynamic_cast<AlgTool*>( _p ) ) {
166 m_svcLocator = _too->serviceLocator();
167 m_threadID = getGaudiThreadIDfromName( _too->m_threadID );
168 } else if ( Auditor* _aud = dynamic_cast<Auditor*>( _p ) ) {
169 m_svcLocator = _aud->serviceLocator();
170 m_threadID = getGaudiThreadIDfromName( _aud->name() );
171 } else {
172 throw GaudiException( "Failure to create tool '" + type + "/" + name + "': illegal parent type '" +
173 System::typeinfoName( typeid( *_p ) ) + "'",
174 "AlgTool", 0 );
175 }
176
177 {
178 // Auditor monitoring properties
179 // Initialize the default value from ApplicationMgr AuditAlgorithms
180 Gaudi::Property<bool> audit( false );
181 // note that here we need that the service locator is already defined
182 auto appMgr = serviceLocator()->service<IProperty>( "ApplicationMgr" );
183 if ( appMgr && appMgr->hasProperty( "AuditTools" ) ) {
184 audit.assign( appMgr->getProperty( "AuditTools" ) );
185 }
186 m_auditInit = audit;
187 m_auditorInitialize = audit;
188 m_auditorStart = audit;
189 m_auditorStop = audit;
190 m_auditorFinalize = audit;
191 m_auditorReinitialize = audit;
192 m_auditorRestart = audit;
193 }
194
195 // check thread ID and try if tool name indicates thread ID
196 if ( m_threadID.empty() ) {
197 m_threadID = getGaudiThreadIDfromName( AlgTool::name() );
198 }
199 }
200
201 //-----------------------------------------------------------------------------
202 StatusCode AlgTool::sysInitialize()
203 {
204 //-----------------------------------------------------------------------------
205 return attempt( *this, "sysInitialize", [&]() {
206 m_targetState = Gaudi::StateMachine::ChangeState( Gaudi::StateMachine::INITIALIZE, m_state );
207 Gaudi::Guards::AuditorGuard guard( this,
208 // check if we want to audit the initialize
209 m_auditorInitialize ? auditorSvc() : nullptr, IAuditor::Initialize );
210 StatusCode sc = initialize();
211 if ( !sc ) return sc;
212
213 m_state = m_targetState;
214 if (m_updateDataHandles) acceptDHVisitor(m_updateDataHandles.get());
215
216 // visit all sub-tools, build full set
217 DHHVisitor avis(m_inputDataObjs, m_outputDataObjs);
218 acceptDHVisitor(&avis);
219
220 // initialize handles
221 initDataHandleHolder(); // this should 'freeze' the handle configuration.
222
223 return sc;
224 } );
225 }
226 //------------------------------------------------------------------------------
227 StatusCode AlgTool::initialize()
228 //------------------------------------------------------------------------------
229 {
230 // For the time being there is nothing to be done here.
231 // Setting the properties is done by the ToolSvc calling setProperties()
232 // explicitly.
233 return StatusCode::SUCCESS;
234 }
235
236 //-----------------------------------------------------------------------------
237 StatusCode AlgTool::sysStart()
238 {
239 //-----------------------------------------------------------------------------
240 return attempt( *this, "sysStart", [&]() {
241 m_targetState = Gaudi::StateMachine::ChangeState( Gaudi::StateMachine::START, m_state );
242 Gaudi::Guards::AuditorGuard guard( this,
243 // check if we want to audit the initialize
244 m_auditorStart ? auditorSvc() : nullptr, IAuditor::Start );
245 StatusCode sc = start();
246 if ( sc.isSuccess() ) m_state = m_targetState;
247 return sc;
248 } );
249 }
250
251 //------------------------------------------------------------------------------
252 StatusCode AlgTool::start()
253 //------------------------------------------------------------------------------
254 {
255 // For the time being there is nothing to be done here.
256 return StatusCode::SUCCESS;
257 }
258
259 //-----------------------------------------------------------------------------
260 StatusCode AlgTool::sysStop()
261 {
262 //-----------------------------------------------------------------------------
263 return attempt( *this, "sysStop", [&]() {
264 m_targetState = Gaudi::StateMachine::ChangeState( Gaudi::StateMachine::STOP, m_state );
265 Gaudi::Guards::AuditorGuard guard( this,
266 // check if we want to audit the initialize
267 m_auditorStop ? auditorSvc() : nullptr, IAuditor::Stop );
268 StatusCode sc = stop();
269 if ( sc.isSuccess() ) m_state = m_targetState;
270 return sc;
271 } );
272 }
273
274 //------------------------------------------------------------------------------
275 StatusCode AlgTool::stop()
276 //------------------------------------------------------------------------------
277 {
278 // For the time being there is nothing to be done here.
279 return StatusCode::SUCCESS;
280 }
281
282 //-----------------------------------------------------------------------------
283 StatusCode AlgTool::sysFinalize()
284 {
285 //-----------------------------------------------------------------------------
286 return attempt( *this, "sysFinalize", [&]() {
287 m_targetState = Gaudi::StateMachine::ChangeState( Gaudi::StateMachine::FINALIZE, m_state );
288 Gaudi::Guards::AuditorGuard guard( this,
289 // check if we want to audit the initialize
290 m_auditorFinalize ? auditorSvc() : nullptr, IAuditor::Finalize );
291 StatusCode sc = finalize();
292 if ( sc.isSuccess() ) m_state = m_targetState;
293 return sc;
294 } );
295 }
296 //------------------------------------------------------------------------------
297 StatusCode AlgTool::finalize()
298 //------------------------------------------------------------------------------
299 {
300 // For the time being there is nothing to be done here.
301 return StatusCode::SUCCESS;
302 }
303
304 //-----------------------------------------------------------------------------
305 StatusCode AlgTool::sysReinitialize()
306 {
307 //-----------------------------------------------------------------------------
308
309 // Check that the current status is the correct one.
310 if ( Gaudi::StateMachine::INITIALIZED != FSMState() ) {
311 error() << "sysReinitialize(): cannot reinitialize tool not initialized" << endmsg;
312 return StatusCode::FAILURE;
313 }
314
315 return attempt( *this, "SysReinitialize()", [&]() {
316 Gaudi::Guards::AuditorGuard guard( this,
317 // check if we want to audit the initialize
318 m_auditorReinitialize ? auditorSvc() : nullptr, IAuditor::ReInitialize );
319 return reinitialize();
320 } );
321 }
322
323 //------------------------------------------------------------------------------
324 StatusCode AlgTool::reinitialize()
325 //------------------------------------------------------------------------------
326 {
327 /* @TODO
328 * MCl 2008-10-23: the implementation of reinitialize as finalize+initialize
329 * is causing too many problems
330 *
331 // Default implementation is finalize+initialize
332 StatusCode sc = finalize();
333 if (sc.isFailure()) {
334 error() << "reinitialize(): cannot be finalized" << endmsg;
335 return sc;
336 }
337 sc = initialize();
338 if (sc.isFailure()) {
339 error() << "reinitialize(): cannot be initialized" << endmsg;
340 return sc;
341 }
342 */
343 return StatusCode::SUCCESS;
344 }
345
346 //-----------------------------------------------------------------------------
347 StatusCode AlgTool::sysRestart()
348 {
349 //-----------------------------------------------------------------------------
350
351 // Check that the current status is the correct one.
352 if ( Gaudi::StateMachine::RUNNING != FSMState() ) {
353 error() << "sysRestart(): cannot reinitialize tool not started" << endmsg;
354 return StatusCode::FAILURE;
355 }
356
357 return attempt( *this, "sysRestart", [&]() {
358 m_targetState = Gaudi::StateMachine::ChangeState( Gaudi::StateMachine::START, m_state );
359 Gaudi::Guards::AuditorGuard guard( this,
360 // check if we want to audit the initialize
361 m_auditorRestart ? auditorSvc() : nullptr, IAuditor::ReStart );
362 return restart();
363 } );
364 }
365
366 //------------------------------------------------------------------------------
367 StatusCode AlgTool::restart()
368 //------------------------------------------------------------------------------
369 {
370 // Default implementation is stop+start
371 StatusCode sc = stop();
372 if ( sc.isFailure() ) {
373 error() << "restart(): cannot be stopped" << endmsg;
374 return sc;
375 }
376 sc = start();
377 if ( sc.isFailure() ) {
378 error() << "restart(): cannot be started" << endmsg;
379 return sc;
380 }
381 return StatusCode::SUCCESS;
382 }
383
384 //------------------------------------------------------------------------------
385 AlgTool::~AlgTool()
386 //------------------------------------------------------------------------------
387 {
388 if ( m_pMonitorSvc ) {
389 m_pMonitorSvc->undeclareAll( this );
390 }
391 }
392
393 void AlgTool::initToolHandles() const
394 {
395
396 IAlgTool* tool( 0 );
397 for ( auto thArr : m_toolHandleArrays ) {
398 if ( !thArr->retrieved() ) {
399 if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) )
400 debug() << "ToolHandleArray " << thArr->propertyName() << " not used: not registering any of its Tools"
401 << endmsg;
402 } else {
403 if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) )
404 debug() << "Registering all Tools in ToolHandleArray " << thArr->propertyName() << endmsg;
405 // Iterate over its tools:
406 for ( auto toolHandle : thArr->getBaseArray() ) {
407 // Try to cast it into a BaseToolHandle pointer:
408 BaseToolHandle* bth = dynamic_cast<BaseToolHandle*>( toolHandle );
409 if ( bth ) {
410 // If the cast was successful, the code is pretty simple:
411 tool = bth->get();
412 if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) ) {
413 debug() << "Adding " << ( bth->isPublic() ? "public" : "private" ) << " ToolHandle tool " << tool->name()
414 << " (" << tool->type() << ") from ToolHandleArray " << thArr->propertyName() << endmsg;
415 }
416 m_tools.push_back( tool );
417 } else {
418 // If it wasn't for some strange reason, then fall back on the
419 // logic implemented previously:
420 if ( toolSvc()->retrieveTool( toolHandle->typeAndName(), tool, this, false ).isSuccess() ) {
421 if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) ) {
422 debug() << "Adding private"
423 << " ToolHandle tool " << tool->name() << " (" << tool->type() << ") from ToolHandleArray "
424 << thArr->propertyName() << endmsg;
425 }
426 m_tools.push_back( tool );
427 } else if ( toolSvc()->retrieveTool( toolHandle->typeAndName(), tool, 0, false ).isSuccess() ) {
428 if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) ) {
429 debug() << "Adding public"
430 << " ToolHandle tool " << tool->name() << " (" << tool->type() << ") from ToolHandleArray "
431 << thArr->propertyName() << endmsg;
432 }
433 m_tools.push_back( tool );
434 } else {
435 warning() << "Error retrieving Tool " << toolHandle->typeAndName() << " in ToolHandleArray "
436 << thArr->propertyName() << ". Not registered" << endmsg;
437 }
438 }
439 }
440 }
441 }
442
443 for ( auto th : m_toolHandles ) {
444 tool = th->get();
445 if ( tool ) {
446 m_tools.push_back( tool );
447 if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) )
448 debug() << "Adding " << ( th->isPublic() ? "Public" : "Private" ) << " ToolHandle tool " << tool->name() << " ("
449 << tool->type() << ")" << endmsg;
450 } else {
451 if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) ) debug() << "ToolHandle " << th->typeAndName() << " not used" << endmsg;
452 }
453 }
454 m_toolHandlesInit = true;
455 }
456
457 const std::vector<IAlgTool*>& AlgTool::tools() const
458 {
459 if ( UNLIKELY( !m_toolHandlesInit ) ) initToolHandles();
460
461 return m_tools;
462 }
463
464 std::vector<IAlgTool*>& AlgTool::tools()
465 {
466 if ( UNLIKELY( !m_toolHandlesInit ) ) initToolHandles();
467
468 return m_tools;
469 }
470
471 //------------------------------------------------------------------------------
473 StatusCode AlgTool::service_i( const std::string& svcName, bool createIf, const InterfaceID& iid, void** ppSvc ) const
474 {
475 const ServiceLocatorHelper helper( *serviceLocator(), *this );
476 return helper.getService( svcName, createIf, iid, ppSvc );
477 }
478
479 //------------------------------------------------------------------------------
480 StatusCode AlgTool::service_i( const std::string& svcType, const std::string& svcName, const InterfaceID& iid,
481 void** ppSvc ) const
482 {
483 const ServiceLocatorHelper helper( *serviceLocator(), *this );
484 return helper.createService( svcType, svcName, iid, ppSvc );
485 }
486
487 SmartIF<IService> AlgTool::service( const std::string& name, const bool createIf, const bool quiet ) const
488 {
489 const ServiceLocatorHelper helper( *serviceLocator(), *this );
490 return helper.service( name, quiet, createIf );
491 }
492
493 //-----------------------------------------------------------------------------
494 IAuditorSvc* AlgTool::auditorSvc() const
495 {
496 //---------------------------------------------------------------------------
497 if ( !m_pAuditorSvc ) {
498 m_pAuditorSvc = service( "AuditorSvc", true );
499 if ( !m_pAuditorSvc ) {
500 throw GaudiException( "Service [AuditorSvc] not found", name(), StatusCode::FAILURE );
501 }
502 }
503 return m_pAuditorSvc.get();
504 }
505
506 //-----------------------------------------------------------------------------
507 void AlgTool::acceptDHVisitor( IDataHandleVisitor* vis ) const
508 {
509 //-----------------------------------------------------------------------------
510 vis->visit( this );
511
512 for ( auto tool : tools() ) vis->visit( dynamic_cast<AlgTool*>( tool ) );
513 }
514
515 //-----------------------------------------------------------------------------
516 void AlgTool::commitHandles()
517 {
518 //-----------------------------------------------------------------------------
519
520 for ( auto h : outputHandles() ) h->commit();
521
522 for ( auto t : m_tools ) {
523 AlgTool* at = dynamic_cast<AlgTool*>( t );
524 if ( at ) at->commitHandles();
525 }
526 }
IAuditor::Start
Definition: IAuditor.h:25
System.h
IToolSvc
The interface implemented by the IToolSvc base class.
Definition: IToolSvc.h:19
MsgStream
Definition of the MsgStream class used to transmit messages.
Definition: MsgStream.h:24
ServiceLocatorHelper
an helper to share the implementation of service() among the various kernel base classes ...
Definition: ServiceLocatorHelper.h:17
Gaudi::StateMachine::INITIALIZED
Definition: StateMachine.h:15
StatusCode::SUCCESS
Definition: StatusCode.h:30
Algorithm.h
AlgTool::m_pMonitorSvc
SmartIF< IMonitorSvc > m_pMonitorSvc
Online Monitoring Service.
Definition: AlgTool.h:333
SmartIF< ISvcLocator >
std::string::empty
T empty(T...args)
GaudiException
Define general base for Gaudi exception.
Definition: GaudiException.h:23
AlgTool::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Retrieve pointer to service locator.
Definition: AlgTool.cpp:84
AlgTool::acceptDHVisitor
virtual void acceptDHVisitor(IDataHandleVisitor *) const override
Definition: AlgTool.cpp:507
AlgTool::m_auditorStart
Gaudi::Property< bool > m_auditorStart
Definition: AlgTool.h:346
AlgTool::m_toolHandlesInit
bool m_toolHandlesInit
Definition: AlgTool.h:358
AlgTool::m_type
std::string m_type
AlgTool type (concrete class name)
Definition: AlgTool.h:326
StatusCode::FAILURE
Definition: StatusCode.h:29
Gaudi::Property
Implementation of property with value of concrete type.
Definition: Property.h:314
IAuditor::Stop
Definition: IAuditor.h:25
AlgTool::commitHandles
void commitHandles() override
Definition: AlgTool.cpp:516
AlgTool::initialize
StatusCode initialize() override
Definition: AlgTool.cpp:227
AlgTool::service_i
StatusCode service_i(const std::string &algName, bool createIf, const InterfaceID &iid, void **ppSvc) const
flag indicating whether ToolHandle tools have been added to m_tools
Definition: AlgTool.cpp:473
System::typeinfoName
GAUDI_API const std::string typeinfoName(const std::type_info &)
Get platform independent information about the class type.
Definition: System.cpp:299
IAlgTool::type
virtual const std::string & type() const =0
The type of an AlgTool, meaning the concrete AlgTool class.
ToolHandleInfo::isPublic
bool isPublic() const noexcept
Definition: ToolHandle.h:38
Gaudi::StateMachine::FINALIZE
Definition: StateMachine.h:28
IAuditor::ReInitialize
Definition: IAuditor.h:25
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:74
AlgTool.h
GaudiPython.Bindings.SUCCESS
SUCCESS
Definition: Bindings.py:52
IProperty::hasProperty
virtual bool hasProperty(const std::string &name) const =0
Return true if we have a property with the given name.
MSG::DEBUG
Definition: IMessageSvc.h:18
AlgTool::m_parent
const IInterface * m_parent
AlgTool parent.
Definition: AlgTool.h:328
AlgTool::toolSvc
IToolSvc * toolSvc() const
The standard ToolSvc service, Return a pointer to the service if present.
Definition: AlgTool.cpp:104
UNLIKELY
#define UNLIKELY(x)
Definition: Kernel.h:126
BaseToolHandle
Non-templated base class for actual ToolHandle<T>.
Definition: ToolHandle.h:73
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:77
AlgTool::sysReinitialize
StatusCode sysReinitialize() override
Initialize AlgTool.
Definition: AlgTool.cpp:305
std::end
T end(T...args)
IProperty::getProperty
virtual StatusCode getProperty(Gaudi::Details::PropertyBase *p) const =0
Get the property by property.
AlgTool::m_auditorReinitialize
Gaudi::Property< bool > m_auditorReinitialize
Definition: AlgTool.h:349
IDataProviderSvc
Data provider interface definition.
Definition: IDataProviderSvc.h:45
AlgTool::~AlgTool
~AlgTool() override
Definition: AlgTool.cpp:385
AlgTool::m_tools
std::vector< IAlgTool * > m_tools
Definition: AlgTool.h:355
AlgTool::queryInterface
StatusCode queryInterface(const InterfaceID &riid, void **ppvUnknown) override
Query for a given interface.
Definition: AlgTool.cpp:44
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:84
ThreadGaudi.h
isGaudiThreaded
GAUDI_API bool isGaudiThreaded(const std::string &name)
test if current Gaudi object is running /will run in a thread
Definition: ThreadGaudi.cpp:73
IAuditor::ReStart
Definition: IAuditor.h:25
AlgTool::setProperties
StatusCode setProperties()
Method for setting declared properties to the values specified in the jobOptions via the job option s...
Definition: AlgTool.cpp:117
AlgTool::sysStart
StatusCode sysStart() override
Start AlgTool.
Definition: AlgTool.cpp:237
std::string
STL class.
AlgTool::sysStop
StatusCode sysStop() override
Stop AlgTool.
Definition: AlgTool.cpp:260
Service.h
SmartIF::get
TYPE * get() const
Get interface pointer.
Definition: SmartIF.h:76
AlgTool::finalize
StatusCode finalize() override
Definition: AlgTool.cpp:297
AlgTool::m_name
const std::string m_name
AlgTool full name.
Definition: AlgTool.h:327
MSG::FATAL
Definition: IMessageSvc.h:22
IDataHandleVisitor::visit
virtual void visit(const IDataHandleHolder *)=0
ISvcLocator::service
StatusCode service(const Gaudi::Utils::TypeNameString &name, T *&svc, bool createIf=true)
Templated method to access a service by name.
Definition: ISvcLocator.h:78
std::vector::push_back
T push_back(T...args)
AlgTool::FSMState
Gaudi::StateMachine::State FSMState() const override
Definition: AlgTool.h:77
InterfaceID
Interface ID class.
Definition: IInterface.h:30
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:117
AlgTool::AlgTool
AlgTool(const std::string &type, const std::string &name, const IInterface *parent)
Standard Constructor.
Definition: AlgTool.cpp:139
Gaudi::StateMachine::INITIALIZE
Definition: StateMachine.h:25
DataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > > >::m_inputDataObjs
DataObjIDColl m_inputDataObjs
Definition: DataHandleHolderBase.h:81
DataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > > >::outputHandles
std::vector< Gaudi::DataHandle * > outputHandles() const override
Definition: DataHandleHolderBase.h:33
IDataManagerSvc.h
IJobOptionsSvc
Main interface for the JobOptions service.
Definition: IJobOptionsSvc.h:20
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:120
std::exception::what
T what(T...args)
AlgTool::m_outputLevel
Gaudi::Property< int > m_outputLevel
Definition: AlgTool.h:339
HiveAlgSequencer.h
h
Definition: HiveAlgSequencer.py:24
CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > >::updateMsgStreamOutputLevel
void updateMsgStreamOutputLevel(int level)
Update the output level of the cached MsgStream.
Definition: CommonMessaging.h:186
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
GaudiException.h
IInterface
Definition of the basic interface.
Definition: IInterface.h:234
IAuditor::Finalize
Definition: IAuditor.h:25
AlgTool::m_threadID
std::string m_threadID
Thread Id for Alg Tool.
Definition: AlgTool.h:352
AlgTool::service
StatusCode service(const std::string &name, T *&svc, bool createIf=true) const
Access a service by name, creating it if it doesn&#39;t already exist.
Definition: AlgTool.h:131
AlgTool::m_auditorStop
Gaudi::Property< bool > m_auditorStop
Definition: AlgTool.h:347
Guards.h
DHHVisitor
Definition: DataHandleHolderVisitor.h:8
GaudiException::tag
virtual const std::string & tag() const
name tag for the exception, or exception type
Definition: GaudiException.h:119
AlgTool::restart
StatusCode restart() override
Definition: AlgTool.cpp:367
IMessageSvc.h
Gaudi::Details::PropertyBase
PropertyBase base class allowing PropertyBase* collections to be "homogeneous".
Definition: Property.h:32
DataHandleHolderVisitor.h
AlgTool::m_ptoolSvc
SmartIF< IToolSvc > m_ptoolSvc
Tool service.
Definition: AlgTool.h:332
AlgTool::tools
const std::vector< IAlgTool * > & tools() const
Definition: AlgTool.cpp:457
std::exception
STL class.
IAuditor::Initialize
Definition: IAuditor.h:25
Gaudi::StateMachine::STOP
Definition: StateMachine.h:27
AlgTool::evtSvc
IDataProviderSvc * evtSvc() const
accessor to event service service
Definition: AlgTool.cpp:93
std::pair< InterfaceID, void * >
AlgTool::m_pAuditorSvc
SmartIF< IAuditorSvc > m_pAuditorSvc
Auditor Service.
Definition: AlgTool.h:334
AlgTool::m_auditorRestart
Gaudi::Property< bool > m_auditorRestart
Definition: AlgTool.h:350
std::unique_ptr::get
T get(T...args)
IDataHandleVisitor
Definition: IDataHandleHolder.h:38
Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:78
std::find_if
T find_if(T...args)
Gaudi::StateMachine::RUNNING
Definition: StateMachine.h:16
AlgTool::name
const std::string & name() const override
Retrieve full identifying name of the concrete tool object.
Definition: AlgTool.cpp:63
std::vector< IAlgTool * >
AlgTool::m_state
Gaudi::StateMachine::State m_state
state of the Tool
Definition: AlgTool.h:365
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:8
AlgTool::m_toolHandles
std::vector< BaseToolHandle * > m_toolHandles
Definition: AlgTool.h:356
CommonMessagingBase::debug
MsgStream & debug() const
shortcut for the method msgStream(MSG::DEBUG)
Definition: CommonMessaging.h:126
std::begin
T begin(T...args)
AlgTool::m_auditInit
Gaudi::Property< bool > m_auditInit
Definition: AlgTool.h:344
fun
double fun(const std::vector< double > &x)
Definition: PFuncTest.cpp:26
AlgTool
Base class from which all the concrete tool classes should be derived.
Definition: AlgTool.h:48
IAlgTool
The interface implemented by the AlgTool base class.
Definition: IAlgTool.h:23
ToolHandle.h
AlgTool::parent
const IInterface * parent() const override
Retrieve parent of the sub-algtool.
Definition: AlgTool.cpp:77
AlgTool::m_svcLocator
SmartIF< ISvcLocator > m_svcLocator
Pointer to Service Locator service.
Definition: AlgTool.h:330
IOTest.appMgr
appMgr
Definition: IOTest.py:83
AlgTool::m_evtSvc
SmartIF< IDataProviderSvc > m_evtSvc
Event data service.
Definition: AlgTool.h:331
Gaudi::StateMachine::START
Definition: StateMachine.h:26
CommonMessagingBase::msgSvc
SmartIF< IMessageSvc > & msgSvc() const
The standard message service.
Definition: CommonMessaging.h:70
ServiceLocatorHelper.h
MSG::ERROR
Definition: IMessageSvc.h:21
Gaudi::Property::assign
bool assign(const Details::PropertyBase &source) override
get the value from another property
Definition: Property.h:596
ServiceLocatorHelper::service
SmartIF< IService > service(const std::string &name, const bool quiet=false, const bool createIf=true) const
Definition: ServiceLocatorHelper.cpp:63
AlgTool::m_auditorInitialize
Gaudi::Property< bool > m_auditorInitialize
Definition: AlgTool.h:345
AlgTool::reinitialize
StatusCode reinitialize() override
Definition: AlgTool.cpp:324
AlgTool::m_interfaceList
InterfaceList m_interfaceList
Interface list.
Definition: AlgTool.h:336
BaseToolHandle::get
const IAlgTool * get() const
Definition: ToolHandle.h:90
AlgTool::stop
StatusCode stop() override
Definition: AlgTool.cpp:275
AlgTool::sysInitialize
StatusCode sysInitialize() override
Initialize AlgTool.
Definition: AlgTool.cpp:202
queryInterface
StatusCode queryInterface(const InterfaceID &iid, void **pinterface) override
AlgTool::m_targetState
Gaudi::StateMachine::State m_targetState
state of the Tool
Definition: AlgTool.h:366
IProperty
The IProperty is the basic interface for all components which have properties that can be set or get...
Definition: IProperty.h:20
Gaudi::Guards::AuditorGuard
It is a simple guard, which "locks" the scope for the Auditor Service is am exception-safe way...
Definition: Guards.h:214
IAuditorSvc
The interface implemented by the IAuditorSvc base class.
Definition: IAuditorSvc.h:15
Service
Base class for all services.
Definition: Service.h:36
CommonMessagingBase::msgLevel
MSG::Level msgLevel() const
get the output level from the embedded MsgStream
Definition: CommonMessaging.h:135
getGaudiThreadIDfromName
GAUDI_API std::string getGaudiThreadIDfromName(const std::string &name)
helper function to extract Gaudi Thread ID from thread copy name
Definition: ThreadGaudi.cpp:26
IMonitorSvc::undeclareAll
virtual void undeclareAll(const IInterface *owner)=0
Undeclare monitoring information.
AlgTool::initToolHandles
void initToolHandles() const
Definition: AlgTool.cpp:393
Auditor.h
ISvcLocator.h
ServiceLocatorHelper::getService
StatusCode getService(const std::string &name, bool createIf, const InterfaceID &iid, void **ppSvc) const
Definition: ServiceLocatorHelper.h:43
AlgTool::type
const std::string & type() const override
Retrieve type (concrete class) of the sub-algtool.
Definition: AlgTool.cpp:70
AlgTool::auditorSvc
IAuditorSvc * auditorSvc() const
Access the auditor service.
Definition: AlgTool.cpp:494
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244
INamedInterface::name
virtual const std::string & name() const =0
Retrieve the name of the instance.
DataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > > >::m_outputDataObjs
DataObjIDColl m_outputDataObjs
Definition: DataHandleHolderBase.h:81
AlgTool::sysFinalize
StatusCode sysFinalize() override
Finalize AlgTool.
Definition: AlgTool.cpp:283
getGaudiThreadGenericName
GAUDI_API std::string getGaudiThreadGenericName(const std::string &name)
helper function to extract Gaudi instance name from thread copy name
Definition: ThreadGaudi.cpp:50
AlgTool::m_toolHandleArrays
std::vector< GaudiHandleArrayBase * > m_toolHandleArrays
Definition: AlgTool.h:357
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:267
AlgTool::m_auditorFinalize
Gaudi::Property< bool > m_auditorFinalize
Definition: AlgTool.h:348
ServiceLocatorHelper::createService
StatusCode createService(const std::string &name, const InterfaceID &iid, void **ppSvc) const
Definition: ServiceLocatorHelper.cpp:40
Gaudi.Configuration.log
log
Definition: Configuration.py:13
Auditor
Base class from which all concrete auditor classes should be derived.
Definition: Auditor.h:35
IJobOptionsSvc.h
AlgTool::sysRestart
StatusCode sysRestart() override
Start AlgTool.
Definition: AlgTool.cpp:347
AlgTool::start
StatusCode start() override
Definition: AlgTool.cpp:252