// $Source: /usr/local/SimSoft/Sfx3D/src/gts/gtstas.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: gtstas.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 "gtstas.h"
#include "gtspal.h"
#include "gtstfk.h"

//==================================================================
//		Declaration
//		for baseclass StlElement
//==================================================================

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
StlElement::StlElement ()
   : ObjNr        (0),
     ObjAnzahl    (0),
     ObjArtikel   (0),
     ObjVariante  (0),
     ObjMenge     (0.0),
     ObjZeit      (0.0)
{ } // ENDE Konstruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
StlElement::StlElement  (const StlElement& copy)
   : ObjNr       (0),
     ObjAnzahl   (copy.ObjAnzahl),
     ObjArtikel  (copy.ObjArtikel),
     ObjVariante (copy.ObjVariante),
     ObjMenge    (copy.ObjMenge),
     ObjZeit     (copy.ObjZeit)
{ }  // ENDE CopyKonstruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
StlElement::~StlElement ()
{ } // ENDE Destruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void StlElement::setNr (const unsigned nr)
{
  ObjNr = nr;
} // ENDE  setNr

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void StlElement::setArtikel (const unsigned artikel)
{
  ObjArtikel = artikel;
} // ENDE  setArtikel

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void StlElement::setAnzahl   (const unsigned anzahl)
{
  ObjAnzahl = anzahl;
} // ENDE  setAnzahl

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void StlElement::setVariante (const unsigned variante)
{
  ObjVariante = variante;
} // ENDE  setVariante

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void StlElement::setMenge    (const double menge)
{
  ObjMenge = menge;
} // ENDE  setMenge

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void StlElement::setZeit     (const double zeit)
{
  ObjZeit  = zeit;
} // ENDE  setZeit

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
unsigned int StlElement::getNr () const
{
  return ObjNr;
} // ENDE  getNr

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
unsigned int StlElement::getArtikel () const
{
  return ObjArtikel;
} // ENDE  getArtikel

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
unsigned int StlElement::getAnzahl () const
{
  return ObjAnzahl;
} // ENDE  getAnzahl

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
unsigned int StlElement::getVariante () const
{
  return ObjVariante;
} // ENDE  getVariante

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
double StlElement::getMenge () const
{
  return ObjMenge;
} // ENDE  getMenge

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
double StlElement::getZeit () const
{
  return ObjZeit;
} // ENDE  getZeit

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void StlElement::read  (InputFile& fin)
{
  SFXToken tok;
  tok.nextToken (fin);  ObjAnzahl   = atol (tok());
  tok.nextToken (fin);  ObjArtikel  = atol (tok());
  tok.nextToken (fin);  ObjVariante = atol (tok());
  tok.nextToken (fin);  ObjMenge    = atof (tok());
  tok.nextToken (fin);  ObjZeit     = atof (tok());
  ObjArtikel  += LASTAFNR;
  tok.EndOfLine (fin);
}  // ENDE read

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void StlElement::write (ostream& ostrm) const
{
  Write (ostrm, "%12u %12u %12u ",   ObjAnzahl, ObjArtikel, ObjVariante);
  Write (ostrm, "%12.5lf %12.5lf\n", ObjMenge, ObjZeit);
}  // ENDE write

//==================================================================
//		Declaration
//		for class Eingang
//==================================================================

Eingang::Eingang ()
   : StlElement()
{ } // ENDE Konstruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Eingang::Eingang  (const Eingang& copy)
   : StlElement (copy)
{ }  // ENDE CopyKonstruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Eingang::~Eingang ()
{ } // ENDE Destruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring Eingang::getInfo (const unsigned art) const
{
  char tmp [256];
  if (art == 0)
    sprintf (tmp, "{%d %u %u %u %f %f}\t",
             ObjNr, ObjAnzahl, ObjArtikel, ObjVariante, ObjMenge, ObjZeit);
  else
    sprintf (tmp, "%u %u %u %f %f\t",
             ObjAnzahl, ObjArtikel, ObjVariante, ObjMenge, ObjZeit);
  Ustring buf(tmp);
  return buf;
} // ENDE getInfo

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Eingang::setEingang (Ustring str)
{
  sscanf((char*)str.str(), " %u %u %u %lf %lf",
          &ObjAnzahl, &ObjArtikel, &ObjVariante, &ObjMenge, &ObjZeit);
} // ENDE setEingang

//==================================================================
//		Declaration
//		for class Ausgang
//==================================================================

Ausgang::Ausgang ()
   : StlElement     (),
     ObjPalvariante (1)
{
  ObjAnzahl = 1;
} // ENDE Konstruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ausgang::Ausgang  (const Ausgang& copy)
   : StlElement     (copy),
     ObjPalvariante (copy.ObjPalvariante)
{ }  // ENDE CopyKonstruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ausgang::~Ausgang ()
{ } // ENDE Destruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Ausgang::setAusgang (Ustring str)
{
  sscanf((char*)str.str(), " %u %u %lf %lf %u",
         &ObjArtikel, &ObjVariante, &ObjMenge, &ObjZeit, &ObjPalvariante);
} // ENDE setAusgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Ausgang::setPalVariante (unsigned int pvar)
{
  ObjPalvariante = pvar;
}  // ENDE  setPalVariante

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
unsigned int Ausgang::getPalVariante () const
{
  return ObjPalvariante;
}  // ENDE  getPalVariante

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring Ausgang::getInfo (const unsigned art) const
{
  char tmp [256];
  Ustring buf;
  if (art == 0)
  {
    sprintf (tmp, "%u %u %f %f ", ObjArtikel, ObjVariante, ObjMenge, ObjZeit);
    buf = Ustring(tmp) +
                  PalBibliothek->getPalettenInfos(ObjPalvariante) +
                  "{" + PalBibliothek->getPalettenInfos() + "}";
  }
  else
  {
    sprintf (tmp, "%u %u %f %f %u",
             ObjArtikel, ObjVariante, ObjMenge, ObjZeit, ObjPalvariante);
    buf = Ustring(tmp);
  }
  return buf;
} // ENDE getInfo

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Ausgang::read  (InputFile& fin)
{
  SFXToken tok;
  StlElement::read  (fin);
  tok.nextToken (fin);
  tok.nextToken (fin);
  tok.nextToken (fin);
  tok.nextToken (fin);
  tok.nextToken (fin);
  tok.nextToken (fin);  ObjPalvariante = atoi (tok());
  tok.EndOfLine (fin);
}  // ENDE read

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Ausgang::write (ostream& ostrm) const
{
  StlElement::write (ostrm);
  Write (ostrm, "%s",
         "                  1.000    1.000    1.000   1.000      1    ");
  Write (ostrm, "%4d\n", ObjPalvariante);
}  // ENDE write

//==================================================================
//		Declaration
//		for class Vorgang
//==================================================================

Vorgang::Vorgang ()
  : ObjNr       (0),
    ObjZiel     (NULL),
    ObjZeit     (0.0),
    ObjProgramm (0),
    ObjName     ("Vorgang")
{ } // ENDE Konstruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Vorgang::Vorgang (const Vorgang& copy)
{
  ObjNr       = copy.ObjNr;
  ObjZiel     = copy.ObjZiel;
  ObjZeit     = copy.ObjZeit;
  ObjProgramm = copy.ObjProgramm;
  ObjName     = copy.ObjName;
}  // ENDE CopyKonstruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Vorgang::operator = (const Vorgang& copy)
{
  if (this == &copy) return;
  ObjNr       = copy.ObjNr;
  ObjZiel     = copy.ObjZiel;
  ObjZeit     = copy.ObjZeit;
  ObjProgramm = copy.ObjProgramm;
  ObjName     = copy.ObjName;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Vorgang::~Vorgang ( )
{
  ObjZiel = NULL;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
typBaustein* Vorgang::AufBaustein () const
{
  return ObjZiel;
} // ENDE AufBaustein

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Vorgang::setNr (int nr)
{
  ObjNr = nr;
} // ENDE setNr

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
unsigned int Vorgang::getNr () const
{
  return ObjNr;
} // ENDE getNr

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring Vorgang::getInfo (const unsigned art) const
{
  char tmp [256];
  if (art == 0)
    sprintf (tmp, "{%d %d %f %d {%s} %d}\t",
       ObjNr, ObjZiel->i_BstNr(), ObjZeit, ObjProgramm,
       (char*)ObjName.str(), ObjZiel->i_BstTyp());
  else
    sprintf (tmp, "%d %f %d {%s}\t",
       ObjZiel->i_BstNr(), ObjZeit, ObjProgramm, (char*)ObjName.str());
  Ustring buf(tmp);
  return buf;
} // ENDE getInfo

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Vorgang::setVorgang (Ustring str)
{
  char tmp [256];
  int bstnr;
  sscanf((char*)str.str(), " %d", &bstnr);
  ObjZiel = BausteinListe->Suche (bstnr);
  sscanf((char*)str.str(), " %d %lf %d %s", &bstnr, &ObjZeit, 
                                            &ObjProgramm, tmp);
  ObjName  = tmp;
  unsigned pos = str.findLeftPos ('{');
  if (pos < str.len())
      ObjName = str.getPart (pos+1, str.findLeftPos ('}')-pos-1);
  if ((ObjName == "Vorgang?") || (ObjName == ""))
     ObjName = Ustring("Vorgang_auf_Bst") + Ustring(bstnr);
} // ENDE setVorgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Vorgang::read (InputFile& fin)
{
  bool OK = true;
  SFXToken tok;
  tok.nextToken (fin);  ObjNr       = atol (tok());
  tok.nextToken (fin);  int bstnr   = atoi (tok());
  tok.nextToken (fin);  ObjZeit     = atof (tok());
  tok.nextToken (fin);  ObjProgramm = atol (tok());
  tok.nextToken (fin);  ObjName     = tok();
  while ((ObjName[ObjName.len()-1] == ';') || (ObjName[ObjName.len()-1] == ' '))
          ObjName.delPart (ObjName.len()-1, 1);

  ObjZiel  = BausteinListe->Suche (bstnr+LASTBSTNR);
  if (!ObjZiel)
  {
    OK = false;
    Meld.Ausgabe(9, bstnr+LASTBSTNR);
  }
  tok.EndOfLine (fin);
  return OK;
} // ENDE read

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Vorgang::write (ostream& ostrm) const
{
  Write (ostrm, "%4d %4d ",         ObjNr, ObjZiel->i_BstNr());
  Write (ostrm, "%12.5f %4d  %s\n", ObjZeit, ObjProgramm, ObjName.str());
}  // ENDE write

//==================================================================
//		Declaration
//		for class Arbeitsplan
//==================================================================

Arbeitsplan::Arbeitsplan ()
  : ArbeitsplanMesswert (4),
    ObjNr               (0),
    ObjName             ("Arbeitsplan"),
    EingangsListe       (),
    AusgangsListe       (),
    VorgangsListe       ()
{ } // ENDE Konstruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Arbeitsplan::~Arbeitsplan ()
{
  ProzessListe->TLMmitArbeitsplanLoeschen (this);
  while (!EingangsListe.isEmpty()) delete EingangsListe.removeFirst();
  while (!AusgangsListe.isEmpty()) delete AusgangsListe.removeFirst();
  while (!VorgangsListe.isEmpty()) delete VorgangsListe.removeFirst();
}  // ENDE Destruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Arbeitsplan::setNr (unsigned int nr)
{
  ObjNr = nr;
} // ENDE setNr

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
unsigned Arbeitsplan::getNr () const
{
  return ObjNr;
}  // ENDE getNr

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Arbeitsplan::setName (Ustring name)
{
  ObjName = name;
  if ((ObjName == "Arbeitsplan?") || (ObjName == ""))
     ObjName = Ustring("Arbeitsplan_") + Ustring(ObjNr);
} // ENDE setName

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring  Arbeitsplan::getName () const
{
  return ObjName;
}  // ENDE getName

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring Arbeitsplan::getInfoArbeitsplan () const
{
  char tmp [256];
  sprintf (tmp, "%d {%s}", ObjNr, (char*)ObjName.str());
  Ustring buf(tmp);
  return buf;
} // ENDE getInfoArbeitsplan

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring Arbeitsplan::getInfoAusgangListe () const
{
  Ustring tmp;
  LCursor<Ausgang> zhilfe = AusgangsListe;
  if (!zhilfe) return Ustring ();
  return zhilfe()->getInfo();
} // ENDE getInfoAusgangListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ausgang* Arbeitsplan::sucheAusgang (const unsigned int artikel,
                                    const unsigned int variante) const
{
  for (LCursor<Ausgang> zhilfe = AusgangsListe; zhilfe; zhilfe++)
  {
    if (variante)
    {
      if ( (zhilfe()->getArtikel()  == artikel)  &&
           (zhilfe()->getVariante() == variante) ) return zhilfe();
    }
    else
      if (zhilfe()->getArtikel()  == artikel) return zhilfe();
  }
  return NULL;
}  // ENDE sucheAusgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Arbeitsplan::ErzeugeAusgang (const unsigned int /*nr*/, Ustring str)
{
  Ausgang* zaus = new Ausgang();
  AusgangsListe.append (*zaus);
  zaus->setAusgang (str);
  return true;
}  // ENDE ErzeugeAusgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Arbeitsplan::AendereAusgang (const unsigned int /*anummer*/, Ustring str)
{
  LCursor<Ausgang> zhilfe = AusgangsListe;
  if (!zhilfe) return false;
  zhilfe()->setAusgang (str);
  return true;
}  // ENDE AendereEingang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring Arbeitsplan::getInfoEingangListe () const
{
  Ustring buf;
  unsigned i = 0;
  for (LCursor<Eingang> zhilfe = EingangsListe; zhilfe (); i++, zhilfe++)
  {
    zhilfe()->setNr (i);
    buf += zhilfe()->getInfo();
  }
  return buf;
} // ENDE getInfoEingangListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Eingang* Arbeitsplan::SucheEingang (const unsigned int nr) const
{
  for (LCursor<Eingang> zhilfe = EingangsListe; zhilfe; zhilfe++)
    if (zhilfe()->getNr() == nr) return zhilfe();
  return NULL;
}  // ENDE SucheEingang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Arbeitsplan::ErzeugeEingang (const unsigned int nr, Ustring str)
{
  Eingang* zein = new Eingang();
  if (nr > 0)
  {
    LCursor<Eingang> zhilfe;
    for (zhilfe = EingangsListe; zhilfe; zhilfe++)
      if (zhilfe()->getNr() == nr) break;
    if (zhilfe) EingangsListe.prepend (*zein, zhilfe);
    else
    EingangsListe.append (*zein);
  }
  else
  EingangsListe.append (*zein);
  zein->setEingang (str);
  return true;
}  // ENDE ErzeugeEingang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Arbeitsplan::AendereEingang (const unsigned int nr, Ustring str)
{
  Eingang* zein = SucheEingang(nr);
  if (!zein) return false;
  zein->setEingang (str);
  return true;
}  // ENDE AendereEingang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Arbeitsplan::LoescheEingang (const unsigned int nr)
{
  Eingang* zein = SucheEingang (nr);
  if (zein)
    delete EingangsListe.remove (*zein);
}  // ENDE LoescheEingang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Arbeitsplan::EingangnachOben (const unsigned int nr)
{
  LCursor<Eingang> zin;
  LCursor<Eingang> zhilfe = EingangsListe;
  while (zhilfe ()) {
   if (zhilfe()->getNr() == nr) break;
   zhilfe++;
  }
  Eingang* zein = zhilfe();
  if (zein)
  {
    zin = zhilfe;
    EingangsListe.remove  (*zein);
    EingangsListe.prepend (*zein, *(--zin));
  }
}  // ENDE EingangnachOben

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Arbeitsplan::EingangnachUnten (const unsigned int nr)
{
  LCursor<Eingang> zin;
  LCursor<Eingang> zhilfe = EingangsListe;
  while (zhilfe ()) {
   if (zhilfe()->getNr() == nr) break;
   zhilfe++;
  }

  Eingang* zein = zhilfe();
  if (zein)
  {
    zin = zhilfe;
    EingangsListe.remove  (*zein);
    EingangsListe.prepend (*zein, *(++zin));
  }
}  // ENDE EingangnachUnten

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring Arbeitsplan::getInfoVorgangListe () const
{
  Ustring buf;
  int i = 0;
  for (LCursor<Vorgang> zhilfe = VorgangsListe; zhilfe (); i++, zhilfe++)
  {
    zhilfe()->setNr (i);
    buf += zhilfe()->getInfo();
  }
  return buf;
} // ENDE getInfoVorgangListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Vorgang* Arbeitsplan::SucheVorgang (const unsigned int nr) const
{
  for (LCursor<Vorgang> zhilfe = VorgangsListe; zhilfe; zhilfe++)
    if (zhilfe()->getNr() == nr) return zhilfe();
  return NULL;
}  // ENDE SucheVorgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Vorgang* Arbeitsplan::FirstVorgang () const
{
  LCursor<Vorgang> zhilfe = VorgangsListe;
  if (zhilfe()) return zhilfe();
  return NULL;
}  // ENDE SucheVorgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Vorgang* Arbeitsplan::SucheVorgang (const typBaustein* zbst) const
{
  for (LCursor<Vorgang> zhilfe = VorgangsListe; zhilfe; zhilfe++)
    if (zhilfe()->AufBaustein() == zbst) return zhilfe();
  return NULL;
} // ENDE Suche

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Arbeitsplan::ErzeugeVorgang (const unsigned int nr, const Ustring str)
{
  int bstnr;
  sscanf((char*)str.str(), " %d", &bstnr);
  typBaustein* zbst = BausteinListe->Suche (bstnr);
  if (zbst == NULL)
  {
    Meld.Ausgabe(9, bstnr);
    return false;
  }
  Vorgang* zvorg = new Vorgang();
  if (nr > 0)
  {
    LCursor<Vorgang> zhilfe;
    for (zhilfe = VorgangsListe; zhilfe; zhilfe++)
      if (zhilfe()->getNr() == nr) break;
    if (zhilfe) VorgangsListe.prepend (*zvorg, zhilfe);
    else
    VorgangsListe.append (*zvorg);
  }
  else
  VorgangsListe.append (*zvorg);
  zvorg->setVorgang (str);
  return true;
}  // ENDE ErzeugeVorgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Arbeitsplan::AendereVorgang (const unsigned int nr, const Ustring str)
{
  int bstnr;
  sscanf((char*)str.str(), " %d", &bstnr);
  typBaustein* zbst = BausteinListe->Suche (bstnr);
  if (zbst == NULL)
  {
    Meld.Ausgabe(9, bstnr);
    return false;
  }
  Vorgang* zvorg = SucheVorgang(nr);
  if (!zvorg) return false;
  zvorg->setVorgang (str);
  return true;
}  // ENDE AendereVorgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Arbeitsplan::LoescheVorgang (const unsigned int nr)
{
  Vorgang* zvorgang = SucheVorgang (nr);
  if (zvorgang)
    delete VorgangsListe.remove (*zvorgang);
}  // ENDE LoescheVorgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Arbeitsplan::VorgangnachOben (const unsigned int nr)
{
  LCursor<Vorgang> zin;
  LCursor<Vorgang> zhilfe = VorgangsListe;
  while (zhilfe ()) {
   if (zhilfe()->getNr() == nr) break;
   zhilfe++;
  }

  Vorgang* zvorgang = zhilfe();
  if (zvorgang)
  {
    zin = zhilfe;
    VorgangsListe.remove  (*zvorgang);
    VorgangsListe.prepend (*zvorgang, *(--zin));
  }
}  // ENDE VorgangnachOben

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Arbeitsplan::VorgangnachUnten (const unsigned int nr)
{
  LCursor<Vorgang> zin;
  LCursor<Vorgang> zhilfe = VorgangsListe;
  while (zhilfe ()) {
   if (zhilfe()->getNr() == nr) break;
   zhilfe++;
  }

  Vorgang* zvorgang = zhilfe();
  if (zvorgang)
  {
    zin = zhilfe;
    VorgangsListe.remove (*zvorgang);
    VorgangsListe.append (*zvorgang, *(++zin));
  }
}  // ENDE VorgangnachUnten

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Arbeitsplan::isEmptyVorgangsListe () const
{
  return VorgangsListe.isEmpty();
} // ENDE isEmptyVorgangsListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Arbeitsplan::BausteinInVorgangLoeschen (const typBaustein* zbaustein)
{
  Vorgang *zhilfe;
  while ((zhilfe = SucheVorgang (zbaustein)) != NULL)
  {
    VorgangsListe.remove (*zhilfe);
    delete zhilfe;
  }
} // ENDE BausteinInVorgangLoeschen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Arbeitsplan::pruefeEingangsListe () const
{
  bool ok = true;
  for (LCursor<Eingang> zhilfe = EingangsListe; zhilfe; zhilfe++)
     if (!ArbeitsplanListe->sucheArtikel (zhilfe()->getArtikel(),
                                          zhilfe()->getVariante())) ok = false;

  if (!ok) Meld.Ausgabe (224, this->getNr());
  return ok;
} // ENDE pruefeEingangsListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Arbeitsplan::pruefeAusgangsListe () const
{
  bool fehler = false;

  if (AusgangsListe.isEmpty())
  {
    Meld.Ausgabe (226, this->getNr());
    fehler = true;
  }
  else
  if (AusgangsListe.Count() > 1)
  {
    Meld.Ausgabe (225, this->getNr());
    fehler = true;
  }
  return fehler;
} // ENDE pruefeAusgangsListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Arbeitsplan::pruefeVorgangsListe () const
{
  bool ok = true;
  unsigned vnr = 0;
  for (LCursor<Vorgang> zhilfe = VorgangsListe; zhilfe; zhilfe++)
  {
    ++vnr;
    if (zhilfe() == VorgangsListe.First())
      switch (zhilfe()->AufBaustein()->i_BstTyp())
      {
        case tQuelle  :
        case tGasse   :
        case tSammler :
        case tKommissionierer :
        case tKomVerwalter    : break;
        default  : Meld.Ausgabe (219);
                   ok = false;
      }
    else
    if (zhilfe() == VorgangsListe.Last())
      switch (zhilfe()->AufBaustein()->i_BstTyp())
      {
        case tSenke   :
        case tGasse   :
        case tSammler : break;
        default : Meld.Ausgabe (220);
                  ok = false;
      }
    else
      switch (zhilfe()->AufBaustein()->i_BstTyp())
      {
        case tMaschine              :
        case tRegaleinheit          :
        case tAbstrakteRegaleinheit :
        case tRegalverwalter        :
        case tKommissionierer       :
        case tKomVerwalter          :
        case tNcPoolverwalter       : break;
        default : Meld.Ausgabe (218, vnr);
                  ok = false;
      }
  }
  return ok;
} // ENDE pruefeVorgangsListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Arbeitsplan::pruefeFahrkurse () const
{
  bool ok = true;
  LCursor<Vorgang> zanfang = VorgangsListe;
  LCursor<Vorgang> zende   = VorgangsListe;
  if (VorgangsListe.Count() < 2)
  {
    Meld.Ausgabe (227, this->getNr());
    return false;
  }

  for (++zende; zende && ok; zanfang++, zende++)
  {
    if (!FahrkursListe->TFKPruefen
       (zanfang()->AufBaustein(), zende()->AufBaustein()))
    {
      Meld.Ausgabe (229);
      FahrkursListe->TFKErzeugen(zanfang()->AufBaustein(), zende()->AufBaustein());
      ok = FahrkursListe->TFKPruefen
          (zanfang()->AufBaustein(), zende()->AufBaustein());
    }
  }
  return ok;
} // ENDE pruefeFahrkurse

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Arbeitsplan::erzeugeFahrkurse () const
{
  LCursor<Vorgang> zanfang = VorgangsListe;
  LCursor<Vorgang> zende   = VorgangsListe;
  if (VorgangsListe.Count() < 2)
  {
    Meld.Ausgabe (227, this->getNr());
    return;
  }

  for (++zende; zende; zanfang++, zende++)
  {
    if (!FahrkursListe->TFKPruefen
       (zanfang()->AufBaustein(), zende()->AufBaustein()))
    {
      FahrkursListe->TFKErzeugen(zanfang()->AufBaustein(), zende()->AufBaustein());
    }
  }
} // ENDE erzeugeFahrkurse

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Arbeitsplan::read (InputFile& fin)
{
  bool OK = true;
  Eingang *zein;
  Ausgang *zaus;
  Vorgang *zvorg;
  unsigned i;

  SFXToken tok;
  tok.nextToken (fin);  ObjNr   = atol (tok());
  ObjNr  += LASTAFNR;
  tok.nextToken (fin);  ObjName = tok();
  while ((ObjName[ObjName.len()-1] == ';') || (ObjName[ObjName.len()-1] == ' '))
          ObjName.delPart (ObjName.len()-1, 1);
  tok.EndOfLine (fin);

// EingangsListe lesen
  tok.nextToken (fin);  unsigned anzahl = atoi (tok());
  if (!anzahl) tok.EndOfLine (fin);
  for (i = 0; i < anzahl; i++)
  {
    zein = new Eingang();
    zein->read (fin);
    EingangsListe.append (*zein);
  }

// AusgangsListe lesen
  tok.nextToken (fin);  anzahl = atoi (tok());
  if (!anzahl) tok.EndOfLine (fin);
  for (i = 0; i < anzahl; i++)
  {
    zaus = new Ausgang();
    zaus->read (fin);
    AusgangsListe.append (*zaus);
  }

// VorgangsListe lesen
  tok.nextToken (fin);  anzahl = atoi (tok());
  if (!anzahl) tok.EndOfLine (fin);
  for (i = 0; i < anzahl; i++)
  {
    zvorg = new Vorgang();
    OK = zvorg->read (fin);
    VorgangsListe.append (*zvorg);
    if (!OK) break;
  }
  return OK;
} // ENDE read

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Arbeitsplan::write (ostream& ostrm) const
{
  Write (ostrm, "%7d   ",    ObjNr);
  Write (ostrm, "%s;\n",    ObjName.str());

  int zaehler = 0;
  if (FirstVorgang())
  {
    if (FirstVorgang()->AufBaustein()->i_BstTyp() == tKommissionierer)
    {
      Write (ostrm, "%12d ", EingangsListe.Count());
      if (EingangsListe.isEmpty()) Write (ostrm, "%s\n", "");
      for (LCursor<Eingang> zeinhilfe = EingangsListe; zeinhilfe; zeinhilfe++, zaehler++)
      {
        if (zaehler) Write (ostrm, "%s            ", " ");
        zeinhilfe()->write (ostrm);
      }
    } else Write (ostrm, "%12d\n", 0);
  } else Write (ostrm, "%12d\n", 0);

  zaehler = 0;
  Write (ostrm, "%12d ", AusgangsListe.Count());
  if (AusgangsListe.isEmpty()) Write (ostrm, "%s\n", "");
  for (LCursor<Ausgang> zaushilfe = AusgangsListe; zaushilfe; zaushilfe++, zaehler++)
  {
    if (zaehler) Write (ostrm, "%s            ", " ");
    zaushilfe()->write (ostrm);
  }

  zaehler = 0;
  Write (ostrm, "%12d ", VorgangsListe.Count());
  if (VorgangsListe.isEmpty()) Write (ostrm, "%s\n", "");
  for (LCursor<Vorgang> zvorghilfe = VorgangsListe; zvorghilfe; zvorghilfe++, zaehler++)
  {
    if (zaehler) Write (ostrm, "%s            ", " ");
    zvorghilfe()->setNr(zaehler+1);
    zvorghilfe()->write (ostrm);
  }
} // ENDE write

//==================================================================
//		Declaration
//		for class AuftragsVerwaltung
//==================================================================

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ArbeitsplanVerwaltung::ArbeitsplanVerwaltung ()
  : ArbeitsplanListe()
{ } // ENDE Konstruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ArbeitsplanVerwaltung::~ArbeitsplanVerwaltung ()
{
  while (!ArbeitsplanListe.isEmpty())
    delete ArbeitsplanListe.removeFirst();
}  // ENDE Destruktor

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Arbeitsplan* ArbeitsplanVerwaltung::Letztes () const
{
  return ArbeitsplanListe.Last();
} // ENDE Letztes

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ArbeitsplanVerwaltung::AusGliedern (Arbeitsplan* zaplan)
{
  ArbeitsplanListe.remove(*zaplan);
} // ENDE AusGliedern

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ArbeitsplanVerwaltung::EinGliedern (Arbeitsplan &zaplan)
{
  LCursor<Arbeitsplan> zhilfe;
  for (zhilfe = ArbeitsplanListe; zhilfe; zhilfe++)
    if (zaplan.getNr() < zhilfe()->getNr()) break;

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

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool ArbeitsplanVerwaltung::read (Ustring datname)
{
  int  satznr = 2;
  bool OK = true;
  Arbeitsplan *zarbeitsplan;
  InputFile *fin;
  SFXToken tok;

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

  while((OK) && (satznr != -999))
  {
    tok.nextToken (*fin);  satznr = atoi (tok());
    if (satznr > 0)
    {
      zarbeitsplan = new Arbeitsplan ();
      OK = zarbeitsplan->read (*fin);
      if (OK)
        EinGliedern (*zarbeitsplan);
      else
        delete zarbeitsplan;
    }
    else
    tok.EndOfLine (*fin);
  }
  fin->close();
  delete fin;
  return OK;
} // ENDE read

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ArbeitsplanVerwaltung::write (Ustring datname) const
{
  int satznr = 3;
  ofstream fout (datname.str ());
  DateiKopfSchreiben (fout, "TAS");
  Write (fout, "%4d  %4d\n", 2, 0);
  Write (fout, "%d\n", -1);
  Write (fout, "%s\n", "-1 SatzNr");
  Write (fout, "%s\n", "-1 ArbeitsplanNr  ArbeitsplanBenennung");
  Write (fout, "%s\n", "-1 EingArtikel: Anzahl  Stueck  ArtikelNr  ArtVariante   TEMenge   HandhZeit");
  Write (fout, "%s\n", "-1 Artikel:     Anzahl  Stueck  ArtikelNr  ArtVariante   TEMenge   HandhZeit");
  Write (fout, "%s\n", "-1 TransportEinheit: Laenge  Breite   Hoehe  Gewicht  Priori    TEVariante");
  Write (fout, "%s\n", "-1 Vorgang:     Anzahl  VorgNr  BstNr  VorgZeit  ProgNr  VorgBenennung");
  Write (fout, "%d\n",  -1);

  for (LCursor<Arbeitsplan> zhilfe = ArbeitsplanListe; zhilfe; zhilfe++)
  {
    Write (fout, "%4d ", satznr);
    satznr++;
    zhilfe()->write (fout);
  }
  DateiFussSchreiben (fout, "TAS");
  fout.close ();
} // ENDE write

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ArbeitsplanVerwaltung::MWSchreiben (ostream& ostrm, int& satznr)
{
  for (LCursor<Arbeitsplan> zhilfe = ArbeitsplanListe; zhilfe; zhilfe++)
  if (zhilfe()->getMesswert())
  {
    satznr++;
    Write (ostrm, "%4d %4d %22d     1 ",
           satznr, 30, zhilfe()->getNr());
    zhilfe()->writeMW (ostrm);
   }
} // ENDE MWSchreiben

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Arbeitsplan* ArbeitsplanVerwaltung::sucheArbeitsplan (const unsigned int nr) const
{
  for (LCursor<Arbeitsplan> zhilfe = ArbeitsplanListe; zhilfe; zhilfe++)
    if (zhilfe()->getNr() == nr) return zhilfe();
  return NULL;
} // ENDE sucheArbeitsplan

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Arbeitsplan* ArbeitsplanVerwaltung::sucheArtikel (const unsigned int artikel,
                                                  const unsigned int variante) const
{
  for (LCursor<Arbeitsplan> zhilfe = ArbeitsplanListe; zhilfe; zhilfe++)
    if (zhilfe()->sucheAusgang (artikel, variante)) return zhilfe();
  return NULL;
} // ENDE sucheArtikel

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ArbeitsplanVerwaltung::Erzeugen (const unsigned int afnr, const Ustring afname)
{
  Arbeitsplan* zaplan = new Arbeitsplan ();
  zaplan->setNr   (afnr);
  zaplan->setName (afname);
  EinGliedern     (*zaplan);
  zaplan->ErzeugeAusgang (1, "0 0 0.0 0.0 1");
}  // ENDE Erzeugen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ArbeitsplanVerwaltung::Loeschen (const unsigned int afnr)
{
  Arbeitsplan* zaplan = sucheArbeitsplan (afnr);
  if (zaplan) delete ArbeitsplanListe.remove (*zaplan);
}  // ENDE Loeschen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ArbeitsplanVerwaltung::TASmitBausteinLoeschen (const typBaustein* zbstein)
{
  Arbeitsplan* zloesch;
  for (LCursor<Arbeitsplan> zhilfe = ArbeitsplanListe; zhilfe; zhilfe++)
  {
    zhilfe()->BausteinInVorgangLoeschen (zbstein);
    if (zhilfe()->isEmptyVorgangsListe ())
    {
      zloesch = zhilfe();
      AusGliedern (zloesch);
      delete zloesch;
    }
  }
}  // ENDE TASmitBausteinLoeschen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ArbeitsplanVerwaltung::AlleArbeitsplaene () const
{
  Ustring str;
  char tmp [64];
  unsigned nr = 0;
  for (LCursor<Arbeitsplan> zhilfe = ArbeitsplanListe;
       zhilfe; zhilfe++, nr++)
  {
    sprintf(tmp, "{%d ", nr);
    str += Ustring(tmp) + zhilfe()->getInfoArbeitsplan() + Ustring("}\t");
  }
  return str;
}  // ENDE AlleArbeitsplaene

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool ArbeitsplanVerwaltung::pruefeArbeitsPlaene () const
{
  Meld.Ausgabe (223);
  if (ArbeitsplanListe.isEmpty())
  {
    Meld.Ausgabe (50);
    return false;
  }
  bool ok = true;
  for (LCursor<Arbeitsplan> zhilfe = ArbeitsplanListe; zhilfe && ok; zhilfe++)
  {
    Meld.Ausgabe (221, zhilfe()->getNr());
    ok = zhilfe()->pruefeEingangsListe();
    if (ok) ok = zhilfe()->pruefeVorgangsListe();
    if (ok) ok = zhilfe()->pruefeFahrkurse();
  }
  return ok;
}  // ENDE pruefeArbeitsPlaene

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ArbeitsplanVerwaltung::erzeugeAlleFahrkurse () const
{
  if (ArbeitsplanListe.isEmpty())
  {
    Meld.Ausgabe (50);
    return;
  }
  for (LCursor<Arbeitsplan> zhilfe = ArbeitsplanListe; zhilfe; zhilfe++)
    zhilfe()->erzeugeFahrkurse();
}  // ENDE erzeugeAlleFahrkurse

