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::list<std::string>   ListName;
  typedef std::vector<std::string> VectorName;

public:

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

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

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

  // implementation of IStateful::state
  virtual Gaudi::StateMachine::State FSMState() const;
  // implementation of IStateful::targetState
  virtual Gaudi::StateMachine::State targetFSMState() const;
  // implementation of IStateful::reinitialize
  virtual StatusCode reinitialize();
  // implementation of IStateful::reinitialize
  virtual StatusCode restart();
  // implementation of IService::sysItinitilaize
  virtual StatusCode sysInitialize() { return StatusCode::SUCCESS; }
  // implementation of IService::sysStart
  virtual StatusCode sysStart() { return StatusCode::SUCCESS; }
  // implementation of IService::sysStop
  virtual StatusCode sysStop() { return StatusCode::SUCCESS; }
  // implementation of IService::sysFinalize
  virtual StatusCode sysFinalize() { return StatusCode::SUCCESS; }
  // implementation of IService::sysReinitialize
  virtual StatusCode sysReinitialize() { return StatusCode::SUCCESS; }
  // implementation of IService::sysRestart
  virtual StatusCode sysRestart() { 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;
  }

  virtual SmartIF<ISvcLocator>& serviceLocator() const {
    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*) {}

  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
  DLLClassManager*    m_classManager;       
  mutable SmartIF<ISvcLocator> m_svcLocator; 

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


  ListSvc             m_topSvcList;         
  ListName            m_topSvcNameList;     

  std::string         m_name;               
  Gaudi::StateMachine::State m_state;              
  Gaudi::StateMachine::State m_targetState;              

  VectorName          m_defServices;        
  VectorName          m_svcMapping;         
  VectorName          m_svcOptMapping;      

  PropertyMgr*        m_propertyMgr;        
  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_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;

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