In This Package:

Algorithm.h

Go to the documentation of this file.

// $Id: Algorithm.h,v 1.34 2008/06/02 14:20:38 marcocle 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 "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/IStateful.h"

#include <string>
#include <vector>

// Extra include files (forward declarations should be sufficient)
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IHistogramSvc.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/INTupleSvc.h"
#include "GaudiKernel/IChronoStatSvc.h"
#include "GaudiKernel/IRndmGenSvc.h"
#include "GaudiKernel/IAuditorSvc.h"
#include "GaudiKernel/IToolSvc.h"
#include "GaudiKernel/IMonitorSvc.h"
#include "GaudiKernel/IExceptionSvc.h"
#include "GaudiKernel/Property.h"

#ifndef PACKAGE_VERSION
#define PACKAGE_VERSION "unknown"
#endif

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

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

  virtual StatusCode sysStart();

  virtual StatusCode sysInitialize();


  virtual StatusCode sysReinitialize();

  virtual StatusCode sysRestart();

  virtual StatusCode sysExecute();

  virtual StatusCode sysStop();

  virtual StatusCode sysFinalize();

  virtual StatusCode sysBeginRun( );

  virtual StatusCode sysEndRun( );

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

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

  virtual StatusCode configure () { return StatusCode::SUCCESS ; }
  virtual StatusCode terminate () { return StatusCode::SUCCESS ; }
  
  virtual StatusCode initialize () { return StatusCode::SUCCESS ; }
  virtual StatusCode start () { return StatusCode::SUCCESS ; }
  virtual StatusCode stop () { return StatusCode::SUCCESS ; }
  virtual StatusCode finalize   () { return StatusCode::SUCCESS ; }

  virtual StatusCode reinitialize ();
  virtual StatusCode restart ();
  
  virtual bool isExecuted( ) const;

  virtual void setExecuted( bool state );

  virtual void resetExecuted( );

  virtual StatusCode beginRun();

  virtual StatusCode endRun();
  
  virtual Gaudi::StateMachine::State FSMState() const { return m_state; }
  
  virtual Gaudi::StateMachine::State targetFSMState() const { return m_targetState; }

  virtual bool isEnabled( ) const;

  virtual bool filterPassed( ) const;

  virtual void setFilterPassed( bool state );

  template <class T>
  StatusCode service
  ( const std::string& name, T*& psvc, bool createIf = true ) const {
    return service_i(name, createIf, T::interfaceID(), (void**)&psvc);
  }

  template <class T>
  StatusCode service( const std::string& svcType, const std::string& svcName,
                      T*& psvc) const {
    return service_i(svcType, svcName, T::interfaceID(), (void**)&psvc);
  }

  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* evtSvc  () const { return eventSvc() ; }
  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;

  // IAIDATupleSvc* atupleSvc() const;


  IRndmGenSvc* randSvc() const;

  IToolSvc* toolSvc() const;

  IExceptionSvc* exceptionSvc() const;

  ISvcLocator* serviceLocator() const;
  ISvcLocator* svcLoc        () const { return serviceLocator() ; }

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

  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);
  }
  // ==========================================================================
  Property* declareRemoteProperty
  ( const std::string& name       , 
    IProperty*         rsvc       ,
    const std::string& rname = "" ) const 
  { 
    return m_propertyMgr -> declareRemoteProperty ( name , rsvc , rname );
  }
  // ==========================================================================
  inline IMonitorSvc* monitorSvc() const
  {
    // If not already located try to locate it without forcing a creation
    if ( !m_pMonitorSvc ){
      service_i( m_monitorSvcName, false, 
                 IMonitorSvc::interfaceID(), pp_cast<void>(&m_pMonitorSvc) );
    }
    return m_pMonitorSvc;
  }
  
  template <class T>
  void declareInfo( const std::string& name,
                    const T& var,
                    const std::string& desc ) const 
  {
    IMonitorSvc* mS = monitorSvc();
    if ( mS ) mS->declareInfo(name, var, desc, this);
  }

  void declareInfo( const std::string& name,
                    const std::string& format,
                    const void* var,
                    int size,
                    const std::string& desc ) const 
  {
    IMonitorSvc* mS = monitorSvc();
    if ( mS ) mS->declareInfo(name, format, var, size, desc, this);
  }

  unsigned long addRef();
  unsigned long release();
  StatusCode queryInterface(const InterfaceID& riid, void**);
  // ==========================================================================
public:
  // ==========================================================================  
  template <class TYPE>
  StatusCode setProperty 
  ( const std::string& name  , 
    const TYPE&        value ) 
  { return Gaudi::Utils::setProperty ( m_propertyMgr , name , value ) ; }
  // ==========================================================================
protected:

  bool isInitialized( ) const { return Gaudi::StateMachine::INITIALIZED == m_state; }

  bool isFinalized( ) const { return Gaudi::StateMachine::CONFIGURED == m_state; }
  
  int  outputLevel() const { return (int)m_outputLevel ; }

  IntegerProperty & outputLevelProperty() { return m_outputLevel; }

  void initOutputLevel(Property& prop);
 

private:

  long m_refCount;               
  std::string m_name;            
  std::string m_version;         
  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 IAIDATupleSvc*    m_ATS;      ///< AIDA tuple service
  mutable IChronoStatSvc*   m_CSS;      
  mutable IRndmGenSvc*      m_RGS;      
  mutable IExceptionSvc*    m_EXS;      
  mutable IAuditorSvc*      m_pAuditorSvc; 
  mutable IToolSvc*         m_ptoolSvc;    
  mutable IMonitorSvc*      m_pMonitorSvc; 
  std::string               m_monitorSvcName; 
  ISvcLocator* m_pSvcLocator;      
  PropertyMgr* m_propertyMgr;      
  IntegerProperty m_outputLevel;   
  int          m_errorMax;         
  int          m_errorCount;       
  BooleanProperty m_auditInit;     
  bool         m_auditorInitialize;
  bool         m_auditorReinitialize;
  bool         m_auditorRestart;   
  bool         m_auditorExecute;   
  bool         m_auditorFinalize;  
  bool         m_auditorBeginRun;  
  bool         m_auditorEndRun;    
  bool         m_auditorStart;
  bool         m_auditorStop;
  bool         m_filterPassed;     
  bool         m_isEnabled;        
  bool         m_isExecuted;       
  Gaudi::StateMachine::State m_state;            
  Gaudi::StateMachine::State m_targetState;      
  bool         m_isFinalized;      

  StatusCode service_i(const std::string& svcName,
                       bool createIf,
                       const InterfaceID& iid,
                       void** ppSvc) const;
  StatusCode service_i(const std::string& svcType,
                       const std::string& svcName,
                       const InterfaceID& iid,
                       void** ppSvc) const;

  Algorithm(const Algorithm& a);

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

#endif //GAUDIKERNEL_ALGORITHM_H

---