ApplicationMgr.h

Go to the documentation of this file.

#ifndef GAUDI_APPLICATIONMGR_H
#define GAUDI_APPLICATIONMGR_H

#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/IAppMgrUI.h"
#include "GaudiKernel/IEventProcessor.h"
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/IStateful.h"
#include "GaudiKernel/IComponentManager.h"
#include "GaudiKernel/IAlgorithm.h"
#include "GaudiKernel/IAlgManager.h"
#include "GaudiKernel/ISvcManager.h"
#include "GaudiKernel/Service.h"
#include "GaudiKernel/CommonMessaging.h"
#include "GaudiKernel/PropertyMgr.h"

// STL include files
#include <list>
#include <vector>

// Forward declarations
class ISvcLocator;
class ServiceManager;
class AlgorithmManager;
class DLLClassManager;

class IMessageSvc;
class IIncidentSvc;
class IRunable;
class IDataManagerSvc;
class IConversionSvc;
class IJobOptionsSvc;

class ApplicationMgr : public CommonMessaging<implements4<IAppMgrUI,
                                                          IEventProcessor,
                                                          IService,
                                                          IStateful> > {
  typedef CommonMessaging<implements4<IAppMgrUI,
                                      IEventProcessor,
                                      IService,
                                      IStateful> > base_class;
public:
  typedef std::list<std::pair<IService*,int> >  ListSvc;
  typedef std::vector<std::string> VectorName;

public:

  // default creator
  ApplicationMgr(IInterface* = nullptr);
  // virtual destructor
  ~ApplicationMgr() override = default;

  // implementation of IInterface::queryInterface
  StatusCode queryInterface(const InterfaceID& iid, void** pinterface) override;

  // implementation of IAppMgrUI::run
  StatusCode run() override;
  // implementation of IAppMgrUI::configure
  StatusCode configure() override;
  // implementation of IAppMgrUI::terminate
  StatusCode terminate() override;
  // implementation of IAppMgrUI::initialize
  StatusCode initialize() override;
  // implementation of IAppMgrUI::start
  StatusCode start() override;
  // implementation of IAppMgrUI::stop
  StatusCode stop() override;
  // implementation of IAppMgrUI::finalize
  StatusCode finalize() override;
  // implementation of IAppMgrUI::nextEvent
  StatusCode nextEvent(int maxevt) override;
  // implementation of IAppMgrUI::name
  const std::string&  name() const override;
  StatusCode executeEvent(void* par) override;
  StatusCode executeRun(int evtmax) override;
  StatusCode stopRun() override;

  // implementation of IStateful::state
  Gaudi::StateMachine::State FSMState() const override;
  // implementation of IStateful::targetState
  Gaudi::StateMachine::State targetFSMState() const override;
  // implementation of IStateful::reinitialize
  StatusCode reinitialize() override;
  // implementation of IStateful::reinitialize
  StatusCode restart() override;
  // implementation of IService::sysItinitilaize
  StatusCode sysInitialize() override { return StatusCode::SUCCESS; }
  // implementation of IService::sysStart
  StatusCode sysStart() override { return StatusCode::SUCCESS; }
  // implementation of IService::sysStop
  StatusCode sysStop() override { return StatusCode::SUCCESS; }
  // implementation of IService::sysFinalize
  StatusCode sysFinalize() override { return StatusCode::SUCCESS; }
  // implementation of IService::sysReinitialize
  StatusCode sysReinitialize() override { return StatusCode::SUCCESS; }
  // implementation of IService::sysRestart
  StatusCode sysRestart() override { return StatusCode::SUCCESS; }

  // SI Go Handler
  void       SIGoHandler             ( Property& theProp );
  // SI Exit handler
  void       SIExitHandler           ( Property& theProp );


  void       evtLoopPropertyHandler  ( Property& theProp );
  StatusCode decodeExtSvcNameList    ( );
  StatusCode decodeCreateSvcNameList ( );
  void createSvcNameListHandler(Property &);
  void       extSvcNameListHandler   ( Property& theProp );
  StatusCode decodeMultiThreadSvcNameList( );
  void  multiThreadSvcNameListHandler( Property& theProp );
  StatusCode decodeDllNameList       ( );
  void       dllNameListHandler      ( Property& theProp );
  void       pluginDebugPropertyHandler ( Property& theProp );
  void       initLoopCheckHndlr      ( Property& );

  template <class I>
  SmartIF<IComponentManager> &getManager() {
    return m_managers[I::interfaceID().id()];
  }

  inline SmartIF<ISvcManager> &svcManager() {
    // Cache the casted pointer to ISvcManager
    if (!m_svcManager) {
      m_svcManager = getManager<IService>();
    }
    return m_svcManager;
  }

  inline SmartIF<IAlgManager> &algManager() {
    // Cache the casted pointer to IAlgManager
    if (!m_algManager) {
      m_algManager = getManager<IAlgorithm>();
    }
    return m_algManager;
  }

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

protected:
  StatusCode declareMultiSvcType(const std::string& name,
                 const std::string& type);
  StatusCode addMultiSvc(const Gaudi::Utils::TypeNameString &typeName,
             int prio);

  // implementation of IService::setServiceManager
  void setServiceManager(ISvcManager*) override {}

  StatusCode i_startup();

  StatusCode GoToState(Gaudi::StateMachine::State state, bool ignoreFailures = false);

  typedef std::map<unsigned long, SmartIF<IComponentManager> > ManagersMap;
  ManagersMap         m_managers;
  StringArrayProperty m_declaredManagers;

  SmartIF<ISvcManager> m_svcManager;

  SmartIF<IAlgManager> m_algManager;


  // data members
  mutable SmartIF<ISvcLocator> m_svcLocator; 
  SmartIF<DLLClassManager>    m_classManager;       
  SmartIF<PropertyMgr> m_propertyMgr;        

  IntegerProperty     m_SIGo;               
  IntegerProperty     m_SIExit;             
  StringArrayProperty m_topAlgNameList;     
  StringArrayProperty m_outStreamNameList;  
  StringProperty      m_outStreamType;      
  StringProperty      m_messageSvcType;     
  StringProperty      m_jobOptionsSvcType;  

  std::string         m_name = "ApplicationMgr";               
  Gaudi::StateMachine::State m_state = Gaudi::StateMachine::OFFLINE;              
  Gaudi::StateMachine::State m_targetState = Gaudi::StateMachine::OFFLINE;              

  VectorName          m_defServices;        
  VectorName          m_svcMapping;         
  VectorName          m_svcOptMapping;      

  SmartIF<IMessageSvc>      m_messageSvc;         
  SmartIF<IRunable>         m_runable;            
  SmartIF<IEventProcessor>  m_processingMgr;      
  SmartIF<IJobOptionsSvc>   m_jobOptionsSvc;      

  //
  // The public ApplicationMgr properties
  //

  int                  m_evtMax;            
  StringArrayProperty  m_extSvcNameList;    
  BooleanProperty      m_extSvcCreates;     

  StringArrayProperty  m_multiThreadSvcNameList;
  int                  m_noOfEvtThreads;    

  StringArrayProperty  m_dllNameList;       
  std::string          m_jobOptionsType;    
  std::string          m_jobOptionsPath;    
  std::string          m_jobOptionsPreAction;  
  std::string          m_jobOptionsPostAction;  
  std::string          m_runableType;       
  std::string          m_eventLoopMgr;      
  std::string          m_evtsel;            
  std::string          m_histPersName;      
  int                  m_outputLevel;       
  std::string          m_appName;           
  std::string          m_appVersion;        
  bool                 m_actHistory;        
  bool                 m_codeCheck;         
  IntegerProperty      m_pluginDebugLevel;  

  StringArrayProperty  m_createSvcNameList;

  BooleanProperty      m_auditTools;
  BooleanProperty      m_auditSvcs;
  BooleanProperty      m_auditAlgs;

  std::map<std::string,std::string> m_environment; 

  BooleanProperty      m_loopCheck;

  BooleanProperty      m_stopOnSignal;

  BooleanProperty      m_stalledEventMonitoring;

  // Flag to activate the printout of properties
  bool                 m_propertiesPrint ; 

  IntegerProperty      m_returnCode;

  // For concurrency
  bool m_useHiveAlgorithmManager;

private:
   std::vector<std::string> m_okDlls;       
};
#endif  // GAUDI_APPLICATIONMGR_H