Gaudi Framework, version v20r2
	Generated: 18 Jul 2008

Auditor.h

Go to the documentation of this file.

// $Header: /local/reps/Gaudi/GaudiKernel/GaudiKernel/Auditor.h,v 1.16 2008/04/03 17:27:01 marcocle Exp $
#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 <string>
#include <vector>

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

class Auditor : virtual public IAuditor,
                virtual public IProperty {
public:

  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 const bool isEnabled() const ;

  IMessageSvc*  msgSvc() const;

  int outputLevel() const { return m_outputLevel; }
   
  void setOutputLevel( int level );
   
  ISvcLocator* serviceLocator() const;

  template <class T>
  StatusCode service( const std::string& name, T*& svc, bool createIf = false ) const {
    IService* theSvc;
    StatusCode sc = serviceLocator()->getService( name, theSvc, createIf );
    if ( sc.isSuccess() ) {
      return theSvc->queryInterface(T::interfaceID(), (void**)&svc);
    }
    svc = 0;
    return sc;
  }

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

  unsigned long addRef();
  unsigned long release();
  StatusCode queryInterface(const InterfaceID& riid, void**);

 private:

  long m_refCount;              
  std::string m_name;             

  IMessageSvc* m_MS;            
  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 asignment operator: NO ASSIGNMENT ALLOWED
  Auditor& operator=(const Auditor& rhs);
};

#endif //GAUDIKERNEL_AUDITOR_H

---