ToolHandleArray< T > Class Template Reference

Array of Handles to be used in lieu of vector of naked pointers to tools. More...

#include <GaudiKernel/ToolHandle.h>

Inheritance diagram for ToolHandleArray< T >:

Collaboration diagram for ToolHandleArray< T >:

Public Member Functions
	ToolHandleArray (const std::vector< std::string > &myTypesAndNames, const IInterface *parent=nullptr, bool createIf=true)
	Generic constructor.
	ToolHandleArray (const IInterface *parent=nullptr, bool createIf=true)
	Constructor which creates and empty list.
bool	push_back (const std::string &toolTypeAndName) override
	Add a handle to the array with given tool type and name.
bool	push_back (const ToolHandle< T > &myHandle) override
	Ensure that for added handles the parent and creatIf are taken from this array.
template<std::derived_from< IProperty > OWNER>
	ToolHandleArray (OWNER *owner, std::string name, const std::vector< std::string > &typesAndNames={}, std::string doc="")
	Autodeclaring constructor with property name, tool type/name and documentation.
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 GaudiHandleArray< ToolHandle< T > >
GaudiHandleArray &	operator= (const std::vector< std::string > &myTypesAndNamesList)
	Set the array of GaudiHandles from typeAndNames given in vector of strings.
GaudiHandleArrayBase::BaseHandleArray	getBaseArray () override
	Get a read-write vector of GaudiHandleBase* pointing to the real handles.
iterator	begin ()
iterator	end ()
const_iterator	rbegin () const
const_iterator	rend () const
size_type	size () const
void	clear () override
	Clear the list of handles.
bool	empty () const override
	Return whether the list of tools is empty.
T &	operator[] (int index)
StatusCode	retrieve () override
	Retrieve all tools.
StatusCode	release () override
	Release all tools.
virtual bool	retrieved () const override
	has Array been retreived?
Public Member Functions inherited from GaudiHandleArrayBase
bool	setTypesAndNames (const std::vector< std::string > &myTypesAndNamesList)
	Set the array of handles from list of "type/name" strings in <myTypesAndNamesList>.
const std::vector< std::string >	typesAndNames () const
	Return a vector with "type/name" strings of all handles in the array.
const std::vector< std::string >	types () const
	Return a vector with "type" strings of all handles in the array.
const std::vector< std::string >	names () const
	Return a vector with "type/name" strings of all handles in the array.
const std::vector< std::string >	getBaseInfos (auto(GaudiHandleBase::*pMemFunc)() const) const
	Helper function to get a vector of strings filled with the return value of each tool of a member function if GaudiHandleBase.
std::string	pythonPropertyClassName () const override
	Name of the componentType with "HandleArray" appended.
std::string	pythonRepr () const override
	Python representation of array of handles, i.e.
virtual ConstBaseHandleArray	getBaseArray () const =0
	Get a read-only vector of const GaudiHandleBase* pointing to the real handles.
Public Member Functions inherited from GaudiHandleInfo
virtual	~GaudiHandleInfo ()
	virtual destructor so that derived class destructor is called.
const std::string &	componentType () const
const std::string &	propertyName () const
	name as used in declareProperty(name,gaudiHandle)
void	setPropertyName (std::string propName)
	set name as used in declareProperty(name,gaudiHandle).
const std::string &	parentName () const
	The name of the parent.

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

Additional Inherited Members
Public Types inherited from GaudiHandleArray< ToolHandle< T > >
typedef std::vector< T >	HandleVector
typedef HandleVector::value_type	value_type
typedef HandleVector::size_type	size_type
typedef HandleVector::reference	reference
typedef HandleVector::const_reference	const_reference
typedef HandleVector::iterator	iterator
typedef HandleVector::const_iterator	const_iterator
typedef HandleVector::reverse_iterator	reverse_iterator
typedef HandleVector::const_reverse_iterator	const_reverse_iterator
Public Types inherited from GaudiHandleArrayBase
using	PropertyType = GaudiHandleArrayProperty
typedef std::vector< GaudiHandleBase * >	BaseHandleArray
typedef std::vector< const GaudiHandleBase * >	ConstBaseHandleArray
Static Public Member Functions inherited from ToolHandleInfo
static std::string	toolComponentType (const IInterface *parent)
static std::string	toolParentName (const IInterface *parent)
Protected Member Functions inherited from ToolHandleInfo
	ToolHandleInfo (const IInterface *parent=nullptr, bool createIf=true)
Protected Member Functions inherited from GaudiHandleArray< ToolHandle< T > >
	GaudiHandleArray (const std::vector< std::string > &myTypesAndNamesList, std::string myComponentType, std::string myParentName)
	Generic constructor.
Protected Member Functions inherited from GaudiHandleArrayBase
	GaudiHandleArrayBase (std::string myComponentType, std::string myParentName)
Protected Member Functions inherited from GaudiHandleInfo
	GaudiHandleInfo (std::string myComponentType, std::string myParentName)
	Some basic information and helper functions shared between various handles/arrays.
void	setComponentType (std::string componentType)
	The component type.
void	setParentName (std::string parent)
	The name of the parent.
Protected Attributes inherited from ToolHandleInfo
const IInterface *	m_parent = nullptr
bool	m_createIf { true }

Detailed Description

template<class T>
class ToolHandleArray< T >

Array of Handles to be used in lieu of vector of naked pointers to tools.

This allows better control through the framework of tool loading and usage. @parameter T is the AlgTool interface class (or concrete class) of the tool to use, and must derive from IAlgTool.

Author

Marti.nosp@m.n.Wo.nosp@m.udstr.nosp@m.a@ce.nosp@m.rn.ch

Definition at line 396 of file ToolHandle.h.

Constructor & Destructor Documentation

ToolHandleArray() [1/3]

template<class T>

ToolHandleArray< T >::ToolHandleArray ( const std::vector< std::string > & myTypesAndNames, const IInterface * parent = nullptr, bool createIf = true )

inline

Generic constructor.

Probably not very useful...

Parameters

typesAndNamesList	: a vector of strings with the concrete "type/name" strings for the list of tools
parent	: passed on to ToolHandle, so has the same meaning as for ToolHandle
createIf	: passed on to ToolHandle, so has the same meaning as for ToolHandle

Definition at line 407 of file ToolHandle.h.

      : ToolHandleInfo( parent, createIf )
      , GaudiHandleArray<ToolHandle<T>>( myTypesAndNames, ToolHandleInfo::toolComponentType( parent ),
                                         ToolHandleInfo::toolParentName( parent ) ) {}

ToolHandleArray() [2/3]

template<class T>

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

inline

Constructor which creates and empty list.

Parameters

parent	: passed on to ToolHandle, so has the same meaning as for ToolHandle
createIf	: passed on to ToolHandle, so has the same meaning as for ToolHandle

Definition at line 417 of file ToolHandle.h.

      : ToolHandleInfo( parent, createIf )
      , GaudiHandleArray<ToolHandle<T>>( ToolHandleInfo::toolComponentType( parent ),
                                         ToolHandleInfo::toolParentName( parent ) ) {}

ToolHandleArray() [3/3]

template<class T>

template<std::derived_from< IProperty > OWNER>

ToolHandleArray< T >::ToolHandleArray ( OWNER * owner, std::string name, const std::vector< std::string > & typesAndNames = {}, std::string doc = "" )

inline

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

Note

the use of requires is required to avoid ambiguities

Definition at line 438 of file ToolHandle.h.

                                                                                                  {},
                          std::string doc = "" )
      : ToolHandleArray( owner ) {
    owner->addToolsArray( *this );
    this->setTypesAndNames( typesAndNames );
    auto p = owner->OWNER::PropertyHolderImpl::declareProperty( std::move( name ), *this, std::move( doc ) );
    p->template setOwnerType<OWNER>();
  }

Member Function Documentation

push_back() [1/2]

template<class T>

bool ToolHandleArray< T >::push_back ( const std::string & toolTypeAndName )

inlineoverridevirtual

Add a handle to the array with given tool type and name.

This function overrides the one in GaudiHandleArray<T>, as this is a special case. The private/public choice and createIf is determined by what was given in the constructor of the ToolHandleArray.

Reimplemented from GaudiHandleArray< ToolHandle< T > >.

Definition at line 426 of file ToolHandle.h.

                                                              {
    ToolHandle<T> handle( toolTypeAndName, ToolHandleInfo::parent(), ToolHandleInfo::createIf() );
    GaudiHandleArray<ToolHandle<T>>::push_back( handle );
    return true;
  }

push_back() [2/2]

template<class T>

bool ToolHandleArray< T >::push_back ( const ToolHandle< T > & myHandle )

inlineoverride

Ensure that for added handles the parent and creatIf are taken from this array.

Definition at line 433 of file ToolHandle.h.

{ return push_back( myHandle.typeAndName() ); }

Friends And Related Symbol Documentation

operator<<

template<class T>

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

friend

Definition at line 447 of file ToolHandle.h.

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

---

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

• GaudiKernel/include/GaudiKernel/ToolHandle.h