Auditor.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 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 files
#include <Gaudi/PluginService.h>
#include <Gaudi/PropertyFwd.h>
#include <GaudiKernel/CommonMessaging.h>
#include <GaudiKernel/IAuditor.h>
#include <GaudiKernel/IProperty.h>
#include <GaudiKernel/IService.h>
#include <GaudiKernel/ISvcLocator.h> /*used by service(..)*/
#include <GaudiKernel/PropertyHolder.h>
#include <string>
 
// Forward declarations
class IService;
class IMessageSvc;
 
class GAUDI_API Auditor : public PropertyHolder<CommonMessaging<implements<IAuditor, IProperty>>> {
public:
  using Factory = Gaudi::PluginService::Factory<IAuditor*( const std::string&, ISvcLocator* )>;
 
  Auditor( std::string name, ISvcLocator* svcloc );
 
  Auditor( const Auditor& a )              = delete;
  Auditor& operator=( const Auditor& rhs ) = delete;
 
  StatusCode sysInitialize() override;
  StatusCode sysFinalize() override;
 
 
  void before( StandardEventType, INamedInterface* ) override {}
  void before( StandardEventType, const std::string& ) override {}
 
  void before( CustomEventTypeRef, INamedInterface* ) override {}
  void before( CustomEventTypeRef, const std::string& ) override {}
 
  void after( StandardEventType, INamedInterface*, const StatusCode& ) override {}
  void after( StandardEventType, const std::string&, const StatusCode& ) override {}
 
  void after( CustomEventTypeRef, INamedInterface*, const StatusCode& ) override {}
  void after( CustomEventTypeRef, const std::string&, const StatusCode& ) override {}
 
  virtual StatusCode initialize() { return StatusCode::SUCCESS; }
  virtual StatusCode finalize() { return StatusCode::SUCCESS; }
 
  const std::string& name() const override { return m_name; }
 
  bool isEnabled() const override { return m_isEnabled; }
 
  SmartIF<ISvcLocator>& serviceLocator() const override { return m_pSvcLocator; }
 
  template <class T>
  [[deprecated( "use service<T>(name, createIf) -> SmartIF<T>" )]] StatusCode service( std::string_view name, T*& svc,
                                                                                       bool createIf = false ) const {
    auto ptr = serviceLocator()->service<T>( name, createIf );
    if ( ptr ) {
      svc = ptr.get();
      svc->addRef();
      return StatusCode::SUCCESS;
    }
    svc = nullptr;
    return StatusCode::FAILURE;
  }
 
  template <class T = IService>
  SmartIF<T> service( std::string_view name, bool createIf = false ) const {
    return serviceLocator()->service<T>( name, createIf );
  }
 
private:
  std::string m_name; 
 
  mutable SmartIF<ISvcLocator> m_pSvcLocator; 
 
  Gaudi::Property<int> m_outputLevel{
      this, "OutputLevel", MSG::NIL,
      [this]( Gaudi::Details::PropertyBase& ) { this->updateMsgStreamOutputLevel( this->m_outputLevel ); },
      "output level" };
  Gaudi::Property<bool> m_isEnabled{ this, "Enable", true, "should the auditor be used or not" };
 
  bool m_isInitialized = false; 
  bool m_isFinalized   = false; 
};