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 <Gaudi/PluginService.h>
#include <string>
#include <vector>

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

class GAUDI_API Auditor : public implements2<IAuditor, IProperty> {
public:
  typedef Gaudi::PluginService::Factory2<IAuditor*,
                                         const std::string&,
                                         ISvcLocator*> Factory;

  Auditor( const std::string& name, ISvcLocator *svcloc );
  virtual ~Auditor();

  StatusCode sysInitialize();
  StatusCode sysFinalize();


  virtual void before(StandardEventType, INamedInterface*);
  virtual void before(StandardEventType, const std::string&);

  virtual void before(CustomEventTypeRef, INamedInterface*);
  virtual void before(CustomEventTypeRef, const std::string&);

  virtual void after(StandardEventType, INamedInterface*, const StatusCode&);
  virtual void after(StandardEventType, const std::string&, const StatusCode&);

  virtual void after(CustomEventTypeRef, INamedInterface*, const StatusCode&);
  virtual void after(CustomEventTypeRef, const std::string&, const StatusCode&);

  // Obsolete methods

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

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

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

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

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

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

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

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

  virtual bool isEnabled() const ;

  SmartIF<IMessageSvc>& msgSvc() const;

  int outputLevel() const { return m_outputLevel; }

  void setOutputLevel( int level );

  SmartIF<ISvcLocator>& serviceLocator() const;

  template <class T>
  StatusCode service( const std::string& name, T*& svc, bool createIf = false ) const {
    SmartIF<T> ptr(serviceLocator()->service(name, createIf));
    if (ptr.isValid()) {
      svc = ptr.get();
      svc->addRef();
      return StatusCode::SUCCESS;
    }
    // else
    svc = 0;
    return StatusCode::FAILURE;
  }

  virtual StatusCode setProperty(const Property& p);

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

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

  virtual StatusCode getProperty(Property* p) const;

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

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

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


  template <class TYPE>
  StatusCode setProperty
  ( const std::string& name  ,
    const TYPE&        value )
  { return Gaudi::Utils::setProperty ( m_PropertyMgr , 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<IMessageSvc> m_MS;            
  mutable SmartIF<ISvcLocator> m_pSvcLocator;   
  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:
  template <typename S>
  static typename S::ReturnType create(typename S::Arg1Type a1,
                                       typename S::Arg2Type a2) {
    return new T(a1, a2);
  }
};

// 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