---

ToolSvc.cpp

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiSvc/src/ToolSvc/ToolSvc.cpp,v 1.1.1.3 2001/04/18 18:32:51 tlindner Exp $

// Include Files
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/Service.h"
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/IToolFactory.h"
#include "GaudiKernel/GaudiException.h"
#include "GaudiKernel/AlgTool.h"
#include "ToolSvc.h"

// Instantiation of a static factory class used by clients to create
//  instances of this service
static SvcFactory<ToolSvc> s_factory;
const ISvcFactory& ToolSvcFactory = s_factory;


//
// ClassName:   ToolSvc
//  
// 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 service has a list of instanciated tools and if
//              an already existing tool is requested the existing
//              instance is passed.
//              The parent of a tool can be an algortihm or a service.
//              The environment of a tool can be set by using that of
//              the parent. A common tool is considered to belong to the
//              ToolSvc itself.
//
// Author:      G.Corti, P.Mato
//------------------------------------------------------------------


// Standard Constructor.
//   Input:  name   String with service name
//   Input:  svc    Pointer to service locator interface
ToolSvc::ToolSvc( const std::string& name, ISvcLocator* svc )
: Service(name, svc) {
  m_objManager = 0;
  m_instancesTools = new ListTools();

}
  
// Destructor.
ToolSvc::~ToolSvc() { 
  delete m_instancesTools;
}

// Inherited Service overrides:
//
  // Initialize the service.
StatusCode ToolSvc::initialize() {

  // initialize the Service Base class
  StatusCode status = Service::initialize();

  MsgStream log( msgSvc(), name() ); 

  if ( status.isFailure() ) {
    log << MSG::ERROR << "Unable to initialize the Service" << endreq;
    return status;
  }

  // set my own (ToolSvc) properties via the jobOptionService 
  setProperties();

  // locate Object Manager to locate later the tools 
  status = serviceLocator()->getService("ApplicationMgr", IID_IObjManager,
                                        reinterpret_cast<IInterface*&>( m_objManager ));
  if( status.isFailure()) {
    log << MSG::ERROR << "Unable to locate ObjectManager Service" << endreq;
    return status;
  }

  return StatusCode::SUCCESS;
}
  
  // Finalise the service.
StatusCode ToolSvc::finalize() {
  MsgStream log( msgSvc(), name() ); 

  // Remove all the tool instances from the list of instanciated
  // tools and release the tools themselves.
  log << MSG::INFO << "Removing all tools created by ToolSvc" << endreq;
  while ( m_instancesTools->size() > 0 ) {
    IAlgTool* itool = m_instancesTools->back();
    log << MSG::DEBUG << "Removing tool " << (m_instancesTools->back())->name() << endreq;
    m_instancesTools->pop_back();
    itool->release();
  }

  // Finalize this specific service
  StatusCode status = Service::finalize();
  return status;
}
  
  // Query the interfaces.
  //   Input: riid, Requested interface ID
  //          ppvInterface, Pointer to requested interface
  //   Return: StatusCode indicating SUCCESS or FAILURE.
  // N.B. Don't forget to release the interface after use!!!
StatusCode ToolSvc::queryInterface( const IID& riid, void** ppvInterface ) {
  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;
}
  
// IToolSvc interfaces overwrite
// 
  // Retrieve tool, create it by default as common tool if it does not already exist.
  // The user provided part of the name is assumed to be the concrete class
StatusCode ToolSvc::retrieve(const std::string& tooltype, IAlgTool*& tool, const IInterface* parent=0, 
                                 bool createIf=true) {

  std::string toolname = tooltype;
  return retrieve(tooltype, toolname, tool, parent, createIf);
}

  // Retrieve tool, but with a name, this allow to have many instances of the
  // same tool with different properties
StatusCode ToolSvc::retrieve(const std::string& tooltype, const std::string& toolname,  
                                 IAlgTool*& tool, const IInterface* parent=0, bool createIf=true) {

  MsgStream log( msgSvc(), name() );
  
  // If parent is not specified it means it is the ToolSvc itself
  if( 0 == parent ) {
    parent = this;
  }
  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;
      tool = *it;
      // Do we need to add references when a new retrieve is done ???
      // In that case we can keep the number of references to the same instance...
      // unsigned long count = tool->addRef();
      return StatusCode::SUCCESS;
    }
  } 
  
  // Instances of this tool do not exist, create an instance if desired otherwise
  // return failure
  if( !createIf ) {
    log << MSG::ERROR << "Tool " << toolname << " not found and creation not requested" 
        << endreq;
    return StatusCode::FAILURE;
  }
    
  return create( tooltype, toolname, parent, tool );
}


// Methods not in the IToolSvc interface 
//
  // Create a Tool "belonging" to the parent with automatically assigned name
StatusCode ToolSvc::create(const std::string& tooltype, const IInterface* parent, IAlgTool*& tool) {

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

  // Create a Tool "belonging" to the parent algorithm with specified name
StatusCode ToolSvc::create(const std::string& tooltype, const std::string& toolname, 
                           const IInterface* parent, IAlgTool*& tool) {
  MsgStream log( msgSvc(), name() );
  
  StatusCode sc;
  const IFactory* factory = 0;
  IToolFactory* toolfactory = 0;
   
  // 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
  std::string fullname = nameTool(toolname, parent);
  if( existsTool( fullname ) ) {
    log << MSG::ERROR << "Tool " << fullname << " already exists" << endreq;
    return StatusCode::FAILURE;
  }

  // Find the factory and check if it is of the right type, set the properties of the
  // tool
  if( m_objManager->existsObjFactory( tooltype ) ) {
    factory = m_objManager->objFactory( tooltype );
    IFactory* fact = const_cast<IFactory*>(factory);
    sc = fact->queryInterface( IID_IToolFactory, (void**)&toolfactory );
    if( sc.isFailure() ) {
      log << MSG::ERROR <<"Found a Factory for " << tooltype << " but is not a Tool factory" << endreq;
      return sc;
    }
    // instanciate the tool using the factory
    try {
      tool = toolfactory->instantiate( fullname, parent );
    }
    catch ( const GaudiException& Exception )  {
            // (1) perform the printout of message
            MsgStream log ( msgSvc() , name() + " retriving tool " + tooltype );
            log << MSG::ERROR << " Exception with tag=" << Exception.tag() << " is caught " << endreq;
      // (2) print  the exception itself (NB!  - GaudiException is a linked list of all "previous exceptions")
            log << MSG::ERROR << Exception  << endreq;
      tool = 0;
      return StatusCode::FAILURE;
    }
    catch( const std::exception& Exception ) {
            // (1) perform the printout of message
            MsgStream log ( msgSvc() , name() + " retriving tool " + tooltype );
            log << MSG::FATAL << " Standard std::exception is caught " << endreq;
            // (2) print  the exception itself (NB!  - GaudiException is a linked list of all "previous exceptions")
            log << MSG::ERROR << Exception.what()  << endreq;
      tool = 0;
      return StatusCode::FAILURE;
    }
    catch(...) {
            // (1) perform the printout
            MsgStream log ( msgSvc() , name() + " retriving tool " + tooltype );
            log << MSG::FATAL << "UNKNOWN Exception is caught " << endreq;
            tool = 0;
      return StatusCode::FAILURE;
    }

    m_instancesTools->push_back( tool );

    // Since only AlgTool has the setProperties() method it is necessary to cast 
    // to the base class in order to set the properties via the JobOptions service
    AlgTool* mytool = dynamic_cast<AlgTool*> (tool);
    if ( mytool != 0 ) { 
      mytool->setProperties();
    }
    return StatusCode::SUCCESS;
    log << MSG::INFO << "Tool " << fullname << " created" << endreq;  
  }
  else {
    log << MSG::ERROR << "Factory for Tool " << tooltype << " not found" << endreq;
    return StatusCode::FAILURE;
  }
}

  // tells what will be the complete tool name
std::string ToolSvc::nameTool(const std::string& toolname, const IInterface* parent) {
  
  MsgStream log ( msgSvc(), name() );
  std::string fullname = "";
  if( parent == 0 ) {
    fullname = this->name() + "." + toolname;
    return fullname;
  }
  else {    
    std::string prefname = "";
    // Query the parent interface to check if it is an algorithm or a service
    StatusCode sc;
    IInterface* cparent = const_cast<IInterface*>(parent);
    // ... is it an algorithm ?
    IAlgorithm* parentAlg = 0;
    sc = cparent->queryInterface( IID_IAlgorithm, (void**)&parentAlg );
    if ( sc.isSuccess() ) {
      prefname = parentAlg->name();
      parentAlg->release();
    }
    // ... since it is not an algorithm maybe it is a service
    else {
      IService* parentSvc = 0;
      sc = cparent->queryInterface( IID_IService, (void**)&parentSvc );
      if ( sc.isSuccess() ) {
        prefname = parentSvc->name();
        parentSvc->release();
      }
      else {
        log << MSG::ERROR << "Parent for tools can only be an Algorithm or a Service" << endreq;
      }
    }
     
   return fullname = prefname + "." + toolname;
  }
}


// existsTool
bool ToolSvc::existsTool( const std::string& fullname) const {
  ListTools::const_iterator it;
  for (it = m_instancesTools->begin(); it != m_instancesTools->end(); it++ ) {
          if( (*it)->name() == fullname ) {
      return true;
    }
  }
  return false;
}

---