Gaudi Framework, version v20r2
	Generated: 18 Jul 2008

ToolSvc Class Reference

#include <ToolSvc.h>

Inheritance diagram for ToolSvc:

[legend]Collaboration diagram for ToolSvc:

[legend]List of all members.

---

Detailed Description

This service manages tools.

Tools can be common, in which case a single instance can be shared by different algorithms, or private in which case it is necessary to specify the parent when requesting it. The parent of a tool can be an algortihm or a Service The environment of a tool is set by using that of the parent. A common tool is considered to belong to the ToolSvc itself.

Author:

G. Corti, P. Mato

Definition at line 23 of file ToolSvc.h.

Public Types
typedef std::list< IAlgTool * >	ListTools
Public Member Functions
virtual StatusCode	initialize ()
	Initialize the service.
virtual StatusCode	finalize ()
	Finalize the service.
virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvInterface)
	Query the interfaces.
virtual StatusCode	retrieve (const std::string &type, const InterfaceID &iid, IAlgTool *&tool, const IInterface *parent, bool createIf)
	Retrieve tool, create it by default as common tool if it does not already exist.
virtual StatusCode	retrieve (const std::string &tooltype, const std::string &toolname, const InterfaceID &iid, IAlgTool *&tool, const IInterface *parent, bool createIf)
	Retrieve tool, create it by default as common tool if it does not already exist.
virtual std::vector< std::string >	getInstances (const std::string &toolType)
	Get names of all tool instances of a given type.
virtual StatusCode	releaseTool (IAlgTool *tool)
	Release tool.
StatusCode	create (const std::string &type, const IInterface *parent, IAlgTool *&tool)
	Create Tool standard way with automatically assigned name.
StatusCode	create (const std::string &type, const std::string &name, const IInterface *parent, IAlgTool *&tool)
	Create Tool standard way with specified name.
bool	existsTool (const std::string &toolname) const
	Check if the tool instance exists.
std::string	nameTool (const std::string &nameByUser, const IInterface *parent)
	Get Tool full name by combining nameByUser and "parent" part.
unsigned long	refCountTool (IAlgTool *tool) const
	Get current refcount for tool.
	ToolSvc (const std::string &name, ISvcLocator *svc)
	Standard Constructor.
virtual	~ToolSvc ()
	Destructor.
virtual void	registerObserver (IToolSvc::Observer *obs)
virtual void	unRegisterObserver (IToolSvc::Observer *obs)
Private Member Functions
unsigned long	totalToolRefCount () const
	The total number of refCounts on all tools in the instancesTools list.
unsigned long	totalToolRefCount (const ListTools &) const
	The total number of refCounts on all tools in the list.
unsigned long	minimumToolRefCount () const
	The minimum number of refCounts of all tools.
StatusCode	finalizeTool (IAlgTool *itool) const
	Finalise the given tool, with exception handling.
Private Attributes
ListTools	m_instancesTools
	Common Tools.
IHistorySvc *	m_pHistorySvc
	Pointer to HistorySvc.
std::vector< IToolSvc::Observer * >	m_observers

---

Member Typedef Documentation

typedef std::list<IAlgTool*> ToolSvc::ListTools

Definition at line 28 of file ToolSvc.h.

---

Constructor & Destructor Documentation

ToolSvc::ToolSvc	(	const std::string &	name,
		ISvcLocator *	svc
	)

Standard Constructor.

Parameters:

	name	String with service name
	svc	Pointer to service locator interface

Definition at line 29 of file ToolSvc.cpp.

  : Service(name, svc),
    m_pHistorySvc(0)
 { }

ToolSvc::~ToolSvc

(

)

[virtual]

Destructor.

Definition at line 36 of file ToolSvc.cpp.

{ 

}

---

Member Function Documentation

StatusCode ToolSvc::initialize

(

)

[virtual]

Initialize the service.

Reimplemented from Service.

Definition at line 43 of file ToolSvc.cpp.

References endreq(), MSG::ERROR, StatusCode::FAILURE, Service::initialize(), StatusCode::isFailure(), Service::msgSvc(), Service::name(), and Service::setProperties().

{

  // initialize the Service Base class
  StatusCode status = Service::initialize();
  if ( status.isFailure() )
  {
    MsgStream log( msgSvc(), name() );
    log << MSG::ERROR << "Unable to initialize the Service" << endreq;
    return status;
  }

  // set my own (ToolSvc) properties via the jobOptionService
  if (setProperties().isFailure()) {
    MsgStream log( msgSvc(), name() );
    log << MSG::ERROR << "Unable to set base properties" << endreq;
    return StatusCode::FAILURE;
  }

  return status;
}

StatusCode ToolSvc::finalize

(

)

[virtual]

Finalize the service.

Algorithm: 2 passes. First pass:

• do not explicitly release any tools
• finalize tools, in the order of increasing number of refCounts Second pass:
• explicitly release all tools, one release() on all tools per loop. -> tools are deleted in the order of increasing number of refCounts.

Inner loop: full loop over all left-over tools + finalize tools with the minimum number of refCounts in the list. + Remove finalized tools from list of tools, and add them to the list of finalized tools, to be deleted at the end. This way, any non-finalized tools who still reference already finalized tools in their finalize() will still find a live tool. Outer loop: keep on going until nothing changes in the list of tools. Checking for: + number of left-over tools + total number of refcounts + minimum number of refcounts

Reimplemented from Service.

Definition at line 67 of file ToolSvc.cpp.

References std::list< _Tp, _Alloc >::back(), std::list< _Tp, _Alloc >::begin(), count(), MSG::DEBUG, std::list< _Tp, _Alloc >::empty(), std::list< _Tp, _Alloc >::end(), endreq(), MSG::ERROR, StatusCode::FAILURE, Service::finalize(), finalizeTool(), std::list< _Tp, _Alloc >::front(), MSG::INFO, m_instancesTools, m_pHistorySvc, minimumToolRefCount(), Service::msgSvc(), Service::name(), std::list< _Tp, _Alloc >::pop_back(), std::list< _Tp, _Alloc >::pop_front(), std::list< _Tp, _Alloc >::push_back(), std::list< _Tp, _Alloc >::push_front(), refCountTool(), IInterface::release(), std::list< _Tp, _Alloc >::size(), StatusCode::SUCCESS, totalToolRefCount(), and MSG::VERBOSE.

{
  // Finalize and delete all left-over tools. Normally all tools created with 
  // ToolSvc are left over, since ToolSvc holds a refCount (via AlgTool ctor).
  // Several cases need to be covered:
  // 1) Simple dependencies: no circular dependencies between tools,
  //    and tools not using other tools
  // 2) Tools-using-tools (but no circular dependencies)
  //   a) release() is called in the tool::finalize() (e.g. via GaudiAlgorithm)
  //   b) release() is called in the tool destructor  (e.g. via ToolHandle)
  // 3) Circular dependencies between tools
  //   a) release() is called in the tool::finalize() (e.g. via GaudiAlgorithm)
  //   b) release() is called in the tool destructor  (e.g. via ToolHandle)
  // 4) In addition to each of the above cases, refCounting of a particular tool 
  //    might not have been done correctly in the code. Typically release() 
  //    is not called, so we are left with a too high refCount.
  //    What to do with those, and how to avoid a crash while handling them...
  
  MsgStream log( msgSvc(), name() );
  ListTools finalizedTools; // list of tools that have been finalized
  log << MSG::INFO  << "Removing all tools created by ToolSvc" << endreq;

  // Print out list of tools
  log << MSG::DEBUG << "  Tool List : ";
  for ( ListTools::const_iterator iTool = m_instancesTools.begin();
        iTool != m_instancesTools.end(); ++iTool ) {
    log << (*iTool)->name() << ":" << refCountTool( *iTool ) << " ";
  }
  log << endreq;

  //
  // first pass: Finalize all tools (but don't delete them)
  //
  bool fail(false);
  size_t toolCount = m_instancesTools.size();
  unsigned long startRefCount = 0;
  unsigned long endRefCount = totalToolRefCount();
  unsigned long startMinRefCount = 0;
  unsigned long endMinRefCount = minimumToolRefCount();
  while ( toolCount > 0 && 
          endRefCount > 0 && 
          (endRefCount != startRefCount || endMinRefCount != startMinRefCount) ) {
    if ( endMinRefCount != startMinRefCount ) {
      log << MSG::DEBUG << toolCount << " tools left to finalize. Summed refCounts: " 
          << endRefCount << endreq;
      log << MSG::DEBUG << "Will finalize tools with refCount <= " 
          << endMinRefCount << endreq;
    }
    startMinRefCount = endMinRefCount;
    startRefCount = endRefCount;
    unsigned long maxLoop = toolCount + 1;
    while ( --maxLoop > 0 &&  m_instancesTools.size() > 0 ) {
      IAlgTool* pTool = m_instancesTools.back();
      // removing tool from list makes ToolSvc::releaseTool( IAlgTool* ) a noop
      m_instancesTools.pop_back();
      unsigned long count = refCountTool( pTool );
      // cache tool name
      std::string toolName = pTool->name();
      if ( count <= startMinRefCount ) {
        log << MSG::DEBUG << "  Performing finalization of " << toolName 
            << " (refCount " << count << ")" << endreq;
        // finalize of one tool may trigger a release of another tool
        //      pTool->sysFinalize().ignore();
        if (!finalizeTool(pTool).isSuccess()) fail = true;
        // postpone deletion
        finalizedTools.push_back(pTool);
      } else {
        // Place back in list to try again later
        // ToolSvc::releaseTool( IAlgTool* ) remains active for this tool
        log << MSG::DEBUG << "  Delaying   finalization of " << toolName
            << " (refCount " << count << ")" << endreq;
        m_instancesTools.push_front(pTool);
      }
    } // end of inner loop
    toolCount = m_instancesTools.size();
    endRefCount = totalToolRefCount();
    endMinRefCount = minimumToolRefCount();
  }; // end of outer loop

  //
  // Second pass: Delete all finalized tools
  //
  // Delete in the order of increasing number of refCounts. 
  // Loop over tools in the same order as the order in which they were finalized.
  // All tools in the list of finalized tools are no longer in the instancesTools list.
  // If a tool destructor calls releaseTool() on another tool, this will have no
  // effect on the 'other tool' if this 'other tool' is in the list of finalized tools.
  // If this 'other tool' is still in the instancesTools list, it may trigger finalization
  // (in releaseTool()), deletion and removal from the instancesTools list.
  // Therefore, the check on non-finalised tools should happen *after* the deletion
  // of the finalized tools.
  log << MSG::DEBUG << "Deleting " << finalizedTools.size() << " finalized tools" << endreq;
  unsigned long maxLoop = totalToolRefCount( finalizedTools ) + 1;
  while ( --maxLoop > 0 && finalizedTools.size() > 0 ) {
    IAlgTool* pTool = finalizedTools.front();
    finalizedTools.pop_front();
    unsigned long count = refCountTool( pTool );
    if ( count == 1 ) {
      log << MSG::DEBUG << "  Performing deletion of " << pTool->name() << endreq;
    } else {
      log << MSG::VERBOSE << "  Delaying   deletion of " << pTool->name()
          << " (refCount " << count << ")" << endreq;
      // Put it back at the end of the list if refCount still not zero
      finalizedTools.push_back(pTool);
    }
    // do a forced release
    pTool->release();
  }

  // Error if by now not all tools are properly finalised
  if ( !m_instancesTools.empty() ) {
    log << MSG::ERROR << "Unable to finalize and delete the following tools : ";
    for ( ListTools::const_iterator iTool = m_instancesTools.begin();
          iTool != m_instancesTools.end(); ++iTool ) { 
      log << (*iTool)->name() << ": " << refCountTool( *iTool ) << " ";
    }
    log << endreq;
  }
  
  // by now, all tools should be deleted and removed.
  if ( finalizedTools.size() > 0 ) {
    log << MSG::ERROR << "Failed to delete the following " <<  finalizedTools.size() 
        << " finalized tools. Bug in ToolSvc::finalize()?: ";
    for ( ListTools::const_iterator iTool = finalizedTools.begin();
          iTool != finalizedTools.end(); ++iTool ) { 
      log << (*iTool)->name() << ": " << refCountTool( *iTool ) << " ";
    }
    log << endreq;
  }
  
  if ( 0 != m_pHistorySvc ) {
    m_pHistorySvc->release();
  }
  
  // Finalize this specific service
  if (! Service::finalize().isSuccess() || fail) {
    return StatusCode::FAILURE;
  } else {
    return StatusCode::SUCCESS;
  }


}

StatusCode ToolSvc::queryInterface	(	const InterfaceID &	riid,
		void **	ppvInterface
	)			[virtual]

Query the interfaces.

Reimplemented from Service.

Definition at line 233 of file ToolSvc.cpp.

References Service::addRef(), IID_IToolSvc, Service::queryInterface(), and StatusCode::SUCCESS.

{
  if ( IID_IToolSvc == riid )    {
    *ppvInterface = (IToolSvc*)this;
  }
  else  {
    // Interface is not directly available: try out a base class
    return Service::queryInterface(riid, ppvInterface);
  }
  addRef();
  return StatusCode::SUCCESS;
}

StatusCode ToolSvc::retrieve	(	const std::string &	type,
		const InterfaceID &	iid,
		IAlgTool *&	tool,
		const IInterface *	parent,
		bool	createIf
	)			[virtual]

Retrieve tool, create it by default as common tool if it does not already exist.

Implements IToolSvc.

Definition at line 258 of file ToolSvc.cpp.

References std::basic_string< _CharT, _Traits, _Alloc >::empty(), endreq(), MSG::ERROR, StatusCode::FAILURE, std::basic_string< _CharT, _Traits, _Alloc >::find(), Service::msgSvc(), Service::name(), std::basic_string< _CharT, _Traits, _Alloc >::npos, and s_PUBLIC.

Referenced by retrieve().

{

  // protect against empty type
  if ( tooltype.empty() ) {
    MsgStream log( msgSvc(), name() );
    log << MSG::ERROR << "retrieve(): No Tool Type/Name given" << endreq;
    return StatusCode::FAILURE;
  }
  
  {
    // check for tools, which by name is required to be public:
    const std::string::size_type pos = tooltype.find ( s_PUBLIC ) ;
    if ( std::string::npos != pos )
    {
      // set parent for PUBLIC tool
      parent = this ;
      return retrieve ( std::string( tooltype , 0 , pos ) ,
                        iid , tool , parent , createIf ) ;
    }
  }

  const std::string::size_type pos = tooltype.find('/');
  if( std::string::npos == pos )
  { return retrieve ( tooltype , tooltype , iid , tool , parent , createIf );}
  const std::string newtype ( tooltype ,       0 , pos               ) ;
  const std::string newname ( tooltype , pos + 1 , std::string::npos ) ;
  return retrieve ( newtype , newname , iid , tool , parent , createIf ) ;
}

StatusCode ToolSvc::retrieve	(	const std::string &	tooltype,
		const std::string &	toolname,
		const InterfaceID &	iid,
		IAlgTool *&	tool,
		const IInterface *	parent,
		bool	createIf
	)			[virtual]

Retrieve tool, create it by default as common tool if it does not already exist.

invoke retrieve callbacks...

Implements IToolSvc.

Definition at line 296 of file ToolSvc.cpp.

References std::vector< _Tp, _Alloc >::begin(), std::list< _Tp, _Alloc >::begin(), create(), MSG::DEBUG, std::vector< _Tp, _Alloc >::empty(), std::basic_string< _CharT, _Traits, _Alloc >::empty(), std::vector< _Tp, _Alloc >::end(), std::list< _Tp, _Alloc >::end(), endreq(), MSG::ERROR, StatusCode::FAILURE, std::basic_string< _CharT, _Traits, _Alloc >::find(), std::for_each(), StatusCode::isFailure(), m_instancesTools, m_observers, Service::msgSvc(), Service::name(), nameTool(), std::basic_string< _CharT, _Traits, _Alloc >::npos, IToolSvc::Observer::onRetrieve(), IInterface::queryInterface(), retrieve(), s_PUBLIC, and MSG::WARNING.

{
  MsgStream log( msgSvc(), name() );
  
  // check the applicability of another method:
  // ignore the provided name if it is empty or the type contains a name
  if( toolname.empty() || (std::string::npos != tooltype.find('/')) )
  { return retrieve ( tooltype , iid , tool , parent , createIf ) ; }

  {
    // check for tools, which by name is required to be public:
    const std::string::size_type pos = toolname.find ( s_PUBLIC ) ;
    if ( std::string::npos != pos )
    {
      // set parent for PUBLIC tool
      parent = this ;
      return retrieve ( tooltype , std::string( toolname , 0 , pos ) ,
                        iid , tool , parent , createIf ) ;
    }
  }

  IAlgTool* itool = 0;
  StatusCode sc(StatusCode::FAILURE);

  tool = 0;

  // If parent is not specified it means it is the ToolSvc itself
  if( 0 == parent ) {
    parent = this;
  }
  const std::string fullname = nameTool( toolname, parent );

  // Find tool in list of those already existing, and tell its
  // interface that it has been used one more time
  ListTools::const_iterator it;
  for( it = m_instancesTools.begin(); it != m_instancesTools.end(); ++it ) {
    if( (*it)->name() == fullname ) {
      log << MSG::DEBUG << "Retrieved tool " << toolname << endreq;
      itool = *it;
      break;
    }
  }

  if ( 0 == itool ) {
    // Instances of this tool do not exist, create an instance if desired
    // otherwise return failure
    if( !createIf ) {
      log << MSG::WARNING << "Tool " << toolname
          << " not found and creation not requested" << endreq;
      return sc;
    }
    else {
      sc = create( tooltype, toolname, parent, itool );
      if ( sc.isFailure() ) { return sc; }
    }
  }

  // Get the right interface of it
  sc = itool->queryInterface( iid, (void**)&tool);
  if( sc.isFailure() ) {
    log << MSG::ERROR << "Tool " << toolname
        << " either does not implement the correct interface, or its version is incompatible"
        << endreq;
    return sc;
  }
  if (!m_observers.empty()) {
     std::for_each( m_observers.begin(), 
                    m_observers.end(), 
                    bl::bind(&IToolSvc::Observer::onRetrieve,
                             bl::_1,
                             itool));
  }

  return sc;
}

std::vector< std::string > ToolSvc::getInstances

(

const std::string &

toolType

)

[virtual]

Get names of all tool instances of a given type.

Implements IToolSvc.

Definition at line 381 of file ToolSvc.cpp.

References std::list< _Tp, _Alloc >::begin(), std::list< _Tp, _Alloc >::end(), m_instancesTools, and std::vector< _Tp, _Alloc >::push_back().

{

  std::vector<std::string> tools;

  ListTools::const_iterator it;
  for (it = m_instancesTools.begin(); it != m_instancesTools.end(); ++it) {
    if ((*it)->type() == toolType) {
      tools.push_back( (*it)->name() );
    }
  }

  return tools;

}

StatusCode ToolSvc::releaseTool

(

IAlgTool *

tool

)

[virtual]

Release tool.

Implements IToolSvc.

Definition at line 398 of file ToolSvc.cpp.

References count(), MSG::DEBUG, endreq(), finalizeTool(), std::find(), m_instancesTools, Service::m_targetState, Service::msgSvc(), INamedInterface::name(), Service::name(), Gaudi::StateMachine::OFFLINE, std::list< _Tp, _Alloc >::rbegin(), refCountTool(), IInterface::release(), std::list< _Tp, _Alloc >::remove(), std::list< _Tp, _Alloc >::rend(), and StatusCode::SUCCESS.

{
  StatusCode sc(StatusCode::SUCCESS);
  // test if tool is in known list (protect trying to access a previously deleted tool)
  if ( m_instancesTools.rend() != std::find( m_instancesTools.rbegin(),
                                              m_instancesTools.rend(),
                                              tool ) ) {
    unsigned long count = refCountTool(tool);
    if ( count == 1 ) {
      MsgStream log( msgSvc(), name() );
      // finalize the tool

      if ( Gaudi::StateMachine::OFFLINE == m_targetState ) {
        // We are being called during ToolSvc::finalize()
        // message format matches the one in ToolSvc::finalize()
        log << MSG::DEBUG << "  Performing finalization of " << tool->name()
            << " (refCount " << count << ")" << endreq;
        // message format matches the one in ToolSvc::finalize()
        log << MSG::DEBUG << "  Performing     deletion of " << tool->name() << endreq;
      } else {
        log << MSG::DEBUG << "Performing finalization and deletion of " << tool->name() << endreq;
      }
      sc = finalizeTool(tool);
      // remove from known tools...
      m_instancesTools.remove(tool);
    }
    tool->release();
  }

  return sc;
}

StatusCode ToolSvc::create	(	const std::string &	type,
		const IInterface *	parent,
		IAlgTool *&	tool
	)

Create Tool standard way with automatically assigned name.

Definition at line 432 of file ToolSvc.cpp.

Referenced by retrieve().

{
  const std::string & toolname = tooltype;
  return create( tooltype, toolname, parent, tool);
}

StatusCode ToolSvc::create	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent,
		IAlgTool *&	tool
	)

Create Tool standard way with specified name.

invoke create callbacks...

Definition at line 442 of file ToolSvc.cpp.

References std::vector< _Tp, _Alloc >::begin(), std::vector< _Tp, _Alloc >::empty(), std::basic_string< _CharT, _Traits, _Alloc >::empty(), std::vector< _Tp, _Alloc >::end(), endreq(), MSG::ERROR, existsTool(), StatusCode::FAILURE, MSG::FATAL, std::for_each(), StatusCode::ignore(), StatusCode::isFailure(), m_instancesTools, m_observers, m_pHistorySvc, Service::msgSvc(), Service::name(), nameTool(), IToolSvc::Observer::onCreate(), std::list< _Tp, _Alloc >::push_back(), IHistorySvc::registerAlgTool(), Service::service(), AlgTool::setProperties(), StatusCode::SUCCESS, IAlgTool::sysInitialize(), GaudiException::tag(), MSG::VERBOSE, and std::exception::what().

{
  MsgStream log( msgSvc(), name() );
  // protect against empty type
  if ( tooltype.empty() ) {
    log << MSG::ERROR << "create(): No Tool Type given" << endreq;
    return StatusCode::FAILURE;
  }

  // If parent has not been specified, assume it is the ToolSvc
  if ( 0 == parent ) parent = this;

  tool = 0;

  // Check if the tool already exist : this should never happen
  const std::string fullname = nameTool(toolname, parent);
  if( existsTool( fullname ) ) {
    log << MSG::ERROR << "Tool " << fullname << " already exists" << endreq;
    return StatusCode::FAILURE;
  }
  // instanciate the tool using the factory
  try {
    tool = PluginService::Create<IAlgTool*>(tooltype, tooltype, fullname, parent);
    if (!tool ){
       log << MSG::ERROR
           << "Cannot create tool " << tooltype << " (No factory found)" << endreq;
       return StatusCode::FAILURE;
    }
  }
  catch ( const GaudiException& Exception )  {
    // (1) perform the printout of message
    MsgStream log ( msgSvc() , name() );
    log << MSG::FATAL << "Exception with tag=" << Exception.tag()
        << " is caught whilst instantiating tool '" << tooltype << "'" << endreq;
    // (2) print  the exception itself
    // (NB!  - GaudiException is a linked list of all "previous exceptions")
    log << MSG::FATAL << Exception  << endreq;
    tool = 0;
    return StatusCode::FAILURE;
  }
  catch( const std::exception& Exception ) {
    // (1) perform the printout of message
    MsgStream log ( msgSvc() , name() );
    log << MSG::FATAL
        << "Standard std::exception is caught whilst instantiating tool '"
          << tooltype << "'" << endreq;
    // (2) print  the exception itself
    // (NB!  - GaudiException is a linked list of all "previous exceptions")
    log << MSG::FATAL << Exception.what()  << endreq;
    tool = 0;
    return StatusCode::FAILURE;
  }
  catch(...) {
    // (1) perform the printout
    MsgStream log ( msgSvc() , name() );
    log << MSG::FATAL << "UNKNOWN Exception is caught whilst instantiating tool '"
        << tooltype << "'" << endreq;
    tool = 0;
    return StatusCode::FAILURE;
  }
  log << MSG::VERBOSE << "Created tool " << tooltype << "/" << fullname << endreq;
  
  m_instancesTools.push_back( tool );
  
  // Since only AlgTool has the setProperties() method it is necessary to cast
  // to downcast IAlgTool to AlgTool in order to set the properties via the JobOptions
  // service
  AlgTool* mytool = dynamic_cast<AlgTool*> (tool);
  if ( mytool != 0 ) {
    StatusCode sc = mytool->setProperties();
    if ( sc.isFailure() ) {
      MsgStream log ( msgSvc() , name() );
      log << MSG::ERROR << "Error setting properties for tool '"
          << fullname << "'" << endreq;
      return sc;
    }
  }
  
  // Initialize the Tool
  StatusCode sc (StatusCode::FAILURE,true);
  try { sc = tool->sysInitialize(); }
  
  // Catch any exceptions
  catch ( const GaudiException & Exception )
    {
      MsgStream msg ( msgSvc(), name() );
      msg << MSG::ERROR
          << "GaudiException with tag=" << Exception.tag()
          << " caught whilst initializing tool '" << fullname << "'" << endreq
          << Exception << endreq;
      return StatusCode::FAILURE;
    }
  catch( const std::exception & Exception )
    {
      MsgStream msg ( msgSvc(), name() );
      msg << MSG::ERROR
          << "Standard std::exception caught whilst initializing tool '" 
          << fullname << "'" << endreq << Exception.what() << endreq;
      return StatusCode::FAILURE;
    }
  catch (...)
    {
      MsgStream msg ( msgSvc(), name() );
      msg << MSG::ERROR
          << "UNKNOWN Exception caught whilst initializing tool '" 
          << fullname << "'" << endreq;
      return StatusCode::FAILURE;
    }
  
  // Status of tool intialization
  if ( sc.isFailure() ) {
    MsgStream log( msgSvc(), name() );
    log << MSG::ERROR << "Error initializing tool '" << fullname << "'" << endreq;
    return sc;
  }
  
  if (!m_observers.empty()) {
      std::for_each( m_observers.begin(), 
                     m_observers.end(), 
                     bl::bind(&IToolSvc::Observer::onCreate,
                              bl::_1,
                              tool));
  }
  // TODO: replace by generic callback
  // Register the tool with the HistorySvc
  if (m_pHistorySvc != 0 || 
      service("HistorySvc",m_pHistorySvc,false).isSuccess() ) {
    m_pHistorySvc->registerAlgTool(*tool).ignore();
  }
  
  return StatusCode::SUCCESS;
 
}

bool ToolSvc::existsTool

(

const std::string &

toolname

)

const

Check if the tool instance exists.

Definition at line 613 of file ToolSvc.cpp.

Referenced by create().

{
  for ( ListTools::const_iterator it = m_instancesTools.begin(); 
        it != m_instancesTools.end(); ++it ) {
    if ( (*it)->name() == fullname ) { return true; }
  }
  return false;
}

std::string ToolSvc::nameTool	(	const std::string &	nameByUser,
		const IInterface *	parent
	)

Get Tool full name by combining nameByUser and "parent" part.

Definition at line 584 of file ToolSvc.cpp.

References endreq(), MSG::ERROR, INamedInterface::interfaceID(), StatusCode::isSuccess(), Service::msgSvc(), Service::name(), and IInterface::queryInterface().

Referenced by create(), and retrieve().

{
  
  std::string fullname = "";
  if ( parent == 0 ) { return this->name() + "." + toolname; }    // RETURN 
  
  
  IInterface* cparent = const_cast<IInterface*>( parent ) ;
  // check that parent has a name!
  INamedInterface* _p = 0 ;
  StatusCode sc = cparent->queryInterface( INamedInterface::interfaceID() , pp_cast<void>(&_p) ) ;
  if ( sc.isSuccess() )
  { 
    fullname = _p->name() + "." + toolname ; 
    _p->release() ;
    return fullname ;                                          // RETURN 
  }

  MsgStream log ( msgSvc(), name() );
  log << MSG::ERROR
      << "Private Tools only allowed for INamedInterfaces"
      << endreq;
  //
  return "." + toolname ;
}

unsigned long ToolSvc::refCountTool

(

IAlgTool *

tool

)

const [inline]

Get current refcount for tool.

Definition at line 70 of file ToolSvc.h.

References IAlgTool::refCount().

Referenced by finalize(), minimumToolRefCount(), and releaseTool().

{ return tool->refCount(); }

void ToolSvc::registerObserver

(

IToolSvc::Observer *

obs

)

[virtual]

Implements IToolSvc.

Definition at line 701 of file ToolSvc.cpp.

References StatusCode::FAILURE, m_observers, and std::vector< _Tp, _Alloc >::push_back().

                                                    {
  if ( 0 == obs )
    throw GaudiException( "Received NULL pointer", this->name() + "::registerObserver", StatusCode::FAILURE );
  m_observers.push_back(obs); 
}

void ToolSvc::unRegisterObserver

(

IToolSvc::Observer *

obs

)

[virtual]

Implements IToolSvc.

Definition at line 707 of file ToolSvc.cpp.

References std::vector< _Tp, _Alloc >::begin(), std::vector< _Tp, _Alloc >::end(), std::vector< _Tp, _Alloc >::erase(), find(), and m_observers.

                                                      {
  std::vector<IToolSvc::Observer*>::iterator i = 
    find(m_observers.begin(),m_observers.end(),obs); 
  if (i!=m_observers.end()) m_observers.erase(i);
}

unsigned long ToolSvc::totalToolRefCount

(

)

const [private]

The total number of refCounts on all tools in the instancesTools list.

Definition at line 679 of file ToolSvc.cpp.

References m_instancesTools.

Referenced by finalize().

{
  return totalToolRefCount( m_instancesTools );
}

unsigned long ToolSvc::totalToolRefCount

(

const ListTools &

)

const [private]

The total number of refCounts on all tools in the list.

Definition at line 667 of file ToolSvc.cpp.

References count().

{
  unsigned long count = 0;
  for ( ListTools::const_iterator iTool = toolList.begin();
        iTool != toolList.end(); ++iTool ) {
    count += refCountTool( *iTool );
  }
  return count;
}

unsigned long ToolSvc::minimumToolRefCount

(

)

const [private]

The minimum number of refCounts of all tools.

Definition at line 685 of file ToolSvc.cpp.

References std::list< _Tp, _Alloc >::begin(), count(), std::list< _Tp, _Alloc >::end(), m_instancesTools, std::min(), refCountTool(), and std::list< _Tp, _Alloc >::size().

Referenced by finalize().

{
  unsigned long count = 0;
  if ( m_instancesTools.size() > 0 ) {
    ListTools::const_iterator iTool = m_instancesTools.begin();
    // start with first
    count = refCountTool( *iTool );
    // then compare the others
    for( ++iTool; iTool != m_instancesTools.end(); ++iTool ) {
      count = std::min( count, refCountTool( *iTool ) );
    }
  }
  return count;
}

StatusCode ToolSvc::finalizeTool

(

IAlgTool *

itool

)

const [private]

Finalise the given tool, with exception handling.

Definition at line 624 of file ToolSvc.cpp.

References endreq(), MSG::ERROR, StatusCode::FAILURE, name, GaudiException::tag(), and std::exception::what().

Referenced by finalize(), and releaseTool().

{

  // Cache tool name in case of errors
  const std::string toolName = itool->name();
  StatusCode sc;

  // Finalise the tool inside a try block
  try { sc = itool->sysFinalize(); }

  // Catch any exceptions
  catch ( const GaudiException & Exception )
  {
    MsgStream msg ( msgSvc(), name() );
    msg << MSG::ERROR
        << "GaudiException with tag=" << Exception.tag()
        << " caught whilst finalizing tool '" << toolName << "'" << endreq
        << Exception << endreq;
    sc = StatusCode::FAILURE;
  }
  catch( const std::exception & Exception )
  {
    MsgStream msg ( msgSvc(), name() );
    msg << MSG::ERROR
        << "Standard std::exception caught whilst finalizing tool '" 
        << toolName << "'" << endreq << Exception.what() << endreq;
    sc = StatusCode::FAILURE;
  }
  catch (...)
  {
    MsgStream msg ( msgSvc(), name() );
    msg << MSG::ERROR
        << "UNKNOWN Exception caught whilst finalizing tool '" 
        << toolName << "'" << endreq;
    sc = StatusCode::FAILURE;
  }

  return sc;

}

---

Member Data Documentation

ListTools ToolSvc::m_instancesTools [private]

Common Tools.

Definition at line 102 of file ToolSvc.h.

Referenced by create(), finalize(), getInstances(), minimumToolRefCount(), releaseTool(), retrieve(), and totalToolRefCount().

IHistorySvc* ToolSvc::m_pHistorySvc [private]

Pointer to HistorySvc.

Definition at line 105 of file ToolSvc.h.

Referenced by create(), and finalize().

std::vector<IToolSvc::Observer*> ToolSvc::m_observers [private]

Definition at line 107 of file ToolSvc.h.

Referenced by create(), registerObserver(), retrieve(), and unRegisterObserver().

---

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

• /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r2/GaudiSvc/v17r1/src/ToolSvc/ToolSvc.h
• /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r2/GaudiSvc/v17r1/src/ToolSvc/ToolSvc.cpp

---