AlgTool Class Reference

Base class from which all the concrete tool classes should be derived. More...

#include <GaudiKernel/AlgTool.h>

Inheritance diagram for AlgTool:

Collaboration diagram for AlgTool:

Public Types
using	Factory = Gaudi::PluginService::Factory< IAlgTool *(const std::string &, const std::string &, const IInterface *)>
Public Types inherited from extends< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > >, IDataHandleHolder >
using	base_class = extends
	Typedef to this class. More...
using	extend_interfaces_base = extend_interfaces< Interfaces... >
	Typedef to the base of this class. More...
Public Types inherited from PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > >
using	PropertyHolderImpl = PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > >
	Typedef used to refer to this class from derived classes, as in. More...
Public Types inherited from CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > >
using	base_class = CommonMessaging
Public Types inherited from extend_interfaces< Interfaces... >
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids... >::type
	take union of the ext_iids of all Interfaces... More...

Public Member Functions
StatusCode	queryInterface (const InterfaceID &riid, void **ppvUnknown) override
	Query for a given interface. More...
const std::string &	name () const override
	Retrieve full identifying name of the concrete tool object. More...
const std::string &	type () const override
	Retrieve type (concrete class) of the sub-algtool. More...
const IInterface *	parent () const override
	Retrieve parent of the sub-algtool. More...
StatusCode	configure () override
StatusCode	initialize () override
StatusCode	start () override
StatusCode	stop () override
StatusCode	finalize () override
StatusCode	terminate () override
StatusCode	reinitialize () override
StatusCode	restart () override
Gaudi::StateMachine::State	FSMState () const override
Gaudi::StateMachine::State	targetFSMState () const override
StatusCode	sysInitialize () override
	Initialize AlgTool. More...
StatusCode	sysStart () override
	Start AlgTool. More...
StatusCode	sysStop () override
	Stop AlgTool. More...
StatusCode	sysFinalize () override
	Finalize AlgTool. More...
StatusCode	sysReinitialize () override
	Initialize AlgTool. More...
StatusCode	sysRestart () override
	Start AlgTool. More...
	AlgTool (const std::string &type, const std::string &name, const IInterface *parent)
	Standard Constructor. More...
SmartIF< ISvcLocator > &	serviceLocator () const override
	Retrieve pointer to service locator. More...
ISvcLocator *	svcLoc () const
	shortcut for the method service locator More...
IDataProviderSvc *	evtSvc () const
	accessor to event service service More...
SmartIF< IDataProviderSvc > &	eventSvc () const final override
	Added for interface compatibility with Algorithm. More...
IToolSvc *	toolSvc () const
	The standard ToolSvc service, Return a pointer to the service if present. More...
StatusCode	setProperties ()
	Method for setting declared properties to the values specified in the jobOptions via the job option service. More...
template<class T >
StatusCode	service (const std::string &name, T *&svc, bool createIf=true) const
	Access a service by name, creating it if it doesn't already exist. More...
template<class T >
StatusCode	service (const std::string &type, const std::string &name, T *&svc) const
	Access a service by name, type creating it if it doesn't already exist. More...
SmartIF< IService >	service (const std::string &name, const bool createIf=true, const bool quiet=false) const
	Return a pointer to the service identified by name (or "type/name") More...
template<typename T >
SmartIF< T >	service (const std::string &name, const bool createIf=true, const bool quiet=false) const
template<class T >
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandle< T > &hndl, const std::string &doc="none")
template<class T >
StatusCode	declareTool (ToolHandle< T > &handle, bool createIf=true)
template<class T >
StatusCode	declareTool (ToolHandle< T > &handle, std::string toolTypeAndName, bool createIf=true)
template<class T >
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandleArray< T > &hndlArr, const std::string &doc="none")
template<class T >
void	addToolsArray (ToolHandleArray< T > &hndlArr)
void	registerTool (IAlgTool *tool) const
void	deregisterTool (IAlgTool *tool) const
const std::vector< IAlgTool * > &	tools () const
IAuditorSvc *	auditorSvc () const
	Access the auditor service. More...
IMonitorSvc *	monitorSvc () const
	Access the monitor service. More...
template<class T >
void	declareInfo (const std::string &name, const T &var, const std::string &desc) const
	Declare monitoring information. More...
void	declareInfo (const std::string &name, const std::string &format, const void *var, int size, const std::string &desc) const
	Declare monitoring information (special case) More...
	~AlgTool () override
Public Member Functions inherited from DataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > > >
	DataHandleHolderBase (Args &&...args)
	NOTE: Cannot use "using Super::Super;" due to a GCC 6 bug. More...
void	registerDataHandle (Gaudi::v2::DataHandle &handle) final override
	Register a data handle of this algorithm/tool. More...
void	addDataDependency (const DataObjID &key, AccessMode access) final override
	Add a data dependency, even after initialization. More...
const DataObjIDColl &	dataDependencies (AccessMode access) const final override
	Tell which whiteboard keys the algorithm will be reading or writing. More...
void	declare (Gaudi::v1::DataHandle &handle) override
	Declare ownership of a legacy DataHandle. More...
void	renounce (Gaudi::v1::DataHandle &handle) override
	Discard ownership of a legacy DataHandle. More...
const DataObjIDColl *	allDataDependencies () const final override
Public Member Functions inherited from extends< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > >, IDataHandleHolder >
void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...
Public Member Functions inherited from PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > >
	PropertyHolder ()=default
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Details::PropertyBase &prop)
	Declare a property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, TYPE &value, const std::string &doc="none")
	Helper to wrap a regular data member and use it as a regular property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, Gaudi::Property< TYPE, VERIFIER, HANDLERS > &prop, const std::string &doc="none")
	Declare a PropertyBase instance setting name and documentation. More...
Gaudi::Details::PropertyBase *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="")
	Declare a remote property. More...
StatusCode	setProperty (const Gaudi::Details::PropertyBase &p) override
	set the property form another property More...
StatusCode	setProperty (const std::string &s) override
	set the property from the formatted string More...
StatusCode	setProperty (const std::string &n, const std::string &v) override
	set the property from name and the value More...
StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value More...
StatusCode	getProperty (Gaudi::Details::PropertyBase *p) const override
	get the property More...
const Gaudi::Details::PropertyBase &	getProperty (const std::string &name) const override
	get the property by name More...
StatusCode	getProperty (const std::string &n, std::string &v) const override
	convert the property to the string More...
const std::vector< Gaudi::Details::PropertyBase * > &	getProperties () const override
	get all properties More...
bool	hasProperty (const std::string &name) const override
	Return true if we have a property with the given name. More...
	PropertyHolder (const PropertyHolder &)=delete
PropertyHolder &	operator= (const PropertyHolder &)=delete
Public Member Functions inherited from CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > >
MSG::Level	msgLevel () const
	get the cached level (originally extracted from the embedded MsgStream) More...
bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream More...
MSG::Level	outputLevel () const
	Backward compatibility function for getting the output level. More...
Public Member Functions inherited from CommonMessagingBase
virtual	~CommonMessagingBase ()=default
	Virtual destructor. More...
const SmartIF< IMessageSvc > &	msgSvc () const
	The standard message service. More...
MsgStream &	msgStream () const
	Return an uninitialized MsgStream. More...
MsgStream &	msgStream (const MSG::Level level) const
	Predefined configurable message stream for the efficient printouts. More...
MsgStream &	always () const
	shortcut for the method msgStream(MSG::ALWAYS) More...
MsgStream &	fatal () const
	shortcut for the method msgStream(MSG::FATAL) More...
MsgStream &	err () const
	shortcut for the method msgStream(MSG::ERROR) More...
MsgStream &	error () const
	shortcut for the method msgStream(MSG::ERROR) More...
MsgStream &	warning () const
	shortcut for the method msgStream(MSG::WARNING) More...
MsgStream &	info () const
	shortcut for the method msgStream(MSG::INFO) More...
MsgStream &	debug () const
	shortcut for the method msgStream(MSG::DEBUG) More...
MsgStream &	verbose () const
	shortcut for the method msgStream(MSG::VERBOSE) More...
MsgStream &	msg () const
	shortcut for the method msgStream(MSG::INFO) More...

Protected Member Functions
template<typename I >
void	declareInterface (I *i)
std::vector< IAlgTool * > &	tools ()
Protected Member Functions inherited from DataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > > >
void	updateDataDependencies (const DataObjIDMapping &keyMap)
	Update the key of each registered data dependency, using a user-defined mapping from the old to the new key. More...
void	collectExplicitDataDependencies ()
	Collect all explicit data dependencies in a single place. More...
StatusCode	handleCircularDataDependencies (CircularDepHandler &&circularDepHandler)
	Look for circular dependencies and let a user-specified handler deal with each of them. More...
void	collectImplicitDataDependencies (const IDataHandleHolder *child)
	Add the dependencies of another DataHandleHolder to our dependency list. More...
const DataObjIDColl &	ignoredDataDependencies (AccessMode access) const
	Tell which data dependencies have been ignored due to an empty key. More...
void	initializeDataHandleHolder ()
	Initialize the DataHandles. More...
Protected Member Functions inherited from PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > >
Gaudi::Details::PropertyBase *	property (const std::string &name) const
Protected Member Functions inherited from CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > >
MSG::Level	setUpMessaging () const
	Set up local caches. More...
MSG::Level	resetMessaging ()
	Reinitialize internal states. More...
void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream. More...

Protected Attributes
DataObjIDMapping	m_updateDependencies
	Hook for for derived classes to alter the DataObjID of dependencies. More...

Private Types
typedef std::list< std::pair< InterfaceID, void * > >	InterfaceList

Private Member Functions
void	initToolHandles () const
void	addUninitializedTool (AlgTool *tool)
void	propagateUninitializedTools (AlgTool *tool)
StatusCode	service_i (const std::string &algName, bool createIf, const InterfaceID &iid, void **ppSvc) const
	implementation of service method More...
StatusCode	service_i (const std::string &svcType, const std::string &svcName, const InterfaceID &iid, void **ppS) const

Private Attributes
std::string	m_type
	AlgTool type (concrete class name) More...
const std::string	m_name
	AlgTool full name. More...
const IInterface *	m_parent = nullptr
	AlgTool parent. More...
SmartIF< ISvcLocator >	m_svcLocator
	Pointer to Service Locator service. More...
SmartIF< IDataProviderSvc >	m_evtSvc
	Event data service. More...
SmartIF< IToolSvc >	m_ptoolSvc
	Tool service. More...
SmartIF< IMonitorSvc >	m_pMonitorSvc
	Online Monitoring Service. More...
SmartIF< IAuditorSvc >	m_pAuditorSvc
	Auditor Service. More...
InterfaceList	m_interfaceList
	Interface list. More...
Gaudi::Property< int >	m_outputLevel
Gaudi::Property< std::string >	m_monitorSvcName
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()"}
std::vector< IAlgTool * >	m_tools
std::vector< BaseToolHandle * >	m_toolHandles
std::vector< GaudiHandleArrayBase * >	m_toolHandleArrays
bool	m_toolHandlesInit = false
std::unordered_set< AlgTool * >	m_uninitializedTools
	flag indicating whether ToolHandle tools have been added to m_tools More...
std::unordered_set< AlgTool * >	m_toolsAwaitingInit
Gaudi::StateMachine::State	m_state = Gaudi::StateMachine::CONFIGURED
	state of the Tool More...
Gaudi::StateMachine::State	m_targetState = Gaudi::StateMachine::CONFIGURED
	state of the Tool More...

Additional Inherited Members
Protected Types inherited from DataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > > >
enum	CircularDepAction
	A circular dependency handling action. More...
using	DataObjIDMapping = std::function< boost::optional< DataObjID >(const DataObjID &)>
	DataObjID mapping function, with optimized identity mapping case. More...
using	CircularDepHandler = std::function< CircularDepAction(const DataObjID &)>
	A circular dependency handler, which can take any user-specified step (e.g. More...

Detailed Description

Base class from which all the concrete tool classes should be derived.

Specific methods for doing something useful should be implemented in the concrete tools. Sub-types of this class could implement an additional interface for behavior common to sets of concrete tools (for example vertexers).

Author

Gloria Corti

Pere Mato

Definition at line 47 of file AlgTool.h.

Member Typedef Documentation

using AlgTool::Factory = Gaudi::PluginService::Factory<IAlgTool*( const std::string&, const std::string&, const IInterface* )>

Definition at line 52 of file AlgTool.h.

typedef std::list<std::pair<InterfaceID, void*> > AlgTool::InterfaceList

private

Definition at line 296 of file AlgTool.h.

Constructor & Destructor Documentation

AlgTool::AlgTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Standard Constructor.

Parameters

type	the concrete class of the sub-algtool
name	the full name of the concrete sub-algtool
parent	the parent of the concrete sub-algtool

Definition at line 126 of file AlgTool.cpp.

    : m_type( type ),
      m_name( name ),
      m_parent( parent )
{
  addRef(); // Initial count set to 1

  IInterface* _p = const_cast<IInterface*>( parent );

  if ( Algorithm* _alg = dynamic_cast<Algorithm*>( _p ) ) {
    m_svcLocator = _alg->serviceLocator();
  } else if ( Service* _svc = dynamic_cast<Service*>( _p ) ) {
    m_svcLocator = _svc->serviceLocator();
  } else if ( AlgTool* _too = dynamic_cast<AlgTool*>( _p ) ) {
    m_svcLocator = _too->serviceLocator();
  } else if ( Auditor* _aud = dynamic_cast<Auditor*>( _p ) ) {
    m_svcLocator = _aud->serviceLocator();
  } else {
    throw GaudiException( "Failure to create tool '" + type + "/" + name + "': illegal parent type '" +
                              System::typeinfoName( typeid( *_p ) ) + "'",
                          "AlgTool", StatusCode::FAILURE );
  }

  // inherit output level from parent
  { // get the "OutputLevel" property from parent
    SmartIF<IProperty> pprop( _p );
    if ( pprop && pprop->hasProperty( "OutputLevel" ) ) {
      m_outputLevel.assign( pprop->getProperty( "OutputLevel" ) );
    }
  }

  {
    // Auditor monitoring properties
    // Initialize the default value from ApplicationMgr AuditAlgorithms
    Gaudi::Property<bool> audit( false );
    // note that here we need that the service locator is already defined
    auto appMgr = serviceLocator()->service<IProperty>( "ApplicationMgr" );
    if ( appMgr && appMgr->hasProperty( "AuditTools" ) ) {
      audit.assign( appMgr->getProperty( "AuditTools" ) );
    }
    m_auditInit           = audit;
    m_auditorInitialize   = audit;
    m_auditorStart        = audit;
    m_auditorStop         = audit;
    m_auditorFinalize     = audit;
    m_auditorReinitialize = audit;
    m_auditorRestart      = audit;
  }
}

AlgTool::~AlgTool ( )

override

Definition at line 399 of file AlgTool.cpp.

{
  if ( m_pMonitorSvc ) {
    m_pMonitorSvc->undeclareAll( this );
  }
}

Member Function Documentation

template<class T >

void AlgTool::addToolsArray ( ToolHandleArray< T > &  hndlArr )

inline

Definition at line 204 of file AlgTool.h.

  {
    m_toolHandleArrays.push_back( &hndlArr );
  }

void AlgTool::addUninitializedTool ( AlgTool *  tool )

private

Definition at line 478 of file AlgTool.cpp.

{
  if ( tool == this ) return;
  m_uninitializedTools.insert( tool );
  tool->m_toolsAwaitingInit.insert( this );
}

IAuditorSvc * AlgTool::auditorSvc

(

)

const

Access the auditor service.

Definition at line 529 of file AlgTool.cpp.

{
  //---------------------------------------------------------------------------
  if ( !m_pAuditorSvc ) {
    m_pAuditorSvc = service( "AuditorSvc", true );
    if ( !m_pAuditorSvc ) {
      throw GaudiException( "Service [AuditorSvc] not found", name(), StatusCode::FAILURE );
    }
  }
  return m_pAuditorSvc.get();
}

StatusCode AlgTool::configure ( )

inlineoverride

Definition at line 67 of file AlgTool.h.

{ return StatusCode::SUCCESS; }

template<class T >

void AlgTool::declareInfo ( const std::string &  name, const T &  var, const std::string &  desc  ) const

inline

Declare monitoring information.

Parameters

name	Monitoring information name known to the external system
var	Monitoring Listener address (the item to monitor...)
desc	Textual description of the information being monitored

Definition at line 272 of file AlgTool.h.

  {
    IMonitorSvc* mS = monitorSvc();
    if ( mS ) mS->declareInfo( name, var, desc, this );
  }

void AlgTool::declareInfo ( const std::string &  name, const std::string &  format, const void *  var, int  size, const std::string &  desc  ) const

inline

Declare monitoring information (special case)

Parameters

name	Monitoring information name known to the external system
format	Format information
var	Monitoring Listener address
size	Monitoring Listener address size
desc	Textual description of the information being monitored

Definition at line 285 of file AlgTool.h.

  {
    IMonitorSvc* mS = monitorSvc();
    if ( mS ) mS->declareInfo( name, format, var, size, desc, this );
  }

template<typename I >

void AlgTool::declareInterface ( I *  i )

inlineprotected

Definition at line 155 of file AlgTool.h.

  {
    m_interfaceList.emplace_back( I::interfaceID(), i );
  }

template<class T >

Gaudi::Details::PropertyBase* AlgTool::declareProperty ( const std::string &  name, ToolHandle< T > &  hndl, const std::string &  doc = "none"  )

inline

Definition at line 164 of file AlgTool.h.

  {
    this->declareTool( hndl, hndl.typeAndName() ).ignore();
    return PropertyHolderImpl::declareProperty( name, hndl, doc );
  }

template<class T >

Gaudi::Details::PropertyBase* AlgTool::declareProperty ( const std::string &  name, ToolHandleArray< T > &  hndlArr, const std::string &  doc = "none"  )

inline

Definition at line 196 of file AlgTool.h.

  {
    addToolsArray( hndlArr );
    return PropertyHolderImpl::declareProperty( name, hndlArr, doc );
  }

template<class T >

StatusCode AlgTool::declareTool ( ToolHandle< T > &  handle, bool  createIf = true  )

inline

Definition at line 172 of file AlgTool.h.

  {
    return this->declareTool( handle, handle.typeAndName(), createIf );
  }

template<class T >

StatusCode AlgTool::declareTool ( ToolHandle< T > &  handle, std::string  toolTypeAndName, bool  createIf = true  )

inline

Definition at line 178 of file AlgTool.h.

  {

    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;
  }

void AlgTool::deregisterTool ( IAlgTool *  tool ) const

inline

Definition at line 216 of file AlgTool.h.

  {
    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;
    }
  }

SmartIF< IDataProviderSvc > & AlgTool::eventSvc ( ) const

finaloverride

Added for interface compatibility with Algorithm.

Definition at line 91 of file AlgTool.cpp.

{
  if ( !m_evtSvc ) {
    m_evtSvc = service( "EventDataSvc", true );
    if ( !m_evtSvc ) {
      throw GaudiException( "Service [EventDataSvc] not found", name(), StatusCode::FAILURE );
    }
  }
  return m_evtSvc;
}

IDataProviderSvc* AlgTool::evtSvc ( ) const

inline

accessor to event service service

Returns

pointer to detector service

Definition at line 113 of file AlgTool.h.

{ return eventSvc().get(); }

StatusCode AlgTool::finalize ( )

override

Definition at line 311 of file AlgTool.cpp.

{
  // For the time being there is nothing to be done here.
  return StatusCode::SUCCESS;
}

Gaudi::StateMachine::State AlgTool::FSMState ( ) const

inlineoverride

Definition at line 75 of file AlgTool.h.

{ return m_state; }

StatusCode AlgTool::initialize ( )

override

Definition at line 241 of file AlgTool.cpp.

{
  // For the time being there is nothing to be done here.
  // Setting the properties is done by the ToolSvc calling setProperties()
  // explicitly.
  return StatusCode::SUCCESS;
}

void AlgTool::initToolHandles ( ) const

private

Definition at line 407 of file AlgTool.cpp.

{

  IAlgTool* tool = nullptr;
  for ( auto thArr : m_toolHandleArrays ) {
    if ( !thArr->retrieved() ) {
      if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) )
        debug() << "ToolHandleArray " << thArr->propertyName() << " not used: not registering any of its Tools"
                << endmsg;
    } else {
      if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) )
        debug() << "Registering all Tools in ToolHandleArray " << thArr->propertyName() << endmsg;
      // Iterate over its tools:
      for ( auto toolHandle : thArr->getBaseArray() ) {
        // Try to cast it into a BaseToolHandle pointer:
        BaseToolHandle* bth = dynamic_cast<BaseToolHandle*>( toolHandle );
        if ( bth ) {
          // If the cast was successful, the code is pretty simple:
          tool = bth->get();
          if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) ) {
            debug() << "Adding " << ( bth->isPublic() ? "public" : "private" ) << " ToolHandle tool " << tool->name()
                    << " (" << tool->type() << ") from ToolHandleArray " << thArr->propertyName() << endmsg;
          }
          m_tools.push_back( tool );
        } else {
          // If it wasn't for some strange reason, then fall back on the
          // logic implemented previously:
          if ( toolSvc()->retrieveTool( toolHandle->typeAndName(), tool, this, false ).isSuccess() ) {
            if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) ) {
              debug() << "Adding private"
                      << " ToolHandle tool " << tool->name() << " (" << tool->type() << ") from ToolHandleArray "
                      << thArr->propertyName() << endmsg;
            }
            m_tools.push_back( tool );
          } else if ( toolSvc()->retrieveTool( toolHandle->typeAndName(), tool, 0, false ).isSuccess() ) {
            if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) ) {
              debug() << "Adding public"
                      << " ToolHandle tool " << tool->name() << " (" << tool->type() << ") from ToolHandleArray "
                      << thArr->propertyName() << endmsg;
            }
            m_tools.push_back( tool );
          } else {
            warning() << "Error retrieving Tool " << toolHandle->typeAndName() << " in ToolHandleArray "
                      << thArr->propertyName() << ". Not registered" << endmsg;
          }
        }
      }
    }
  }

  for ( auto th : m_toolHandles ) {
    if ( !th->isEnabled() ) {
      if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) && !th->typeAndName().empty() )
        debug() << "ToolHandle " << th->typeAndName() << " not used" << endmsg;
      continue;
    }
    if ( !th->get() ) {
      auto sc = th->retrieve();
      if ( UNLIKELY( sc.isFailure() ) ) {
        throw GaudiException( "Failed to retrieve tool " + th->typeAndName(), this->name(), StatusCode::FAILURE );
      }
    }
    tool = th->get();
    if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) )
      debug() << "Adding " << ( th->isPublic() ? "public" : "private" ) << " ToolHandle tool " << tool->name() << " ("
              << tool->type() << ")" << endmsg;
    m_tools.push_back( tool );
  }
  m_toolHandlesInit = true;
}

IMonitorSvc* AlgTool::monitorSvc ( ) const

inline

Access the monitor service.

Attention

Note that this method will return a NULL pointer if no monitor service is configured to be present. You must take this possibility into account when using the pointer

Returns

Pointer to the Monitor service

Return values

NULL	No monitor service is present
non-NULL	A monitor service is present and available to be used

Definition at line 259 of file AlgTool.h.

  {
    // 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();
  }

const std::string & AlgTool::name ( ) const

override

Retrieve full identifying name of the concrete tool object.

Definition at line 61 of file AlgTool.cpp.

{
  return m_name;
}

const IInterface * AlgTool::parent ( ) const

override

Retrieve parent of the sub-algtool.

Definition at line 75 of file AlgTool.cpp.

{
  return m_parent;
}

void AlgTool::propagateUninitializedTools ( AlgTool *  tool )

private

Definition at line 485 of file AlgTool.cpp.

{
  for ( auto uninitializedTool : tool->m_uninitializedTools ) {
    addUninitializedTool( uninitializedTool );
  }
}

StatusCode AlgTool::queryInterface ( const InterfaceID &  riid, void **  ppvUnknown  )

override

Query for a given interface.

Definition at line 42 of file AlgTool.cpp.

{
  if ( !ppvi ) {
    return StatusCode::FAILURE;
  } // RETURN
  StatusCode sc = base_class::queryInterface( riid, ppvi );
  if ( sc.isSuccess() ) return sc;
  auto i = std::find_if( std::begin( m_interfaceList ), std::end( m_interfaceList ),
                         [&]( const std::pair<InterfaceID, void*>& item ) { return item.first.versionMatch( riid ); } );
  if ( i == std::end( m_interfaceList ) ) {
    *ppvi = nullptr;
    return Status::NO_INTERFACE; // RETURN
  }
  *ppvi = i->second;
  addRef();
  return StatusCode::SUCCESS; // RETURN
}

void AlgTool::registerTool ( IAlgTool *  tool ) const

inline

Definition at line 210 of file AlgTool.h.

  {
    if ( UNLIKELY( msgLevel( MSG::DEBUG ) ) ) debug() << "Registering tool " << tool->name() << endmsg;
    m_tools.push_back( tool );
  }

StatusCode AlgTool::reinitialize ( )

override

Definition at line 338 of file AlgTool.cpp.

{
  /* @TODO
   * MCl 2008-10-23: the implementation of reinitialize as finalize+initialize
   *                 is causing too many problems
   *
  // Default implementation is finalize+initialize
  StatusCode sc = finalize();
  if (sc.isFailure()) {
    error() << "reinitialize(): cannot be finalized" << endmsg;
    return sc;
  }
  sc = initialize();
  if (sc.isFailure()) {
    error() << "reinitialize(): cannot be initialized" << endmsg;
    return sc;
  }
  */
  return StatusCode::SUCCESS;
}

StatusCode AlgTool::restart ( )

override

Definition at line 381 of file AlgTool.cpp.

{
  // Default implementation is stop+start
  StatusCode sc = stop();
  if ( sc.isFailure() ) {
    error() << "restart(): cannot be stopped" << endmsg;
    return sc;
  }
  sc = start();
  if ( sc.isFailure() ) {
    error() << "restart(): cannot be started" << endmsg;
    return sc;
  }
  return StatusCode::SUCCESS;
}

template<class T >

StatusCode AlgTool::service ( const std::string &  name, T *&  svc, bool  createIf = true  ) const

inline

Access a service by name, creating it if it doesn't already exist.

Definition at line 131 of file AlgTool.h.

  {
    return service_i( name, createIf, T::interfaceID(), (void**)&svc );
  }

template<class T >

StatusCode AlgTool::service ( const std::string &  type, const std::string &  name, T *&  svc  ) const

inline

Access a service by name, type creating it if it doesn't already exist.

Definition at line 139 of file AlgTool.h.

  {
    return service_i( type, name, T::interfaceID(), reinterpret_cast<void**>( &svc ) );
  }

SmartIF< IService > AlgTool::service	(	const std::string &	name,
		const bool	createIf = true,
		const bool	quiet = false
	)		const

Return a pointer to the service identified by name (or "type/name")

Definition at line 522 of file AlgTool.cpp.

{
  const ServiceLocatorHelper helper( *serviceLocator(), *this );
  return helper.service( name, quiet, createIf );
}

template<typename T >

SmartIF<T> AlgTool::service ( const std::string &  name, const bool  createIf = true, const bool  quiet = false  ) const

inline

Definition at line 148 of file AlgTool.h.

  {
    return SmartIF<T>( service( name, createIf, quiet ) );
  }

StatusCode AlgTool::service_i ( const std::string &  algName, bool  createIf, const InterfaceID &  iid, void **  ppSvc  ) const

private

implementation of service method

Definition at line 508 of file AlgTool.cpp.

{
  const ServiceLocatorHelper helper( *serviceLocator(), *this );
  return helper.getService( svcName, createIf, iid, ppSvc );
}

StatusCode AlgTool::service_i ( const std::string &  svcType, const std::string &  svcName, const InterfaceID &  iid, void **  ppS  ) const

private

Definition at line 515 of file AlgTool.cpp.

{
  const ServiceLocatorHelper helper( *serviceLocator(), *this );
  return helper.createService( svcType, svcName, iid, ppSvc );
}

SmartIF< ISvcLocator > & AlgTool::serviceLocator ( ) const

override

Retrieve pointer to service locator.

Definition at line 82 of file AlgTool.cpp.

{
  return m_svcLocator;
}

StatusCode AlgTool::setProperties

(

)

Method for setting declared properties to the values specified in the jobOptions via the job option service.

This method is called by the ToolSvc after creating the concrete tool, before passing it to the requesting parent and does not need to be called explicitly.

Definition at line 115 of file AlgTool.cpp.

{
  if ( !m_svcLocator ) return StatusCode::FAILURE;
  auto jos = m_svcLocator->service<IJobOptionsSvc>( "JobOptionsSvc" );
  if ( !jos ) return StatusCode::FAILURE;

  return jos->setMyProperties( name(), this );
}

StatusCode AlgTool::start ( )

override

Definition at line 266 of file AlgTool.cpp.

{
  // For the time being there is nothing to be done here.
  return StatusCode::SUCCESS;
}

StatusCode AlgTool::stop ( )

override

Definition at line 289 of file AlgTool.cpp.

{
  // For the time being there is nothing to be done here.
  return StatusCode::SUCCESS;
}

ISvcLocator* AlgTool::svcLoc ( ) const

inline

shortcut for the method service locator

Definition at line 108 of file AlgTool.h.

{ return serviceLocator(); }

StatusCode AlgTool::sysFinalize ( )

override

Finalize AlgTool.

Definition at line 297 of file AlgTool.cpp.

{
  //-----------------------------------------------------------------------------
  return attempt( *this, "sysFinalize", [&]() {
    m_targetState = Gaudi::StateMachine::ChangeState( Gaudi::StateMachine::FINALIZE, m_state );
    Gaudi::Guards::AuditorGuard guard( this,
                                       // check if we want to audit the initialize
                                       m_auditorFinalize ? auditorSvc() : nullptr, IAuditor::Finalize );
    StatusCode sc                 = finalize();
    if ( sc.isSuccess() ) m_state = m_targetState;
    return sc;
  } );
}

StatusCode AlgTool::sysInitialize ( )

override

Initialize AlgTool.

Definition at line 178 of file AlgTool.cpp.

{
  //-----------------------------------------------------------------------------
  return attempt( *this, "sysInitialize", [&]() {
    m_targetState = Gaudi::StateMachine::ChangeState( Gaudi::StateMachine::INITIALIZE, m_state );
    Gaudi::Guards::AuditorGuard guard( this,
                                       // check if we want to audit the initialize
                                       m_auditorInitialize ? auditorSvc() : nullptr, IAuditor::Initialize );
    StatusCode sc = initialize();
    if ( !sc ) return sc;

    m_state = m_targetState;

    // Perfor any scheduled dependency update
    if ( m_updateDependencies ) updateDataDependencies( m_updateDependencies );

    // Collect all explicit dependencies in a single place
    collectExplicitDataDependencies();

    // Check for explicit circular data dependencies
    sc = handleCircularDataDependencies( [this]( const DataObjID& key ) -> CircularDepAction {
      error() << "Explicit circular data dependency detected for id " << key << endmsg;
      return CircularDepAction::Abort;
    } );
    if ( !sc ) return sc;

    // Add tool dependencies to our dependency list
    for ( auto i_tool : tools() ) {
      auto tool = dynamic_cast<AlgTool*>( i_tool );

      // Here, there is an edge case to be handled concerning circular
      // dependencies between tools: in the presence of a circular dependency,
      // one tool will observe the other in an uninitialized state, before its
      // data dependencies are ready and finalized.
      //
      // To handle this, we need to setup a notification mechanism so that this
      // tool may complete our dependency list once it is initialized. And we
      // also need to propagate this information and notification to any tool
      // depending on us which will be initialized in meantime.
      //
      if ( tool->FSMState() >= Gaudi::StateMachine::INITIALIZED ) {
        collectImplicitDataDependencies( tool );
        propagateUninitializedTools( tool );
      } else {
        addUninitializedTool( tool );
      }
    }

    // Initialize the inner DataHandles
    initializeDataHandleHolder(); // this should 'freeze' the handle configuration.

    // Notify all tools waiting for us to be initialized
    for ( auto tool : m_toolsAwaitingInit ) {
      tool->collectImplicitDataDependencies( this );
      tool->propagateUninitializedTools( this );
      tool->m_uninitializedTools.erase( this );
    }
    m_toolsAwaitingInit.clear();

    return sc;
  } );
}

StatusCode AlgTool::sysReinitialize ( )

override

Initialize AlgTool.

Definition at line 319 of file AlgTool.cpp.

{
  //-----------------------------------------------------------------------------

  // Check that the current status is the correct one.
  if ( Gaudi::StateMachine::INITIALIZED != FSMState() ) {
    error() << "sysReinitialize(): cannot reinitialize tool not initialized" << endmsg;
    return StatusCode::FAILURE;
  }

  return attempt( *this, "SysReinitialize()", [&]() {
    Gaudi::Guards::AuditorGuard guard( this,
                                       // check if we want to audit the initialize
                                       m_auditorReinitialize ? auditorSvc() : nullptr, IAuditor::ReInitialize );
    return reinitialize();
  } );
}

StatusCode AlgTool::sysRestart ( )

override

Start AlgTool.

Definition at line 361 of file AlgTool.cpp.

{
  //-----------------------------------------------------------------------------

  // Check that the current status is the correct one.
  if ( Gaudi::StateMachine::RUNNING != FSMState() ) {
    error() << "sysRestart(): cannot reinitialize tool not started" << endmsg;
    return StatusCode::FAILURE;
  }

  return attempt( *this, "sysRestart", [&]() {
    m_targetState = Gaudi::StateMachine::ChangeState( Gaudi::StateMachine::START, m_state );
    Gaudi::Guards::AuditorGuard guard( this,
                                       // check if we want to audit the initialize
                                       m_auditorRestart ? auditorSvc() : nullptr, IAuditor::ReStart );
    return restart();
  } );
}

StatusCode AlgTool::sysStart ( )

override

Start AlgTool.

Definition at line 251 of file AlgTool.cpp.

{
  //-----------------------------------------------------------------------------
  return attempt( *this, "sysStart", [&]() {
    m_targetState = Gaudi::StateMachine::ChangeState( Gaudi::StateMachine::START, m_state );
    Gaudi::Guards::AuditorGuard guard( this,
                                       // check if we want to audit the initialize
                                       m_auditorStart ? auditorSvc() : nullptr, IAuditor::Start );
    StatusCode sc                 = start();
    if ( sc.isSuccess() ) m_state = m_targetState;
    return sc;
  } );
}

StatusCode AlgTool::sysStop ( )

override

Stop AlgTool.

Definition at line 274 of file AlgTool.cpp.

{
  //-----------------------------------------------------------------------------
  return attempt( *this, "sysStop", [&]() {
    m_targetState = Gaudi::StateMachine::ChangeState( Gaudi::StateMachine::STOP, m_state );
    Gaudi::Guards::AuditorGuard guard( this,
                                       // check if we want to audit the initialize
                                       m_auditorStop ? auditorSvc() : nullptr, IAuditor::Stop );
    StatusCode sc                 = stop();
    if ( sc.isSuccess() ) m_state = m_targetState;
    return sc;
  } );
}

Gaudi::StateMachine::State AlgTool::targetFSMState ( ) const

inlineoverride

Definition at line 76 of file AlgTool.h.

{ return m_targetState; }

StatusCode AlgTool::terminate ( )

inlineoverride

Definition at line 72 of file AlgTool.h.

{ return StatusCode::SUCCESS; }

const std::vector< IAlgTool * > & AlgTool::tools

(

)

const

Definition at line 492 of file AlgTool.cpp.

{
  if ( UNLIKELY( !m_toolHandlesInit ) ) initToolHandles();

  return m_tools;
}

std::vector< IAlgTool * > & AlgTool::tools ( )

protected

Definition at line 499 of file AlgTool.cpp.

{
  if ( UNLIKELY( !m_toolHandlesInit ) ) initToolHandles();

  return m_tools;
}

IToolSvc * AlgTool::toolSvc

(

)

const

The standard ToolSvc service, Return a pointer to the service if present.

Definition at line 102 of file AlgTool.cpp.

{
  if ( !m_ptoolSvc ) {
    m_ptoolSvc = service( "ToolSvc", true );
    if ( !m_ptoolSvc ) {
      throw GaudiException( "Service [ToolSvc] not found", name(), StatusCode::FAILURE );
    }
  }
  return m_ptoolSvc.get();
}

const std::string & AlgTool::type ( ) const

override

Retrieve type (concrete class) of the sub-algtool.

Definition at line 68 of file AlgTool.cpp.

{
  return m_type;
}

Member Data Documentation

Gaudi::Property<bool> AlgTool::m_auditInit {this, "AuditTools", false, "[[deprecated]] unused"}

private

Definition at line 319 of file AlgTool.h.

Gaudi::Property<bool> AlgTool::m_auditorFinalize {this, "AuditFinalize", false, "trigger auditor on finalize()"}

private

Definition at line 323 of file AlgTool.h.

Gaudi::Property<bool> AlgTool::m_auditorInitialize {this, "AuditInitialize", false, "trigger auditor on initialize()"}

private

Definition at line 320 of file AlgTool.h.

Gaudi::Property<bool> AlgTool::m_auditorReinitialize {this, "AuditReinitialize", false, "trigger auditor on reinitialize()"}

private

Definition at line 324 of file AlgTool.h.

Gaudi::Property<bool> AlgTool::m_auditorRestart {this, "AuditRestart", false, "trigger auditor on restart()"}

private

Definition at line 325 of file AlgTool.h.

Gaudi::Property<bool> AlgTool::m_auditorStart {this, "AuditStart", false, "trigger auditor on start()"}

private

Definition at line 321 of file AlgTool.h.

Gaudi::Property<bool> AlgTool::m_auditorStop {this, "AuditStop", false, "trigger auditor on stop()"}

private

Definition at line 322 of file AlgTool.h.

SmartIF<IDataProviderSvc> AlgTool::m_evtSvc

mutableprivate

Event data service.

Definition at line 303 of file AlgTool.h.

InterfaceList AlgTool::m_interfaceList

private

Interface list.

Definition at line 308 of file AlgTool.h.

Gaudi::Property<std::string> AlgTool::m_monitorSvcName

private

Initial value:

{this, "MonitorService", "MonitorSvc",
                                                "name to use for Monitor Service"}

Definition at line 316 of file AlgTool.h.

const std::string AlgTool::m_name

private

AlgTool full name.

Definition at line 299 of file AlgTool.h.

Gaudi::Property<int> AlgTool::m_outputLevel

private

Initial value:

{this, "OutputLevel", setUpMessaging(),
                                     [this]( auto& ) { this->updateMsgStreamOutputLevel( this->m_outputLevel ); },
                                     "output level"}

Definition at line 312 of file AlgTool.h.

const IInterface* AlgTool::m_parent = nullptr

private

AlgTool parent.

Definition at line 300 of file AlgTool.h.

SmartIF<IAuditorSvc> AlgTool::m_pAuditorSvc

mutableprivate

Auditor Service.

Definition at line 306 of file AlgTool.h.

SmartIF<IMonitorSvc> AlgTool::m_pMonitorSvc

mutableprivate

Online Monitoring Service.

Definition at line 305 of file AlgTool.h.

SmartIF<IToolSvc> AlgTool::m_ptoolSvc

mutableprivate

Tool service.

Definition at line 304 of file AlgTool.h.

Gaudi::StateMachine::State AlgTool::m_state = Gaudi::StateMachine::CONFIGURED

private

state of the Tool

Definition at line 342 of file AlgTool.h.

SmartIF<ISvcLocator> AlgTool::m_svcLocator

mutableprivate

Pointer to Service Locator service.

Definition at line 302 of file AlgTool.h.

Gaudi::StateMachine::State AlgTool::m_targetState = Gaudi::StateMachine::CONFIGURED

private

state of the Tool

Definition at line 343 of file AlgTool.h.

std::vector<GaudiHandleArrayBase*> AlgTool::m_toolHandleArrays

mutableprivate

Definition at line 330 of file AlgTool.h.

std::vector<BaseToolHandle*> AlgTool::m_toolHandles

mutableprivate

Definition at line 329 of file AlgTool.h.

bool AlgTool::m_toolHandlesInit = false

mutableprivate

Definition at line 331 of file AlgTool.h.

std::vector<IAlgTool*> AlgTool::m_tools

mutableprivate

Definition at line 328 of file AlgTool.h.

std::unordered_set<AlgTool*> AlgTool::m_toolsAwaitingInit

private

Definition at line 335 of file AlgTool.h.

std::string AlgTool::m_type

private

AlgTool type (concrete class name)

Definition at line 298 of file AlgTool.h.

std::unordered_set<AlgTool*> AlgTool::m_uninitializedTools

private

flag indicating whether ToolHandle tools have been added to m_tools

Definition at line 334 of file AlgTool.h.

DataObjIDMapping AlgTool::m_updateDependencies

protected

Hook for for derived classes to alter the DataObjID of dependencies.

Definition at line 233 of file AlgTool.h.

---

The documentation for this class was generated from the following files:

• GaudiKernel/GaudiKernel/AlgTool.h
• GaudiKernel/src/Lib/AlgTool.cpp