Processor.h

// -*- mode: c++; mode: auto-fill; mode: flyspell-prog; -*-

#ifndef Processor_h
#define Processor_h 1

#include "gloria/GloriaDataContainer.h"

#include "StringParameters.h"
#include "ProcessorParameter.h"

#include "streamlog/streamlog.h"

#include <map>

using namespace gloria ;


namespace luiza{

  class ProcessorMgr ;
  //  class ProcessorParameter ;
  class XMLFixCollTypes ;

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


  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 startAnalysis( GloriaDataContainer* ) { } 


    virtual void processData( GloriaDataContainer* ) { } 


    virtual void check( GloriaDataContainer* ) { }



    virtual void concludeAnalysis( GloriaDataContainer* ) { } 


    virtual void end(){ }
  

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

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

    virtual const std::string & logLevelName() const { return _logLevelName ; } 


    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 ; } ;
    

     GloriaCollectionType getGloriaInType( const std::string& colName ) ;


     GloriaCollectionType getGloriaOutType( 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 GloriaCollectionType& type,
                                 const std::string& name, 
                                 const std::string& description,
                                 std::string& parameter,
                                 const std::string& defaultVal,
                                 int setSize=0 ) {
      
      setGloriaInType( name , type ) ;
      registerProcessorParameter( name, description, parameter, defaultVal, setSize ) ; 
    }
    

    void registerOutputCollection(const GloriaCollectionType& type,
                                  const std::string& name, 
                                  const std::string& description,
                                  std::string& parameter,
                                  const std::string& defaultVal,
                                  int setSize=0 ) {
      
      setGloriaOutType( name , type ) ;
      registerProcessorParameter( name, description, parameter, defaultVal, setSize ) ; 
    }


    void registerInputCollections(const GloriaCollectionType& type,
                                  const std::string& name, 
                                  const std::string& description,
                                  StringVec& parameter,
                                  const StringVec& defaultVal,
                                  int setSize=0 ) {
      
      setGloriaInType( 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 ) {}
     }
    }

     /* @deprecated
     */
    std::stringstream& log() const ;


  protected:  // need to be accessible from derived classes as well

    virtual void setProcessorParameters( StringParameters* parameters) {
        setParameters( parameters ) ;
    }
    
    virtual void updateParameters();


    virtual void updateTelescopeParameters(std::string name );



    virtual void updateTelescopeParameters(GloriaFitsHeader* header);


  private: // called by ProcessorMgr
    
    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 setGloriaInType(const std::string& colName,  const  GloriaCollectionType& gloriaInType) ;
    


    void setGloriaOutType(const std::string& collectionName,  const  GloriaCollectionType& gloriaOutType) ;
    

    const ProcParamMap& procMap() { return _map ; }  


    
  protected:

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

    ProcParamMap _map ;  
    bool _isFirstEvent ;
    GloriaTypeMap   _inTypeMap ;
    GloriaTypeMap   _outTypeMap ;

    std::string _logLevelName ;
    
  private:
    mutable std::stringstream* _str ;

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

#endif