ApplicationMgr.h

Go to the documentation of this file.

// $Header: /local/reps/Gaudi/GaudiSvc/src/ApplicationMgr/ApplicationMgr.h,v 1.34 2008/11/10 15:29:09 marcocle Exp $    //
#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/Service.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 : virtual public IAppMgrUI,
                       virtual public IEventProcessor,
                       virtual public IService,
                       virtual public IStateful {
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();

  // implmentation of IInterface::addRef
  virtual unsigned long addRef();
  // implmentation of IInterface::release
  virtual unsigned long release();
  // 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::initalize
  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 IService::type
  virtual const InterfaceID& type() const;
  // implementation of IStateful::state
  virtual Gaudi::StateMachine::State FSMState() const;
  // implementation of IStateful::targetState
  virtual Gaudi::StateMachine::State targetFSMState() const;
  // implementation of IStateful::reinitilaize
  virtual StatusCode reinitialize();
  // implementation of IStateful::reinitilaize
  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       reflexDebugPropertyHandler ( Property& theProp );
  void       initLoopCheckHndlr      ( Property& );

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

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

  StatusCode i_startup();

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

  // data members
  int                 m_refcount;           
  ServiceManager*     m_svcManager;         
  AlgorithmManager*   m_algManager;         
  DLLClassManager*    m_classManager;       
  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;        
  IMessageSvc*        m_messageSvc;         
  IRunable*           m_runable;            
  IEventProcessor*    m_processingMgr;      
  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_reflexDebugLevel;  

  StringArrayProperty  m_createSvcNameList;

  BooleanProperty      m_auditTools;
  BooleanProperty      m_auditSvcs;
  BooleanProperty      m_auditAlgs;

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

  BooleanProperty      m_loopCheck;

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

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