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

#include "Messung.h"
#include "Token.h"

#define _ARBPLAN_CPP
#include "modell.h"
#include "arbplan.h"

#include "sfx.h"
#include "transp.h"
#include "programm.h"

//---------------------------------------------------------
// class typStlElement
//---------------------------------------------------------

typStlElement::typStlElement ()
 : ObjAnzahl   (0),
   ObjArtikel  (0),
   ObjVariante (0),
   ObjMenge    (0.0),
   ObjZeit     ()
 { }

 typStlElement::typStlElement (const typStlElement& stlEl)
 : ObjAnzahl   (stlEl.ObjAnzahl),
   ObjArtikel  (stlEl.ObjArtikel),
   ObjVariante (stlEl.ObjVariante),
   ObjMenge    (stlEl.ObjMenge),
   ObjZeit     (stlEl.ObjZeit)
 { }

 typStlElement::~typStlElement ()
 { }

const SimTime& typStlElement::Zeit () const {
  return ObjZeit;
}

const unsigned& typStlElement::Variante () const {
  return ObjVariante;
}

const unsigned& typStlElement::Anzahl() const {
  return ObjAnzahl;
}

const unsigned& typStlElement::incAnzahl () {
  return (++ObjAnzahl);
}

const unsigned& typStlElement::decAnzahl () {
  return (--ObjAnzahl);
}

const unsigned& typStlElement::setAnzahl (const unsigned& newAnzahl) {
  return (ObjAnzahl = newAnzahl);
}

const unsigned& typStlElement::Artikel () const {
  return ObjArtikel;
}

const unsigned& typStlElement::setArtikel (const unsigned& artNr) {
  return ObjArtikel = artNr;
}

const double& typStlElement::Menge () const {
  return ObjMenge;
}

const double& typStlElement::incMenge (const double& deltaM) {
  return (ObjMenge += deltaM);
}

const double& typStlElement::decMenge (const double& deltaM) {
  return (ObjMenge -= deltaM);
}

const double& typStlElement::setMenge (const double& newMenge) {
  return (ObjMenge = newMenge);
}

void typStlElement::lesen (InputFile& file) {
  SFXToken tok;

  tok.nextToken (file);
  ObjAnzahl = atoi (tok ());

  tok.nextToken (file);
  ObjArtikel = atoi (tok ());

  tok.nextToken (file);
  ObjVariante = atoi (tok ());

  tok.nextToken (file);
  ObjMenge = atof (tok ());

  tok.nextToken (file);
  ObjZeit = atof (tok ()) * SimTime::SecondsPerMinute ();
}

ostream& typStlElement::schreiben (ostream& ostrm) const {
  ostrm.precision (2);
  ostrm << "Anzahl ";
  ostrm.width (3);
  ostrm << ObjAnzahl << " Artikel ";
  ostrm.width (3);
  ostrm << ObjArtikel << " Variante ";
  ostrm.width (3);
  ostrm << ObjVariante << " Menge ";
  ostrm.width (3);
  ostrm << ObjMenge << " H_Zeit ";
  ostrm << ObjZeit.inMinutes () << endl;
  return ostrm;
}

//-------------------------------------------------------
//  class typVorgang
//-------------------------------------------------------

typVorgang::typVorgang ()
 : ObjNummer  (0),
   ObjProgNr  (0),
   ObjZielBst (NULL),
   ObjDauer   (),
   ObjName    ()
 { }

typVorgang::~typVorgang ()
 { }

unsigned typVorgang::Nummer () const {
  return ObjNummer;
}

typBaustein* typVorgang::ZielBaustein () const {
  return ObjZielBst;
}

const int& typVorgang::ProgNr () const {
  return ObjProgNr;
}

const SimTime& typVorgang::Dauer () const {
  return ObjDauer;
}
void typVorgang::setDauer (const SimTime& zeit) {
  ObjDauer = zeit;
}

void typVorgang::lesen (InputFile& file) {
  SFXToken tok;

  tok.nextToken (file);
  ObjNummer = atoi (tok ());

  tok.nextToken (file);
  ObjZielBst = baustein [atoi (tok ())];

  tok.nextToken (file);
  ObjDauer = atof (tok ()) * SimTime::SecondsPerMinute ();

  tok.nextToken (file);
  ObjProgNr = atoi (tok ());

  switch (ObjZielBst->Basistyp ()) {
    case tQuelle:
    case tSenke:
    case tMaschine:
    case tNcPoolverwalter: PrgModul->installProg (ObjProgNr); break;
    default: break;
  }

  tok.nextToken (file);
  ObjName = Ustring (tok ());

  file.jump (100); //EOL
}

ostream& typVorgang::schreiben (ostream& ostrm) const {
  ostrm.precision (2);
  ostrm << " ";
  ostrm.width (3);
  ostrm << ObjNummer << " ";
  ostrm.width (3);
  ostrm << ObjZielBst->Nummer () << " ";
  ostrm.width (5);
  ostrm << ObjDauer.inMinutes () << " ";
  ostrm.width (3);
  ostrm << ObjProgNr << " ";
  ostrm << ObjName.str () << endl;
  return ostrm;
}

//-------------------------------------------------------
//  Klasse typArbeitsplan
//-------------------------------------------------------

typArbeitsplan::typArbeitsplan (unsigned n)
 : ObjNummer        (n),
   ObjAnzahl        (0),
   ObjPalvariante   (0),
   ObjTempEin       (0),
   ObjTempAus       (0),

   ObjTransportPos  (),
   ObjName          (),

   ObjBestandGeschichte    (NULL),
   ObjDlzRegister   (NULL),
   ObjWechselzeit   (),

   ObjEingangsListe (1),
   ObjBestandsListe (1),
   ObjVorgaenge     ()
 { }

typArbeitsplan::~typArbeitsplan () {
  if (ObjDlzRegister) delete ObjDlzRegister;
  while (ObjEingangsListe.Last ()) delete ObjEingangsListe.removeLast ();
  while (ObjBestandsListe.Last ()) delete ObjBestandsListe.removeLast ();
  while (ObjVorgaenge.Last ())     delete ObjVorgaenge.removeLast ();
}

unsigned typArbeitsplan::Nummer () const {
  return ObjNummer;
}

unsigned typArbeitsplan::Palettenvariante () const {
  return ObjPalvariante;
}

unsigned typArbeitsplan::TempEin () const {
  return ObjTempEin;
}

unsigned typArbeitsplan::TempAus () const {
  return ObjTempAus;
}

const SimTime& typArbeitsplan::Wechselzeit () const {
  return ObjWechselzeit;
}

const Vec3D& typArbeitsplan::TransportPos () const {
  return ObjTransportPos;
}

Geschichte * typArbeitsplan::BestandGeschichte () const {
   return ObjBestandGeschichte;
}

void typArbeitsplan::setBestandGeschichte (Geschichte *newGeschichte) {
   ObjBestandGeschichte = newGeschichte;
}

Register *typArbeitsplan::DlzRegister () const {
  return ObjDlzRegister;
}

void typArbeitsplan::setDlzRegister (Register *newReg) {
  ObjDlzRegister = newReg;
}

SimTime typArbeitsplan::SummeVorgangszeit () const {
  SimTime sumZeit (0.0);
  for (LCursor<typVorgang> c (ObjVorgaenge); c; c++)
     sumZeit += c ()->Dauer ();
  return sumZeit;
}

const List<typVorgang>& typArbeitsplan::Vorgaenge () const {
  return ObjVorgaenge;
}

typVorgang* typArbeitsplan::findeVorgang (const unsigned vorgNr) const {
  for (LCursor<typVorgang> c (ObjVorgaenge); c; c++)
    if (c ()->Nummer () == vorgNr) return c ();
  return NULL;
}

const DynArray<typStlElement>& typArbeitsplan::EingangsListe () const {
  return ObjEingangsListe;
}

const DynArray<typStlElement>& typArbeitsplan::BestandsListe () const {
return ObjBestandsListe;
}

void typArbeitsplan::startBDE () {
  ObjTempEin++;
  ObjWechselzeit = Modellzeit ();
  if (ObjBestandGeschichte) {
      ObjBestandGeschichte->erfassen(ObjTempEin-ObjTempAus);
  }
}

void typArbeitsplan::stopBDE (typTransportEinheit *zTE) {
  ObjTempAus++;
  if (ObjDlzRegister)
    ObjDlzRegister->erfassen (zTE->Laufzeit ().inMinutes ());
  ObjWechselzeit = Modellzeit ();
  if (ObjBestandGeschichte) {
      ObjBestandGeschichte->erfassen(ObjTempEin-ObjTempAus);
  }
}

void typArbeitsplan::lesen (InputFile& file) {
  SFXToken tok;
  typVorgang *zvorgang;

  tok.nextToken (file);
  ObjName = Ustring (tok ());

  file.jump (100); //EOL

  int anzahl;
  typStlElement *zStlEl;

  tok.nextToken (file);
  anzahl = atoi (tok ());

  for (int x = 0; x < anzahl; x++) {
    zStlEl = new typStlElement ();
    zStlEl->lesen (file);
    ObjEingangsListe.append (*zStlEl);
  }

  file.jump (100); //EOL

  tok.nextToken (file);
  anzahl = atoi (tok ());

  if (anzahl) {
    for (int x = 0; x < anzahl; x++) {
      zStlEl = new typStlElement();
      zStlEl->lesen (file);
      ObjBestandsListe.append (*zStlEl);
    }
  }
  file.jump (100); //EOL

  liesVariante (file);

  tok.nextToken (file);
  ObjAnzahl = atoi (tok ());

  for (unsigned v = 1; v <= ObjAnzahl; v++) {
    zvorgang = new typVorgang;
    zvorgang->lesen (file);
    ObjVorgaenge.append (*zvorgang);
  }
}

ostream& typArbeitsplan::schreiben (ostream& ostrm) const {
  ostrm.precision (2);
  ostrm << "TAS:  ";
  ostrm.width (3);
  ostrm << ObjNummer << " ";
  ostrm.width (3);
  ostrm << ObjName.str () << endl << "     ";
  ostrm.width (5);
  ostrm << ObjEingangsListe.Count () << "       E_Stueckzahl" << endl;
  ostrm.width (5);
  ostrm << ObjBestandsListe.Count () << "       B_Stueckzahl" << endl << "PalVariante ";
  ostrm.width (3);
  ostrm << ObjPalvariante << endl;
  ostrm.width (4);
  ostrm << ObjAnzahl << " Vorgaenge" << endl;
  for (LCursor<typVorgang> c (ObjVorgaenge); c; c++)
    c ()->schreiben (ostrm);
  return ostrm;

}

ostream& typArbeitsplan::schreibeZustand (ostream& ostrm) const {
  ostrm.precision (5);
  ostrm << " ";
  ostrm.width (5);
  ostrm << ObjNummer << " ";
  ostrm.width (5);
  ostrm << ObjTempEin << " ";
  ostrm.width (5);
  ostrm << ObjTempAus << " ";
  ostrm.width (5);
  ostrm << (ObjTempEin - ObjTempAus) << "  ";
  return ostrm;
}

ostream& typArbeitsplan::schreibeProtokoll (ostream& ostrm) const {
  schreibeZustand (ostrm);
  if (ObjDlzRegister)
    ostrm << (*ObjDlzRegister);
  return ostrm;
}

void typArbeitsplan::liesVariante (InputFile& file) {
  SFXToken tok;
  double x, y, z;

  tok.nextToken (file);
  x = atof (tok ());
  tok.nextToken (file);
  y = atof (tok ());
  tok.nextToken (file);
  z = atof (tok ());

  ObjTransportPos = Vec3D (x, y, z);

  tok.nextToken (file);
  tok.nextToken (file);
  tok.nextToken (file);
  ObjPalvariante = atoi (tok ());

  file.jump (100); //EOL
}
// typArbeitsplan
