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"

//----- Marlin version macros are now defined in MarlinConfig.h generated by cmake -----
#include "marlin/MarlinConfig.h"

#include "streamlog/streamlog.h"

#include <map>
#include <memory>

// ----- define some useful macros-----------
// for backward compatibility - use streamlog_out( MESSAGE )  instead 
// - this conflicts with a boost header und should not be used by now anywhere ...
//#define m_out( VERBOSITY ) streamlog_out( VERBOSITY )  
//#define m_endl std::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 ;

  private:
    //prevent users from making (default) copies of processors
    Processor(const Processor& /*typeName*/) = delete;
    Processor& operator=(const Processor& /*typeName*/) = delete;

  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 const std::string & logLevelName() const { return _logLevelName ; } 


    virtual std::shared_ptr<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) ;
    
    virtual void setParameters( std::shared_ptr<StringParameters> parameters) ;

    virtual void setName( const std::string & processorName) { _processorName = processorName ; }

  protected:

    void setReturnValue( bool val) ;

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


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

    void registerInputCollections(const std::string& collectionType,
                                  const std::string& parameterName, 
                                  const std::string& parameterDescription,
                                  StringVec& parameter,
                                  const StringVec& defaultVal,
                                  int setSize=0 ) {
      
      setLCIOInType( parameterName , collectionType ) ;
      registerProcessorParameter( parameterName, parameterDescription, parameter, defaultVal, setSize ) ; 
    }
    
    template<class T>
    void registerOptionalParameter(const std::string& parameterName, 
                                   const std::string& parameterDescription,
                                   T& parameter,
                                   const T& defaultVal,
                                   int setSize=0 ) {

      checkForExistingParameter( parameterName );
      _map[ parameterName ] = new ProcessorParameter_t<T>( parameterName , parameterDescription, 
                                                  parameter, defaultVal, 
                                                  true , setSize) ;
    }
    
    bool parameterSet( const std::string& name ) ;
    
    void checkForExistingParameter( const std::string& parameterName ) {
       auto paraIt = _map.find( parameterName );
       if (paraIt != _map.end() ) {
         std::stringstream errorMessage;
         errorMessage << "Parameter " << parameterName
                      << " already defined for processor "
                      << this->type()
                      << std::endl;
         throw std::logic_error(  errorMessage.str() );
       }
    }

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

      if( streamlog::out.template write<T>() ) 
        streamlog::out() << m << 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( std::shared_ptr<StringParameters> processorParameters) {
        setParameters( processorParameters ) ;
    }
    
    virtual void updateParameters();
    
    virtual void baseInit() ;
    
    void setFirstEvent( bool firstEvent ) { _isFirstEvent =  firstEvent ; }

    // 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="";
    std::shared_ptr<StringParameters> _parameters{};

    ProcParamMap _map{};
    bool _isFirstEvent = false;
    LCIOTypeMap   _inTypeMap{};
    LCIOTypeMap   _outTypeMap{};

    std::string _logLevelName{};
    
  private:
    mutable std::stringstream* _str=NULL;

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

#endif