Processor.h

#ifndef Processor_h
#define Processor_h 1

#include "lcio.h"

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

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

#include "StringParameters.h"
#include "ProcessorParameter.h"
//#include "LogStream.h"
#include "marlin/VerbosityLevels.h"
#include "streamlog/streamlog.h"

#include <map>

// ----- define some useful macros-----------
// for backward compatibility 
#define m_out( VERBOSITY ) streamlog_out( VERBOSITY )  
#define m_endl std::endl 


//----- define Marlin version macros -------

#define MARLIN_MAJOR_VERSION 0
#define MARLIN_MINOR_VERSION 9
#define MARLIN_PATCH_LEVEL 8

#define MARLIN_VERSION_GE( MAJV , MINV , PLEV)  ( (  MARLIN_MAJOR_VERSION  > MAJV ) ||   ( (MARLIN_MAJOR_VERSION==MAJV) && ( MARLIN_MINOR_VERSION > MINV ) ) ||   ( (MARLIN_MAJOR_VERSION==MAJV) && ( MARLIN_MINOR_VERSION == MINV ) && ( MARLIN_PATCH_LEVEL >= PLEV ) ) )




//#define m_out( VERBOSITY ) message<VERBOSITY>( VERBOSITY::active && log() 
//#define m_out( VERBOSITY ) message<VERBOSITY>( log() 

//#define m_endl "" ) 


//#define m_endl "" ) 

using namespace lcio ;


namespace marlin{

  class ProcessorMgr ;
  //  class ProcessorParameter ;
  class XMLFixCollTypes ;

  typedef std::map<std::string, ProcessorParameter* > ProcParamMap ;
  typedef std::map<std::string, std::string >         LCIOTypeMap ;

  class Processor {
    
    friend class ProcessorMgr ;
    friend class CMProcessor ;
    friend class XMLFixCollTypes ;

  public:

//      /** Possible verbosity levels */
//     enum{ VERBOSE = 0, DEBUG = 0, MESSAGE = 1, WARNING = 2, ERROR = 3, SILENT = 4 };
 
//      /** Global variable used to set the verbosity level */
//     static int Verbosity;
  
    Processor(const std::string& typeName) ; 

    virtual ~Processor() ; 
  
  
    virtual Processor*  newProcessor() = 0 ;
  

    virtual void init() { }

    virtual void processRunHeader( LCRunHeader* ) { } 

    virtual void processEvent( LCEvent * ) { }

    virtual void check( LCEvent* ) { }


    virtual void end(){ }
  

    virtual const std::string & type() const { return _typeName ; } 

    virtual const std::string & name() const { return _processorName ; } 

    virtual StringParameters* parameters() { return _parameters ; } 


    virtual void printDescription() ;

    virtual void printDescriptionXML(std::ostream& stream=std::cout) ;


    template <class T>
    void printParameters() {
    
      
      if( streamlog::out.template write<T>() ) {

        
        typedef ProcParamMap::iterator PMI ;

        streamlog::out()  << std::endl  
                        << "---- " << name()  <<" -  parameters: " << std::endl ;
        
        
        for( PMI i = _map.begin() ; i != _map.end() ; i ++ ) {
          
          if( ! i->second->isOptional() || i->second->valueSet() ){
            streamlog::out.template write<T>() ;
            streamlog::out() << "\t"   << i->second->name()   
                             << ":  "  << i->second->value() 
                             << std::endl ;
          }
        }
        
        streamlog::out.template write<T>() ;
        streamlog::out() << "-------------------------------------------------" 
                         << std::endl ;
        
      }
    }

    void printParameters() ; 
  


    const std::string& description() { return _description ; }


    bool isFirstEvent() { return _isFirstEvent ; } ;
    
    std::string getLCIOInType( const std::string& colName ) ;

    std::string getLCIOOutType( const std::string& colName ) ;

    bool isInputCollectionName( const std::string& parameterName  ) ;  


    bool isOutputCollectionName( const std::string& parameterName  ) ;  


//     /** Helper function returns the ProcessorParameter for the given name
//      */
//     ProcessorParameter* getProcessorParameter( const std::string name) ;
    
  protected:

    void setReturnValue( bool val) ;

    void setReturnValue( const std::string& name, bool val ) ;


     template<class T>
     void registerProcessorParameter(const std::string& name, 
                                    const std::string& description,
                                    T& parameter,
                                    const T& defaultVal,
                                    int setSize=0 ) {
    
       _map[ name ] = new ProcessorParameter_t<T>( name , description, 
                                                   parameter, defaultVal, 
                                                   false , setSize) ;
     }
    
    void registerInputCollection(const std::string& type,
                                 const std::string& name, 
                                 const std::string& description,
                                 std::string& parameter,
                                 const std::string& defaultVal,
                                 int setSize=0 ) {
      
      setLCIOInType( name , type ) ;
      registerProcessorParameter( name, description, parameter, defaultVal, setSize ) ; 
    }
    
    void registerOutputCollection(const std::string& type,
                                  const std::string& name, 
                                  const std::string& description,
                                  std::string& parameter,
                                  const std::string& defaultVal,
                                  int setSize=0 ) {
      
      setLCIOOutType( name , type ) ;
      registerProcessorParameter( name, description, parameter, defaultVal, setSize ) ; 
    }

    void registerInputCollections(const std::string& type,
                                  const std::string& name, 
                                  const std::string& description,
                                  StringVec& parameter,
                                  const StringVec& defaultVal,
                                  int setSize=0 ) {
      
      setLCIOInType( name , type ) ;
      registerProcessorParameter( name, description, parameter, defaultVal, setSize ) ; 
    }
    
    template<class T>
    void registerOptionalParameter(const std::string& name, 
                                   const std::string& description,
                                   T& parameter,
                                   const T& defaultVal,
                                   int setSize=0 ) {
      
      _map[ name ] = new ProcessorParameter_t<T>( name , description, 
                                                  parameter, defaultVal, 
                                                  true , setSize) ;
    }
    
    bool parameterSet( const std::string& name ) ;
    
    

    template <class T>
    void message(  const std::string& message ) const {
      

      if( streamlog::out.template write<T>() ) 
        streamlog::out() << message << std::endl ;
      
    }
    

    template <class T>
    inline void message( const std::basic_ostream<char, std::char_traits<char> >& m) const {

     if( T::active ){  // allow the compiler to optimize this away ...

       try{
         const std::stringstream& mess = dynamic_cast<const std::stringstream&>( m ) ; 

         this->template message<T>( mess.str() ) ;

       }
       catch( std::bad_cast ) {}
     }
    }

    std::stringstream& log() const ;


  private: // called by ProcessorMgr
    
    virtual void setProcessorParameters( StringParameters* parameters) {
        setParameters( parameters ) ;
    }
    
    virtual void updateParameters();

    virtual void setName( const std::string & name) { _processorName = name ; }
    
    virtual void setParameters( StringParameters* parameters) ; 
    
    virtual void baseInit() ;
    
    void setFirstEvent( bool isFirstEvent ) { _isFirstEvent =  isFirstEvent ; }

    // called internally
    
    void setLCIOInType(const std::string& colName,  const std::string& lcioInType) ;
    


    void setLCIOOutType(const std::string& collectionName,  const std::string& lcioOutType) ;
    

    const ProcParamMap& procMap() { return _map ; }  


    
  protected:

    std::string _description ;
    std::string _typeName  ;
    std::string _processorName ;
    StringParameters* _parameters ;

    ProcParamMap _map ;  
    bool _isFirstEvent ;
    LCIOTypeMap   _inTypeMap ;
    LCIOTypeMap   _outTypeMap ;

    //    mutable LogStream* _log ; 

  private:
    mutable std::stringstream* _str ;

    Processor() ; 
  
  };
 
} // end namespace marlin 

#endif

---