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

#include <stdlib.h>

#include "Zufall.h"

#include "Token.h"

#define _PROZESS_CPP
#include "modell.h"
#include "prozess.h"

//---------------------------------------------------------
// Klasse typProzess
//---------------------------------------------------------

typProzess::typProzess (unsigned nr, unsigned typ)
  : ObjBetrifft   (0),
    ObjNummer     (nr),
    ObjTyp        (typ),
    ObjStatusFlag (GO)
 { }

typProzess::~typProzess ()
 { }

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

unsigned typProzess::Typ () const {
  return ObjTyp;
}

unsigned typProzess::Betrifft () const {
  return ObjBetrifft;
}

bool typProzess::isStopped () const {
  return (ObjStatusFlag == STOP);
}

void typProzess::stop () {
  ObjStatusFlag = STOP;
}

void typProzess::go () {
  ObjStatusFlag = GO;
}

/*virtual*/ ostream& typProzess::schreiben (ostream& ostrm) const {
  ostrm << "Nummer: ";
  ostrm.width (2);
  ostrm << ObjNummer << "  Typ: ";
  ostrm.width (2);
  ostrm << ObjTyp << "  Betrifft: ";
  ostrm.width (2);
  ostrm << ObjBetrifft << endl;
  return ostrm;
}

//---------------------------------------------------------
// Klasse typAnkunftsProzess
//---------------------------------------------------------

typAnkunftsProzess::typAnkunftsProzess (unsigned nr)
  : typProzess    (nr, ANKUNFT),
    ObjAbstand    (NULL),
    ObjMenge      (NULL)
  { }

typAnkunftsProzess::~typAnkunftsProzess () { 
  if (ObjAbstand) delete ObjAbstand;
  if (ObjMenge)   delete ObjMenge;
}

double typAnkunftsProzess::ZufAbstand () {
  return ObjAbstand->NeueZahl ();
}

int typAnkunftsProzess::ZufMenge () {
  return (int) ObjMenge->NeueZahl ();
}

void typAnkunftsProzess::lesen (InputFile& file) {
  SFXToken tok;
  unsigned art;

  tok.nextToken (file);
  ObjBetrifft = atoi (tok ());
  tok.nextToken (file);
  art = atoi (tok ());

  ObjAbstand = Verteilung::erzeugen (art);
  ObjAbstand->lesen (file);

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

  ObjMenge = Verteilung::erzeugen (art);
  ObjMenge->lesen (file);
}

/*virtual*/ ostream& typAnkunftsProzess::schreiben (ostream& ostrm) const {
  ostrm << "typAnkunftsProzess: ";
  return typProzess::schreiben (ostrm);
}

//---------------------------------------------------------
// Klasse typStoerProzess
//---------------------------------------------------------

typStoerProzess::typStoerProzess (unsigned nr)
  : typProzess    (nr, STOERUNG),
    ObjAbstand    (NULL),
    ObjDauer      (NULL)
 { }

typStoerProzess::~typStoerProzess () {
  if (ObjAbstand) delete ObjAbstand;
  if (ObjDauer)   delete ObjDauer;
}

double typStoerProzess::ZufAbstand () {
  return ObjAbstand->NeueZahl ();
}

double typStoerProzess::ZufDauer() {
  return ObjDauer->NeueZahl ();
}

void typStoerProzess::lesen (InputFile& file) {
  SFXToken tok;
  unsigned art;

  tok.nextToken (file);
  ObjBetrifft = atoi (tok ());
  tok.nextToken (file);
  art = atoi (tok ());

  ObjAbstand = Verteilung::erzeugen (art);
  ObjAbstand->lesen (file);

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

  ObjDauer = Verteilung::erzeugen (art);
  ObjDauer->lesen (file);
}

/*virtual*/ ostream& typStoerProzess::schreiben (ostream& ostrm) const {
  ostrm << "typStoerProzess: ";
  return typProzess::schreiben (ostrm);
}

//---------------------------------------------------------
// Klasse typPRGProzess
//---------------------------------------------------------

typPRGProzess::typPRGProzess (unsigned nr)
  : typProzess (nr, PRG),
    ObjV1      (NULL),
    ObjV2      (NULL)
 { }

typPRGProzess::typPRGProzess (unsigned nr, int Art, float v1_min, float v1_mittel, float v1_max, int v1_start, float v2_min, float v2_mittel, float v2_max, int v2_start)
  : typProzess (nr, PRG) {
 if (Art == 1) {
   ObjV1 = new RealExpMitGrenzeNeuziehen (v1_min, v1_mittel, v1_max, v1_start);
   ObjV2 = new RealExpMitGrenzeNeuziehen (v2_min, v2_mittel, v2_max, v2_start);
 } 
}
 

typPRGProzess::~typPRGProzess () {
  if (ObjV1) delete ObjV1;
  if (ObjV2) delete ObjV2;
}

double typPRGProzess::ZufV1 () {
  return ObjV1->NeueZahl ();
}

double typPRGProzess::ZufV2 () {
  return ObjV2->NeueZahl ();
}

void typPRGProzess::lesen (InputFile& file) {
  SFXToken tok;
  unsigned art;

  tok.nextToken (file);
  ObjBetrifft = atoi (tok ());
  tok.nextToken (file);
  art = atoi (tok ());

  ObjV1 = Verteilung::erzeugen (art);
  ObjV1->lesen (file);

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

  ObjV2 = Verteilung::erzeugen (art);
  ObjV2->lesen (file);
}

/*virtual*/ ostream& typPRGProzess::schreiben (ostream& ostrm) const {
  ostrm << "typPRGProzess: ";
  return typProzess::schreiben (ostrm);
}


