GslSvc.cpp

Go to the documentation of this file.

// $Id: GslSvc.cpp,v 1.2 2006/01/10 20:00:05 hmd Exp $
// Include files 
// from Gaudi
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/System.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IToolSvc.h"
// STD & STL 
#include <algorithm>
#include <functional>
// GaudiGSL
#include "GaudiGSL/IGslErrorHandler.h"
#include "GaudiGSL/GslError.h"
// local 
#include "GaudiGSL/GaudiGSL.h"
#include "GslSvc.h"
#include "GaudiGSL/GslErrorHandlers.h"
// gsl 
#include "gsl/gsl_errno.h"

// ============================================================================
// ============================================================================

// ============================================================================
// ============================================================================
DECLARE_SERVICE_FACTORY(GslSvc)
// ============================================================================

// ============================================================================
// ============================================================================
GslSvc::GslSvc( const std::string& name ,
                ISvcLocator*       svc  )
  : Service ( name , svc ) 
  , m_errorPolicy       ( "GSL" )
  , m_handlersTypeNames ()
  , m_handlers          ()
  , m_ignore            ()
{
  declareProperty( "ErrorPolicy" , m_errorPolicy       ) ;  
  declareProperty( "Handlers"    , m_handlersTypeNames ) ;
  declareProperty( "IgnoreCodes" , m_ignore            ) ;
};
// ============================================================================

// ============================================================================
// ============================================================================
GslSvc::~GslSvc() {}; 
// ============================================================================

// ============================================================================
// ============================================================================
StatusCode GslSvc::initialize() 
{
  // initialize the base class 
  StatusCode sc = Service::initialize();      
  MsgStream log( msgSvc() , name() );
  if( sc.isFailure() )
    { log << MSG::ERROR 
          << " Error in initialization of base class 'Service'"<< endreq;
    return sc;
    }
  // activate the static accessor to the service  
  GaudiGSL::setGslSvc( this );
  // set the error handlers 
  if      ( "GSL"       == m_errorPolicy ) { /* nothing to do */ }
  else if ( "Off"       == m_errorPolicy )
    { gsl_set_error_handler_off()                                ; }
  else if ( "Abort"     == m_errorPolicy )
    { gsl_set_error_handler ( 0 )                                ; }
  else if ( "Ignore"    == m_errorPolicy )
    { gsl_set_error_handler ( GslErrorHandlers::ignoreTheError ) ; }
  else if ( "Exception" == m_errorPolicy ) 
    { gsl_set_error_handler ( GslErrorHandlers::throwException ) ; }
  else if ( "Handle"    == m_errorPolicy )
    { gsl_set_error_handler ( GslErrorHandlers::handleTheError ) ; }
  else 
    { log << MSG::ERROR 
          << " Unknown Error policy '" << m_errorPolicy << "'" 
          << " Valid policies: " 
          << "[ 'GSL' , 'Off' , 'Abort' , 'Ignore' , 'Exception' , 'Handle' ]"
          << endreq;
    return StatusCode::FAILURE ;
    }
  GslErrorHandler handler = gsl_set_error_handler( 0 );
  gsl_set_error_handler( handler );
  if( 0 != handler )
    { log << MSG::VERBOSE
          << " GSL Error Handler is '" 
          << System::typeinfoName( typeid(*handler) ) << "'"
          << endreq; }
  else { log << MSG::INFO << " Error Handler is NULL" << endreq ; }
  
  if( !m_handlersTypeNames.empty() )
    {
      IToolSvc* toolsvc = 0 ;
      StatusCode sc = 
        serviceLocator()->service( "ToolSvc" , toolsvc , true );
      if ( sc.isFailure() )
        { log << MSG::ERROR << " Could not locate Tool Service! " << endreq ;
        return sc ; }
      if ( 0 == toolsvc   ) 
        { log << MSG::ERROR << " Could not locate Tool Service! " << endreq ;
        return StatusCode::FAILURE ; }      
      for( Names::const_iterator it = m_handlersTypeNames.begin() ;
           m_handlersTypeNames.end() != it ; ++it )
        {
          std::string::const_iterator ipos = 
            std::find( it->begin() , it->end() , '/');
          const std::string::size_type pos = ipos - it->begin() ;
          IGslErrorHandler* eh = 0 ;
          if( it->end() != ipos ) 
            { sc = toolsvc->retrieveTool 
                ( std::string( *it , 0 , pos )       , 
                  std::string( *it , pos + 1, it->length() ), eh , this ) ; }
          else 
            { sc = toolsvc->retrieveTool 
                ( *it , std::string( *it , pos + 1, it->length() ) , 
                  eh , this ) ; }
          if( sc.isFailure() )
            { log << MSG::ERROR 
                  << " Could not retrieve tool '" << *it << "'"<< endreq ;
            return sc ; }
          if( 0 == eh )
            { log << MSG::ERROR 
                  << " Could not retrieve tool '" << *it << "'"<< endreq ;
            return StatusCode::FAILURE  ; }
          m_handlers.push_back( eh );
        }
    }    
  //
  return StatusCode::SUCCESS;
};
// ============================================================================

// ============================================================================
// ============================================================================
StatusCode GslSvc::finalize() 
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "==> Finalize" << endreq;
  
  // deactivate the static accessor to the service  
  GaudiGSL::setGslSvc( 0 );
  
  // finalize the base class 
  return Service::finalize() ;
};
// ============================================================================

// ============================================================================
// ============================================================================
StatusCode GslSvc::queryInterface 
( const InterfaceID& iid , 
  void**             ppi ) 
{
  if     ( 0 == ppi                          ) { return StatusCode::FAILURE ; }
  if     ( IGslSvc::    interfaceID() == iid )
    { *ppi = static_cast<IGslSvc*>    ( this ); }
  else if( IService::   interfaceID() == iid )
    { *ppi = static_cast<IService*>   ( this ); }
  else if( IInterface:: interfaceID() == iid )
    { *ppi = static_cast<IInterface*> ( this ); }
  else 
    { return Service::queryInterface( iid , ppi ) ; }      // RETURN !
  //
  addRef();
  //
  return StatusCode::SUCCESS ;
};
// ============================================================================

// ============================================================================
// ============================================================================
IGslSvc::GslErrorHandler GslSvc::handler ()    const 
{
  GslErrorHandler hh = gsl_set_error_handler( 0 );
  gsl_set_error_handler( hh );  
  return hh ;
};
// ============================================================================

// ============================================================================
// ============================================================================
IGslSvc::GslErrorHandler GslSvc::setHandler 
( IGslSvc::GslErrorHandler handler ) const 
{
  gsl_set_error_handler( handler );  
  {
    MsgStream log( msgSvc(), name() );
    log << MSG::DEBUG << " New GSL handler is set '" ;
    if( 0 == handler ) { log << "NULL"                                  ; }
    else               { log << System::typeinfoName( typeid(handler) ) ; }
    log << "'" << endreq ;
  }
  return handler ;
};
// ============================================================================

// ============================================================================
// ============================================================================
StatusCode GslSvc::status        ( const int error         ) const
{
  if( GSL_SUCCESS == error ){ return StatusCode::SUCCESS ; }
  StatusCode sc( error );
  if( sc.isSuccess()       ){ return StatusCode::FAILURE ; }
  return sc ;
};
// ============================================================================

// ============================================================================
// ============================================================================
StatusCode GslSvc::handle 
( const GslError& error ) const 
{
  StatusCode sc = StatusCode::SUCCESS ;
  // code to be ignored? 
  if( m_ignore.end() != std::find( m_ignore.begin () ,
                                   m_ignore.end   () , 
                                   error.code        ) ) { return sc ; }
  // invoke all handlers 
  for( Handlers::const_iterator handler = m_handlers.begin() ;
       sc.isSuccess() && m_handlers.end() != handler ; ++handler ) 
    { sc = (*handler)->handle( error  ); }
  //
  return sc ;
};
// ============================================================================

// ============================================================================
// The END 
// ============================================================================