---

ApplicationMgr.h

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiSvc/src/ApplicationMgr/ApplicationMgr.h,v 1.1.1.3 2001/04/18 18:32:48 tlindner Exp $      //
#ifndef GAUDI_APPLICATIONMGR_H
#define GAUDI_APPLICATIONMGR_H 

#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/IAppMgrUI.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IObjManager.h"
#include "GaudiKernel/ISvcManager.h"
#include "GaudiKernel/IAlgManager.h"
#include "GaudiKernel/ICnvManager.h"
#include "GaudiKernel/IClassManager.h"
#include "GaudiKernel/IEventProcessor.h"
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/PropertyMgr.h"

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

// Forward declarations
class ServiceFactory;
class AlgorithmFactory;
class ConverterFactory;
class DLLClassManager;

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

class ApplicationMgr : virtual public IAppMgrUI,
                       virtual public ISvcLocator,
                       virtual public ISvcManager,
                       virtual public IAlgManager,
                       virtual public ICnvManager,
                       virtual public IObjManager,
                       virtual public IEventProcessor,
                       virtual public IProperty,
                       virtual public IClassManager {
public:
  typedef std::list<IService*>     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 IID& 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::finalize
  virtual StatusCode finalize();
  // implementation of IAppMgrUI::nextEvent
  virtual StatusCode nextEvent(int maxevt);
  // implementation of IAppMgrUI::state: current state of the application manager
  virtual const std::string& state()  const;
  // implementation of IAppMgrUI::name
  virtual const std::string&  name() const;
  virtual StatusCode executeEvent(void* par);

  // implementation of ISvcLocation::getService
  virtual StatusCode getService( const std::string& name, IService*& svc);
  // implementation of ISvcLocation::getService
  virtual StatusCode getService( const std::string& name, const IID& iid, IInterface*& pinterface);
  // implementation of ISvcLocation::existsService
  virtual bool existsService( const std::string& name) const;
  // implementation of ISvcLocation::getService
  virtual StatusCode getService( const std::string& name, IService*& svc, bool createIf);
  // Return the list of Services
  virtual std::list<IService*>& getServices( ) const;

  // implementation of ISvcManager::addService
  virtual StatusCode addService( IService* svc);
  // implementation of ISvcManager::removeService
  virtual StatusCode removeService( IService* svc);
  // implementation of ISvcManager::declareSvcCreator
  virtual StatusCode declareSvcCreator( ISvcManager::SvcCreator creator, const std::string& svctype );
  // implementation of ISvcManager::declareSvcModule
  virtual StatusCode declareSvcModule( const std::string& module, const std::string& svctype );
  // implementation of ISvcManager::declareSvcFactory
  virtual StatusCode declareSvcFactory( const ISvcFactory& factory, const std::string& svctype );
  // implementation of ISvcManager::createService
  virtual StatusCode createService( const std::string& svctype, const std::string& svcname, IService*& svc );

  // implementation of IAlgManager::addAlgorithm
  virtual StatusCode addAlgorithm( IAlgorithm* alg);
  // implementation of IAlgManager::removeAlgorithm
  virtual StatusCode removeAlgorithm( IAlgorithm* alg);
  // implementation of IAlgManager::declareAlgCreator
  virtual StatusCode declareAlgCreator( IAlgManager::AlgCreator creator, const std::string& algtype );
  // implementation of IAlgManager::declareAlgModule
  virtual StatusCode declareAlgModule( const std::string& module, const std::string& algtype );
  // implementation of IAlgManager::declareAlgFactory
  virtual StatusCode declareAlgFactory( const IAlgFactory& factory, const std::string& algtype );
  // implementation of IAlgManager::createAlgorithm
  virtual StatusCode createAlgorithm( const std::string& algtype, const std::string& algname, IAlgorithm*& alg);
  // implementation of IAlgManager::getAlgorithm
  virtual StatusCode getAlgorithm( const std::string& name, IAlgorithm*& alg) const;
  // implementation of IAlgManager::existsAlgorithm
  virtual bool existsAlgorithm( const std::string& name) const;
  // Return the list of Algorithms
  virtual std::list<IAlgorithm*>& getAlgorithms( ) const;

  // implementation of ICnvManager::declareCnvFactory
  virtual StatusCode declareCnvFactory( const ICnvFactory& factory      // Reference to the abastract factory
                                      );
  // implementation of ICnvManager::existsConverter
  virtual bool existsConverter(         const unsigned char repSvctype, // Converter service type 
                                        const CLID& objtype             // Converter object type
                                      ) const;
  // Get an existing converter factory
  virtual const ICnvFactory* factory(   const unsigned char repSvctype, // Converter service type 
                                        const CLID& objtype             // Converter object type
                                      ) const;
  // implementation of ICnvManager::begin
  virtual CnvIterator cnvBegin();
  // implementation of ICnvManager::end
  virtual CnvIterator cnvEnd();

  // implementation of IManager::existsFactory
  virtual bool existsObjFactory(        const std::string& objtype   // Factory's object type
                                      ) const;
  // implementation of IObjManager::objFactory
  virtual const IFactory* objFactory(   const std::string& objtype   // Factory's object type
                                      ) const;
  // implementation of IObjManager::declareObjFactory
  virtual StatusCode declareObjFactory( const IFactory& factory      // Reference to the abastract factory
                                      );
  // implementation of IObjManager::begin
  virtual ObjIterator objBegin();
  // implementation of IObjManager::end
  virtual ObjIterator objEnd();

  // implementation of IProperty::setProperty
  virtual StatusCode setProperty(const Property& value);
  virtual StatusCode setProperty( std::istream& s );
  virtual StatusCode setProperty( const std::string& n, const std::string& v );
  // implementation of IProperty::getProperty
  virtual StatusCode getProperty(Property* value) const;
  // implementation of IProperty::getProperty
  const Property& getProperty( const std::string& name ) const;
  // implementation of IProperty::getProperties
  const std::vector<Property*>& getProperties( ) const;
  virtual StatusCode getProperty( const std::string& n, std::string& v ) const;

  // implementation of IClassManager::declareFactory
  virtual StatusCode declareFactory( const IFactory& factory );
  // implementation of IClassManager::loadModule 
  virtual StatusCode loadModule( const std::string& module ); 

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

  // Property handlers
  void       evtLoopPropertyHandler  ( Property& theProp );
  StatusCode decodeExtSvcNameList    ( );
  void       extSvcNameListHandler   ( Property& theProp );
  StatusCode decodeDllNameList       ( );
  void       dllNameListHandler      ( Property& theProp );

protected:

  StatusCode i_startup();
  IService* i_connectService(const std::string& typ, const std::string& name);
  // enums
  enum State { OFFLINE, CONFIGURED, FINALIZED, INITIALIZED };

  // data members
  int                 m_refcount;           
  IObjManager*        m_objFactory;         
  ServiceFactory*     m_svcFactory;         
  AlgorithmFactory*   m_algFactory;         
  ConverterFactory*   m_cnvFactory;         
  DLLClassManager*    m_classManager;       
  ISvcLocator*        m_svcLocator;         

  IntegerProperty     m_SIGo;               
  IntegerProperty     m_SIExit;             
  StringArrayProperty m_topAlgNameList;     
  StringArrayProperty m_outStreamNameList;  

  
  ListSvc             m_topSvcList;         
  ListName            m_topSvcNameList;     
 
  std::string         m_name;               
  State               m_state;              

  VectorName          m_stateName;          
  VectorName          m_defServices;        

  PropertyMgr*        m_propertyMgr;        
  IMessageSvc*        m_messageSvc;         
  IRunable*           m_runable;            
  IAppMgrUI*          m_processingMgr;      
  
  //
  // The public ApplicationMgr properties
  //

  int                  m_evtMax;            
  StringArrayProperty  m_extSvcNameList;    
  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;      

};
#endif  // GAUDI_APPLICATIONMGR_H

---