Algorithm.h

Go to the documentation of this file.

#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/IAlgContextSvc.h"
#include "GaudiKernel/Property.h"
#include <Gaudi/PluginService.h>

#ifndef PACKAGE_VERSION
#define PACKAGE_VERSION "unknown"
#endif

class GAUDI_API Algorithm: public implements3<IAlgorithm, IProperty, IStateful> {
public:
#ifndef __REFLEX__
  typedef Gaudi::PluginService::Factory<IAlgorithm*,
                                        const std::string&,
                                        ISvcLocator*> Factory;
#endif

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

  inline int errorCount() const { return m_errorCount; }

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

  SmartIF<IService> service(const std::string& name, const bool createIf = true, const bool quiet = false) const;

  void setOutputLevel( int level );

  SmartIF<IAuditorSvc>& auditorSvc() const;

  SmartIF<IChronoStatSvc>& chronoSvc() const;
  SmartIF<IChronoStatSvc>& chronoStatService() const;

  SmartIF<IDataProviderSvc>& detSvc() const;

  SmartIF<IDataProviderSvc>& detDataService() const;

  SmartIF<IConversionSvc>& detCnvSvc() const;

  SmartIF<IConversionSvc>& detDataCnvService() const;

  SmartIF<IDataProviderSvc>& eventSvc() const;
  SmartIF<IDataProviderSvc>& evtSvc  () const { return eventSvc() ; }
  SmartIF<IDataProviderSvc>& eventDataService() const;

  SmartIF<IConversionSvc>&   eventCnvSvc() const;
  SmartIF<IConversionSvc>&   eventDataCnvService() const;

  SmartIF<IHistogramSvc>& histoSvc() const;
  SmartIF<IHistogramSvc>& histogramDataService() const;

  SmartIF<IMessageSvc>&      msgSvc() const;

  SmartIF<IMessageSvc>&      messageService() const;

  SmartIF<INTupleSvc>& ntupleSvc() const;

  SmartIF<INTupleSvc>& ntupleService() const;

  // SmartIF<IAIDATupleSvc>& atupleSvc() const;


  SmartIF<IRndmGenSvc>& randSvc() const;

  SmartIF<IToolSvc>& toolSvc() const;

  SmartIF<IExceptionSvc>& exceptionSvc() const;

  SmartIF<IAlgContextSvc>& contextSvc() const ;

  SmartIF<ISvcLocator>& serviceLocator() const;
  SmartIF<ISvcLocator>& svcLoc        () const { return serviceLocator() ; }

  bool registerContext() const { return m_registerContext ; }

  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;
  virtual bool hasProperty(const std::string& name) 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 SmartIF<IMonitorSvc>& monitorSvc() const
  {
    // If not already located try to locate it without forcing a creation
    if ( !m_pMonitorSvc.isValid() ){
      m_pMonitorSvc = service(m_monitorSvcName, false, true); // do not create and be quiet
    }
    return m_pMonitorSvc;
  }

  template <class T>
  void declareInfo( const std::string& name,
                    const T& var,
                    const std::string& desc ) const
  {
    IMonitorSvc* mS = monitorSvc().get();
    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().get();
    if ( mS ) mS->declareInfo(name, format, var, size, desc, this);
  }

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

  std::string m_name;            
  std::string m_version;         
  std::vector<Algorithm *>* m_subAlgms; 

  mutable SmartIF<IMessageSvc>      m_MS;       
  mutable SmartIF<IDataProviderSvc> m_EDS;      
  mutable SmartIF<IConversionSvc>   m_ECS;      
  mutable SmartIF<IDataProviderSvc> m_DDS;      
  mutable SmartIF<IConversionSvc>   m_DCS;      
  mutable SmartIF<IHistogramSvc>    m_HDS;      
  mutable SmartIF<INTupleSvc>       m_NTS;      
  //  mutable SmartIF<IAIDATupleSvc>    m_ATS;      ///< AIDA tuple service
  mutable SmartIF<IChronoStatSvc>   m_CSS;      
  mutable SmartIF<IRndmGenSvc>      m_RGS;      
  mutable SmartIF<IExceptionSvc>    m_EXS;      
  mutable SmartIF<IAuditorSvc>      m_pAuditorSvc; 
  mutable SmartIF<IToolSvc>         m_ptoolSvc;    
  mutable SmartIF<IMonitorSvc>      m_pMonitorSvc; 
  mutable SmartIF<IAlgContextSvc>   m_contextSvc ; 
  bool  m_registerContext ; 
  std::string               m_monitorSvcName; 
  SmartIF<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);
};

#ifndef GAUDI_NEW_PLUGIN_SERVICE
template <class T>
class AlgFactory {
public:
#ifndef __REFLEX__
  template <typename S, typename... Args>
  static typename S::ReturnType create(Args... args) {
    return new T(args...);
  }
#endif
};

// Macros to declare component factories
#define DECLARE_ALGORITHM_FACTORY(x) \
  DECLARE_FACTORY_WITH_CREATOR(x, AlgFactory< x >, Algorithm::Factory)
#define DECLARE_NAMED_ALGORITHM_FACTORY(x, n) \
  DECLARE_FACTORY_WITH_CREATOR_AND_ID(x, AlgFactory< x >, \
                                      #n, Algorithm::Factory)
#define DECLARE_NAMESPACE_ALGORITHM_FACTORY(n, x) \
  DECLARE_ALGORITHM_FACTORY(n::x)

#else

// Macros to declare component factories
#define DECLARE_ALGORITHM_FACTORY(x)              DECLARE_COMPONENT(x)
#define DECLARE_NAMED_ALGORITHM_FACTORY(x, n)     DECLARE_COMPONENT_WITH_ID(x, #n)
#define DECLARE_NAMESPACE_ALGORITHM_FACTORY(n, x) DECLARE_COMPONENT(n::x)

#endif

#endif //GAUDIKERNEL_ALGORITHM_H