Guards.h

Go to the documentation of this file.

// $Id: Guards.h,v 1.2 2008/04/03 14:40:19 marcocle Exp $
// ============================================================================
#ifndef GAUDIKERNEL_GUARDS_H 
#define GAUDIKERNEL_GUARDS_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL 
// ============================================================================
#include <exception>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/INamedInterface.h"
#include "GaudiKernel/IExceptionSvc.h"
#include "GaudiKernel/IAuditor.h"
// ============================================================================
// forward declaration
// ============================================================================
class GaudiException ;
// ============================================================================
namespace Gaudi
{
  namespace Guards 
  {
    class ExceptionGuard
    {
    public:
      /* constructor form the object/scope, function and log-stream
       * @param obj the object/scope 
       * @param fun function to be used 
       * @param log output log-stream
       */
      template <class OBJECT, class FUNCTION>
      ExceptionGuard
      ( OBJECT         obj     , 
        FUNCTION       fun     , 
        MsgStream&     log     , 
        IExceptionSvc* svc = 0 )
        : m_sc  ( StatusCode::FAILURE ) 
      {
        try  
        { 
          // execute the functor:
          m_sc = fun ( obj ) ;  
          // in the case of error try use Exception Service 
          if ( 0 != svc && m_sc.isFailure() ) { m_sc = svc->handleErr ( *obj , m_sc ) ; }
        }
        catch ( const GaudiException& e ) 
        {
          // Use the local handler and then (if possible) the Exception Service  
          handle ( e  , log ) ; 
          if ( 0 != svc ) { m_sc = svc -> handle ( *obj , e ) ; } 
        }
        catch ( const std::exception& e ) 
        {
          // Use the local handler and then (if possible) the Exception Service  
          handle ( e  , log ) ; 
          if ( 0 != svc ) { m_sc = svc -> handle ( *obj , e ) ; } 
        }
        catch ( ...  ) 
        {
          // Use the local handler and then (if possible) the Exception Service  
          handle (      log ) ; 
          if ( 0 != svc ) { m_sc = svc -> handle ( *obj     ) ; } 
        } 
      }   
      ~ExceptionGuard() ;
    public:
      const StatusCode&    code () const { return m_sc   ; }
      operator const StatusCode&() const { return code() ; }
    private:
      // default constructor is disabled 
      ExceptionGuard() ; 
      // copy constructor is disabled 
      ExceptionGuard           ( const ExceptionGuard& ) ; 
      // assignement operator is disabled 
      ExceptionGuard& operator=( const ExceptionGuard& ) ; 
    protected:
      void handle ( const GaudiException& e , MsgStream& s ) ;
      void handle ( const std::exception& e , MsgStream& s ) ;
      void handle (                           MsgStream& s ) ;
    private:
      // status code: result of the function evaluation 
      StatusCode m_sc    ; 
    } ;
    // ========================================================================
    class AuditorGuard 
    {
    public:
      AuditorGuard ( INamedInterface*             obj      , 
                     IAuditor*                    svc      ,
                     IAuditor::StandardEventType  evt      ) ;
      AuditorGuard ( INamedInterface*             obj      , 
                     IAuditor*                    svc      ,
                     IAuditor::CustomEventTypeRef evt      ) ;
      
      AuditorGuard ( INamedInterface*             obj      , 
                     IAuditor*                    svc      ,
                     IAuditor::StandardEventType  evt      ,
                     const StatusCode            &sc       ) ;
      AuditorGuard ( INamedInterface*             obj      , 
                     IAuditor*                    svc      ,
                     IAuditor::CustomEventTypeRef evt      ,
                     const StatusCode            &sc       ) ;
      AuditorGuard ( const std::string           &name     , 
                     IAuditor*                    svc      ,
                     IAuditor::StandardEventType  evt      ) ;
      AuditorGuard ( const std::string           &name     , 
                     IAuditor*                    svc      ,
                     IAuditor::CustomEventTypeRef evt      ) ;
      
      AuditorGuard ( const std::string           &name     , 
                     IAuditor*                    svc      ,
                     IAuditor::StandardEventType  evt      ,
                     const StatusCode            &sc       ) ;
      AuditorGuard ( const std::string           &name     , 
                     IAuditor*                    svc      ,
                     IAuditor::CustomEventTypeRef evt      ,
                     const StatusCode            &sc       ) ;
      
      ~AuditorGuard() ;
    public:
      // get the status code 
      const StatusCode &code () const { return *m_sc ; }
    private:
      // the default constructor is disabled
      AuditorGuard () ; 
      // the copy constructor is disabled
      AuditorGuard           ( const AuditorGuard& right ) ; 
      // assignement operator is disabled
      AuditorGuard& operator=( const AuditorGuard& right ) ; 
    private :
      INamedInterface*            m_obj   ;
      std::string                 m_objName;
      IAuditor*                   m_svc   ;
      IAuditor::StandardEventType m_evt   ;
      IAuditor::CustomEventType   m_cevt  ;
      const StatusCode           *m_sc    ;
      bool                        m_customEvtType;
      
      inline void i_before() {
        if ( 0 != m_svc ) { // if the service is not available, we cannot do anything
          m_svc->addRef(); // increase the reference counting
          if (0 != m_obj) {
            if (m_customEvtType) {
              m_svc->before(m_cevt,m_obj);
            } else {
              m_svc->before(m_evt,m_obj);
            }
          } else { // use object name 
            if (m_customEvtType) {
              m_svc->before(m_cevt,m_objName);
            } else {
              m_svc->before(m_evt,m_objName);
            }
          }
        }
      }
      
      inline void i_after() {
        if ( 0 != m_svc ) { // if the service is not available, we cannot do anything
          if (0 != m_obj) {
            if (m_customEvtType) {
              if (0 != m_sc) {
                m_svc->after(m_cevt,m_obj,*m_sc);
              } else {
                m_svc->after(m_cevt,m_obj);
              }
            } else {
              if (0 != m_sc) {
                m_svc->after(m_evt,m_obj,*m_sc);
              } else {
                m_svc->after(m_evt,m_obj);
              }
            }
          } else { // use object name 
            if (m_customEvtType) {
              if (0 != m_sc) {
                m_svc->after(m_cevt,m_objName,*m_sc);
              } else {
                m_svc->after(m_cevt,m_objName);
              }
            } else {
              if (0 != m_sc) {
                m_svc->after(m_evt,m_objName,*m_sc);
              } else {
                m_svc->after(m_evt,m_objName);
              }
            }
          }
          m_svc->release(); // we do not need the service anymore
          m_svc = 0 ;
        }
      }
    } ;
  } // end of namespace Gaudi::Guards
} //end of namespace Gaudi 


// ============================================================================
// The END 
// ============================================================================
#endif // GAUDIKERNEL_GUARDS_H
// ============================================================================