Guards.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2026 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.                                             *
\***********************************************************************************/
#pragma once
 
#include <Gaudi/IAuditor.h>
#include <GaudiKernel/EventContext.h>
#include <GaudiKernel/IExceptionSvc.h>
#include <GaudiKernel/SmartIF.h>
#include <exception>
 
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:
      // user facing constructors
      AuditorGuard( std::string name, IAuditor* svc, std::string const& evt );
      AuditorGuard( std::string name, IAuditor* svc, std::string const& evt, EventContext const& context );
      AuditorGuard( std::string name, IAuditor* svc, std::string const& evt, StatusCode const& sc );
      AuditorGuard( std::string name, IAuditor* svc, std::string const& evt, StatusCode const& sc,
                    EventContext const& context );
 
      ~AuditorGuard() { i_after(); }
 
    public:
      // get the status code
      const StatusCode code() const { return m_sc ? *m_sc : StatusCode::SUCCESS; }
 
    private:
      // delete the default/copy constructor and assigment
      AuditorGuard( const AuditorGuard& right )            = delete;
      AuditorGuard& operator=( const AuditorGuard& right ) = delete;
 
    private:
      /// entire lifetime.
      static EventContext const& defaultContext() {
        static EventContext const context{};
        return context;
      }
 
      inline void i_before() {
        if ( m_svc ) { // if the service is not available, we cannot do anything
          m_svc->before( m_evt, m_objName, m_context ? *m_context : defaultContext() );
        }
      }
 
      inline void i_after() {
        if ( m_svc ) { // if the service is not available, we cannot do anything
          if ( m_sc ) {
            m_svc->after( m_evt, m_objName, m_context ? *m_context : defaultContext(), *m_sc );
          } else {
            m_svc->after( m_evt, m_objName, m_context ? *m_context : defaultContext() );
          }
          m_svc.reset();
        }
      }
 
    private:
      std::string m_objName;
      SmartIF<IAuditor> m_svc;
      std::string const m_evt;
      StatusCode const* m_sc{};
      EventContext const* m_context{};
    };
  } // namespace Guards
} // namespace Gaudi