GslSvc.cpp

Go to the documentation of this file.

// Include files
// from Gaudi
#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_COMPONENT(GslSvc)
// ============================================================================

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

// ============================================================================
// ============================================================================
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'"<< endmsg;
    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' ]"
          << endmsg;
    return StatusCode::FAILURE ;
    }
  GslErrorHandler handler = gsl_set_error_handler( nullptr );
  gsl_set_error_handler( handler );
  if( handler )
    { log << MSG::VERBOSE
          << " GSL Error Handler is '"
          << System::typeinfoName( typeid(*handler) ) << "'"
          << endmsg; }
  else { log << MSG::INFO << " Error Handler is NULL" << endmsg ; }

  if( !m_handlersTypeNames.empty() )
    {
      auto  toolsvc = serviceLocator()->service<IToolSvc>("ToolSvc");
      if (!toolsvc) {
        log << MSG::ERROR << " Could not locate Tool Service! " << endmsg;
        return StatusCode::FAILURE;
      }
      for( const auto& it : m_handlersTypeNames )
        {
          auto pos = it.find('/');
          IGslErrorHandler* eh = nullptr ;
          if( pos != std::string::npos ) { 
              sc = toolsvc->retrieveTool
                ( it.substr( 0 , pos ), it.substr( pos + 1 ), eh , this ) ; 
          } else { 
              sc = toolsvc->retrieveTool( it , it , eh , this ) ; 
          }
          if( sc.isFailure() )
            { log << MSG::ERROR
                  << " Could not retrieve tool '" << it << "'"<< endmsg ;
            return sc ; }
          if( !eh )
            { log << MSG::ERROR
                  << " Could not retrieve tool '" << it << "'"<< endmsg ;
            return StatusCode::FAILURE  ; }
          m_handlers.push_back( eh );
        }
    }
  //
  return StatusCode::SUCCESS;
}
// ============================================================================

// ============================================================================
// ============================================================================
StatusCode GslSvc::finalize()
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "==> Finalize" << endmsg;

  // deactivate the static accessor to the service
  GaudiGSL::setGslSvc( nullptr );

  // finalize the base class
  return Service::finalize() ;
}
// ============================================================================

// ============================================================================
// ============================================================================
IGslSvc::GslErrorHandler GslSvc::handler ()    const
{
  GslErrorHandler hh = gsl_set_error_handler( nullptr );
  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( !handler ) { log << "NULL"                                  ; }
    else           { log << System::typeinfoName( typeid(handler) ) ; }
    log << "'" << endmsg ;
  }
  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( auto handler = m_handlers.begin() ;
       sc.isSuccess() && m_handlers.end() != handler ; ++handler )
    { sc = (*handler)->handle( error  ); }
  //
  return sc ;
}
// ============================================================================

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