Auditor.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_AUDITOR_H
#define GAUDIKERNEL_AUDITOR_H

// Include files
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/IAuditor.h"
#include "GaudiKernel/IService.h"
#include "GaudiKernel/ISvcLocator.h"  /*used by service(..)*/
#include "GaudiKernel/PropertyMgr.h"
#include "GaudiKernel/CommonMessaging.h"
#include <Gaudi/PluginService.h>
#include <string>
#include <vector>

// Forward declarations
class IService;
class IMessageSvc;
class Property;
class Algorithm;

class GAUDI_API Auditor : public 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() override = default;

  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;

  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 setProperty(const Property& p) override;

  StatusCode setProperty( const std::string& s ) override;

  StatusCode setProperty( const std::string& n, const std::string& v) override;

  StatusCode getProperty(Property* p) const override;

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

  StatusCode getProperty( const std::string& n, std::string& v ) const override;

  const std::vector<Property*>& getProperties( ) const override;

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

  template <class TYPE>
  StatusCode setProperty
  ( const std::string& name  ,
    const TYPE&        value )
  { return Gaudi::Utils::setProperty ( m_PropertyMgr.get() , name , value ) ; }

  StatusCode setProperties();

  // ==========================================================================
  template <class T>
  Property* declareProperty( const std::string& name, T& property,
                 const std::string& doc = "none") const {
    return m_PropertyMgr->declareProperty(name, property, doc);
  }

 private:

  std::string m_name;             

  mutable SmartIF<ISvcLocator> m_pSvcLocator;   
  SmartIF<PropertyMgr> m_PropertyMgr;   
  int          m_outputLevel;   
  bool         m_isEnabled;     
  bool         m_isInitialized; 
  bool         m_isFinalized;   

  // Private Copy constructor: NO COPY ALLOWED
  Auditor(const Auditor& a);

  // Private assignment operator: NO ASSIGNMENT ALLOWED
  Auditor& operator=(const Auditor& rhs);
};

#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