// $Source: /usr/local/SimSoft/Sfx3D/src/gts/gtstzt.cpp,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.cpp,v $
// Revision 1.2  2001/11/29 15:18:10  baum
// -Realzeitsteuerung eingebaut
// -Handsteuerung eingebaut
//

/*** Windows headers ***/
#ifdef WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#undef WIN32_LEAN_AND_MEAN
//#include <winnt.h>
#endif /*WIN32*/

#include "gtstzt.h"             

//==================================================================
//		Declaration
//		for baseclass Zeit
//==================================================================

Zeit::Zeit (): Tage (0), Stunde (0), Minute (0),
               Sekunde (0), HundertstelSekunde (0)
{ }

Zeit::Zeit (unsigned int dd, unsigned int hh, unsigned int mm,
            unsigned int ss, unsigned int hs) :
            Tage (dd), Stunde (hh), Minute (mm),
            Sekunde (ss), HundertstelSekunde (hs)
{ }
             
Zeit::Zeit  (const Zeit& copy)
  : Tage   (copy.Tage),   Stunde  (copy.Stunde),
    Minute (copy.Minute), Sekunde (copy.Sekunde),
    HundertstelSekunde (copy.HundertstelSekunde)
{ }

void Zeit::operator = (const Zeit& copy)
{
  Tage    = copy.Tage;
  Stunde  = copy.Stunde;
  Minute  = copy.Minute;
  Sekunde = copy.Sekunde;
  HundertstelSekunde = copy.HundertstelSekunde;
}
int Zeit::operator > (const Zeit& time) const
  {
  return (Tage > time.Tage) ||
         ( (Tage == time.Tage) && (Stunde >  time.Stunde) ) ||
         ( (Tage == time.Tage) && (Stunde == time.Stunde) &&
           (Minute > time.Minute) ) ||
         ( (Tage == time.Tage) && (Stunde == time.Stunde) &&
           (Minute == time.Minute) && (Sekunde > time.Sekunde) ) ||
         ( (Tage == time.Tage) && (Stunde == time.Stunde) &&
           (Minute == time.Minute) && (Sekunde == time.Sekunde) &&
           (HundertstelSekunde > time.HundertstelSekunde) );
  }

int Zeit::operator < (const Zeit& time) const
  {
  return (Tage < time.Tage) ||
         ( (Tage == time.Tage) && (Stunde <  time.Stunde) ) ||
         ( (Tage == time.Tage) && (Stunde == time.Stunde) &&
           (Minute < time.Minute) ) ||
         ( (Tage == time.Tage) && (Stunde == time.Stunde) &&
           (Minute == time.Minute) && (Sekunde < time.Sekunde) ) ||
         ( (Tage == time.Tage) && (Stunde == time.Stunde) &&
           (Minute == time.Minute) && (Sekunde == time.Sekunde) &&
           (HundertstelSekunde < time.HundertstelSekunde) );
  }

void Zeit::Pruefe  ()
{
  while (HundertstelSekunde >= 100)
  {
    Sekunde++;
    HundertstelSekunde -= 100;
  }
  while (Sekunde >= 60)
  {
    Minute++;
    Sekunde -= 60;
  }
  while (Minute >= 60)
  {
    Stunde++;
    Minute -= 60;
  }
  while (Stunde >= 24)
  {
    Tage++;
    Stunde -= 24;
  }
}  // ENDE Pruefe

void Zeit::read  (InputFile& fin)
{
  SFXToken tok;
  tok.nextToken (fin);  Tage               = atoi (tok());
  tok.nextToken (fin);  Stunde             = atoi (tok());
  tok.nextToken (fin);  Minute             = atoi (tok());
  tok.nextToken (fin);  Sekunde            = atoi (tok());
  tok.nextToken (fin);  HundertstelSekunde = atoi (tok());
}  // ENDE read

void Zeit::write (ostream& ostrm) const
{
  Write (ostrm, "%5d ", Tage);
  Write (ostrm, "%2d ", Stunde);
  Write (ostrm, "%2d ", Minute);
  Write (ostrm, "%2d ", Sekunde);
  Write (ostrm, "%2d ", HundertstelSekunde);
}  // ENDE write

Ustring Zeit::getZeit (const unsigned art)
{
  char tmp [512];
  if (art == 0)
    sprintf(tmp, "%4d:%2d:%2d:%2d:%3d", Tage, Stunde, Minute,
                  Sekunde, HundertstelSekunde);
    else
    sprintf(tmp, "%d %d %d %d %d", Tage, Stunde, Minute,
                  Sekunde, HundertstelSekunde);
  Ustring buf(tmp);
  return buf;
}  // ENDE getZeit

Ustring Zeit::setZeit (Ustring str, const unsigned art)
{
  sscanf((char*)str.str(), " %i %i %i %i %i",
         &Tage, &Stunde, &Minute, &Sekunde, &HundertstelSekunde);
  Pruefe();
  return getZeit(art);
}  // ENDE setZeit

//==================================================================
//		Declaration
//		for abstract baseclass Ereignis
//==================================================================

Ereignis::Ereignis  () : Typ (0), Nr (0)
{ }

Ereignis::Ereignis  (const Ereignis& copy) :
          Typ (copy.Typ), Nr (0), Modellzeit (copy.Modellzeit)
{ }


void Ereignis::operator = (const Ereignis& copy)
{
  Typ = copy.Typ;
  Nr  = 0;
}

//==================================================================
//		Declaration
//		for class BstEreignis
//==================================================================

BstEreignis::BstEreignis () : Ereignis (), zbst (NULL)
{ }

BstEreignis::BstEreignis (const BstEreignis& copy) : Ereignis (copy)
{
  zbst = copy.zbst;
}

BstEreignis::~BstEreignis ( )
{
  zbst = NULL;
}

void BstEreignis::operator = (const BstEreignis& copy)
{
  if (this == &copy) return;
  Ereignis::operator = (copy);
  zbst = copy.zbst;
}

bool BstEreignis::read (InputFile& fin, Zeit zeit, int etyp)
{
  SFXToken tok;
  Modellzeit = zeit;
  Typ        = etyp;
  tok.nextToken (fin);  int bstnr = atoi(tok());
  zbst  = BausteinListe->Suche (bstnr + LASTBSTNR);
  if (!zbst)
  {
    Meld.Ausgabe(9, bstnr+LASTBSTNR);
    tok.EndOfLine (fin);
    return false;
  }
   tok.EndOfLine (fin);
  return true;
} // ENDE read

void BstEreignis::write (ostream& ostrm, int& satznr)
{
  satznr++;
  Write (ostrm, "%4d   4  ", satznr);
  Modellzeit.write (ostrm);
  Write (ostrm, "%4d ", Typ);
  Write (ostrm, "%8d ", zbst->i_BstNr());
  Write (ostrm, "%s\n", "     0      0");
}  // ENDE write

Ustring BstEreignis::getInfo (const unsigned art)
{
  char tmp [256];
  if (art == 0)
    sprintf (tmp, "{%d {%s} %d %d %d %d}\t",
                   Nr, (char*)Modellzeit.getZeit().str(),
                   Typ, zbst->i_BstNr(), 0, 0);
  else
    sprintf (tmp, "%d %s %d %d %d %d\t",
                   Nr,(char*)Modellzeit.getZeit(art).str(),
                   Typ, zbst->i_BstNr(), 0, 0);
  Ustring buf(tmp);
  return buf;
}  // ENDE getInfo

bool BstEreignis::setEreignis (Ustring str)
{
  int dmy, bstnr;
  sscanf((char*)str.str(), " %i %i %i %i %i %i %i",
                            &dmy, &dmy, &dmy, &dmy, &dmy, &Typ, &bstnr);


  zbst  = BausteinListe->Suche (bstnr);
  if (zbst == NULL)
  {
    Meld.Ausgabe(9, bstnr);
    return false;
  }
  Modellzeit.setZeit (str);
  return true;
}  // ENDE setEreignis

//==================================================================
//		Declaration
//		for class ProzessEreignis
//==================================================================

ProzessEreignis::ProzessEreignis ()
 : Ereignis (), zprozess (NULL)
 { }

ProzessEreignis::ProzessEreignis (const ProzessEreignis& copy)
 : Ereignis (copy), zprozess (copy.zprozess)
 { }

ProzessEreignis::~ProzessEreignis ( )
{
  zprozess = NULL;
}

void ProzessEreignis::operator = (const ProzessEreignis& copy)
{
  if (this == &copy) return;
  Ereignis::operator = (copy);
  zprozess = copy.zprozess;
}

bool ProzessEreignis::read (InputFile& fin, Zeit zeit, int etyp)
{
  SFXToken tok;
  Modellzeit = zeit;
  Typ        = etyp;

  tok.nextToken (fin);  int nr = atoi (tok());
  zprozess = ProzessListe->suche (nr+LASTPROZESS);
  if (!zprozess)
  {
    Meld.Ausgabe(93, nr+LASTPROZESS);
    tok.EndOfLine (fin);
    return false;
  }
  if (zprozess->getTyp() == Programm)
  {
    Meld.Ausgabe (110);
    return false;
  }
  tok.EndOfLine (fin);
  return true;
} // ENDE read

void ProzessEreignis::write (ostream& ostrm, int& satznr)
{
  satznr++;
  Write (ostrm, "%4d   4  ", satznr);
  Modellzeit.write (ostrm);
  Write (ostrm, "%4d ", Typ);
  Write (ostrm, "%8d ", zprozess->getNr());
  Write (ostrm, "%s\n", "     0      0");
}  // ENDE write

Ustring ProzessEreignis::getInfo (const unsigned art)
{
  char tmp [256];
  if (art == 0)
    sprintf (tmp, "{%d {%s} %d %d %d %d}\t",
                   Nr, (char*)Modellzeit.getZeit().str(),
                   Typ, zprozess->getNr(), 0, 0);
  else
    sprintf (tmp, "%d %s %d %d %d %d\t",
                   Nr, (char*)Modellzeit.getZeit(art).str(),
                   Typ, zprozess->getNr(), 0, 0);
  Ustring buf(tmp);
  return buf;
}  // ENDE getInfo

bool ProzessEreignis::setEreignis (Ustring str)
{
  int dmy, pnr;
  sscanf((char*)str.str(), " %i %i %i %i %i %i %i",
                            &dmy, &dmy, &dmy, &dmy, &dmy, &Typ, &pnr);
  zprozess = ProzessListe->suche (pnr);
  if (zprozess == NULL)
  {
    Meld.Ausgabe(93, pnr);
    return false;
  }
  Modellzeit.setZeit (str);
  return true;
}  // ENDE setEreignis

//==================================================================
//		Declaration
//		for class ArbeitsplanEreignis
//==================================================================

ArbeitsplanEreignis::ArbeitsplanEreignis ()
 : Ereignis (), ObjAnzahl (0), zarbeitsplan (NULL)
 { }

ArbeitsplanEreignis::ArbeitsplanEreignis (const ArbeitsplanEreignis& copy)
 : Ereignis     (copy), 
   ObjAnzahl    (copy.ObjAnzahl),
   zarbeitsplan (copy.zarbeitsplan)
 { }

ArbeitsplanEreignis::~ArbeitsplanEreignis ( )
{
  zarbeitsplan = NULL;
}

void ArbeitsplanEreignis::operator = (const ArbeitsplanEreignis& copy)
{
  if (this == &copy) return;
  Ereignis::operator = (copy);
  zarbeitsplan = copy.zarbeitsplan;
  ObjAnzahl = copy.ObjAnzahl;
}

bool ArbeitsplanEreignis::read (InputFile& fin, Zeit zeit, int etyp)
{
  SFXToken tok;
  Modellzeit = zeit;
  Typ        = etyp;
  tok.nextToken (fin);  int nr = atoi (tok());
  zarbeitsplan = ArbeitsplanListe->sucheArbeitsplan (nr+LASTAFNR);
  if (!zarbeitsplan)
  {
    Meld.Ausgabe(280, nr+LASTAFNR);
    tok.EndOfLine (fin);
    return false;
  }
  tok.nextToken (fin);  ObjAnzahl = atoi (tok());
  tok.EndOfLine (fin);
  return true;
} // ENDE read

void ArbeitsplanEreignis::write (ostream& ostrm, int& satznr)
{
  satznr++;
  Write (ostrm, "%4d   4  ", satznr);
  Modellzeit.write (ostrm);
  Write (ostrm, "%4d ", Typ);
  Write (ostrm, "%8d %6d ", zarbeitsplan->getNr(), ObjAnzahl);
  Write (ostrm, "%s\n", "     0");
}  // ENDE write

Ustring ArbeitsplanEreignis::getInfo (const unsigned art)
{
  char tmp [256];
  if (art == 0)
    sprintf (tmp, "{%d {%s} %d %d %d %d}\t",
                   Nr, (char*)Modellzeit.getZeit().str(),
                   Typ, zarbeitsplan->getNr(), ObjAnzahl, 0);
  else
    sprintf (tmp, "%d %s %d %d %d %d\t",
                   Nr, (char*)Modellzeit.getZeit(art).str(),
                   Typ, zarbeitsplan->getNr(), ObjAnzahl, 0);
  Ustring buf(tmp);
  return buf;
}  // ENDE getInfo

bool ArbeitsplanEreignis::setEreignis (Ustring str)
{

  int dmy, anr;
  sscanf((char*)str.str(), " %i %i %i %i %i %i %i %i",
                &dmy, &dmy, &dmy, &dmy, &dmy, &Typ, &anr, &ObjAnzahl);

  zarbeitsplan = ArbeitsplanListe->sucheArbeitsplan (anr);
  if (zarbeitsplan == NULL)
  {
    Meld.Ausgabe(280, anr);
    return false;
  }
  Modellzeit.setZeit (str);

  return true;
}  // ENDE setEreignis

//==================================================================
//		Declaration
//		for class AllgemeinEreignis
//==================================================================

AllgemeinEreignis::AllgemeinEreignis () : Ereignis(),
                                          info1(0), info2(0), info3(0)
{ }

AllgemeinEreignis::AllgemeinEreignis (const AllgemeinEreignis& copy)
 : Ereignis (copy),
   info1    (copy.info1),
   info2    (copy.info2),
   info3    (copy.info3)
{ }

AllgemeinEreignis::~AllgemeinEreignis ( )
{ }

void AllgemeinEreignis::operator = (const AllgemeinEreignis& copy)
{
  if (this == &copy) return;
  Ereignis::operator = (copy);
  info1 = copy.info1;
  info2 = copy.info2;
  info3 = copy.info3;
}

bool AllgemeinEreignis::read (InputFile& fin, Zeit zeit, int etyp)
{
  SFXToken tok;
  Modellzeit = zeit;
  Typ        = etyp;
  tok.nextToken (fin);  info1 = atoi (tok());
  tok.nextToken (fin);  info2 = atoi (tok());
  tok.nextToken (fin);  info3 = atoi (tok());
  tok.EndOfLine (fin);
  if ((Typ == ETprotokoll) && (info2 == 0)) return false;
  return true;
} // ENDE read

void AllgemeinEreignis::write (ostream& ostrm, int& satznr)
{
  satznr++;
  Write (ostrm, "%4d   4  ", satznr);
  Modellzeit.write (ostrm);
  Write (ostrm, "%4d ",  Typ);
  Write (ostrm, "%8d ",  info1);
  Write (ostrm, "%6d ",  info2);
  Write (ostrm, "%6d\n", info3);
}  // ENDE write

Ustring AllgemeinEreignis::getInfo (const unsigned art)
{
  char tmp [256];
  if (art == 0)
    sprintf (tmp, "{%d {%s} %d %d %d %d}\t",
                   Nr, (char*)Modellzeit.getZeit().str(),
                   Typ, info1, info2, info3);
  else
    sprintf (tmp, "%d %s %d %d %d %d\t",
                   Nr, (char*)Modellzeit.getZeit(art).str(),
                   Typ, info1, info2, info3);
  Ustring buf(tmp);
  return buf;
}  // ENDE getInfo

bool AllgemeinEreignis::setEreignis (Ustring str)
{
  int dmy;
  sscanf((char*)str.str(), "%i %i %i %i %i %i %i %i %i",
         &dmy, &dmy, &dmy, &dmy, &dmy, &Typ, &info1, &info2, &info3);
  Modellzeit.setZeit (str);
  return true;
}  // ENDE setEreignis

//==================================================================
//		Declaration
//		for class EreignisVerwaltung
//==================================================================

void EreignisVerwaltung::readSimulationEnde (InputFile& fin)
{
  SFXToken tok;
  SimEnde.read  (fin);
  tok.EndOfLine (fin);
}  // ENDE readSimulationEnde

Ustring EreignisVerwaltung::getSimulationEnde (const unsigned art)
{
  return SimEnde.getZeit(art);
}  // ENDE getSimulationEnde

Ustring EreignisVerwaltung::setSimulationEnde (Ustring str, const unsigned art)
{
  return SimEnde.setZeit(str, art);
}  // ENDE setSimulationEnde

Ereignis* EreignisVerwaltung::Erzeuge (int etyp)
{
  switch (etyp)
  {
    case ETazeitreihe:
    case ETezeitreihe:
    case ETprotokoll:
    case ETprogramm : return new AllgemeinEreignis ();

    case ETasperren :
    case ETesperren :
    case ETastoeren :
    case ETestoeren : return new BstEreignis ();

    case ETstartextprozess :
    case ETstopextprozess  : return new ProzessEreignis ();
    case ETexplerzeugen    : return new ArbeitsplanEreignis ();
    default  : Msg.Warning ("EreignisVerwaltung::Erzeuge()",
                            "Ereignis %d nicht implementiert", etyp);
  }  // ENDE switch
  return NULL;
} // ENDE Erzeuge

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool EreignisVerwaltung::read (Ustring datname)
{
  int  satznr = 2;
  bool OK = true;
  int  zeittyp, etyp;
  Zeit mzeit;
  Ereignis *zereig;
  InputFile *fin;
  SFXToken tok;

  fin = new InputFile (datname.str());
  if (!tok.findSentence (satznr, *fin))
    Msg.Error ("EreignisVerwaltung::read()",
               "Satznr.= %d in TZT-Datei nicht vorhanden", satznr);
  tok.EndOfLine (*fin);

  while((OK) && (satznr != -999))
  {
    tok.nextToken (*fin);  satznr = atoi (tok());
    if (satznr > 0)
    {
      tok.nextToken (*fin);  zeittyp = atoi (tok());
      if (zeittyp == 3) readSimulationEnde (*fin);
      if (zeittyp == 4)
      {
        mzeit.read (*fin);
        tok.nextToken (*fin);  etyp = atoi (tok());
        zereig = Erzeuge (etyp);
        if (zereig)
        {
          OK = zereig->read (*fin, mzeit, etyp);
          if (OK)
            EinGliedern (*zereig);
          else
          {
            delete zereig;
            if (etyp == ETprotokoll) OK = true;
          }
        }
        else
        tok.EndOfLine (*fin);
      }
    }
    else
    tok.EndOfLine (*fin);
  }
  fin->close();
  delete fin;
  return OK;
} // ENDE read

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void EreignisVerwaltung::write (Ustring datname) const
{
  int satznr = 4;
  LCursor<Ereignis> zhilfe;
  ofstream fout (datname.str ());
  DateiKopfSchreiben (fout, "TZT");
  Write (fout, "%4d  %4d\n", 2, 0);
  Write (fout, "%d\n", -1);
  Write (fout, "%s\n", "-1 SatzNr");
  Write (fout, "%s\n", "-1    ZeitTyp  EreignisZeit  ETyp   Info1  Info2  Info3");
  Write (fout, "%d\n", -1);
  Write (fout, "%s", "   3   3  ");
  SimEnde.write (fout);
  Write (fout, "%s\n", "  ; Modellprozessende");
  Write (fout, "%d\n", -1);
  Write (fout, "%s\n", "   4   4      0  1  0  0  0    3       60      0      0");

  for (zhilfe = EreignisListe; zhilfe; zhilfe++)
       zhilfe()->write (fout, satznr);

  DateiFussSchreiben (fout, "TZT");
  fout.close ();
} // ENDE write

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ereignis* EreignisVerwaltung::Suche (typBaustein* zbst)
{
  for (LCursor<Ereignis> zhilfe = EreignisListe; zhilfe; zhilfe++)
    if (zhilfe()->AufBaustein() == zbst) return zhilfe();
  return NULL;
} // ENDE Suche

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ereignis* EreignisVerwaltung::Suche (int enr)
{
  for (LCursor<Ereignis> zhilfe = EreignisListe; zhilfe (); zhilfe++)
    if (zhilfe()->getNr() == enr) return zhilfe();
  return NULL; //EreignisListe;
} // ENDE Suche

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void EreignisVerwaltung::TZTmitBausteinLoeschen (typBaustein* zbstein)
{
  for (LCursor<Ereignis> zhilfe = EreignisListe; zhilfe (); zhilfe++)
    if (zhilfe()->AufBaustein() == zbstein)
      delete EreignisListe.remove(*(zhilfe()));
}  // ENDE TZTmitBausteinLoeschen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void EreignisVerwaltung::TZTmitProzessLoeschen  (Prozess* zprozess)
{
  for (LCursor<Ereignis> zhilfe = EreignisListe; zhilfe; zhilfe++)
    if (zhilfe()->AufProzess() == zprozess)
      delete EreignisListe.remove(*(zhilfe()));
}  // ENDE TZTmitProzessLoeschen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring EreignisVerwaltung::Info ()
{
  Ustring buf;
  int i = 0;
  for (LCursor<Ereignis> zhilfe = EreignisListe; zhilfe (); i++, zhilfe++)
  {
    zhilfe()->setNr (i);
    buf += zhilfe()->getInfo();
  }
  return buf;
}  // ENDE Info

void EreignisVerwaltung::nachOben (int enummer)
{
  LCursor<Ereignis> zin;
  LCursor<Ereignis> zhilfe = EreignisListe;
  while (zhilfe ()) {
   if (zhilfe()->getNr() == enummer) break;
   zhilfe++;
  }

  Ereignis* zereignis = zhilfe();
  if (zereignis)
  {
    zin = zhilfe;
    EreignisListe.remove  (*zereignis);
    EreignisListe.prepend (*zereignis, *(--zin));
  }
}  // ENDE nachOben

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void EreignisVerwaltung::nachUnten (int enummer)
{
  LCursor<Ereignis> zin;
  LCursor<Ereignis> zhilfe = EreignisListe;
  while (zhilfe ()) {
   if (zhilfe()->getNr() == enummer) break;
   zhilfe++;
  }
  
  Ereignis* zereignis = zhilfe();
  if (zereignis)
  {
    zin = zhilfe;
    EreignisListe.remove (*zereignis);
    EreignisListe.append (*zereignis, *(++zin));
  }
}  // ENDE nachUnten

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void EreignisVerwaltung::EinGliedern (Ereignis &zereignis)
{
  LCursor<Ereignis> zhilfe;
  for (zhilfe = EreignisListe; zhilfe (); zhilfe++)
    if (zereignis.getModellzeit() < zhilfe()->getModellzeit()) break;

  if (zhilfe() != NULL)
    EreignisListe.prepend (zereignis, zhilfe);
  else
    EreignisListe.append(zereignis);
}  // ENDE EinGliedern

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void EreignisVerwaltung::loeschen (int enummer)
{
  Ereignis* zereignis = Suche (enummer);
  if (zereignis)
    delete EreignisListe.remove (*zereignis);
}  // ENDE Loeschen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void EreignisVerwaltung::loeschen ()
{
  while (!EreignisListe.isEmpty()) delete EreignisListe.removeFirst();
}  // ENDE Loeschen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring EreignisVerwaltung::Select (int enummer)
{
  Ereignis* zereignis = Suche (enummer);
  if (zereignis) return zereignis->getInfo(1);
  return Ustring ();
}  // ENDE Select

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring EreignisVerwaltung::Erzeugen (Ustring str)
{
  int etyp, einfo1, dmy;
  unsigned pos = str.findLeftPos (':');
  Ustring tmp = str.getPart (pos+1, str.len()-pos);

  sscanf((char*)tmp.str(), " %i %i %i %i %i %i %i",
                            &dmy, &dmy, &dmy, &dmy, &dmy, &etyp, &einfo1);

  if ((etyp == ETstartextprozess) ||
      (etyp == ETstopextprozess))
  {
    Prozess* zprozess = ProzessListe->suche (einfo1);
    if (!zprozess)
    {
      Meld.Ausgabe (93, einfo1);
      return Ustring (0);
    }
    if (zprozess->getTyp() == Programm)
    {
      Meld.Ausgabe (110);
      return Ustring (0);
    }
  }

  Ereignis* zereignis = Erzeuge (etyp);
  if (!zereignis)
  {
    Msg.Warning ("EreignisVerwaltung::Erzeugen()",
                 "Ereignistyp %d nicht vorhanden", etyp);
    return Ustring (0);
  }

  if (zereignis->setEreignis(tmp))
    EinGliedern (*zereignis);
  else
  {
    delete zereignis;
    return Ustring (0);
  }
  return Ustring (1);
}  // ENDE Erzeugen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring EreignisVerwaltung::Aendern (Ustring str)
{
  int enr, etyp, einfo1, dmy;
  sscanf((char*)str.str(), " %i", &enr);
  unsigned pos = str.findLeftPos (':');
  Ustring tmp = str.getPart (pos+1, str.len()-pos);

  sscanf((char*)tmp.str(), " %i %i %i %i %i %i %i",
                            &dmy, &dmy, &dmy, &dmy, &dmy, &etyp, &einfo1);
  if ((etyp == ETstartextprozess) ||
      (etyp == ETstopextprozess))
  {
    Prozess* zprozess = ProzessListe->suche (einfo1);
    if (!zprozess)
    {
      Meld.Ausgabe (93, einfo1);
      return Ustring (0);
    }
    if (zprozess->getTyp() == Programm)
    {
      Meld.Ausgabe (110);
      return Ustring (0);
    }
  }

  Ereignis* zloesch = Suche (enr);
  if (!zloesch)
  {
    Msg.Warning ("EreignisVerwaltung::Aendern",
                 "Ereignisnr. %d nicht gefunden", enr);
    return Ustring (0);
  }
  sscanf((char*)tmp.str(), " %i %i %i %i %i %i",
                            &dmy, &dmy, &dmy, &dmy, &dmy, &etyp);

  if (etyp == Programm)
  {
    Meld.Ausgabe(110);
    return Ustring (0);
  }

  Ereignis* zereignis = Erzeuge (etyp);
  if (!zereignis)
  {
    Msg.Warning ("EreignisVerwaltung::Aendern",
                 "Ereignistyp %d nicht vorhanden", etyp);
    return Ustring (0);
  }

  if (zereignis->setEreignis(tmp))
  {
    delete EreignisListe.remove (*zloesch);
    EinGliedern (*zereignis);
  }
  else
  {
    delete zereignis;
    return Ustring (0);
  }
  return Ustring (1);
}  // ENDE Aendern

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EreignisVerwaltung::~EreignisVerwaltung ()
{
  while (!EreignisListe.isEmpty()) delete EreignisListe.removeFirst();
}  // ENDE ~EreignisVerwaltung

