Guards.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_GUARDS_H
#define GAUDIKERNEL_GUARDS_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <exception>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/SmartIF.h"
#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 )
      {
        try
        {
          // execute the functor:
          m_sc = fun ( obj ) ;  
          // in the case of error try use Exception Service
          if ( 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 ( 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 ( svc ) { m_sc = svc -> handle ( *obj , e ) ; }
        }
        catch ( ...  )
        {
          // Use the local handler and then (if possible) the Exception Service
          handle (      log ) ;
          if ( svc ) { m_sc = svc -> handle ( *obj     ) ; }
        }
      }
      ~ExceptionGuard() ;
    public:
      const StatusCode&    code () const { return m_sc   ; }
      operator const StatusCode&() const { return code() ; }
    private:
      // delete default/copy constructor and assignment
      ExceptionGuard() = delete; 
      ExceptionGuard           ( const ExceptionGuard& ) = delete;
      ExceptionGuard& operator=( const ExceptionGuard& ) = delete;
    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 = StatusCode::FAILURE   ; 
    } ;
    // ========================================================================
    class GAUDI_API AuditorGuard final
    {
    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 ( std::string                  name     ,
                     IAuditor*                    svc      ,
                     IAuditor::StandardEventType  evt      ) ;
      AuditorGuard ( std::string                  name     ,
                     IAuditor*                    svc      ,
                     IAuditor::CustomEventTypeRef evt      ) ;

      AuditorGuard ( std::string                  name     ,
                     IAuditor*                    svc      ,
                     IAuditor::StandardEventType  evt      ,
                     const StatusCode            &sc       ) ;
      AuditorGuard ( 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:
      // delete the default/copy constructor and assigment
      AuditorGuard () = delete;
      AuditorGuard           ( const AuditorGuard& right ) = delete;
      AuditorGuard& operator=( const AuditorGuard& right ) = delete;
    private :
      INamedInterface*                     m_obj  = nullptr ;
      std::string                 m_objName;
      SmartIF<IAuditor>                   m_svc   = nullptr;
      IAuditor::StandardEventType m_evt   ;
      IAuditor::CustomEventType   m_cevt  ;
      const StatusCode           *m_sc    = nullptr;
      bool                        m_customEvtType = false;

      inline void i_before() {
        if ( m_svc ) { // if the service is not available, we cannot do anything
          if (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 ( m_svc ) { // if the service is not available, we cannot do anything
          if ( m_obj) {
            if (m_customEvtType) {
              if ( m_sc) {
                m_svc->after(m_cevt,m_obj,*m_sc);
              } else {
                m_svc->after(m_cevt,m_obj);
              }
            } else {
              if (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 (m_sc) {
                m_svc->after(m_cevt,m_objName,*m_sc);
              } else {
                m_svc->after(m_cevt,m_objName);
              }
            } else {
              if (m_sc) {
                m_svc->after(m_evt,m_objName,*m_sc);
              } else {
                m_svc->after(m_evt,m_objName);
              }
            }
          }
          m_svc.reset();
        }
      }
    } ;
  } // end of namespace Gaudi::Guards
} //end of namespace Gaudi


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