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 <map>
#include <set>
#include <list>

using namespace lcio ;

namespace marlin{

  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 {

friend class  Processor ;   
friend class  CMProcessor ;   
friend class  MarlinSteerCheck ;   

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 ,
                           std::shared_ptr<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 processRunHeader( LCRunHeader* ) ;   
  virtual void processEvent( LCEvent* ) ;
  virtual void end() ;
  
  
  virtual void modifyRunHeader( LCRunHeader*) ; 
  virtual void modifyEvent( LCEvent *) ; 

  virtual void readDataSource( 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{};

  ProcessorList _eventModifierList{};

  LogicalExpressions _conditions{};
//   LCIOOutputProcessor* _outputProcessor ;

};
  
} // end namespace marlin 
#endif