#include <GaudiKernel/ToolHandle.h>

Inheritance diagram for ToolHandle< T >:

[legend]

Collaboration diagram for ToolHandle< T >:

[legend]

Public Member Functions
	ToolHandle (const IInterface *parent=nullptr, bool createIf=true)
	Constructor for a tool with default tool type and name. More...

template<typename CT = T, typename NCT = std::remove_const_t<T>>
	requires (std::is_const_v< CT > &&!std::is_same_v< CT, NCT >) ToolHandle(const ToolHandle< NCT > &other)
	Copy constructor from a non const T to const T tool handle. More...

	ToolHandle (const std::string &toolTypeAndName, const IInterface *parent=nullptr, bool createIf=true)
	Create a handle ('smart pointer') to a tool. More...

template<std::derived_from< IProperty > OWNER>
	ToolHandle (OWNER *owner, std::string propName, std::string toolType, std::string doc="")
	Autodeclaring constructor with property propName, tool type/name and documentation. More...

template<typename... Args>
	ToolHandle (std::tuple< Args... > &&args)

StatusCode	initialize (const std::string &toolTypeAndName, const IInterface *parent=nullptr, bool createIf=true)

StatusCode	retrieve () const override
	Retrieve the AlgTool. More...

StatusCode	retrieve (DisableTool sd) override

StatusCode	retrieve (EnableTool sd) override

StatusCode	release () const
	Release the AlgTool. More...

StatusCode	retrieve (T *&algTool) const override
	Do the real retrieval of the AlgTool. More...

StatusCode	release (T *algTool) const override
	Do the real release of the AlgTool. More...

std::string	typeAndName () const override

std::add_const_t< T > *	get () const

T *	get ()

Public Member Functions inherited from BaseToolHandle
StatusCode	retrieve (IAlgTool *&tool) const

const IAlgTool *	get () const

IAlgTool *	get ()

bool	isEnabled () const
	Helper to check if the ToolHandle should be retrieved. More...

void	enable ()

void	disable ()

bool	setEnabled (bool flag)

Public Member Functions inherited from ToolHandleInfo
virtual	~ToolHandleInfo ()=default

bool	isPublic () const noexcept

bool	createIf () const noexcept

const IInterface *	parent () const noexcept

Public Member Functions inherited from GaudiHandle< T >
template<typename CT = T, typename NCT = std::remove_const_t<T>>
	GaudiHandle (const GaudiHandle< NCT > &other) requires(std
	Copy constructor needed for correct ref-counting. More...

	GaudiHandle (const GaudiHandle &other)
	Copy constructor needed for correct ref-counting. More...

template<typename CT = T, typename NCT = std::remove_const_t<T>>
	requires (std::is_const_v< CT > &&!std::is_same_v< CT, NCT >) GaudiHandle &operator
	Assignment operator for correct ref-counting. More...

Public Member Functions inherited from GaudiHandleBase
const std::string &	typeAndName () const
	The full type and name: "type/name". More...

std::string	type () const
	The concrete component class name: the part before the '/'. More...

std::string	name () const
	The instance name: the part after the '/'. More...

bool	empty () const
	Check if the handle has been set to empty string (i.e. More...

void	setTypeAndName (std::string myTypeAndName)
	The component "type/name" string. More...

void	setName (std::string_view myName)
	Set the instance name (part after the '/') without changing the class type. More...

std::string	pythonPropertyClassName () const override
	Name of the componentType with "Handle" appended. More...

std::string	messageName () const
	name used for printing messages More...

std::string	pythonRepr () const override
	Python representation of handle, i.e. More...

Public Member Functions inherited from GaudiHandleInfo
virtual	~GaudiHandleInfo ()
	virtual destructor so that derived class destructor is called. More...

const std::string &	componentType () const

const std::string &	propertyName () const
	name as used in declareProperty(name,gaudiHandle) More...

void	setPropertyName (std::string propName)
	set name as used in declareProperty(name,gaudiHandle). More...

const std::string &	parentName () const
	The name of the parent. More...

Protected Member Functions
const IAlgTool *	getAsIAlgTool () const override

IAlgTool *	getAsIAlgTool () override

StatusCode	i_retrieve (IAlgTool *&algTool) const override

Protected Member Functions inherited from BaseToolHandle
	BaseToolHandle (const IInterface *parent=nullptr, bool createIf=true)

Protected Member Functions inherited from ToolHandleInfo
	ToolHandleInfo (const IInterface *parent=nullptr, bool createIf=true)

Protected Member Functions inherited from GaudiHandle< T >
	GaudiHandle (std::string myTypeAndName, std::string myComponentType, std::string myParentName)

Protected Member Functions inherited from GaudiHandleBase
	GaudiHandleBase (std::string myTypeAndName, std::string myComponentType, std::string myParentName)
	Create a handle ('smart pointer') to a gaudi component. More...

Protected Member Functions inherited from GaudiHandleInfo
	GaudiHandleInfo (std::string myComponentType, std::string myParentName)
	Some basic information and helper functions shared between various handles/arrays. More...

void	setComponentType (std::string componentType)
	The component type. More...

void	setParentName (std::string parent)
	The name of the parent. More...

Private Member Functions
template<typename... Args, std::size_t... Is>
	ToolHandle (std::tuple< Args... > &&args, std::index_sequence< Is... >)

Private Attributes
ServiceHandle< IToolSvc >	m_pToolSvc

Friends
class	Gaudi::Algorithm

class	AlgTool

class	Service

std::ostream &	operator<< (std::ostream &os, const ToolHandle< T > &handle)

Additional Inherited Members
Public Types inherited from GaudiHandleBase
using	PropertyType = GaudiHandleProperty

Static Public Member Functions inherited from ToolHandleInfo
static std::string	toolComponentType (const IInterface *parent)

static std::string	toolParentName (const IInterface *parent)

Protected Attributes inherited from BaseToolHandle
bool	m_enabled = true

Protected Attributes inherited from ToolHandleInfo
const IInterface *	m_parent = nullptr

bool	m_createIf { true }

Detailed Description

template<class T>
class ToolHandle< T >

Handle to be used in lieu of naked pointers to tools. This allows better control through the framework of tool loading and usage. @paramater T is the AlgTool interface class (or concrete class) of the tool to use, and must derive from IAlgTool.

Author: Wim Lavrijsen WLavr.nosp@m.ijse.nosp@m.n@lbl.nosp@m..gov; Marti.nosp@m.n.Wo.nosp@m.udstr.nosp@m.a@ce.nosp@m.rn.ch

Definition at line 136 of file ToolHandle.h.

Constructor & Destructor Documentation

◆ ToolHandle() [1/5]

template<class T >

template<typename... Args, std::size_t... Is>

ToolHandle< T >::ToolHandle	(	std::tuple< Args... > &&	args,
		std::index_sequence< Is... >
	)

inlineprivate

Definition at line 143 of file ToolHandle.h.

144 : ToolHandle( std::get<Is>( std::move( args ) )... ) {}

◆ ToolHandle() [2/5]

template<class T >

ToolHandle< T >::ToolHandle	(	const IInterface *	parent = `nullptr`,
		bool	createIf = `true`
	)

inline

Constructor for a tool with default tool type and name.

Can be called only if the type T is a concrete tool type (not an interface), and you want to use the default name.

Definition at line 150 of file ToolHandle.h.

       : BaseToolHandle( parent, createIf )
       , GaudiHandle<T>( "", toolComponentType( parent ), toolParentName( parent ) )
       , m_pToolSvc( "ToolSvc", GaudiHandleBase::parentName() ) {}

◆ ToolHandle() [3/5]

template<class T >

ToolHandle< T >::ToolHandle	(	const std::string &	toolTypeAndName,
		const IInterface *	parent = `nullptr`,
		bool	createIf = `true`
	)

inline

Create a handle ('smart pointer') to a tool.

The arguments are passed on to ToolSvc, and have the same meaning:

StatusCode ToolSvc::retrieveTool ( const std::string& type            ,
                                   T*&                tool            ,
                                   const IInterface*  parent   = 0    ,
                                   bool               createIf = true )

Parameters

owner	class owning the ToolHandle
toolType	"MyToolType/MyToolName" "MyToolType" is short for "MyToolType/MyToolType" 'MyToolType' is the name of the class of the concrete tool 'MyToolName' is to distinguish several tool instances of the same class
parent	the parent Algorithm,Tool or Service of which this tool is a member. If non-zero, the the tool is a private tool of the parent, otherwise it is a public (shared) tool.
createIf	if true, create tool if not yet existing.

Definition at line 194 of file ToolHandle.h.

       : BaseToolHandle( parent, createIf )
       , GaudiHandle<T>( toolTypeAndName, toolComponentType( parent ), toolParentName( parent ) )
       , m_pToolSvc( "ToolSvc", GaudiHandleBase::parentName() ) {
   }

◆ ToolHandle() [4/5]

template<class T >

template<std::derived_from< IProperty > OWNER>

ToolHandle< T >::ToolHandle	(	OWNER *	owner,
		std::string	propName,
		std::string	toolType,
		std::string	doc = `""`
	)

inline

Autodeclaring constructor with property propName, tool type/name and documentation.

Note: the use of requires is required to avoid ambiguities

Definition at line 203 of file ToolHandle.h.

                                                                                          : ToolHandle( owner ) {
     // convert name and type to a valid type/name string
     // - if type does not contain '/' use type/type
     // - otherwise type is already a type/name string
     if ( !toolType.empty() and toolType.find( '/' ) == std::string::npos ) { toolType += '/' + toolType; }
     owner->declareTool( *this, std::move( toolType ) ).ignore();
     auto p = owner->OWNER::PropertyHolderImpl::declareProperty( std::move( propName ), *this, std::move( doc ) );
     p->template setOwnerType<OWNER>();
   }

◆ ToolHandle() [5/5]

template<class T >

template<typename... Args>

ToolHandle< T >::ToolHandle ( std::tuple< Args... > && args )

inline

Definition at line 214 of file ToolHandle.h.

214 : ToolHandle( std::move( args ), std::index_sequence_for<Args...>{} ) {}

Member Function Documentation

◆ get() [1/2]

template<class T >

T* ToolHandle< T >::get ( )

inline

Definition at line 281 of file ToolHandle.h.

281 { return GaudiHandle<T>::get(); }

◆ get() [2/2]

template<class T >

std::add_const_t<T>* ToolHandle< T >::get ( ) const

inline

Definition at line 279 of file ToolHandle.h.

279 { return GaudiHandle<T>::get(); }

◆ getAsIAlgTool() [1/2]

template<class T >

const IAlgTool* ToolHandle< T >::getAsIAlgTool ( ) const

inlineoverrideprotectedvirtual

Implements BaseToolHandle.

Definition at line 288 of file ToolHandle.h.

                                                  {
     // const cast to support T being const
     return GaudiHandle<T>::get();
   }

◆ getAsIAlgTool() [2/2]

template<class T >

IAlgTool* ToolHandle< T >::getAsIAlgTool ( )

inlineoverrideprotectedvirtual

Implements BaseToolHandle.

Definition at line 293 of file ToolHandle.h.

                                      {
     // const cast to support T being const
     return ::details::nonConst( GaudiHandle<T>::get() );
   }

◆ i_retrieve()

template<class T >

StatusCode ToolHandle< T >::i_retrieve ( IAlgTool *& algTool ) const

inlineoverrideprotectedvirtual

Implements BaseToolHandle.

Definition at line 298 of file ToolHandle.h.

                                                              {
     return m_pToolSvc->retrieve( typeAndName(), IAlgTool::interfaceID(), algTool, ToolHandleInfo::parent(),
                                  ToolHandleInfo::createIf() );
   }

◆ initialize()

template<class T >

StatusCode ToolHandle< T >::initialize	(	const std::string &	toolTypeAndName,
		const IInterface *	parent = `nullptr`,
		bool	createIf = `true`
	)

inline

Definition at line 217 of file ToolHandle.h.

                                                 {
  
     GaudiHandleBase::setTypeAndName( toolTypeAndName );
     GaudiHandleBase::setComponentType( toolComponentType( parent ) );
     GaudiHandleBase::setParentName( toolParentName( parent ) );
  
     m_parent   = parent;
     m_createIf = createIf;
  
     return m_pToolSvc.initialize( "ToolSvc", GaudiHandleBase::parentName() );
   }

◆ release() [1/2]

template<class T >

StatusCode ToolHandle< T >::release ( ) const

inline

Release the AlgTool.

Function must be repeated here to avoid hiding the function release( T*& )

Definition at line 256 of file ToolHandle.h.

                              { // not really const, because it updates m_pObject
     return GaudiHandle<T>::release();
   }

◆ release() [2/2]

template<class T >

StatusCode ToolHandle< T >::release ( T * algTool ) const

inlineoverridevirtual

Do the real release of the AlgTool.

Reimplemented from GaudiHandle< T >.

Definition at line 275 of file ToolHandle.h.

275 { return m_pToolSvc->releaseTool( ::details::nonConst( algTool ) ); }

◆ requires()

template<class T >

template<typename CT = T, typename NCT = std::remove_const_t<T>>

ToolHandle< T >::requires ( std::is_const_v< CT > &&!std::is_same_v< CT, NCT > ) const &

inline

Copy constructor from a non const T to const T tool handle.

Definition at line 157 of file ToolHandle.h.

       : BaseToolHandle( other.parent(), other.createIf() )
       , GaudiHandle<CT>( other )
       , m_pToolSvc( "ToolSvc", GaudiHandleBase::parentName() ) {}

◆ retrieve() [1/4]

template<class T >

StatusCode ToolHandle< T >::retrieve ( ) const

inlineoverridevirtual

Retrieve the AlgTool.

Release existing tool if needed. Function must be repeated here to avoid hiding the function retrieve( T*& )

Implements BaseToolHandle.

Definition at line 232 of file ToolHandle.h.

                                        { // not really const, because it updates m_pObject
     return GaudiHandle<T>::retrieve();
   }

◆ retrieve() [2/4]

template<class T >

StatusCode ToolHandle< T >::retrieve ( DisableTool sd )

inlineoverridevirtual

Implements BaseToolHandle.

Definition at line 236 of file ToolHandle.h.

                                                  {
     if ( isEnabled() && sd == DisableTool{ false } ) {
       return GaudiHandle<T>::retrieve();
     } else {
       disable();
       return StatusCode::SUCCESS;
     }
   }

◆ retrieve() [3/4]

template<class T >

StatusCode ToolHandle< T >::retrieve ( EnableTool sd )

inlineoverridevirtual

Implements BaseToolHandle.

Definition at line 245 of file ToolHandle.h.

                                                 {
     if ( isEnabled() && sd == EnableTool{ true } ) {
       return GaudiHandle<T>::retrieve();
     } else {
       disable();
       return StatusCode::SUCCESS;
     }
   }

◆ retrieve() [4/4]

template<class T >

StatusCode ToolHandle< T >::retrieve ( T *& algTool ) const

inlineoverride

Do the real retrieval of the AlgTool.

Definition at line 261 of file ToolHandle.h.

                                                     {
     IAlgTool* iface = nullptr;
     if ( i_retrieve( iface ).isFailure() ) { return StatusCode::FAILURE; }
  
     algTool = dynamic_cast<T*>( iface );
     if ( !algTool ) {
       throw GaudiException( "unable to dcast AlgTool " + typeAndName() + " to interface " +
                                 System::typeinfoName( typeid( T ) ),
                             typeAndName() + " retrieve", StatusCode::FAILURE );
     }
     return StatusCode::SUCCESS;
   }

◆ typeAndName()

template<class T >

std::string ToolHandle< T >::typeAndName ( ) const

inlineoverridevirtual

Implements BaseToolHandle.

Definition at line 277 of file ToolHandle.h.

277 { return GaudiHandleBase::typeAndName(); }

Friends And Related Function Documentation

◆ AlgTool

template<class T >

friend class AlgTool

friend

Definition at line 139 of file ToolHandle.h.

◆ Gaudi::Algorithm

template<class T >

friend class Gaudi::Algorithm

friend

Definition at line 138 of file ToolHandle.h.

◆ operator<<

template<class T >

std::ostream& operator<<	(	std::ostream &	os,
		const ToolHandle< T > &	handle
	)

friend

Definition at line 283 of file ToolHandle.h.

                                                                                {
     return os << static_cast<const GaudiHandleInfo&>( handle );
   }

◆ Service

template<class T >

friend class Service

friend

Definition at line 140 of file ToolHandle.h.

Member Data Documentation

◆ m_pToolSvc

template<class T >

ServiceHandle<IToolSvc> ToolHandle< T >::m_pToolSvc

mutableprivate

Definition at line 307 of file ToolHandle.h.

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

GaudiKernel/include/GaudiKernel/ToolHandle.h

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

template<class T> class ToolHandle< T >

Constructor & Destructor Documentation

◆ ToolHandle() [1/5]

◆ ToolHandle() [2/5]

◆ ToolHandle() [3/5]

◆ ToolHandle() [4/5]

◆ ToolHandle() [5/5]

Member Function Documentation

◆ get() [1/2]

◆ get() [2/2]

◆ getAsIAlgTool() [1/2]

◆ getAsIAlgTool() [2/2]

◆ i_retrieve()

◆ initialize()

◆ release() [1/2]

◆ release() [2/2]

◆ requires()

◆ retrieve() [1/4]

◆ retrieve() [2/4]

◆ retrieve() [3/4]

◆ retrieve() [4/4]

◆ typeAndName()

Friends And Related Function Documentation

◆ AlgTool

◆ Gaudi::Algorithm

◆ operator<<

◆ Service

Member Data Documentation

◆ m_pToolSvc

template<class T>
class ToolHandle< T >