EventHandler.hh

Go to the documentation of this file.

#ifndef EVENTHANDLER_h
#define EVENTHANDLER_h

#include "ParameterList.hh"
#include "Event.hh"
#include "runinfo.hh"
#include <string>
#include <vector>

class BaseModule;
class AsyncEventHandler;

class EventHandler : public ParameterList{
private:
  EventHandler();
  EventHandler(const EventHandler& right);
  EventHandler& operator=(const EventHandler& right);

public:
  static EventHandler* GetInstance();
  ~EventHandler();
  
  int AddModule(BaseModule* mod, 
                bool processme = true,
                bool registerme = true);
  BaseModule* GetModule(const std::string& modname);
  
  template<class Module> 
  Module* AddModule(const std::string& name=Module::GetDefaultName(),
                    bool processme = true,
                    bool registerme = true);
  template<class Module>
  Module* GetModule(const std::string& name=Module::GetDefaultName());
  
  int AddCommonModules(); 
  
  void  AddAsyncReceiver(AsyncEventHandler* handler)
  { if(handler) _async_receivers.push_back(handler); }
  void ClearAsyncReceivers(){ _async_receivers.clear(); }
  
  //public interface functions
  //return 0 if no errors
  int Initialize();
  int Process(RawEventPtr raw);
  int Process(EventPtr evt);
  int Finalize();
  
  EventPtr GetCurrentEvent(){ return _current_event; }
  const std::vector<BaseModule*>* GetListOfModules() const{ return &_modules; }
  std::vector<BaseModule*>* GetListOfModules(){ return &_modules;}
  const std::vector<BaseModule*>* GetProcessingModules() const 
  { return &_processing_modules; }
  std::vector<BaseModule*>* GetProcessingModules() 
  { return &_processing_modules;}
  
  void SetRunID(int id){ run_id = id; }
  int SetRunIDFromFilename(const std::string& filename);
  int GetRunID(){ return run_id; }
  runinfo* GetRunInfo(){ return &_runinfo; }
  void AllowDatabaseAccess(bool setval){ _access_database=setval; }
  bool GetFailOnBadCal() const { return _fail_on_bad_cal;}
private:
  std::vector<BaseModule*> _modules;
  std::vector<BaseModule*> _processing_modules;
  std::vector<AsyncEventHandler*> _async_receivers;
  EventPtr _current_event;
  bool _is_initialized;  
  int run_id;
  runinfo _runinfo; 
  bool _access_database; 
  bool _fail_on_bad_cal; 
  
  bool _run_parallel;   
  std::vector<AsyncEventHandler*> _para_handlers;
};

#include "BaseModule.hh"

template<class Module> inline 
Module* EventHandler::AddModule(const std::string& name,
                                bool processme,
                                bool registerme)
{
  for(std::vector<BaseModule*>::iterator it = _modules.begin(); 
      it != _modules.end(); it++){
    if( (*it)->GetName() == name && dynamic_cast<Module*>(*it) )
      return dynamic_cast<Module*>( *it );
  }
  //if we get here, this module doesn't exist yet, so add it
  BaseModule* newmod = new Module;
  newmod->SetName(name);
  AddModule(newmod, processme, registerme);
  return dynamic_cast<Module*>( newmod );
}

template<class Module> inline 
Module* EventHandler::GetModule(const std::string& name)
{
  for(std::vector<BaseModule*>::iterator it = _modules.begin(); 
      it != _modules.end(); it++){
    if( (*it)->GetName() == name && dynamic_cast<Module*>(*it) )
      return dynamic_cast<Module*>( *it );
  }
  //if we get here, this module doesn't exist yet
  return 0;
}


#endif