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 GAUDI_API 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& ) ; 
      // assignment 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 GAUDI_API 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
// ============================================================================