AlgTool.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_ALGTOOL_H
#define GAUDIKERNEL_ALGTOOL_H
// ============================================================================
// Include files
#include "GaudiKernel/IAlgTool.h"
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/IService.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/IToolSvc.h"
#include "GaudiKernel/PropertyMgr.h"
#include "GaudiKernel/IAuditorSvc.h"
#include "GaudiKernel/IMonitorSvc.h"
#include "GaudiKernel/IStateful.h"
#include <Gaudi/PluginService.h>

#include <vector>
#include <list>

// Forward declarations

class GAUDI_API AlgTool: public implements3<IAlgTool, IProperty, IStateful> {
  friend class ToolSvc;
public:
#ifndef __REFLEX__
  typedef Gaudi::PluginService::Factory<IAlgTool*,
                                        const std::string&,
                                        const std::string&,
                                        const IInterface*> Factory;
#endif

  virtual StatusCode queryInterface(const InterfaceID& riid, void** ppvUnknown);

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

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

  virtual const IInterface*  parent() const;

  // State machine implementation
  virtual StatusCode configure() { return StatusCode::SUCCESS; }
  virtual StatusCode initialize();
  virtual StatusCode start();
  virtual StatusCode stop();
  virtual StatusCode finalize();
  virtual StatusCode terminate() { return StatusCode::SUCCESS; }
  virtual StatusCode reinitialize();
  virtual StatusCode restart();
  virtual Gaudi::StateMachine::State FSMState() const { return m_state; }
  virtual Gaudi::StateMachine::State targetFSMState() const { return m_targetState; }

  virtual StatusCode sysInitialize();

  virtual StatusCode sysStart();

  virtual StatusCode sysStop();

  virtual StatusCode sysFinalize();

  virtual StatusCode sysReinitialize();

  virtual StatusCode sysRestart();

  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;

  inline PropertyMgr * getPropertyMgr() { return m_propertyMgr; }

public:

  template <class TYPE>
  StatusCode setProperty
  ( const std::string& name  ,
    const TYPE&        value )
  { return Gaudi::Utils::setProperty ( m_propertyMgr , name , value ) ; }


  AlgTool( const std::string& type,
           const std::string& name,
           const IInterface* parent);

  ISvcLocator* serviceLocator()  const;

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

  IMessageSvc* msgSvc() const;

  IToolSvc* toolSvc() const;

  StatusCode setProperties();

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

  template <class T>
  StatusCode service( const std::string& type, const std::string& name, T*& svc) const {
    return service_i(type, name, T::interfaceID(), (void**)&svc);
  }

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

  void declInterface( const InterfaceID&, void*);

  template <class I> class declareInterface {
  public:
    template <class T> declareInterface(T* tool) {
      tool->declInterface( I::interfaceID(), (I*)tool);
    }
  };
  // ==========================================================================
  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 ) ;
  }
  // ==========================================================================
  IAuditorSvc* auditorSvc() const;

  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) ).ignore();
    }
    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);
  }

protected:

  int           outputLevel () const { return (int)m_outputLevel ; }

  IntegerProperty & outputLevelProperty() { return m_outputLevel; }

  void initOutputLevel(Property& prop);



protected:

  // Standard destructor.
  virtual ~AlgTool();

private:
  typedef std::list<std::pair<InterfaceID,void*> >  InterfaceList;
  IntegerProperty      m_outputLevel;      
  std::string          m_type;             
  const std::string    m_name;             
  const IInterface*    m_parent;           
  mutable ISvcLocator* m_svcLocator;       
  mutable IMessageSvc* m_messageSvc;       
  mutable IToolSvc*    m_ptoolSvc;         
  mutable IMonitorSvc* m_pMonitorSvc;      
  std::string          m_monitorSvcName;   
  PropertyMgr*         m_propertyMgr;      
  InterfaceList        m_interfaceList;    
  std::string          m_threadID;         

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

  mutable IAuditorSvc*      m_pAuditorSvc; 

  BooleanProperty m_auditInit;
  bool         m_auditorInitialize;
  bool         m_auditorStart;     
  bool         m_auditorStop;      
  bool         m_auditorFinalize;  
  bool         m_auditorReinitialize;
  bool         m_auditorRestart;     

  Gaudi::StateMachine::State m_state;            
  Gaudi::StateMachine::State m_targetState;      
};


#ifndef GAUDI_NEW_PLUGIN_SERVICE
template <class T>
class ToolFactory {
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_TOOL_FACTORY(x) \
  DECLARE_FACTORY_WITH_CREATOR(x, ToolFactory< x >, AlgTool::Factory)
#define DECLARE_NAMESPACE_TOOL_FACTORY(n, x) \
    DECLARE_TOOL_FACTORY(n::x)

#else

// Macros to declare component factories
#define DECLARE_TOOL_FACTORY(x)              DECLARE_COMPONENT(x)
#define DECLARE_NAMESPACE_TOOL_FACTORY(n,x)  DECLARE_COMPONENT(n::x)

#endif


#endif // GAUDIKERNEL_ALGTOOL_H