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 );
  ~Algorithm() override = default;

  StatusCode sysStart() override;

  StatusCode sysInitialize() override;


  StatusCode sysReinitialize() override;

  StatusCode sysRestart() override;

  StatusCode sysExecute() override;

  StatusCode sysStop() override;

  StatusCode sysFinalize() override;

  StatusCode sysBeginRun( ) override;

  StatusCode sysEndRun( ) override;

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

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

  StatusCode configure() override { return StatusCode::SUCCESS ; }
  StatusCode terminate() override { return StatusCode::SUCCESS ; }

  StatusCode initialize() override { return StatusCode::SUCCESS ; }
  StatusCode start() override { return StatusCode::SUCCESS ; }
  StatusCode stop() override { return StatusCode::SUCCESS ; }
  StatusCode finalize() override { return StatusCode::SUCCESS ; }
  StatusCode reinitialize() override;
  StatusCode restart() override;
  Gaudi::StateMachine::State FSMState() const override { return m_state; }
  Gaudi::StateMachine::State targetFSMState() const override { return m_targetState; }

  bool isExecuted( ) const override;

  void setExecuted( bool state ) override;

  void resetExecuted( ) override;

  StatusCode beginRun() override;

  StatusCode endRun() override;


  bool isEnabled( ) const override;

  bool filterPassed( ) const override;

  void setFilterPassed( bool state ) override;

  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;

  template <class T>
  SmartIF<T> service( const std::string& name, bool createIf = true, bool quiet = false ) const {
    return service(name,createIf,quiet).as<T>();
  }

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

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

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

  StatusCode setProperty( const Property& p ) override;
  StatusCode setProperty( const std::string& s ) override;
  StatusCode setProperty( const std::string& n, const std::string& v) override;
  StatusCode getProperty(Property* p) const override;
  const Property& getProperty( const std::string& name) const override;
  StatusCode getProperty( const std::string& n, std::string& v ) const override;
  const std::vector<Property*>& getProperties( ) const override;
  bool hasProperty(const std::string& name) const override;

  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 ){
      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.get() , name , value ) ; }
  // ==========================================================================
protected:

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

  bool isFinalized( ) const  override{ 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 = false ; 
  std::string               m_monitorSvcName; 
  SmartIF<ISvcLocator>  m_pSvcLocator;      
  SmartIF<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 = true;     
  bool         m_isEnabled = true;        
  bool         m_isExecuted = false;      
  Gaudi::StateMachine::State m_state = Gaudi::StateMachine::CONFIGURED;            
  Gaudi::StateMachine::State m_targetState = Gaudi::StateMachine::CONFIGURED;      
  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(std::forward<Args>(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