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


//==================================================================
//		Declaration
//		for abstract baseclass Prozess
//==================================================================

Prozess* Prozess::erzeugen (unsigned ptyp, unsigned betrifft)
{
  Arbeitsplan *zaf;
  typBaustein *zbst;
  switch (ptyp) {
    case Last  : zaf = ArbeitsplanListe->sucheArbeitsplan (betrifft);
                 if (!zaf)
                 {
                   Meld.Ausgabe(280, betrifft);
                   return NULL;
                 }
                 return new LastProzess (zaf);

    case Stoer : zbst = BausteinListe->Suche (betrifft);
                 if (!zbst)
                 {
                   Meld.Ausgabe(9, betrifft);
                   return NULL;
                 }
                 return new StoerProzess (zbst);

    case Programm : return new PrgProzess ();

    default  :    Msg.Warning ("Prozess::erzeugen()",
                             "Prozessart %d nicht implementiert", ptyp);
  }
  return NULL;
}  //  ENDE erzeugen

    
Prozess::Prozess  () : ObjTyp(0), ObjlfdNr(0), ObjNr(0),
                       ObjAbstand(NULL), ObjMengeDauer(NULL)
{ }

Prozess::Prozess (const Prozess& copy) : ObjTyp(copy.ObjTyp), ObjlfdNr(0),
                  ObjNr(0), ObjAbstand(copy.ObjAbstand),
                  ObjMengeDauer(copy.ObjMengeDauer)
{ }

void Prozess::operator = (const Prozess& copy)
{
  ObjlfdNr      = 0;
  ObjNr         = 0;
  ObjTyp        = copy.ObjTyp;
  ObjAbstand    = copy.ObjAbstand;
  ObjMengeDauer = copy.ObjMengeDauer;
}

Ustring Prozess::getAbstandVerteilung ()
{
  Ustring buf = Ustring(ObjAbstand->getVerteilTyp ()) +
                '\t' + ObjAbstand->getVerteilung ();
  return buf;
}  // ENDE getAbstandVerteilung

Ustring Prozess::setAbstandVerteilung (Ustring str)
{
  unsigned vnr;
  sscanf ((char*)str.str(), "%u", &vnr);
  Ustring tmp = str.delPart (0, str.findLeftPos('\t')+1);
  if (ObjAbstand) delete ObjAbstand;
  ObjAbstand = Verteilung::erzeugen (vnr);
  ObjAbstand->setVerteilung (tmp);
  return ObjAbstand->getVerteilung ();
}  // ENDE setAbstandVerteilung

Ustring Prozess::setAbstandVerteilung (unsigned vnr, Ustring str)
{
  if (ObjAbstand) delete ObjAbstand;
  ObjAbstand = Verteilung::erzeugen (vnr);
  ObjAbstand->setVerteilung (str);
  return ObjAbstand->getVerteilung ();
}  // ENDE setAbstandVerteilung

Ustring Prozess::getMengeDauerVerteilung ()
{
  Ustring buf  = Ustring(ObjMengeDauer->getVerteilTyp ()) +
                 '\t' + ObjMengeDauer->getVerteilung ();
  return buf;
}  // ENDE getMengeDauerVerteilung

Ustring Prozess::setMengeDauerVerteilung (Ustring str)
{
  unsigned vnr;
  sscanf ((char*)str.str(), "%u", &vnr);
  Ustring tmp = str.delPart (0, str.findLeftPos('\t')+1);
  if (ObjMengeDauer) delete ObjMengeDauer;
  ObjMengeDauer = Verteilung::erzeugen (vnr);
  ObjMengeDauer->setVerteilung (tmp);
  return ObjMengeDauer->getVerteilung ();
}  // ENDE setMengeDauerVerteilung

Ustring Prozess::setMengeDauerVerteilung (unsigned vnr, Ustring str)
{
  if (ObjMengeDauer) delete ObjMengeDauer;
  ObjMengeDauer = Verteilung::erzeugen (vnr);
  ObjMengeDauer->setVerteilung (str);
  return ObjMengeDauer->getVerteilung ();
}  // ENDE setMengeDauerVerteilung

Prozess::~Prozess ( )
{
  if (ObjAbstand)    delete ObjAbstand;
  if (ObjMengeDauer) delete ObjMengeDauer;
}

//==================================================================
//		Declaration
//		for class LastProzess
//==================================================================

LastProzess::LastProzess () : Prozess (), dummy (0), zablaufplan (NULL)
{ ObjTyp = 1; }

LastProzess::LastProzess (Arbeitsplan *zbetrifft)
            : Prozess (), dummy (0), zablaufplan (zbetrifft)
{ ObjTyp = 1; }

LastProzess::LastProzess (const LastProzess& copy) : Prozess (copy)
{
  zablaufplan = copy.zablaufplan;
}

LastProzess::~LastProzess ( )
{
  EreignisListe->TZTmitProzessLoeschen (this);
  zablaufplan = NULL;
}

void LastProzess::operator = (const LastProzess& copy)
{
  if (this == &copy) return;
  Prozess::operator = (copy);
  zablaufplan = copy.zablaufplan;
}

void LastProzess::read (InputFile& fin, unsigned nr)
{
  unsigned vnr;
  SFXToken tok;
  ObjNr  = nr + LASTPROZESS;
  tok.nextToken (fin);  vnr = atol (tok());
  ObjAbstand = Verteilung::erzeugen (vnr);
  ObjAbstand->lesen (fin);
  tok.EndOfLine  (fin);
  tok.nextToken (fin);  vnr = atol (tok());
  ObjMengeDauer = Verteilung::erzeugen (vnr);
  ObjMengeDauer->lesen (fin);
  tok.EndOfLine  (fin);
} // ENDE read

void LastProzess::write (ostream& ostrm)
{
  Write (ostrm, "%4d ",  ObjNr);
  Write (ostrm, "%4d ",  ObjTyp);
  Write (ostrm, "%4d\n", zablaufplan->getNr());
  Write (ostrm, "%s", "        ");
  Write (ostrm, "%4d ",  ObjAbstand->getVerteilTyp());
  ObjAbstand->schreiben    (ostrm);
  Writeln (ostrm);
  Write (ostrm, "%s", "        ");
  Write (ostrm, "%4d ",  ObjMengeDauer->getVerteilTyp());
  ObjMengeDauer->schreiben    (ostrm);
  Writeln (ostrm);
}  // ENDE write

Ustring LastProzess::getProzess (const unsigned art)
{
  char tmp [256];
  Ustring buf(tmp);
  if (art == 0)
  {
    sprintf (tmp, "{%d %d {%d\t%d\n     ",
             ObjlfdNr, ObjNr, ObjTyp, zablaufplan->getNr());
    buf = tmp;
    buf += Ustring(ObjAbstand->getVerteilTyp ());
    buf += '\t';
    buf += ObjAbstand->getVerteilung ();
    buf += Ustring("\n     ");
    buf += Ustring(ObjMengeDauer->getVerteilTyp ());
    buf += '\t';
    buf += ObjMengeDauer->getVerteilung ();
    buf += Ustring ("}}\n");
  }
  else
  if (art == 1)
  {
    sprintf (tmp, "%d %d %d", ObjNr, ObjTyp, zablaufplan->getNr());
    buf = tmp;
  }
  else
  if (art == 2)
  {
    sprintf (tmp, "%d %d %d", ObjNr, ObjTyp, zablaufplan->getNr());
    buf = tmp;
  }
  return buf;
}  // ENDE getProzess

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void LastProzess::setDefaultProzess (unsigned pnr)
{
  ObjNr = pnr;
  ObjAbstand = Verteilung::erzeugen (200);
  ObjAbstand->setVerteilung (Ustring ("0.1 20.0 3183"));
  ObjMengeDauer = Verteilung::erzeugen (210);
  ObjMengeDauer->setVerteilung (Ustring ("1 6 1581"));
}  // ENDE setDefaultProzess

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
unsigned int LastProzess::getBetrifft ()
{
  return zablaufplan->getNr();
}  // ENDE getBetrifft

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
unsigned int LastProzess::setBetrifft (unsigned nr)
{
  Arbeitsplan *zhilfe = ArbeitsplanListe->sucheArbeitsplan (nr);
  if (zhilfe == NULL)
  {
    Meld.Ausgabe(280, nr);
    return false;
  }
  zablaufplan = zhilfe;
  return zablaufplan->getNr();
}  // ENDE setBetrifft

//==================================================================
//		Declaration
//		for class StoerProzess
//==================================================================

StoerProzess::StoerProzess () : Prozess (), zbst (NULL)
{ ObjTyp = 2; }

StoerProzess::StoerProzess (typBaustein *zbetrifft)
             : Prozess (), zbst (zbetrifft)
{ ObjTyp = 2; }

StoerProzess::StoerProzess (const StoerProzess& copy) : Prozess (copy)
{
  zbst = copy.zbst;
}

StoerProzess::~StoerProzess ( )
{
  EreignisListe->TZTmitProzessLoeschen (this);
  zbst = NULL;
}

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

void StoerProzess::read (InputFile& fin, unsigned nr)
{
  unsigned vnr;
  SFXToken tok;
  ObjNr  = nr + LASTPROZESS;
  tok.nextToken (fin);  vnr = atol (tok());
  ObjAbstand = Verteilung::erzeugen (vnr);
  ObjAbstand->lesen (fin);
  tok.EndOfLine  (fin);
  tok.nextToken (fin);  vnr = atol (tok());
  ObjMengeDauer = Verteilung::erzeugen (vnr);
  ObjMengeDauer->lesen (fin);
  tok.EndOfLine  (fin);
} // ENDE read

void StoerProzess::write (ostream& ostrm)
{
  Write (ostrm, "%4d ",  ObjNr);
  Write (ostrm, "%4d ",  ObjTyp);
  Write (ostrm, "%4d\n", zbst->i_BstNr());
  Write (ostrm, "%s", "        ");
  Write (ostrm, "%4d ",  ObjAbstand->getVerteilTyp());
  ObjAbstand->schreiben    (ostrm);
  Write (ostrm, "%s\n", "");
  Write (ostrm, "%s", "        ");
  Write (ostrm, "%4d ",  ObjMengeDauer->getVerteilTyp());
  ObjMengeDauer->schreiben    (ostrm);
  Write (ostrm, "%s\n", "");
}  // ENDE write

Ustring StoerProzess::getProzess (const unsigned art)
{
  char tmp [256];
  Ustring buf(tmp);
  if (art == 0)
  {
    sprintf (tmp, "{%d %d {%d\t%d\n     ",
             ObjlfdNr, ObjNr, ObjTyp, zbst->i_BstNr());
    buf = tmp;
    buf += Ustring(ObjAbstand->getVerteilTyp ());
    buf += '\t';
    buf += ObjAbstand->getVerteilung ();
    buf += Ustring("\n     ");
    buf += Ustring(ObjMengeDauer->getVerteilTyp ());
    buf += '\t';
    buf += ObjMengeDauer->getVerteilung ();
    buf += Ustring ("}}\n");
  }
  else
  if (art == 1)
  {
    sprintf (tmp, "%d %d %d", ObjNr, ObjTyp, zbst->i_BstNr());
    buf = tmp;
  }
  else
  if (art == 2)
  {
    sprintf (tmp, "%d %d %d", ObjNr, ObjTyp, zbst->i_BstNr());
    buf = tmp;
  }
  return buf;
}  // ENDE getProzess

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void StoerProzess::setDefaultProzess (unsigned pnr)
{
  ObjNr = pnr;
  ObjAbstand = Verteilung::erzeugen (200);
  ObjAbstand->setVerteilung (Ustring ("0.1 20.0 3183"));
  ObjMengeDauer = Verteilung::erzeugen (210);
  ObjMengeDauer->setVerteilung (Ustring ("1 6 1581"));
}  // ENDE setDefaultProzess

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
unsigned int StoerProzess::setBetrifft (unsigned nr)
{
  typBaustein* zhilfe = BausteinListe->Suche (nr);
  if (zhilfe == NULL)
  {
    Meld.Ausgabe(9, nr);
    return false;
  }
  zbst = zhilfe;
  return zbst->i_BstNr();
}  // ENDE setBetrifft

//==================================================================
//		Declaration
//		for class PrgProzess
//==================================================================

PrgProzess::PrgProzess () : Prozess (), ObjBetrifft (0)
{ ObjTyp = 3; }

PrgProzess::PrgProzess (typBaustein* /*zbetrifft*/) : Prozess (), ObjBetrifft (0)
{ ObjTyp = 3; }

PrgProzess::PrgProzess (const PrgProzess& copy) : Prozess (copy)
{  }

PrgProzess::~PrgProzess ( )
{
}

void PrgProzess::operator = (const PrgProzess& copy)
{
  if (this == &copy) return;
  Prozess::operator = (copy);
}

void PrgProzess::read (InputFile& fin, unsigned nr)
{
  unsigned vnr;
  SFXToken tok;
  ObjNr  = nr + LASTPROZESS;
  tok.nextToken (fin);  vnr = atol (tok());
  ObjAbstand = Verteilung::erzeugen (vnr);
  ObjAbstand->lesen (fin);
  tok.EndOfLine  (fin);
  tok.nextToken (fin);  vnr = atol (tok());
  ObjMengeDauer = Verteilung::erzeugen (vnr);
  ObjMengeDauer->lesen (fin);
  tok.EndOfLine  (fin);
} // ENDE read

void PrgProzess::write (ostream& ostrm)
{
  Write (ostrm, "%4d ",  ObjNr);
  Write (ostrm, "%4d ",  ObjTyp);
  Write (ostrm, "%4d\n", ObjBetrifft);
  Write (ostrm, "%s", "        ");
  Write (ostrm, "%4d ",  ObjAbstand->getVerteilTyp());
  ObjAbstand->schreiben    (ostrm);
  Write (ostrm, "%s\n", "");
  Write (ostrm, "%s", "        ");
  Write (ostrm, "%4d ",  ObjMengeDauer->getVerteilTyp());
  ObjMengeDauer->schreiben    (ostrm);
  Write (ostrm, "%s\n", "");
}  // ENDE write

Ustring PrgProzess::getProzess (const unsigned art)
{
  char tmp [256];
  Ustring buf(tmp);
  if (art == 0)
  {
    sprintf (tmp, "{%d %d {%d\t%d\n     ", ObjlfdNr, ObjNr, ObjTyp, ObjBetrifft);
    buf = tmp;
    buf += Ustring(ObjAbstand->getVerteilTyp ());
    buf += '\t';
    buf += ObjAbstand->getVerteilung ();
    buf += Ustring("\n     ");
    buf += Ustring(ObjMengeDauer->getVerteilTyp ());
    buf += '\t';
    buf += ObjMengeDauer->getVerteilung ();
    buf += Ustring ("}}\n");
  }
  else
  if (art == 1)
  {
    sprintf (tmp, "%d %d %d", ObjNr, ObjTyp, ObjBetrifft);
    buf = tmp;
  }
  else
  if (art == 2)
  {
    sprintf (tmp, "%d %d %d", ObjNr, ObjTyp, ObjBetrifft);
    buf = tmp;
  }
  return buf;
}  // ENDE getProzess

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void PrgProzess::setDefaultProzess (unsigned pnr)
{
  ObjNr = pnr;
  ObjAbstand = Verteilung::erzeugen (200);
  ObjAbstand->setVerteilung (Ustring ("0.1 20.0 3183"));
  ObjMengeDauer = Verteilung::erzeugen (210);
  ObjMengeDauer->setVerteilung (Ustring ("1 6 1581"));
}  // ENDE setDefaultProzess

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
unsigned int PrgProzess::setBetrifft (unsigned nr)
{
  return (ObjBetrifft = nr);
}  // ENDE setBetrifft

//==================================================================
//		Declaration
//		for class ProzessVerwaltung
//==================================================================

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ProzessVerwaltung::ersetzen (Prozess &zalt, Prozess &zneu)
{
  Prozess *zhilfe = ProzessListe.find (zalt);
  if (zhilfe)
  {
    ProzessListe.prepend (zneu, zalt);    
    ausgliedern (zhilfe);
    delete zhilfe;
  }
}  //  ENDE ersetzen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool ProzessVerwaltung::read (Ustring datname)
{
  int  satznr = 2;
  bool OK = true;
  unsigned  nr;
  unsigned  typ;
  unsigned  objnr = 0;
  unsigned  betrifft;
  Prozess *zprozess;
  InputFile *fin;
  SFXToken tok;

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

  while((OK) && (satznr != -999))
  {
    tok.nextToken (*fin);  satznr = atoi (tok());
    if (satznr > 0)
    {
      tok.nextToken (*fin);  nr       = atol (tok());
      tok.nextToken (*fin);  typ      = atol (tok());
      tok.nextToken (*fin);  betrifft = atol (tok());
      tok.EndOfLine (*fin);

      switch (typ)
      {
        case Last  : objnr = betrifft + LASTAFNR;  break;
        case Stoer : objnr = betrifft + LASTBSTNR; break;
        case Programm : objnr = 0;                 break;
        default:  tok.nextToken (*fin); tok.EndOfLine (*fin);
                  tok.nextToken (*fin); tok.EndOfLine (*fin);
      }  // ENDE switch

      zprozess = Prozess::erzeugen (typ, objnr);
      if (zprozess)
      {
        zprozess->read (*fin, nr);
        eingliedern (*zprozess);
      }
      else
      {
        delete zprozess;
        OK = false;
      }
    }
    else
    tok.EndOfLine (*fin);
  }
  fin->close();
  delete fin;
  return OK;
} // ENDE read

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ProzessVerwaltung::write (Ustring datname) const
{
  int satznr = 3;
  LCursor<Prozess> zhilfe;
  ofstream fout (datname.str ());
  DateiKopfSchreiben (fout, "TLM");
  Write (fout, "%4d  %4d\n", 2, 0);
  Write (fout, "%d\n", -1);
  Write (fout, "%s\n", "-1 SatzNr       ProzessNr    ProzessTyp   betrifftBst");
  Write (fout, "%s\n", "-1 Abstand:     VerteilTyp   Parameter 1 .. n            Startzahl");
  Write (fout, "%s\n", "-1 Menge/Dauer: VerteilTyp   Parameter 1 .. n            Startzahl");
  Write (fout, "%d\n", -1);

  for (zhilfe = ProzessListe; zhilfe; zhilfe++)
  {
    Write (fout, "%4d    ", satznr);
    zhilfe()->write (fout);
    satznr++;
  }
  DateiFussSchreiben (fout, "TLM");
  fout.close ();
} // ENDE write

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Prozess* ProzessVerwaltung::suche (typBaustein* zbst)
{
  LCursor<Prozess> zhilfe;
  for (zhilfe = ProzessListe; zhilfe; zhilfe++)
    if (zhilfe()->AufBaustein() == zbst) return zhilfe();
  return NULL;
} // ENDE suche

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Prozess* ProzessVerwaltung::suche (unsigned int enr)
{
  LCursor<Prozess> zhilfe;
  for (zhilfe = ProzessListe; zhilfe; zhilfe++)
    if (zhilfe()->getNr() == enr) return zhilfe();
  return NULL;
} // ENDE suche

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ProzessVerwaltung::TLMmitBausteinLoeschen (typBaustein* zbstein)
{
  Prozess *zloesch;
  LCursor<Prozess> zhilfe;
  
  for (zhilfe = ProzessListe; zhilfe; zhilfe++)
    if (zhilfe()->AufBaustein() == zbstein)
    {
      zloesch = zhilfe();
      ausgliedern (zloesch);
      delete zloesch;
    }
}  // ENDE TLMmitBausteinLoeschen                        

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ProzessVerwaltung::TLMmitArbeitsplanLoeschen (Arbeitsplan* zaplan)
{
  Prozess *zloesch;
  LCursor<Prozess> zhilfe;
  
  for (zhilfe = ProzessListe; zhilfe; zhilfe++)
    if (zhilfe()->AufArbeitsplan() == zaplan)
    {
      zloesch = zhilfe();
      ausgliedern (zloesch);
      delete zloesch;
    }
}  // ENDE TLMmitArbeitsplanLoeschen                        

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ProzessVerwaltung::erzeugen (unsigned pnr, unsigned ptyp, 
                                     unsigned betrifft)
{
  if (!pnr)
  {
    Meld.Ausgabe(210);
    return Ustring ((int) false);
  }
  Prozess *zprozess = suche (pnr);
  if (zprozess)
  {
    Meld.Ausgabe(94, pnr);
    return Ustring ((int) false);
  }
  zprozess = Prozess::erzeugen(ptyp, betrifft);
  if (!zprozess) return Ustring((int) false);
  
  zprozess->setDefaultProzess (pnr);
  eingliedern (*zprozess);
  return Ustring((int) true);
}  // ENDE erzeugen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ProzessVerwaltung::loeschen (unsigned pnr)
{
  Prozess* zprozess = suche (pnr);
  if (zprozess)
    delete ProzessListe.remove (*zprozess);
}  // ENDE loeschen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ProzessVerwaltung::loeschen ()
{
  while (!ProzessListe.isEmpty()) delete ProzessListe.removeFirst();
}  // ENDE loeschen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ProzessVerwaltung::eingliedern (Prozess &zprozess)
{
  LCursor<Prozess> zhilfe;
  for (zhilfe = ProzessListe; zhilfe (); zhilfe++)
    if (zprozess.getNr() < zhilfe()->getNr()) break;

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

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ProzessVerwaltung::Info ()
{
  Ustring buf;
  unsigned i = 0;
  for (LCursor<Prozess> zhilfe = ProzessListe; zhilfe (); i++, zhilfe++)
  {
    zhilfe()->setLfdNr (i);
    buf += zhilfe()->getProzess();
  }
  return buf;
}  // ENDE Info

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ProzessVerwaltung::setProzessnr (unsigned altnr, unsigned neunr)
{
  Prozess* zalt = suche (altnr);
  Prozess* zneu = suche (neunr);
  if (!zalt)
  {
    Meld.Ausgabe(93, altnr);
    return Ustring (altnr);
  }
  if (zneu)
  {
    Meld.Ausgabe(94, neunr);
    return Ustring (altnr);
  }
  zalt->setNr (neunr);
  ausgliedern (zalt);
  eingliedern (*zalt);
  return Ustring (zalt->getNr());
}  // ENDE setProzessnr

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ProzessVerwaltung::setBetrifft (unsigned pnr, unsigned ptyp, 
                                        unsigned betrifft)
{
  Prozess* zalt = suche (pnr);
  if (!zalt)
  {
    Meld.Ausgabe(93, pnr);
    return Ustring ((int) false);
  }

  Prozess *zneu = Prozess::erzeugen(ptyp, betrifft);
  if (!zneu) return Ustring((int) false);
  
  zneu->setNr(zalt->getNr());
  zneu->setLfdNr(zalt->getLfdNr());
  zneu->setAbstandVerteilung (zalt->getAbstandVerteilung());
  zneu->setMengeDauerVerteilung (zalt->getMengeDauerVerteilung());
  ersetzen (*zalt, *zneu);
  return Ustring (zneu->setBetrifft (betrifft));
}  // ENDE setBetrifft

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ProzessVerwaltung::getAbstandVerteilung (unsigned pnr)
{
  Prozess* zprozess = suche (pnr);
  if (zprozess) return zprozess->getAbstandVerteilung ();
  return Ustring ();
}  // ENDE getAbstandVerteilung

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ProzessVerwaltung::setAbstandVerteilung (unsigned pnr, unsigned vnr, Ustring str)
{
  Prozess* zprozess = suche (pnr);
  if (!zprozess)
  {
    Msg.Warning ("ProzessVerwaltung::setAbstandVerteilung",
                 "Prozessnr. %d nicht gefunden", pnr);
    return Ustring ();
  }
  if (zprozess) 
  {
    zprozess->setAbstandVerteilung (vnr, str);
    return zprozess->getAbstandVerteilung ();
  }  
  return Ustring ();
}  // ENDE setAbstandVerteilung

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ProzessVerwaltung::getMengeDauerVerteilung (unsigned pnr)
{
  Prozess* zprozess = suche (pnr);
  if (zprozess) return zprozess->getMengeDauerVerteilung ();
  return Ustring ();
}  // ENDE getMengeDauerVerteilung

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ProzessVerwaltung::setMengeDauerVerteilung (unsigned pnr, unsigned vnr, Ustring str)
{
  Prozess* zprozess = suche (pnr);
  if (!zprozess)
  {
    Msg.Warning ("ProzessVerwaltung::setMengeDauerVerteilung",
                 "Prozessnr. %d nicht gefunden", pnr);
    return Ustring ();
  }
  
  if (zprozess) 
  {
    zprozess->setMengeDauerVerteilung (vnr, str);
    return zprozess->getMengeDauerVerteilung();
  }
  return Ustring ();
}  // ENDE setMengeDauerVerteilung

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ProzessVerwaltung::Select (int pnr)
{
  Prozess* zprozess = suche (pnr);
  if (zprozess) return zprozess->getProzess(1);
  return Ustring ();
}  // ENDE Select

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

