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

class GAUDI_API Auditor : public PropertyHolder<CommonMessaging<implements<IAuditor, IProperty>>>
{
public:
#ifndef __REFLEX__
  typedef Gaudi::PluginService::Factory<IAuditor*, const std::string&, ISvcLocator*> Factory;
#endif

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

#ifndef GAUDI_NEW_PLUGIN_SERVICE
template <class T>
class AudFactory
{
public:
#ifndef __REFLEX__
  template <typename S, typename... Args>
  static typename S::ReturnType create( Args&&... args )
  {
    return new T( std::forward<Args>( args )... );
  }
#endif
};

// Macros to declare component factories
#define DECLARE_AUDITOR_FACTORY( x ) DECLARE_FACTORY_WITH_CREATOR( x, AudFactory<x>, Auditor::Factory )
#define DECLARE_NAMESPACE_AUDITOR_FACTORY( n, x ) DECLARE_AUDITOR_FACTORY( n::x )

#else

// macros to declare factories
#define DECLARE_AUDITOR_FACTORY( x ) DECLARE_COMPONENT( x )
#define DECLARE_NAMESPACE_AUDITOR_FACTORY( n, x ) DECLARE_COMPONENT( n::x )

#endif

#endif // GAUDIKERNEL_AUDITOR_H