CCProcessor.h

#ifndef CCPROCESSOR_H
#define CCPROCESSOR_H

#include "marlin/Processor.h"

#include <set>
#include <fstream>

#define MAX_ERRORS 3
#define ACTIVE true
#define INACTIVE false
#define NO_PARAMETERS 0
#define NOT_INSTALLED 1
#define COL_ERRORS 2
#define INPUT "lcioInType"
#define OUTPUT "lcioOutType"
#define UNAVAILABLE "lcioUnavailableType"
#define DUPLICATE "lcioDuplicate"

namespace marlin {

  class CCCollection;

  typedef std::set< std::string > sSet;
  typedef std::vector< CCCollection* > ColVec;
  typedef std::map< std::string, std::string > ssMap;
  typedef std::map< std::string, ssMap > sssMap;
  typedef std::map< std::string, ColVec > sColVecMap;
  typedef std::map< std::string, sColVecMap > ssColVecMap;

  class CCProcessor{

  public:

    // Constructor
    CCProcessor( bool status, const std::string& name, const std::string& type, std::shared_ptr<StringParameters> p);

    // Copy Constructor
    CCProcessor( CCProcessor &p );
    
    // Destructor
    ~CCProcessor();

    // assignment operator, unused, verboten
    CCProcessor& operator=( const CCProcessor &) = delete;
    
    bool hasErrors();
    
    bool hasParameters(){ return !_error[ NO_PARAMETERS ]; }
    
    bool hasErrorCols(){ return _error[ COL_ERRORS ]; }

    bool isInstalled(){ return !_error[ NOT_INSTALLED ]; }

    bool isActive(){ return _status; }

    bool hasCondition( const std::string& condition );

    const std::string& getName(){ return _name; }

    const std::string& getType(){ return _type; }

    sSet& getConditions(){ return _conditions; }

    const std::string getDescription(){ return (isInstalled() ? _proc->description() : 
            "This processor is NOT installed in your Marlin binary: parameter descriptions and types lost!!");
    }
    
    /* Returns a string vector with the errors of the processor - Obsolete: use getError() instead */
    //const StringVec& getErrors(){ return _errors; }
    
    const std::string getError(){ return ( _errors.size() != 0 ? _errors[0] : "" ); }
    
    const std::string getStatusDesc(){ return ( isActive() ? "Active" : "Inactive" ); }
    
    bool isErrorCol( const std::string& type, const std::string& value );
    
    bool isParamOptional( const std::string& key );
    
    std::shared_ptr<StringParameters> getParameters(){ return _param; }
    
    const ssMap& getColHeaders( const std::string& iotype ){ return _types[iotype]; }

    ColVec& getCols( const std::string& iotype, const std::string& type_name="ALL_COLLECTIONS" );

    sSet& getColTypeNames( const std::string& iotype );
    
    void addCol( const std::string& iotype, const std::string& name, const std::string& type, const std::string& value );

    void remCol( const std::string& iotype, const std::string& name, unsigned int index );

    void addUCol( CCCollection* c );
   
    void addDCol( CCCollection* c );
   
    void changeStatus();

    void setName( const std::string& name ){ _name = name; };
    
    void setConditions( const std::string& conditions );
    
    void setError( int error );

    void clearError( int error );

    void setOptionalParam( const std::string& key, bool optional=true );
    
    void writeToXML( std::ofstream& stream );

  private:

    // METHODS
    void addColsFromParam( std::shared_ptr<StringParameters> p );
    void writeColsToParam();
    void clearParameters();
    void setMarlinProc();           //sets error flag NOT_INSTALLED if processor couldn't be set
    CCCollection* popCol( ColVec& v, CCCollection* c );   

    // VARIABLES
    bool _status;                   // false = INACTIVE ; true = ACTIVE
    std::vector<bool> _error;       // 0 = proc has no parameters; 1 = proc is not build in this marlin installation; 2 = unavailable collections
    std::string _name;              // name of the processor
    std::string _type;              // type of the processor
    std::shared_ptr<StringParameters> _param;       // parameters from processor
    Processor* _proc;               // associated Marlin processor
 
    const StringVec _error_desc{ "Processor has no Parameters", "Processor not available!", "Some Collections have Errors"}; // error descriptions for all processors
    StringVec _errors{};            // list of errors found in a processor

    sSet _conditions;               // processor's conditions
  
    ssColVecMap _cols;      // first key for Types INPUT : OUTPUT : UNAVAILABLE : DUPLICATE
                                    // for INPUT/OUPUT the second key is for Collection Names
                                    // for UNAVAILABLE/DUPLICATE the second key is for Collection Types

    sssMap _types;                  // first key for Types INPUT : OUTPUT
                                    // second key is for Collection Names and the third string for Collection Types

    sSet _optParams;                // list of optional parameters that shall be written out as normal parameters
  };

} // end namespace marlin
#endif