---

AlgTool.cpp

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiKernel/src/Lib/AlgTool.cpp,v 1.1.1.1 2001/04/18 18:14:18 tlindner Exp $


// Include files
#include "GaudiKernel/AlgTool.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IJobOptionsSvc.h"
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/Service.h"


// IInterface::addRef
unsigned long AlgTool::addRef()   {
  m_refCount++;
  return m_refCount;
}

// IInterface::release
unsigned long AlgTool::release()   {
  unsigned long count = --m_refCount;
  if( count <= 0) {
    delete this;
  }
  return count;
}

// IInterface::queryInterface
StatusCode AlgTool::queryInterface(const IID& riid, void** ppvInterface)  {
  if ( IID_IInterface.versionMatch(riid) )   {
    *ppvInterface = (IInterface*)this;
  }
  else if ( IID_IAlgTool.versionMatch(riid) )  {
    *ppvInterface = (IAlgTool*)this;
  }
  else if ( IID_IProperty.versionMatch(riid) )  {
    *ppvInterface = (IProperty*)this;
  }
  else   {
     return NO_INTERFACE;
  }
  addRef();
  return SUCCESS;
}


// IAlgTool::name, retrieve full name of concrete tool
const std::string& AlgTool::name()   const {
  return m_name;
}

// IAlgTool::type, retrieve class of concrete tool
const std::string& AlgTool::type()  const {
  return m_type;
}

// IAlgTool::parent, retrieve interface of parent 
const IInterface* AlgTool::parent() const {
  return m_parent;
}

// Retrieve pointer to service locator
ISvcLocator* AlgTool::serviceLocator()    {
  return m_svcLocator;
}

// Retrieve pointer to message service
IMessageSvc* AlgTool::msgSvc()    {
  return m_messageSvc;
}
IMessageSvc* AlgTool::msgSvc()  const  {
  return m_messageSvc;
}

// IProperty::setProperty, delegate to the property manager
StatusCode AlgTool::setProperty(const Property& p) {
        return m_propertyMgr->setProperty(p);
}

StatusCode AlgTool::setProperty(std::istream& s) {
        return m_propertyMgr->setProperty(s);
}
StatusCode AlgTool::setProperty(const std::string& n, const std::string& v) {
        return m_propertyMgr->setProperty(n,v);
}

// IProperty::getProperty, delegate to the property manager
StatusCode AlgTool::getProperty(Property* p) const {
        return m_propertyMgr->getProperty(p);
}

// IProperty::getProperty, delegate to the property manager
const Property& AlgTool::getProperty(const std::string& n) const {
  return m_propertyMgr->getProperty(n);
}

StatusCode AlgTool::getProperty(const std::string& n, std::string& v ) const {
        return m_propertyMgr->getProperty(n,v);
}

// IProperty::getProperties, delegate to the property manager
const std::vector<Property*>& AlgTool::getProperties() const {
        return m_propertyMgr->getProperties();
}

// Use the job options service to set declared properties
StatusCode AlgTool::setProperties() {
        IJobOptionsSvc* jos;
  if( m_svcLocator == 0) {
    return StatusCode::FAILURE;
  }
        StatusCode sc = m_svcLocator->getService( "JobOptionsSvc", IID_IJobOptionsSvc, 
                                            (IInterface*&) jos);
    if( !sc.isSuccess() )  return StatusCode::FAILURE;

    std::string test = name();
    jos->setMyProperties( name(), this );
    // Change my own outputlevel
    if( m_messageSvc ) m_messageSvc->setOutputLevel( name(), m_outputLevel );

        return StatusCode::SUCCESS;
}


//
// Standard Constructor
AlgTool::AlgTool( const std::string& type, const std::string& name, const IInterface* parent) :
  m_type( type ), m_name( name ), m_parent( parent ) {
  m_refCount   = 1;
  m_svcLocator = 0;
  m_messageSvc = 0;
  m_propertyMgr = new PropertyMgr();
  m_outputLevel = MSG::NIL;

  // Try to cast the IInterface interface to a base class Algorithm or to a 
  // base class Service
  StatusCode sc;
  IntegerProperty outlevel("OutputLevel", 0);
  Algorithm* alg = dynamic_cast<Algorithm*>(const_cast<IInterface*>(parent));
  // .. the parent is an algorithm
  if( alg != 0 ) {
    m_svcLocator  = alg->serviceLocator();
    m_messageSvc  = alg->msgSvc();
    // Get the OutputLevel property of the parent
    sc = alg->getProperty( &outlevel );
    if( sc.isSuccess() ) {
      m_outputLevel = outlevel.value();
    }
  }
  // ... since it is not an algorithm maybe it is a service
  else {
    Service* svc = dynamic_cast<Service*>(const_cast<IInterface*>(parent));
    if( svc != 0 ) {
      m_svcLocator  = svc->serviceLocator();
      m_messageSvc  = svc->msgSvc();
      sc = svc->getProperty( &outlevel );
      if( sc.isSuccess() ) {
        m_outputLevel = outlevel.value();
      }
    }
    // the parent is neither an algorithm nor a service,
    else {
        // throw exception here?
    }
  }

  // Declare common AlgTool properties with their defaults
  declareProperty( "OutputLevel", m_outputLevel);
}

// Standard Destructor
AlgTool::~AlgTool() {
  delete m_propertyMgr;
}

---