ExceptionSvc Class Reference

#include <ExceptionSvc.h>

Inheritance diagram for ExceptionSvc:

[legend]

Collaboration diagram for ExceptionSvc:

[legend]

List of all members.

Detailed Description

Simple implementation of IExceptionSvc abstract interface.

Author:: (1) ATLAS collaboration
(2) modified by Vanya BELYAEV ibelyaev@physics.syr.edu

Date:: 2007-03-08

Definition at line 24 of file ExceptionSvc.h.


Public Member Functions
virtual StatusCode	handle (const INamedInterface &o, const GaudiException &e) const
	Handle caught GaudiExceptions.
virtual StatusCode	handle (const INamedInterface &o, const std::exception &e) const
	Handle caught std::exceptions.
virtual StatusCode	handle (const INamedInterface &o) const
	Handle caught (unknown)exceptions.
virtual StatusCode	handleErr (const INamedInterface &o, const StatusCode &s) const
	Handle errors.
virtual StatusCode	initialize ()
	initialize the service
virtual StatusCode	finalize ()
	finalize the service
virtual StatusCode	queryInterface (const InterfaceID &iid, void **ppvi)
	query the interface
	ExceptionSvc (const std::string &name, ISvcLocator *svc)
	standard constructor
virtual	~ExceptionSvc ()
	Destructor.
Private Types
enum	Policy { ALL, NONE }
enum	ReturnState { SUCCESS, FAILURE, RECOVERABLE, RETHROW, DEFAULT }
Private Member Functions
	ExceptionSvc ()
	no default constructor
	ExceptionSvc (const ExceptionSvc &)
	no copy constructor
ExceptionSvc &	operator= (const ExceptionSvc &)
	no assignement
Private Attributes
Policy	m_mode_exc
Policy	m_mode_err
StringProperty	m_mode_exc_s
StringProperty	m_mode_err_s
std::map< std::string, ReturnState >	m_retCodesExc
std::map< std::string, ReturnState >	m_retCodesErr
MsgStream	m_log
Friends
class	SvcFactory< ExceptionSvc >

Member Enumeration Documentation

enum ExceptionSvc::Policy [private]

Enumerator:

ALL
NONE

Definition at line 76 of file ExceptionSvc.h.

00076 { ALL, NONE };

enum ExceptionSvc::ReturnState [private]

Enumerator:

SUCCESS	Normal successful completion.
FAILURE
RECOVERABLE
RETHROW
DEFAULT

Definition at line 77 of file ExceptionSvc.h.

00077 { SUCCESS, FAILURE, RECOVERABLE, RETHROW, DEFAULT };

Constructor & Destructor Documentation

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

standard constructor

Parameters:

	name	service instance name
	pSvc	pointer to Service Locator

Definition at line 42 of file ExceptionSvc.cpp.

00043   : Service( name, svc )
00044   , m_mode_exc ( ALL ), m_mode_err( NONE )
00045   , m_log(msgSvc(), name )
00046 {
00047   // for exceptions
00048   declareProperty( "Catch"      , m_mode_exc_s="ALL" ) ;
00049 
00050   // for return codes
00051   declareProperty( "Errors"     , m_mode_err_s="NONE" ) ;
00052 }

ExceptionSvc::~ExceptionSvc ( ) [virtual]

Destructor.

Definition at line 56 of file ExceptionSvc.cpp.

00056                             {
00057 
00058 }

ExceptionSvc::ExceptionSvc ( ) [private]

no default constructor

ExceptionSvc::ExceptionSvc ( const ExceptionSvc & ) [private]

no copy constructor

Member Function Documentation

StatusCode ExceptionSvc::handle	(	const INamedInterface &	o,
		const GaudiException &	e
	)			const `[virtual]`

Handle caught GaudiExceptions.

Handle caught exceptions

Implements IExceptionSvc.

Definition at line 356 of file ExceptionSvc.cpp.

00358 {
00359 
00360   m_log << MSG::DEBUG << "Handling GaudiExcept for " << alg.name() << endmsg;
00361 
00362   // is this Alg special?
00363   if (m_retCodesExc.find(alg.name()) != m_retCodesExc.end()) {
00364     ReturnState iret = m_retCodesExc.find(alg.name())->second;
00365 
00366     switch ( iret ) {
00367     case DEFAULT:
00368       return exc.code();
00369     case SUCCESS:
00370       return StatusCode::SUCCESS;
00371     case FAILURE:
00372       return StatusCode::FAILURE;
00373     case RECOVERABLE:
00374       return StatusCode::RECOVERABLE;
00375     case RETHROW:
00376       throw ( exc );
00377     }
00378 
00379   } else {
00380 
00381     if (m_mode_exc == ALL) {
00382       throw (exc);
00383     } else {
00384       assert (m_mode_exc == NONE);
00385       return StatusCode::FAILURE;
00386     }
00387   }
00388 
00389 
00390   return StatusCode::FAILURE;
00391 
00392 }

StatusCode ExceptionSvc::handle	(	const INamedInterface &	o,
		const std::exception &	e
	)			const `[virtual]`

Handle caught std::exceptions.

Handle caught exceptions

Implements IExceptionSvc.

Definition at line 317 of file ExceptionSvc.cpp.

00319 {
00320   m_log << MSG::DEBUG << "Handling std:except for " << alg.name() << endmsg;
00321 
00322   // is this Alg special?
00323   if (m_retCodesExc.find(alg.name()) != m_retCodesExc.end()) {
00324     ReturnState iret = m_retCodesExc.find(alg.name())->second;
00325 
00326     switch ( iret ) {
00327     case DEFAULT:
00328       // there is no default
00329       return StatusCode::FAILURE;
00330     case SUCCESS:
00331       return StatusCode::SUCCESS;
00332     case FAILURE:
00333       return StatusCode::FAILURE;
00334     case RECOVERABLE:
00335       return StatusCode::RECOVERABLE;
00336     case RETHROW:
00337       throw ( exc );
00338     }
00339 
00340   } else {
00341 
00342     if (m_mode_exc == ALL) {
00343       throw (exc);
00344     } else {
00345       assert (m_mode_exc == NONE);
00346       return StatusCode::FAILURE;
00347     }
00348   }
00349 
00350   return StatusCode::FAILURE;
00351 
00352 }

StatusCode ExceptionSvc::handle ( const INamedInterface & o ) const [virtual]

Handle caught (unknown)exceptions.

Handle caught exceptions

Implements IExceptionSvc.

Definition at line 279 of file ExceptionSvc.cpp.

00280 {
00281   m_log << MSG::DEBUG << "Handling unknown exception for " << alg.name() << endmsg;
00282 
00283   // is this Alg special?
00284   if (m_retCodesExc.find(alg.name()) != m_retCodesExc.end()) {
00285     ReturnState iret = m_retCodesExc.find(alg.name())->second;
00286 
00287     switch ( iret ) {
00288     case DEFAULT:
00289       // there is no default
00290       return StatusCode::FAILURE;
00291     case SUCCESS:
00292       return StatusCode::SUCCESS;
00293     case FAILURE:
00294       return StatusCode::FAILURE;
00295     case RECOVERABLE:
00296       return StatusCode::RECOVERABLE;
00297     case RETHROW:
00298       throw;
00299     }
00300 
00301   } else {
00302 
00303     if (m_mode_exc == ALL) {
00304       throw;
00305     } else {
00306       assert (m_mode_exc == NONE);
00307       return StatusCode::FAILURE;
00308     }
00309   }
00310 
00311   return StatusCode::FAILURE;
00312 
00313 }

StatusCode ExceptionSvc::handleErr	(	const INamedInterface &	o,
		const StatusCode &	s
	)			const `[virtual]`

Handle errors.

Handle errors

Implements IExceptionSvc.

Definition at line 236 of file ExceptionSvc.cpp.

00238 {
00239   m_log << MSG::DEBUG << "Handling Error from " << alg.name() << endmsg;
00240 
00241   // is this Alg special?
00242   if (m_retCodesErr.find(alg.name()) != m_retCodesErr.end()) {
00243     ReturnState iret = m_retCodesErr.find(alg.name())->second;
00244 
00245     switch ( iret ) {
00246     case SUCCESS:
00247       return StatusCode::SUCCESS;
00248     case FAILURE:
00249       return StatusCode::FAILURE;
00250     case RECOVERABLE:
00251       return StatusCode::RECOVERABLE;
00252     case RETHROW:
00253       // should never get here
00254       break;
00255     case DEFAULT:
00256       // should never get here
00257       break;
00258     }
00259 
00260   } else {
00261 
00262     if (m_mode_err == ALL) {
00263       // turn it into a FAILURE
00264       return StatusCode::FAILURE;
00265 
00266     } else {
00267       assert (m_mode_err == NONE );
00268       // don't touch the return code
00269       return st;
00270     }
00271   }
00272 
00273   return StatusCode::FAILURE;
00274 
00275 }

StatusCode ExceptionSvc::initialize ( ) [virtual]

initialize the service

Reimplemented from Service.

Definition at line 64 of file ExceptionSvc.cpp.

00064                          {
00065   StatusCode status = Service::initialize();
00066   m_log.setLevel( m_outputLevel.value() );
00067 
00068   if ( status.isFailure() )  { return status ; }                  // RETURN
00069 
00070   string key = m_mode_exc_s.value();
00071 
00072   string::size_type loc = key.find(" ");
00073   std::string mode;
00074   if (loc == std::string::npos) {
00075     mode = key;
00076   } else {
00077     mode = key.substr(0,loc);
00078   }
00079 
00080   toupper(mode);
00081 
00082   if (mode == "NONE") {
00083     m_mode_exc = NONE;
00084   } else if (mode == "ALL") {
00085     m_mode_exc = ALL;
00086   } else {
00087     m_log << MSG::ERROR << "Unknown mode for Exception handling: \"" << mode
00088         << "\". Default must be one of \"ALL\" or \"NONE\"" << endmsg;
00089     m_state = Gaudi::StateMachine::OFFLINE;
00090     return StatusCode::FAILURE;
00091   }
00092 
00093   if (loc == string::npos) {
00094     key = "";
00095   } else {
00096     key = key.substr(loc+1,key.length());
00097   }
00098 
00099   Tokenizer tok(true);
00100   std::string val,VAL,TAG;
00101 
00102   tok.analyse( key, " ", "", "", "=", "", "");
00103 
00104   for ( Tokenizer::Items::iterator i = tok.items().begin();
00105         i != tok.items().end(); i++)    {
00106     const std::string& tag = (*i).tag();
00107     TAG = tag;
00108 
00109     val = (*i).value();
00110     VAL = val;
00111     toupper(VAL);
00112 
00113     if (VAL == "SUCCESS") {
00114       m_retCodesExc[TAG] = SUCCESS;
00115     } else if ( VAL == "FAILURE" ) {
00116       m_retCodesExc[TAG] = FAILURE;
00117     } else if ( VAL == "REVOVERABLE" ) {
00118       m_retCodesExc[TAG] = RECOVERABLE;
00119     } else if ( VAL == "RETHROW" ) {
00120       m_retCodesExc[TAG] = RETHROW;
00121     } else if ( VAL == "DEFAULT" ) {
00122       m_retCodesExc[TAG] = DEFAULT;
00123     } else {
00124       m_log << MSG::ERROR << "In JobOpts: unknown return code \"" << VAL
00125           << "\" for Algorithm " << TAG << std::endl
00126           << "   Must be one of: DEFAULT, SUCCESS, FAILURE, RECOVERABLE, RETHROW"
00127           << endmsg;
00128       m_state = Gaudi::StateMachine::OFFLINE;
00129       return StatusCode::FAILURE;
00130     }
00131 
00132     m_log << MSG::DEBUG << "Will catch exceptions thrown by: " << TAG
00133         << " -> action: " << VAL << endmsg;
00134 
00135   }
00136 
00137   // now process errors
00138 
00139   key = m_mode_err_s.value();
00140 
00141   loc = key.find(" ");
00142   if (loc == std::string::npos) {
00143     mode = key;
00144   } else {
00145     mode = key.substr(0,loc);
00146   }
00147 
00148   toupper(mode);
00149 
00150   if (mode == "NONE") {
00151     m_mode_err = NONE;
00152   } else if (mode == "ALL") {
00153     m_mode_err = ALL;
00154   } else {
00155     m_log << MSG::ERROR << "Unknown mode for Error handling: \"" << mode
00156         << "\". Default must be one of \"ALL\" or \"NONE\"" << endmsg;
00157     m_state = Gaudi::StateMachine::OFFLINE;
00158     return StatusCode::FAILURE;
00159   }
00160 
00161   if (loc == string::npos) {
00162     key = "";
00163   } else {
00164     key = key.substr(loc+1,key.length());
00165   }
00166 
00167   Tokenizer tok2(true);
00168   tok2.analyse( key, " ", "", "", "=", "", "");
00169 
00170   for ( Tokenizer::Items::iterator i = tok2.items().begin();
00171         i != tok2.items().end(); i++)    {
00172     const std::string& tag = (*i).tag();
00173     TAG = tag;
00174 
00175     val = (*i).value();
00176     VAL = val;
00177     toupper(VAL);
00178 
00179     if (VAL == "SUCCESS") {
00180       m_retCodesErr[TAG] = SUCCESS;
00181     } else if ( VAL == "FAILURE" ) {
00182       m_retCodesErr[TAG] = FAILURE;
00183     } else if ( VAL == "RECOVERABLE" ) {
00184       m_retCodesErr[TAG] = RECOVERABLE;
00185     } else {
00186       m_log << MSG::ERROR << "In JobOpts: unknown return code \"" << VAL
00187           << "\" for Algorithm " << TAG << std::endl
00188           << "   Must be one of: SUCCESS, FAILURE, RECOVERABLE"
00189           << endmsg;
00190       m_state = Gaudi::StateMachine::OFFLINE;
00191       return StatusCode::FAILURE;
00192     }
00193 
00194     m_log << MSG::DEBUG << "Will process Errors returned by: " << TAG
00195         << " -> action: " << VAL << endmsg;
00196 
00197   }
00198 
00199 
00200 
00201   return status;
00202 }

StatusCode ExceptionSvc::finalize ( void ) [virtual]

finalize the service

Reimplemented from Service.

Definition at line 207 of file ExceptionSvc.cpp.

00207                        {
00208   StatusCode status = Service::finalize();
00209 
00210   return status;
00211 }

StatusCode ExceptionSvc::queryInterface	(	const InterfaceID &	iid,
		void **	ppvi
	)			`[virtual]`

query the interface

See also:: IInterface

Implements IInterface.

Definition at line 217 of file ExceptionSvc.cpp.

00219 {
00220   // invalid placeholder
00221   if ( 0 == ppvi ) { return StatusCode::FAILURE   ; }   // RETURN
00222   // check the identidier
00223   if ( IExceptionSvc::interfaceID().versionMatch( iid ) )
00224   { *ppvi = static_cast<IExceptionSvc*>  ( this ) ; }  // OK !
00225   else  // ask for base class
00226   { return Service::queryInterface ( iid , ppvi ) ; }  // RETURN
00227   // increment the reference counter
00228   addRef() ;
00229   //
00230   return StatusCode::SUCCESS ;                        // RETURN
00231 }

ExceptionSvc& ExceptionSvc::operator= ( const ExceptionSvc & ) [private]

no assignement

Friends And Related Function Documentation

friend class SvcFactory< ExceptionSvc > [friend]

Definition at line 28 of file ExceptionSvc.h.

Member Data Documentation

Policy ExceptionSvc::m_mode_exc [private]

Definition at line 79 of file ExceptionSvc.h.

Policy ExceptionSvc::m_mode_err [private]

Definition at line 79 of file ExceptionSvc.h.

StringProperty ExceptionSvc::m_mode_exc_s [private]

Definition at line 80 of file ExceptionSvc.h.

StringProperty ExceptionSvc::m_mode_err_s [private]

Definition at line 80 of file ExceptionSvc.h.

std::map<std::string,ReturnState> ExceptionSvc::m_retCodesExc [private]

Definition at line 81 of file ExceptionSvc.h.

std::map<std::string,ReturnState> ExceptionSvc::m_retCodesErr [private]

Definition at line 81 of file ExceptionSvc.h.

MsgStream ExceptionSvc::m_log [mutable, private]

Definition at line 83 of file ExceptionSvc.h.

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

/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r6/GaudiSvc/src/ExceptionSvc/ExceptionSvc.h
/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r6/GaudiSvc/src/ExceptionSvc/ExceptionSvc.cpp

Gaudi Framework, version v21r6

ExceptionSvc Class Reference

Detailed Description

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation