Auditor.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_AUDITOR_H
#define GAUDIKERNEL_AUDITOR_H

// Include files
#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/PropertyFwd.h"
#include "GaudiKernel/PropertyHolder.h"
#include <Gaudi/PluginService.h>
#include <string>
#include <vector>

// 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( const 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;

  // Obsolete methods

  void beforeInitialize( INamedInterface* ) override;
  void afterInitialize( INamedInterface* ) override;

  void beforeReinitialize( INamedInterface* ) override;
  void afterReinitialize( INamedInterface* ) override;

  void beforeExecute( INamedInterface* ) override;
  void afterExecute( INamedInterface*, const StatusCode& ) override;

  void beforeFinalize( INamedInterface* ) override;
  void afterFinalize( INamedInterface* ) override;

  void beforeBeginRun( INamedInterface* ) override;
  void afterBeginRun( INamedInterface* ) override;

  void beforeEndRun( INamedInterface* ) override;
  void afterEndRun( INamedInterface* ) override;

  virtual StatusCode initialize();
  virtual StatusCode finalize();

  const std::string& name() const override;

  bool isEnabled() const override;

  SmartIF<ISvcLocator>& serviceLocator() const override;

  template <class T>
  StatusCode service( const std::string& 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( const std::string& name, bool createIf = false ) const {
    return serviceLocator()->service<T>( name, createIf );
  }

  StatusCode setProperties();

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; 
};

#endif // GAUDIKERNEL_AUDITOR_H