ProcessorMgr.h

#ifndef ProcessorMgr_h
#define ProcessorMgr_h 1

// #include "lcio.h"
#include "Processor.h"
// #include "LCIOOutputProcessor.h"

// #include "IO/LCRunListener.h"
// #include "IO/LCEventListener.h"

// #include "EVENT/LCEvent.h"
// #include "EVENT/LCRunHeader.h"

#include "LogicalExpressions.h"

#include "gloria/GloriaDataContainer.h"

#include <map>
#include <set>
#include <list>

using namespace gloria;

namespace luiza{

  //  class ProcessorEventSeeder;

typedef std::map< const std::string , Processor* > ProcessorMap ;
typedef std::list< Processor* > ProcessorList ;
typedef std::map< const std::string , int > SkippedEventMap ;

// class ProcessorMgr : public LCRunListener, public LCEventListener {
class ProcessorMgr {

friend class  Processor ;   
friend class  CMProcessor ;   
friend class  LuizaSteerCheck ;   

public:
  
  static ProcessorMgr* instance() ;

  virtual ~ProcessorMgr() ;

//   bool addActiveProcessor( const std::string& processorType , const std::string& processorName ,
//                         StringParameters* parameters=0 ) ;

  bool addActiveProcessor( const std::string& processorType , const std::string& processorName ,
                           StringParameters* parameters , const std::string condition="true" ) ;
  
  void removeActiveProcessor(  const std::string& name ) ;


  Processor* getActiveProcessor( const std::string& name ) ;

  Processor* getProcessor( const std::string& type ) ;
  
  void dumpRegisteredProcessors() ;

  void dumpRegisteredProcessorsXML() ;
  
  virtual void init() ;

  virtual void startAnalysis( GloriaDataContainer* ) ;

  virtual bool processData( GloriaDataContainer* ) ;

  virtual void concludeAnalysis( GloriaDataContainer* ) ;

  virtual void end() ;
  
  
  // virtual void readDataSource( int numEvents ) ;

  void processingLoop( int numEvents ) ;


  virtual void setProcessorReturnValue( Processor* proc, bool val ) ;

  virtual void setProcessorReturnValue( Processor* proc, bool val , const std::string& name) ;


protected:
  void registerProcessor( Processor* processor ) ;
  
  std::set< std::string > getAvailableProcessorTypes() ;
  
//   ProcessorMgr() : _outputProcessor(0) {}
//   ProcessorMgr() {}
  ProcessorMgr() ;

private:
  static ProcessorMgr*  _me ;
  ProcessorMap _map ;
  ProcessorMap _activeMap ;
  ProcessorList _list ;
  SkippedEventMap _skipMap ;

  LogicalExpressions _conditions ;

};
  
} // end namespace luiza
#endif