---

Algorithm.h

Go to the documentation of this file.

// $Header: /afs/cern.ch/sw/Gaudi/cvs/GaudiKernel/GaudiKernel/Algorithm.h,v 1.8 2001/06/29 13:47:40 mato Exp $
#ifndef GAUDIKERNEL_ALGORITHM_H
#define GAUDIKERNEL_ALGORITHM_H

// Include files
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/IAlgorithm.h"
#include "GaudiKernel/IService.h"
#include "GaudiKernel/PropertyMgr.h"
#include <string>
#include <vector>

// Forward declarations
class ISvcLocator;
class IMessageSvc;
class IDataProviderSvc;
class IHistogramSvc;
class IConversionSvc;
class INTupleSvc;
class IChronoStatSvc;
class IRndmGenSvc;
class IAuditorSvc;
class Property;

class Algorithm : virtual public IAlgorithm,
                  virtual public IProperty {
public:

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

  virtual StatusCode sysInitialize();

  virtual StatusCode sysExecute();
  

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

  virtual bool isExecuted( ) const;

  virtual StatusCode setExecuted( bool state );

  virtual StatusCode resetExecuted( );

  virtual StatusCode beginRun();
  virtual StatusCode endRun();

  virtual bool isEnabled( ) const;

  virtual bool filterPassed( ) const;

  virtual StatusCode setFilterPassed( bool state );



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

  void setOutputLevel( int level );

  IAuditorSvc* auditorSvc() const;

  IChronoStatSvc* chronoSvc() const;
  IChronoStatSvc* chronoStatService() const;

  IDataProviderSvc* detSvc() const;
  IDataProviderSvc* detDataService() const;

  IConversionSvc* detCnvSvc() const;
  IConversionSvc* detDataCnvService() const;

  IDataProviderSvc* eventSvc() const;
  IDataProviderSvc* eventDataService() const;

  IConversionSvc*   eventCnvSvc() const;
  IConversionSvc*   eventDataCnvService() const;

  IHistogramSvc* histoSvc() const;
  IHistogramSvc* histogramDataService() const;

  IMessageSvc*      msgSvc() const;
  IMessageSvc*      messageService() const;

  INTupleSvc* ntupleSvc() const;
  INTupleSvc* ntupleService() const;
  
  IRndmGenSvc* randSvc() const;

  ISvcLocator* serviceLocator() const;
 
  StatusCode createSubAlgorithm( const std::string& type, 
             const std::string& name, Algorithm*& pSubAlg );

  std::vector<Algorithm*>* subAlgorithms() const;

  virtual StatusCode setProperty(const Property& p);
  virtual StatusCode setProperty( std::istream& 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;
  virtual const std::vector<Property*>& getProperties( ) const;

  StatusCode setProperties();

  template <class T>
  StatusCode declareProperty( const std::string& name, T& property ) const {
        m_propertyMgr->declareProperty(name, property);
          return StatusCode::SUCCESS;
  }
  StatusCode declareRemoteProperty( const std::string& name, IProperty* rsvc, 
                                    const std::string& rname = "" ) const {
        m_propertyMgr->declareRemoteProperty(name, rsvc, rname);
        return StatusCode::SUCCESS;
  }


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

protected:
  bool isInitialized( ) const;

  void setInitialized( );

  bool isFinalized( ) const;

  void setFinalized( );

private:

  long m_refCount;                      
  std::string m_name;                   
  std::vector<Algorithm *>* m_subAlgms; 

  mutable IMessageSvc*      m_MS;               
  mutable IDataProviderSvc* m_EDS;              
  mutable IConversionSvc*   m_ECS;              
  mutable IDataProviderSvc* m_DDS;              
  mutable IConversionSvc*   m_DCS;              
  mutable IHistogramSvc*    m_HDS;              
  mutable INTupleSvc*       m_NTS;              
  mutable IChronoStatSvc*   m_CSS;              
  mutable IRndmGenSvc*      m_RGS;              
  mutable IAuditorSvc*      m_pAuditorSvc;      
  ISvcLocator*      m_pSvcLocator;      
  PropertyMgr*      m_propertyMgr;      
  int               m_outputLevel;      
  int               m_errorMax;         
  int               m_errorCount;       
  bool              m_auditorInitialize;
  bool              m_auditorExecute;   
  bool              m_auditorFinalize;  
  bool              m_filterPassed;     
  bool              m_isEnabled;        
  bool              m_isExecuted;       
  bool              m_isInitialized;    
  bool              m_isFinalized;      

  Algorithm(const Algorithm& a);                 

  Algorithm& operator=(const Algorithm& rhs);
};

#endif //GAUDIKERNEL_ALGORITHM_H

---