Skip to content
Snippets Groups Projects
Commit 2a28fda4 authored by Marco Clemencic's avatar Marco Clemencic
Browse files

Merge branch 'GAUDI-1127' into 'master' 

removed the need for ToolHandle<IAlgTool> specialization

Modified the implementation of BaseToolHandle so that the retrieve
method can be implemented without conflicting with the retrieve method
of ToolHandle<T> with T=IAlgTool.

This, BTW, fixes GAUDI-1127.

See CFHEP-177 and merge request !10.

See merge request !67
parents 0870b7f6 9342e604
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
GaudiKernel/GaudiKernel/ToolHandle.h
+ 24
− 142
View file @ 2a28fda4
...@@ -69,13 +69,14 @@ protected: ...@@ -69,13 +69,14 @@ protected:
: ToolHandleInfo(parent, createIf) : ToolHandleInfo(parent, createIf)
{} {}
public: virtual StatusCode retrieveGeneric(IAlgTool*&) const = 0;
virtual ~BaseToolHandle() {};
public: public:
//Get a reference to the generic IAlgTool virtual ~BaseToolHandle() {}
virtual StatusCode retrieve( IAlgTool*& algTool ) const = 0;
StatusCode retrieve(IAlgTool*& tool) const {
return retrieveGeneric(tool);
}
}; };
/** @class ToolHandle ToolHandle.h GaudiKernel/ToolHandle.h /** @class ToolHandle ToolHandle.h GaudiKernel/ToolHandle.h
...@@ -102,8 +103,8 @@ public: ...@@ -102,8 +103,8 @@ public:
ToolHandle(const IInterface* parent=0, bool createIf = true ) ToolHandle(const IInterface* parent=0, bool createIf = true )
: BaseToolHandle(parent,createIf), : BaseToolHandle(parent,createIf),
GaudiHandle<T>( GaudiHandle<T>::getDefaultType(), GaudiHandle<T>( GaudiHandle<T>::getDefaultType(),
ToolHandleInfo::toolComponentType(parent), ToolHandleInfo::toolComponentType(parent),
ToolHandleInfo::toolParentName(parent) ), ToolHandleInfo::toolParentName(parent) ),
m_pToolSvc( "ToolSvc", GaudiHandleBase::parentName() ) m_pToolSvc( "ToolSvc", GaudiHandleBase::parentName() )
{ } { }
...@@ -141,15 +142,15 @@ public: ...@@ -141,15 +142,15 @@ public:
ToolHandle(const std::string& toolTypeAndName, const IInterface* parent = 0, bool createIf = true ) ToolHandle(const std::string& toolTypeAndName, const IInterface* parent = 0, bool createIf = true )
: BaseToolHandle(parent,createIf), : BaseToolHandle(parent,createIf),
GaudiHandle<T>( toolTypeAndName, GaudiHandle<T>( toolTypeAndName,
ToolHandleInfo::toolComponentType(parent), ToolHandleInfo::toolComponentType(parent),
ToolHandleInfo::toolParentName(parent) ), ToolHandleInfo::toolParentName(parent) ),
m_pToolSvc( "ToolSvc", GaudiHandleBase::parentName() ) m_pToolSvc( "ToolSvc", GaudiHandleBase::parentName() )
{ } { }
public: public:
StatusCode initialize(const std::string& toolTypeAndName, StatusCode initialize(const std::string& toolTypeAndName,
const IInterface* parent = 0, bool createIf = true){ const IInterface* parent = 0, bool createIf = true){
GaudiHandleBase::setTypeAndName(toolTypeAndName); GaudiHandleBase::setTypeAndName(toolTypeAndName);
GaudiHandleBase::setComponentType(ToolHandleInfo::toolComponentType(parent)); GaudiHandleBase::setComponentType(ToolHandleInfo::toolComponentType(parent));
...@@ -176,141 +177,22 @@ public: ...@@ -176,141 +177,22 @@ public:
} }
/** Do the real retrieval of the AlgTool. */ /** Do the real retrieval of the AlgTool. */
virtual StatusCode retrieve( T*& algTool ) const { StatusCode retrieve( T*& algTool ) const {
return m_pToolSvc->retrieve( GaudiHandleBase::typeAndName(), T::interfaceID(), return m_pToolSvc->retrieve( GaudiHandleBase::typeAndName(), T::interfaceID(),
(IAlgTool*&)(algTool), reinterpret_cast<IAlgTool*&>(algTool),
ToolHandleInfo::parent(), ToolHandleInfo::createIf() ); ToolHandleInfo::parent(), ToolHandleInfo::createIf() );
}
/** Get a generic reference of the IAlgTool for processing in the sysInitialize. */
virtual StatusCode retrieve( IAlgTool*& algTool ) const {
//This explicit casting is required in order to properly re-interpret the <T> Tool
T * tool;
StatusCode sc = retrieve(tool);
algTool = tool;
return sc;
} }
/** Do the real release of the AlgTool. */ /** Do the real release of the AlgTool. */
virtual StatusCode release( T* algTool ) const { StatusCode release( T* algTool ) const {
return m_pToolSvc->releaseTool( algTool ); return m_pToolSvc->releaseTool( algTool );
} }
private: protected:
// StatusCode retrieveGeneric(IAlgTool*& algTool) const override {
// Private data members
//
mutable ServiceHandle<IToolSvc> m_pToolSvc;
};
//-----------------------------------------------------------------------//
// specialization for IAlgTool
template<>
class ToolHandle<IAlgTool> : public BaseToolHandle, public GaudiHandle<IAlgTool> {
friend class Algorithm;
friend class AlgTool;
friend class Service;
public:
/** 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. */
ToolHandle(const IInterface* parent=0, bool createIf = true )
: BaseToolHandle(parent,createIf),
GaudiHandle<IAlgTool>( GaudiHandle<IAlgTool>::getDefaultType(),
ToolHandleInfo::toolComponentType(parent),
ToolHandleInfo::toolParentName(parent) ),
m_pToolSvc( "ToolSvc", GaudiHandleBase::parentName() )
{ }
public:
//
// Constructors etc.
//
/** Create a handle ('smart pointer') to a tool.
The arguments are passed on to ToolSvc, and have the same meaning:
@code
StatusCode ToolSvc::retrieveTool ( const std::string& type ,
IAlgTool*& tool ,
const IInterface* parent = 0 ,
bool createIf = true )
@endcode
@param owner: class owning the ToolHandle
@param 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
@param 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.
@param createIf: if true, create tool if not yet existing.
*/
#if defined(TOOLHANDLE_DEPR_WARN)
//warn about using deprecated explicit ToolHandle construction
#pragma message("Untracked ToolHandle: Migrate explicit DataHandle constructor to declareTool Algorithm Property")
__attribute__ ((deprecated))
#endif
ToolHandle(const std::string& toolTypeAndName, const IInterface* parent = 0, bool createIf = true )
: BaseToolHandle(parent,createIf),
GaudiHandle<IAlgTool>( toolTypeAndName,
ToolHandleInfo::toolComponentType(parent),
ToolHandleInfo::toolParentName(parent) ),
m_pToolSvc( "ToolSvc", GaudiHandleBase::parentName() )
{ }
public:
StatusCode initialize(const std::string& toolTypeAndName,
const IInterface* parent = 0, bool createIf = true){
GaudiHandleBase::setTypeAndName(toolTypeAndName);
GaudiHandleBase::setComponentType(ToolHandleInfo::toolComponentType(parent));
GaudiHandleBase::setParentName(ToolHandleInfo::toolParentName(parent));
m_parent = parent;
m_createIf = createIf;
StatusCode sc = m_pToolSvc.initialize("ToolSvc", GaudiHandleBase::parentName());
return sc;
}
/** Retrieve the AlgTool. Release existing tool if needed.
Function must be repeated here to avoid hiding the function retrieve( T*& ) */
StatusCode retrieve() const { // not really const, because it updates m_pObject
return GaudiHandle<IAlgTool>::retrieve();
}
/** Release the AlgTool.
Function must be repeated here to avoid hiding the function release( T*& ) */
StatusCode release() const { // not really const, because it updates m_pObject
return GaudiHandle<IAlgTool>::release();
}
/** Get a generic reference of the IAlgTool for processing in the sysInitialize. */
virtual StatusCode retrieve( IAlgTool*& algTool ) const {
return m_pToolSvc->retrieve( GaudiHandleBase::typeAndName(), IAlgTool::interfaceID(), return m_pToolSvc->retrieve( GaudiHandleBase::typeAndName(), IAlgTool::interfaceID(),
(IAlgTool*&)(algTool), algTool,
ToolHandleInfo::parent(), ToolHandleInfo::createIf() ); ToolHandleInfo::parent(), ToolHandleInfo::createIf() );
}
/** Do the real release of the AlgTool. */
virtual StatusCode release( IAlgTool* algTool ) const {
return m_pToolSvc->releaseTool( algTool );
} }
private: private:
...@@ -347,11 +229,11 @@ public: ...@@ -347,11 +229,11 @@ public:
@param createIf : passed on to ToolHandle, so has the same meaning as for ToolHandle @param createIf : passed on to ToolHandle, so has the same meaning as for ToolHandle
*/ */
ToolHandleArray( const std::vector< std::string >& myTypesAndNames, ToolHandleArray( const std::vector< std::string >& myTypesAndNames,
const IInterface* parent = 0, bool createIf = true ) const IInterface* parent = 0, bool createIf = true )
: ToolHandleInfo( parent, createIf ), : ToolHandleInfo( parent, createIf ),
GaudiHandleArray< ToolHandle<T> >( myTypesAndNames, GaudiHandleArray< ToolHandle<T> >( myTypesAndNames,
ToolHandleInfo::toolComponentType(parent), ToolHandleInfo::toolComponentType(parent),
ToolHandleInfo::toolParentName(parent) ) ToolHandleInfo::toolParentName(parent) )
{} {}
/** Constructor which creates and empty list. /** Constructor which creates and empty list.
...@@ -361,7 +243,7 @@ public: ...@@ -361,7 +243,7 @@ public:
ToolHandleArray( const IInterface* parent = 0, bool createIf = true ) ToolHandleArray( const IInterface* parent = 0, bool createIf = true )
: ToolHandleInfo( parent, createIf ), : ToolHandleInfo( parent, createIf ),
GaudiHandleArray< ToolHandle<T> >( ToolHandleInfo::toolComponentType(parent), GaudiHandleArray< ToolHandle<T> >( ToolHandleInfo::toolComponentType(parent),
ToolHandleInfo::toolParentName(parent) ) ToolHandleInfo::toolParentName(parent) )
{ } { }
/** Add a handle to the array with given tool type and name. /** Add a handle to the array with given tool type and name.
...@@ -370,8 +252,8 @@ public: ...@@ -370,8 +252,8 @@ public:
in the constructor of the ToolHandleArray. */ in the constructor of the ToolHandleArray. */
virtual bool push_back( const std::string& toolTypeAndName ) { virtual bool push_back( const std::string& toolTypeAndName ) {
ToolHandle<T> handle( toolTypeAndName, ToolHandle<T> handle( toolTypeAndName,
ToolHandleInfo::parent(), ToolHandleInfo::parent(),
ToolHandleInfo::createIf() ); ToolHandleInfo::createIf() );
GaudiHandleArray< ToolHandle<T> >::push_back( handle ); GaudiHandleArray< ToolHandle<T> >::push_back( handle );
return true; return true;
} }
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment