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/IAuditor.h"
#include "GaudiKernel/IExceptionSvc.h"
#include "GaudiKernel/INamedInterface.h"
#include "GaudiKernel/SmartIF.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
// ============================================================================