MarlinSteerCheck.h

#ifndef MARLINSTEERCHECK_H
#define MARLINSTEERCHECK_H

#include "marlin/CCProcessor.h"
#include "marlin/CCCollection.h"
#include "marlin/CMProcessor.h"
#include "marlin/XMLParser.h"

//comment out the line below if your terminal
//doesn't support colored output
#define TERM_COLOR

#ifdef TERM_COLOR

#define clrscr() printf("\033[2J")
#define dblue() printf("\x1b[34m")
#define dred() printf("\x1b[31m")
#define dyellow() printf("\x1b[33m")
#define dgreen() printf("\x1b[32m")
#define dunderline() printf("\x1b[4m")
#define ditalic() printf("\x1b[3m")
#define ddunkel() printf("\x1b[2m")
#define dhell() printf("\x1b[1m")
#define dblink() printf("\x1b[5m")
#define endcolor() printf("\x1b[m")

#else

#define clrscr()
#define dblue()
#define dred()
#define dyellow()
#define dgreen()
#define dunderline()
#define ditalic()
#define ddunkel()
#define dhell()
#define dblink()
#define endcolor()

#endif

#define MAXEVENTS 30

namespace marlin {

  class CCCollection;
  class CCProcessor;

  typedef std::vector< CCProcessor* > ProcVec;

  class MarlinSteerCheck{

  public:

    // Constructor
    MarlinSteerCheck( const char* steerFileName=NULL, const CommandLineParametersMap * cmdlineparams=NULL );

    // Destructor
    ~MarlinSteerCheck();

    CMProcessor* getMProcs() { return _marlinProcs; };
    
    ProcVec& getAProcs() { return _aProc; };
    
    ProcVec& getIProcs() { return _iProc; };

    int existsProcessor( const std::string& type, const std::string& name="" );
    
    ColVec& getLCIOCols() const;
    
    StringVec& getLCIOFiles(){ return _lcioFiles; }

    sSet& getColsSet( const std::string& type, const std::string& name, CCProcessor* proc );

    StringParameters* getGlobalParameters(){ return _gparam; }
    
    void dumpColErrors( unsigned int i, std::ostream& stream, bool separators=false );
  
    int addLCIOFile( const std::string& file );

    void remLCIOFile( const std::string& file );
    
    void changeLCIOFilePos( unsigned int pos, unsigned int newPos );
 
    void addProcessor( bool status, const std::string& name, const std::string& type, StringParameters* p=NULL );

    void remProcessor( unsigned int index, bool status );

    void activateProcessor( unsigned int index );
    
    void deactivateProcessor( unsigned int index );

    void changeProcessorPos( unsigned int pos, unsigned int newPos );
    
    void consistencyCheck();

    bool saveAsXMLFile( const std::string& file );

    /* Returns the relative path of the XML file */
    const std::string getXMLFileRelPath(){ return _XMLFileRelPath; }
    
    /* Returns the absolute path of the XML file */
    const std::string getXMLFileAbsPath(){ return _XMLFileAbsPath; }
    
    /* Returns the XML fileName */
    const std::string getXMLFileName(){ return _XMLFileName; }
    
    /* Returns the XML file as given by the user in the command prompt */
    const std::string getXMLFile(){ return _steeringFile; }
    
    void dump_information();

    sSet& getErrors(){ return _errors; };

    sSet& getPConditions(){ return _pConditions; };

    const std::string getCondition( unsigned int index );
    
    void addCondition( const std::string& condition );
    
    void repCondition( const std::string& oldCond, const std::string& newCond );
    
    void remCondition( const std::string& condition );
    
    bool saveAsDOTFile(const std::string& file);
    
  private:
    
    //METHODS

    // Return all available collections from the active or inactive processors
    ColVec& getProcCols( const ProcVec& v, const std::string& iotype ) const;

    // Return all available collections found in LCIO files and active/inactive processors
    ColVec& getAllCols() const;
   
    // Return all available collections found in LCIO files and active/inactive processors
    ProcVec& getAllProcs() const;
    
    // Parse the given steering file
    bool parseXMLFile( const std::string& file, const CommandLineParametersMap * cmdlineparams=NULL );
    
    // Pop a processor out of a vector from processors
    CCProcessor* popProc(ProcVec& v, CCProcessor* p);

    // Find matching collections of a given type and value in a vector of collections for a given processor
    ColVec& findMatchingCols( ColVec& v, CCProcessor* srcProc, 
            const std::string& type, const std::string& value="UNDEFINED", const std::string& name="UNDEFINED" );
    
    //VARIABLES

    sSet _errors;                       //XML File parsing error
                                        //LCIO Files loading error
                                        //GEAR File loading error
                                        //Some Processors have no parameters
                                        //Some Active Processors are not installed
                                        //Some Active Processors have collection errors
                                        //Warning: Some Inactive Processors are not installed

    IParser* _parser;                   //parser
    StringParameters* _gparam;          //global parameters (without LCIO Files)
    
    std::string _steeringFile;          //steering file name + path as passed by the user in the command line
    std::string _XMLFileName;           //steering file name
    std::string _XMLFileAbsPath;        //steering file (absolute path without filename)
    std::string _XMLFileRelPath;        //steering file (relative path without filename)

    ProcVec _aProc;                     //active processors
    ProcVec _iProc;                     //inactive processors
    sColVecMap _lcioCols;               //LCIO collections
    StringVec _lcioFiles;               //LCIO filenames
    
    sSet _colValues;                    //all available collection values for a given type (use in ComboBox)

    sSet _pConditions;                  //all processor's conditions

    CMProcessor* _marlinProcs;          //Sigleton class containing all marlin processors
  };

} // namespace
#endif