// $Source: /usr/local/SimSoft/Sfx3D/src/gts/gtstzt.h,v $
// $Revision: 1.2 $
// $Author: baum $
// $Date: 2001/11/29 15:18:10 $
//
// Login name of the user who locked the revision
// $Locker:  $
// Tag name used to checkout the file
// $Name: Release-14 $
// State assigned to revision
// $State: Exp $
//
//
// $Log: gtstzt.h,v $
// Revision 1.2  2001/11/29 15:18:10  baum
// -Realzeitsteuerung eingebaut
// -Handsteuerung eingebaut
//

#ifndef _GTSTZT_H
#define _GTSTZT_H     1

#include "Strings.h"
#include "List.h"

#include "XGraph/Select.h"
#include "XGraph/Parent.h"
#include "XGraph/GeoObj.h"
#include "XGraph/Space.h"

#include "gtsbst.h"
#include "gtstlm.h"
#include "gtstas.h"

//==================================================================
//		Definition
//		for baseclass Zeit
//==================================================================

class Zeit  {
  public:
    Zeit  ();
    Zeit  (unsigned int dd, unsigned int hh, unsigned int mm,
           unsigned int ss, unsigned int hs);
    Zeit  (const Zeit& copy);
    ~Zeit () { };
    void operator = (const Zeit& copy);
    int  operator > (const Zeit& time) const;
    int  operator < (const Zeit& time) const;
    void read       (InputFile& fin);
    void write      (ostream& ostrm) const;
    Ustring getZeit (const unsigned art = 0);
    Ustring setZeit (Ustring str, const unsigned art = 0);

  protected:
    void Pruefe ();
    unsigned int Tage;
    unsigned int Stunde;
    unsigned int Minute;
    unsigned int Sekunde;
    unsigned int HundertstelSekunde;
};  // ENDE Zeit

//==================================================================
//		Definition
//		for abstract baseclass Ereignis
//==================================================================

class Ereignis
{
  public:
    Ereignis  ();
    void setNr (int nr)  { Nr = nr;   };
    int  getNr ()        { return Nr; };
    Zeit getModellzeit   () { return Modellzeit; };

    virtual bool read     (InputFile& fin, Zeit zeit, int etyp) = 0;
    virtual void write    (ostream& ostrm, int& satznr) = 0;
    virtual typBaustein*   AufBaustein    () { return NULL; };
    virtual Prozess*       AufProzess     () { return NULL; };
    virtual Arbeitsplan*   AufArbeitsplan () { return NULL; };
    virtual Ustring        getInfo (const unsigned art = 0) = 0;
    virtual bool setEreignis (Ustring str) = 0;
    virtual ~Ereignis () { };

  protected:
    Ereignis  (const Ereignis& copy);
    void operator = (const Ereignis& copy);

    int  Typ;
    int  Nr;
    Zeit Modellzeit;
};  // ENDE Ereignis

//==================================================================
//		Definition
//		for class BstEreignis
//==================================================================

class BstEreignis : public Ereignis {
  public:
    BstEreignis  ();
    typBaustein* AufBaustein () { return zbst; };
   ~BstEreignis ();

    virtual bool    read     (InputFile& fin, Zeit zeit, int etyp);
    virtual void    write    (ostream& ostrm, int& satznr);
    virtual Ustring getInfo  (const unsigned art = 0);
    virtual bool setEreignis (Ustring str);

  protected:
    BstEreignis  (const BstEreignis& copy);
    void operator = (const BstEreignis& copy);

    typBaustein *zbst;
};  // ENDE BstEreignis

//==================================================================
//		Definition
//		for class ProzessEreignis
//==================================================================

class ProzessEreignis : public Ereignis {
  public:
    ProzessEreignis  ();
    Prozess* AufProzess () { return zprozess; };
   ~ProzessEreignis ();

    virtual bool    read    (InputFile& fin, Zeit zeit, int etyp);
    virtual void    write   (ostream& ostrm, int& satznr);
    virtual Ustring getInfo (const unsigned art = 0);
    virtual bool setEreignis (Ustring str);

  protected:
    ProzessEreignis  (const ProzessEreignis& copy);
    void operator = (const ProzessEreignis& copy);

    Prozess *zprozess;
};  // ENDE ProzessEreignis

//==================================================================
//		Definition
//		for class AblaufplanEreignis
//==================================================================

class ArbeitsplanEreignis : public Ereignis {
  public:
    ArbeitsplanEreignis  ();
    Arbeitsplan* AufArbeitsplan () { return zarbeitsplan; };
   ~ArbeitsplanEreignis ();

    virtual bool    read    (InputFile& fin, Zeit zeit, int etyp);
    virtual void    write   (ostream& ostrm, int& satznr);
    virtual Ustring getInfo (const unsigned art = 0);
    virtual bool setEreignis (Ustring str);

  protected:
    ArbeitsplanEreignis  (const ArbeitsplanEreignis& copy);
    void operator = (const ArbeitsplanEreignis& copy);

    int ObjAnzahl;
    Arbeitsplan *zarbeitsplan;
};  // ENDE ArbeitsplanEreignis

//==================================================================
//		Definition
//		for class AllgemeinEreignis
//==================================================================

class AllgemeinEreignis : public Ereignis {
  public:
    AllgemeinEreignis  ();
   ~AllgemeinEreignis ();

    virtual bool read  (InputFile& fin, Zeit zeit, int etyp);
    virtual void write (ostream& ostrm, int& satznr);
    virtual Ustring getInfo (const unsigned art = 0);
    virtual bool setEreignis (Ustring str);

  protected:
    AllgemeinEreignis  (const AllgemeinEreignis& copy);
    void operator = (const AllgemeinEreignis& copy);

    int info1;
    int info2;
    int info3;
};  // ENDE AllgemeinEreignis

//==================================================================
//		Definition
//		for class EreignisVerwaltung
//==================================================================

class EreignisVerwaltung {
 public:
    EreignisVerwaltung  () : EreignisListe(), SimEnde (1, 0, 0, 0, 0) { };
    ~EreignisVerwaltung ();

    Ustring getSimulationEnde (const unsigned art = 0);
    Ustring setSimulationEnde (Ustring str, const unsigned art = 0);
    Ustring Erzeugen  (Ustring str);
    Ustring Aendern   (Ustring str);
    void nachOben  (int enummer);
    void nachUnten (int enummer);

    bool read               (Ustring datname);
    void write              (Ustring datname) const;

    void loeschen               (int enummer);
    void loeschen               ();
    void TZTmitBausteinLoeschen (typBaustein* zbstein);
    void TZTmitProzessLoeschen  (Prozess* zprozess);

    Ustring Info   ();
    Ustring Select (int enummer);

  protected:
    Ereignis* Erzeuge (int etyp);
    List<Ereignis> EreignisListe;
    Zeit SimEnde;

    void EinGliedern (Ereignis &zereignis);
    Ereignis* Suche  (typBaustein* zbst);
    Ereignis* Suche  (int enr);

    void readSimulationEnde (InputFile& fin);

}; // EreignisVerwaltung

#endif /* _GTSTZT */
