Guards.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2024 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#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();
        }
      }
    };
  } // namespace Guards
} // end of namespace Gaudi
 
// ============================================================================
// The END
// ============================================================================
#endif // GAUDIKERNEL_GUARDS_H