ConfigParser.h

Go to the documentation of this file.

#ifndef CONFIGPARSER_H
#define CONFIGPARSER_H
/*********************************************/
/*            Konfigurations Parser          */
/*********************************************/

// Parser Version
extern const char* PARSER_VERSION;

/*********************************************/
#ifdef _MSC_VER
#pragma warning(disable : 4786)
#endif

#include <string>
#include <fstream>
#include <list>

#include "Bath.h"

/*********************************************/
enum BufferStrategie {LinksRechts=0, LinksPrior, Nacheinander, Fairness, OfenPrior, SpeicherOpt1, SpeicherOpt2, Multi, unknownStrat};
extern const char* strBufferStrategie[unknownStrat];

class Tokenizer {
public:
        Tokenizer() : errorString(""), commentStarter("//"), whitespace(" ,\t"), tokenAndWhitespace("=") {};

        // Scaner
        bool tokenize(const std::string inputLine); // Gibt false zurück, wenn ein Fehler auftrat

        // Fehlerbehandlung     
        const std::string& getError() const {return errorString;}

        // Token
        unsigned int getTokenNumber() const {return tokenList.size();}
        const std::string& getToken(unsigned int index) const;
        int getTokenPos(unsigned int index) const;

protected:
        // Implementation
        std::string errorString;                        // Fehlerbeschreibung
                
        std::list<std::string> tokenList;       // Tokenliste
        std::list<unsigned int> tokenPos;       // Tokenposition in Eingabezeile
        std::string line;                                       // Eingabe

        // Einstellungen
        std::string commentStarter;                     // Anfang von Kommentaren (Rest der Zeile wird ignoriert)
        std::string whitespace;                         // Trennzeichen für Token
        std::string tokenAndWhitespace  ;       // Trennzeichen und Token
};

/*********************************************/
class ConfigParser : public Tokenizer {
public:
        ConfigParser();

        // Fehlerbehandlung     
        unsigned int getErrorPos() const {return errorPos;}

        // Parse
        bool parse(std::ifstream& configFile); // Gibt false zurück, wenn ein Fehler auftrat

        // Voreinstellung
        void reset();

        // Konfiguration
        // Beladungszeiten
        double getRequestDELAY() const {return requestDELAY;}                           // Umrüstzeit

        // Fahrzeiten in der Pufferstrecke
        double getDRIVE_ORIGIN_LEFT() const {return DRIVE_ORIGIN_LEFT;} // Dauer:[15m] Beladeposition - linke Startposition
        double getDRIVE_ORIGIN_RIGHT() const {return DRIVE_ORIGIN_RIGHT;}       // Dauer:[15m] Beladeposition - rechte Startposition
        double getDRIVE_THROUGH() const {return DRIVE_THROUGH;}                 // Dauer: in der - Pufferstrecke 
        double getDRIVE_LEFT_RIGHT() const {return DRIVE_LEFT_RIGHT;}           // Dauer: von linker Endposition - Endladeposition
        double getDRIVE_RIGHT_FINAL() const {return DRIVE_RIGHT_FINAL;} // Dauer: von rechter Endposition - Endladeposition
        double getDRIVE_RIGHT_RETURN() const {return DRIVE_RIGHT_RETURN;}       // Dauer: Entladeposition - Rückfahrposition
        double getDRIVE_LEFT_RETURN() const {return DRIVE_LEFT_RETURN;} // Dauer: Entladeposition - Rückfahrposition

        // Ofenkonfiguration [0..9]
        unsigned int getOVEN_CONFIG(unsigned int i) const {return OVEN_CONFIG[i];}

        
        double getSHIFT() const  {return SHIFT;}                                                                // Versatz zwischen zwei Ofenstarts 
        double getONPALETTE(int variante) const {return 60 * ONPALETTE[variante];}
        double getOVEN1    (int variante) const {return 60 * OVEN1[variante];}
        double getCHILL    (int variante, BathType bath) const;
        
        double getOVEN2    (int variante) const {return 60 * OVEN2[variante];}
        double getCOOLING  (int variante) const {return 60 * COOLING[variante];}

        double getH2O_CHILL()           { return H2O_CHILL; }
        double getH2OAIRH2O_CHILL() { return H2OAIRH2O_CHILL; }
        double getH2OPOLYMER_CHILL(){ return H2OPOLYMER_CHILL; }
        double getPOLYMER_CHILL()       { return POLYMER_CHILL; }
        double getAIR_CHILL()           { return AIR_CHILL; }
        double getVENTILATOR_CHILL(){ return VENTILATOR_CHILL; }


        // Kranfahrzeiten
        bool getNO_CRANE_TIME() const {return NO_CRANE_TIME;}           // Kran verbraucht kein Zeit

        // Leere Paletten
        double getEMPTY_PALETTIES_DELAY() const {return EMPTY_PALETTIES_DELAY;} // Erzeuge leere Paletten

        // Buffer Schiebestrategie
        BufferStrategie getBUFFERSchiebeStrategie() const {return BUFFERSchiebeStrategie;} // Abwechselnd (LeftRight), Nacheinander(LeftFullRight)

        // Bäder
        bool getBADUmfuellen() const {return BADUmfuellen;} // Kann Bad nach Bedarf umgefuellt werden
        double getBADUmfuellzeit() const {return BADUmfuellzeit;} // Zeitbedarf für das Umfuellen des Bades
        int getBADkapazitaet() const {return BADkapazitaet;} // Einzel oder Doppelbäder

        // Berichte
        bool getBERICHTAuftraege() const {return BERICHTAuftraege;} // Auftraegebericht
        bool getBERICHTPuffer() const {return BERICHTPuffer;}       // Pufferstatistik
        bool getBERICHTWaermebehandlungen() const {return BERICHTWaermebehandlungen;} // Pufferstatistik
        bool getBERICHTPaletten() const {return BERICHTPaletten;} // Palettenstatistik
        bool getBERICHTUeberlaeufe() const {return BERICHTUeberlaeufe;} // zeitliche Überlappungen im Lastprofil


        // Vorausschau
        double getOFENVORSCHAU() const {return OFENVORSCHAU;} // Ofenvorschau

protected:
        // Implementation
        unsigned int errorPos;                  // Fehlerbeschreibung

        // Konfiguration (wird durch parse Initialisiert)
        // Beladungszeiten
        double requestDELAY;

        // Fahrzeiten in der Pufferstrecke
        double DRIVE_ORIGIN_LEFT;
        double DRIVE_ORIGIN_RIGHT;
        double DRIVE_THROUGH;
        double DRIVE_LEFT_RIGHT;
        double DRIVE_RIGHT_FINAL;
        double DRIVE_RIGHT_RETURN;
        double DRIVE_LEFT_RETURN;

        // Ofenkonfiguration
        unsigned int OVEN_CONFIG[9];


        double SHIFT;

        double ONPALETTE[5];
        double OVEN1[5];        
        double CHILL[5];        
        double OVEN2[5];
        double COOLING[5];

        // Abschreckzeiten
        double H2O_CHILL;
        double H2OAIRH2O_CHILL;
        double H2OPOLYMER_CHILL;
        double POLYMER_CHILL;
        double AIR_CHILL;
        double VENTILATOR_CHILL;

        // Kranfahrzeiten
        bool NO_CRANE_TIME;

        // Leere Paletten
        double EMPTY_PALETTIES_DELAY;

        // Buffer strategie     
        BufferStrategie BUFFERSchiebeStrategie;

        // Baeder
        bool BADUmfuellen;
        double BADUmfuellzeit;
        int BADkapazitaet;

        // zusätzliche Berichte
        bool BERICHTAuftraege;
        bool BERICHTPuffer;
        bool BERICHTWaermebehandlungen;
        bool BERICHTPaletten;
        bool BERICHTUeberlaeufe;

        // Vorausschau
        double OFENVORSCHAU;
};

/*********************************************/
class ExperimentParser : public Tokenizer {
public:
        ExperimentParser();

        // Fehlerbehandlung     
        unsigned int getErrorPos() const {return errorPos;}

        // Parse
        bool parse(std::ifstream& experimentFile); // Gibt false zurück, wenn ein Fehler auftrat

        // Voreinstellung
        void reset();

        // Konfiguration
        // Dateinamen
        const std::string& getLAST_DATEINAME() const {return LAST_DATEINAME;} // Auftragsliste
        const std::string& getCONFIG_DATEINAME() const {return CONFIG_DATEINAME;} // Technologie-Konfiguration

        // Pausen- und Wartungszeit je Schicht
        double getPAUSENLAENGE() const {return PAUSENLAENGE;}
        double getSCHICHTWARTUNG() const {return SCHICHTWARTUNG;}

        // Produktionszeiten
        unsigned int getTimeSlicesCount() const {return START_DATE.size();}
        const std::string& getSTART_DATE(unsigned int i) const;
        const std::string& getEND_DATE(unsigned int i) const;   

#ifdef _USE_CORBA
        // Experimentkonfiguration wird vom Animator übernommen
        void setLAST_DATEINAME(const char* last) {LAST_DATEINAME = last;}
        void setCONFIG_DATEINAME(const char* tech) {CONFIG_DATEINAME = tech;}
        void setPAUSENLAENGE(double l) {PAUSENLAENGE = l;}
        void setSCHICHTWARTUNG(double w) {SCHICHTWARTUNG = w;}
        void clearSTART_DATE() {START_DATE.clear();}
        void clearEND_DATE() {END_DATE.clear();}
        bool addSTART_DATE(const char* date) {std::string sd = date; if (!isValidDateTime(sd)) return false; START_DATE.push_back(sd); return true;}
        bool addEND_DATE(const char* date) {std::string sd = date; if (!isValidDateTime(sd)) return false; END_DATE.push_back(sd); return true;}
#endif

        bool isValidDateTime(const std::string& dateTime);
protected:
        // Implementation
        unsigned int errorPos;                  // Fehlerbeschreibung

        // Konfiguration (wird durch parse Initialisiert)
        // Lastdatei
        std::string LAST_DATEINAME;
        int     LAST_DATEITYPE;

        // Technologie-Konfiguration
        std::string CONFIG_DATEINAME;

        // Pausen- und Wartungszeit je Schicht
        double PAUSENLAENGE;
        double SCHICHTWARTUNG;

        // Datum/Zeit Einstellungen
        std::list<std::string> START_DATE;
        std::list<std::string> END_DATE;        
};

// Experiment (Dateinamen, Produktionszeiten)
extern ExperimentParser experiment;

// Konfiguration (Zeiten, Schalter, Ofenkonfiguration)
extern ConfigParser conf;

#endif

---