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

#define _BESTELL_CPP
#include "bestell.h"

#include "transp.h"

//-----------------------------------------------------
//   Klasse Bestellzettel
//-----------------------------------------------------

Bestellzettel::Bestellzettel (unsigned istv, unsigned sollv, unsigned wieoft)
 : ObjIstvorgang   (istv),
   ObjSollvorgang  (sollv),
   ObjWieoft       (wieoft)
 { }

/*virtual*/ Bestellzettel::~Bestellzettel ()
 { }

unsigned Bestellzettel::IstVorgang () const {
  return ObjIstvorgang;
}

unsigned Bestellzettel::SollVorgang () const {
  return ObjSollvorgang;
}

unsigned Bestellzettel::Wieoft () const {
  return ObjWieoft;
}

unsigned Bestellzettel::decWieoft () {
  return --ObjWieoft;
}

/*virtual*/ bool Bestellzettel::hatArbeitsplan (unsigned, unsigned) const {
  return false;
}

/*virtual*/ bool Bestellzettel::hatArtikel (unsigned, unsigned) const {
  return false;
}

/*virtual*/ void Bestellzettel::DruckeBestellZettel () const {
   cout << "Bestellzettel: IstVorgang " << IstVorgang()
        << " -- SollVorgang " << SollVorgang()
        << " -- Menge " << Wieoft()
        << endl;
}

//-----------------------------------------------------
//   Klasse ArbeitsplanBestellzettel
//-----------------------------------------------------

ArbeitsplanBestellzettel::ArbeitsplanBestellzettel (unsigned arbNr,
  unsigned istv, unsigned sollv, unsigned wieoft)
 : Bestellzettel    (istv, sollv, wieoft),
   ObjArbeitsplanNr (arbNr)
 { }

/*virtual*/ ArbeitsplanBestellzettel::~ArbeitsplanBestellzettel ()
 { }

/*virtual*/ unsigned ArbeitsplanBestellzettel::IdentNr () const {
  return ObjArbeitsplanNr;
}

/*virtual*/ bool ArbeitsplanBestellzettel::hatArbeitsplan (unsigned idnr, unsigned istv) const {
  return (idnr == ObjArbeitsplanNr) && ((istv == IstVorgang ()) || (istv == 0));
}

/*virtual*/ bool ArbeitsplanBestellzettel::TransportEinheitPasst (typTransportEinheit* zTE) const {
  return zTE->hatArbeitsplan (ObjArbeitsplanNr, IstVorgang ());
}

/*virtual*/ void ArbeitsplanBestellzettel::DruckeBestellZettel () const {
   cout << "Bestellzettel: Arbeitsplan Nr. " << IdentNr()
        << " -- IstVorgang " << IstVorgang()
        << " -- SollVorgang " << SollVorgang()
        << " -- Menge " << Wieoft()
        << endl;
}

//-----------------------------------------------------
//   Klasse ArtikelBestellzettel
//-----------------------------------------------------

ArtikelBestellzettel::ArtikelBestellzettel (unsigned artNr, unsigned istv,
  unsigned sollv, unsigned wieoft)
 : Bestellzettel (istv, sollv, wieoft),
   ObjArtikelNr  (artNr)
 { }

/*virtual*/ ArtikelBestellzettel::~ArtikelBestellzettel ()
 { }

/*virtual*/ unsigned ArtikelBestellzettel::IdentNr () const {
  return ObjArtikelNr;
}

/*virtual*/ bool ArtikelBestellzettel::hatArtikel (unsigned idnr, unsigned istv) const {
  return (idnr == ObjArtikelNr) && ((istv == IstVorgang ()) || (istv == 0));
}

/*virtual*/ bool ArtikelBestellzettel::TransportEinheitPasst (typTransportEinheit* zTE) const {
  return zTE->hatArtikel (ObjArtikelNr, IstVorgang ());
}

/*virtual*/ void ArtikelBestellzettel::DruckeBestellZettel () const {
  cout << "Bestellzettel: Artikel Nr. " << IdentNr()
        << " -- IstVorgang " << IstVorgang()
        << " -- SollVorgang " << SollVorgang()
        << " -- Menge " << Wieoft()
        << endl;
}

//-----------------------------------------------------
//   Klasse TEBestellzettel
//-----------------------------------------------------

TEBestellzettel::TEBestellzettel (typTransportEinheit* welcheTE, unsigned sollv)
 : Bestellzettel (0/*istv*/, sollv, 1/*menge*/),
   ObjTE  (welcheTE)
 { }

/*virtual*/ TEBestellzettel::~TEBestellzettel ()
 { }

/*virtual*/ unsigned TEBestellzettel::IdentNr () const {
  return 0;
}

typTransportEinheit* TEBestellzettel::TE () const {
  return ObjTE;
}

/*virtual*/ bool TEBestellzettel::TransportEinheitPasst (typTransportEinheit* zTE) const {
  return (ObjTE == zTE);
}

void TEBestellzettel::DruckeBestellZettel () const {
   cout << "TEBestellzettel: TransportEinheit " << TE()->ID()
        << " -- IstVorgang " << IstVorgang()
        << " -- SollVorgang " << SollVorgang()
        << " -- Menge " << Wieoft()
        << endl;
}

//-----------------------------------------------------
//   Klasse Zuweisung
//-----------------------------------------------------

Zuweisung::Zuweisung (unsigned fuerwen, unsigned istv, unsigned sollv,
                      unsigned wieoft)
 : Bestellzettel    (istv, sollv, wieoft),
   ObjFuerBaustein (fuerwen)
 { }

/*virtual*/ Zuweisung::~Zuweisung () { }

unsigned Zuweisung::FuerBaustein () const {
  return ObjFuerBaustein;
}

/*virtual*/ bool Zuweisung::hatArbeitsplan (unsigned, unsigned) const {
  return false;
}

/*virtual*/ bool Zuweisung::hatArtikel (unsigned, unsigned) const {
  return false;
}
//-----------------------------------------------------
//   Klasse ArbeitsplanZuweisung
//-----------------------------------------------------

ArbeitsplanZuweisung::ArbeitsplanZuweisung (unsigned arbNr, unsigned fuerwen,
  unsigned istv, unsigned sollv, unsigned wieoft)
 : Zuweisung (fuerwen, istv, sollv, wieoft),
   ObjArbeitsplanNr (arbNr)
 { }

/*virtual*/ ArbeitsplanZuweisung::~ArbeitsplanZuweisung ()
 { }

/*virtual*/ unsigned ArbeitsplanZuweisung::IdentNr  () const {
  return ObjArbeitsplanNr;
}

/*virtual*/ bool ArbeitsplanZuweisung::hatArbeitsplan (unsigned idnr, unsigned istv) const {
  return (idnr == ObjArbeitsplanNr) && ((istv == IstVorgang ()) || (istv == 0));
}

/*virtual*/ bool ArbeitsplanZuweisung::TransportEinheitPasst (typTransportEinheit* zTE) const {
  return zTE->hatArbeitsplan (ObjArbeitsplanNr, IstVorgang ());
}

//-----------------------------------------------------
//   Klasse ArtikelZuweisung
//-----------------------------------------------------

ArtikelZuweisung::ArtikelZuweisung (unsigned artNr, unsigned fuerwen,
  unsigned istv, unsigned sollv, unsigned wieoft)
 : Zuweisung (fuerwen, istv, sollv, wieoft),
   ObjArtikelNr (artNr)
 { }

/*virtual*/ ArtikelZuweisung::~ArtikelZuweisung ()
 { }

 /*virtual*/ unsigned ArtikelZuweisung::IdentNr  () const {
  return ObjArtikelNr;
}

/*virtual*/ bool ArtikelZuweisung::hatArtikel (unsigned idnr, unsigned istv) const {
  return (idnr == ObjArtikelNr) && ((istv == IstVorgang ()) || (istv == 0));
}

/*virtual*/ bool ArtikelZuweisung::TransportEinheitPasst (typTransportEinheit* zTE) const {
  return zTE->hatArtikel (ObjArtikelNr, IstVorgang ());
}


//---------------------------------------------------------
// Klasse typTransportBestellung
//---------------------------------------------------------

typTransportBestellung::typTransportBestellung (unsigned werBstNr, unsigned zielBstNr, unsigned palPlatz, unsigned typ)
 : ObjPrio       				(-10),
   ObjTransportBausteinNr	(werBstNr),
   ObjZielBausteinNr			(zielBstNr),
   ObjTransportPalPlatz		(palPlatz),
   ObjTyp						(typ) // 0 = holen, 1 = bringen
 { }

typTransportBestellung::~typTransportBestellung ()
{}

const unsigned typTransportBestellung::TransportBausteinNr () const
{
	return ObjTransportBausteinNr;
}

const unsigned typTransportBestellung::ZielBausteinNr () const
{
	return ObjZielBausteinNr;
}

const unsigned typTransportBestellung::TransportPalPlatz () const
{
	return ObjTransportPalPlatz;
}

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

int typTransportBestellung::Prioritaet () const
{
  return ObjPrio;
}

void typTransportBestellung::incPrioritaet (int wert)
{
  ObjPrio += wert;
}

void typTransportBestellung::decPrioritaet (int wert)
{
  ObjPrio -= wert;
}

void typTransportBestellung::setPrioritaet (int wert)
{
  ObjPrio = wert;
}

void typTransportBestellung::AnfangGliedern (List<typTransportBestellung>& lst)
{
	lst.prepend (*this);
}

void typTransportBestellung::PrioEingliedern (List<typTransportBestellung>& lst)
{
	LCursor<typTransportBestellung> c (lst);
	for ( ; c; c++)
	{
		if (ObjPrio > c ()->Prioritaet ())
		{
			break;
		}
	}
	lst.prepend (*this, c);
}

void typTransportBestellung::VorGliedern (List<typTransportBestellung>& lst, const typTransportBestellung *alt)
{
	LCursor<typTransportBestellung> c (lst);
	for ( ; c; c++)
	{
		if (c () == alt)
		{
			break;
		}
	}
	lst.prepend (*this, c);
}

void typTransportBestellung::print ()
{
	cout	<< " Prio= " << ObjPrio
			<< " Transpbst= " << ObjTransportBausteinNr
			<< " Zielbst= " << ObjZielBausteinNr
			<< " Platz= " << ObjTransportPalPlatz
			<< " Typ= " << ObjTyp	<< endl;
}