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

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
typBstZeiger* typPoolVerwaltung::Suche (typBaustein* zbstein, 
                                        List<typBstZeiger> &LST)
{
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = LST; zhilfe; zhilfe++)
     if (zhilfe()->zBst == zbstein) return zhilfe();
  return NULL;
}  // ENDE Suche

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool typPoolVerwaltung::LiesPoolListe (InputFile& fin,
                                       List<typBstZeiger> &LST)
{
  int zaehler, bstnr;
  typBaustein* zbst;
  typBstZeiger* zhilfe;
  SFXToken tok;

  tok.nextToken (fin);  int anzelemente = atoi (tok());
  if (!anzelemente) return true;
  for (zaehler = 1; (zaehler <= anzelemente); zaehler++)
  {
    tok.nextToken (fin);  bstnr = atoi (tok());
    if (((zaehler % 10)== 0) && (zaehler < anzelemente))
       tok.EndOfLine (fin);
    zbst = BausteinListe->Suche(bstnr+LASTBSTNR);
    if (!zbst)
    {
      Meld.Ausgabe(9, bstnr+LASTBSTNR);
      return  false;
    }

    if (!Suche (zbst, LST))
    {
//          if zpoolbaustein^.zbaus^.basistyp in [tregaleinheit]
//          then zpoolbaustein^.zbaus^.zmeinverwalter := zbaustein;
      zhilfe = new typBstZeiger(zbst);
      LST.append (*zhilfe);
    }
  }
  tok.EndOfLine (fin);
  return true;
} // ENDE LiesPoolListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool typPoolVerwaltung::BPVLesen (InputFile& fin, int btyp)
{
  bool OK = LiesPoolListe (fin, InhaltsListe);
   if (OK)
   if ((btyp == tRegalverwalter) || (btyp == tFtsLadepool))
       OK = LiesPoolListe(fin, BetreuteListe);
  return OK;
}  // ENDE BPVLesen

void typPoolVerwaltung::SchreibPoolListe (ostream& ostrm,
                                          List<typBstZeiger>& LST)
{
  int zaehler = 1;

  LCursor<typBstZeiger> zhilfe = LST;
  if (zhilfe)
  {
    Write (ostrm, "%6d  ", LST.Count());
    for (zhilfe = LST; zhilfe; zhilfe++, zaehler++)
    {
      Write (ostrm, "%4d ", zhilfe()->zBst->i_BstNr());
      if (((zaehler % 10)== 0) && (zhilfe() != LST.Last()))
         Write (ostrm, "\n%s", "                          ");
    }
    Write (ostrm, "%s\n", "");
  }
  else
    Write (ostrm, "%6d\n", LST.Count());
}  // ENDE SchreibPoolListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::BPVSchreiben (ostream& ostrm,
                                      typBaustein* zbstein, int& satznr)
{
  satznr++;
  Write (ostrm, "%4d ", satznr);
  Write (ostrm, "%4d ", zbstein->i_BstNr());
  Write (ostrm, "%7d ", zbstein->i_BstTyp());
  SchreibPoolListe (ostrm, InhaltsListe);
  if ((zbstein->i_BstTyp() == tRegalverwalter) ||
      (zbstein->i_BstTyp() == tFtsLadepool))
  {
    Write (ostrm, "%s", "                  ");
    SchreibPoolListe (ostrm, BetreuteListe);
  }
}  // ENDE BPVSchreiben

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::TFKErzeugenVonPoolZuBaustein (typBaustein* /*zanfang*/,
                                                      typBaustein* zende)
{
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
  {
     if ((zhilfe()->zBst->i_BstTyp() == tRegalverwalter)  ||
         (zhilfe()->zBst->i_BstTyp() == tNcPoolverwalter))
        zhilfe()->zBst->TFKErzeugenVonPoolZuBaustein (zhilfe()->zBst, zende);
        else
        FahrkursListe->TFKErzeugen(zhilfe()->zBst, zende);
  }
}  // ENDE TFKErzeugenVonPoolZuBaustein

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::TFKErzeugenVonBausteinZuPool (typBaustein* zanfang,
                                                      typBaustein* /*zende*/)
{
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
  {
     if ((zhilfe()->zBst->i_BstTyp() == tRegalverwalter)  ||
         (zhilfe()->zBst->i_BstTyp() == tNcPoolverwalter))
        zhilfe()->zBst->TFKErzeugenVonBausteinZuPool (zanfang, zhilfe()->zBst);
        else
        FahrkursListe->TFKErzeugen(zanfang, zhilfe()->zBst);
  }
}  // ENDE TFKErzeugenVonBausteinZuPool

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::TFKErzeugenVonPoolZuPool (typBaustein* /*zanfang*/,
                                                  typBaustein* zende)
{
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
  {
     if ((zhilfe()->zBst->i_BstTyp() == tRegalverwalter)  ||
         (zhilfe()->zBst->i_BstTyp() == tNcPoolverwalter))
        zhilfe()->zBst->TFKErzeugenVonPoolZuPool (zhilfe()->zBst, zende);
        else
     if ((zende->i_BstTyp() == tRegalverwalter)  ||
         (zende->i_BstTyp() == tNcPoolverwalter))
        zende->TFKErzeugenVonBausteinZuPool (zhilfe()->zBst, zende);
        else
        FahrkursListe->TFKErzeugen(zhilfe()->zBst, zende);
  }
}  // ENDE TFKErzeugenVonPoolZuPool

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool typPoolVerwaltung::TFKSuchenVonPoolZuBaustein (typBaustein* zanfang,
                                                    typBaustein* zende)
{
  bool found = false;
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
  {
    if ((zhilfe()->zBst->i_BstTyp() == tRegalverwalter)  ||
        (zhilfe()->zBst->i_BstTyp() == tNcPoolverwalter))
          found = zhilfe()->zBst->TFKSuchenVonPoolZuBaustein (zhilfe()->zBst, zende);
        else
          found = FahrkursListe->TFKSuchen(zhilfe()->zBst, zende) ? true : false;
        if (!found) break;
  }
  if (!found) Meld.Ausgabe (100, zanfang->i_BstNr(), zende->i_BstNr());
  return found;
}  // ENDE TFKSuchenVonPoolZuBaustein

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool typPoolVerwaltung::TFKSuchenVonBausteinZuPool (typBaustein* zanfang,
                                                    typBaustein* zende)
{
  bool found = false;
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
  {
    if ((zhilfe()->zBst->i_BstTyp() == tRegalverwalter)  ||
        (zhilfe()->zBst->i_BstTyp() == tNcPoolverwalter))
        found = zhilfe()->zBst->TFKSuchenVonBausteinZuPool (zanfang, zhilfe()->zBst);
      else
        found = FahrkursListe->TFKSuchen(zanfang, zhilfe()->zBst) ? true : false;
    if (!found) break;
  }
  if (!found) Meld.Ausgabe (99, zanfang->i_BstNr(), zende->i_BstNr());
  return found;
}  // ENDE TFKSuchenVonBausteinZuPool

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool typPoolVerwaltung::TFKSuchenVonPoolZuPool (typBaustein* /*zanfang*/,
                                                typBaustein* zende)
{
  bool found = false;
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
  {
     if ((zhilfe()->zBst->i_BstTyp() == tRegalverwalter)  ||
         (zhilfe()->zBst->i_BstTyp() == tNcPoolverwalter))
        found = zhilfe()->zBst->TFKSuchenVonPoolZuPool (zhilfe()->zBst, zende);
        else
     if ((zende->i_BstTyp() == tRegalverwalter)  ||
         (zende->i_BstTyp() == tNcPoolverwalter))
        found = zende->TFKSuchenVonBausteinZuPool (zhilfe()->zBst, zende);
        else
        found = FahrkursListe->TFKSuchen(zhilfe()->zBst, zende) ? true : false;
     if (!found) break;
  }
  return found;
}  // ENDE TFKSuchenVonPoolZuPool

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::TFKZeigenVonPoolZuBaustein (typBaustein* /*zanfang*/,
                                                    typBaustein* zende)
{
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
     FahrkursListe->TFKZeigen (zhilfe()->zBst, zende);
}  // ENDE TFKZeigenVonPoolZuBaustein

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::TFKZeigenVonBausteinZuPool (typBaustein* zanfang,
                                                    typBaustein* /*zende*/)
{
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
     FahrkursListe->TFKZeigen (zanfang, zhilfe()->zBst);
}  // ENDE TFKZeigenVonBausteinZuPool

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::TFKZeigenVonPoolZuPool (typBaustein* /*zanfang*/,
                                                typBaustein* zende)
{
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
     FahrkursListe->TFKZeigen (zhilfe()->zBst, zende);
}  // ENDE TFKZeigenVonPoolZuPool

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::BPVmitBausteinLoeschen (typBaustein* zbstein)
{
    typBstZeiger* zhilfe;
    zhilfe = Suche (zbstein, InhaltsListe);
    if (zhilfe)
    {
      InhaltsListe.remove (*zhilfe);
      delete zhilfe;
    }

    zhilfe = Suche (zbstein, BetreuteListe);
    if (zhilfe)
    {
      BetreuteListe.remove (*zhilfe);
      delete zhilfe;
    }
}  // ENDE BPVmitBausteinLoeschen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring typPoolVerwaltung::getPoolListe ()
{
  char tmp [128];
  Ustring str;
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
  {
    sprintf (tmp, "{%d  (%s)}\t", zhilfe()->zBst->i_BstNr(),
                               (char*)zhilfe()->zBst->getName().str());
    str += tmp;
  }
  return str;
}  // ENDE getPoolListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring typPoolVerwaltung::getBetreuteListe ()
{
  char tmp [128];
  Ustring str;
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = BetreuteListe; zhilfe; zhilfe++)
  {
    sprintf (tmp, "{%d  (%s)}\t", zhilfe()->zBst->i_BstNr(),
                               (char*)zhilfe()->zBst->getName().str());
    str += tmp;
  }
  return str;
}  // ENDE getBetreuteListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool typPoolVerwaltung::inPoolListe (int bstnr)
{
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
    if (zhilfe()->zBst->i_BstNr() == bstnr) return true;
  return false;
}  // ENDE inPoolListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool typPoolVerwaltung::inBetreuteListe (int bstnr)
{
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = BetreuteListe; zhilfe; zhilfe++)
    if (zhilfe()->zBst->i_BstNr() == bstnr) return true;
  return false;
}  // ENDE inBetreuteListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::setBstInListe (int anzahl, Ustring str,
                                        List<typBstZeiger> &LST)
{
  int  bstnr = 0;
  unsigned ausl = 0, bel = 0, stoer = 0;
  Ustring tmp;
  char buf [128];
  bool copy = true;
  typBstZeiger* zhilfe;
  while (!LST.isEmpty()) delete LST.removeFirst();

  for (unsigned i = 0; i < str.len(); i++ )
  {
    if (str[i] == '(') copy = false;
    if (copy)
       if (!((str[i] == '{') || (str[i] == '}'))) tmp += str[i];
    if (str[i] == ')') copy = true;
  }
  str = tmp;
  for (int zaehler = 0; zaehler < anzahl; zaehler++ )
  {
    str.toInt (bstnr);
    zhilfe = new typBstZeiger(BausteinListe->Suche(bstnr));
    if (zhilfe->zBst)
    {
      LST.append (*zhilfe);
      tmp = zhilfe->zBst->getTMWWerte();
      sscanf ((char*)tmp.str(), "%d %d %d", &ausl, &bel, &stoer);
      ausl = 1;
      sprintf (buf, "%d\t%d\t%d", ausl, bel, stoer);
      zhilfe->zBst->setTMWWerte(Ustring(buf));
    }
    else
      delete zhilfe;

    bool zahl = false;
    for (unsigned int i = 0; i < str.len(); i++)
    {
      if (!zahl)
         if (str[i] != ' ') zahl = true;
      if (zahl)
        if (str[i] == ' ')
        {
          str.delPart (0, i+1);
          break;
        }
    }
  }
}  // ENDE setBstInListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::setPoolListe (int anzahl, Ustring str)
{
  setBstInListe (anzahl, str, InhaltsListe);
}  // ENDE setPoolListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::setBetreuteListe (int anzahl, Ustring str)
{
  setBstInListe (anzahl, str, BetreuteListe);
}  // ENDE setBetreuteListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::mitPoolVerketten (typBaustein* zvon, int vonplatz, 
                                          typBaustein* zmit, 
                                          int mitplatz, int unterwinkel)
{
  if (InhaltsListe.isEmpty())
  {
    Meld.Ausgabe (80, zmit->i_BstNr());
    return;
  }
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
      zvon->BstVerketten (vonplatz, zhilfe()->zBst, mitplatz, unterwinkel);
}  // ENDE mitPoolVerketten

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::vonPoolVerketten (typBaustein* zvon, int vonplatz, 
                                          typBaustein* zmit, 
                                          int mitplatz, int unterwinkel)
{
  if (InhaltsListe.isEmpty())
  {
    Meld.Ausgabe (80, zvon->i_BstNr());
    return;
  }
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
      zhilfe()->zBst->verkette (vonplatz, zmit, mitplatz, unterwinkel);
}  // ENDE mitPoolVerketten

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::loeseVerkettungmitPool (typBaustein* zvon, 
                                                typBaustein* zmit)
{
  if (InhaltsListe.isEmpty())
  {
    Meld.Ausgabe (80, zmit->i_BstNr());
    return;
  }
  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
       zvon->loeseVerkettung (zhilfe()->zBst);
}  // ENDE loeseVerkettungmitPool

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::loeseVerkettungvonPool (typBaustein* zvon, 
                                                typBaustein* zmit)
{
  if (InhaltsListe.isEmpty())
  {
    Meld.Ausgabe (80, zvon->i_BstNr());
    return;
  }

  LCursor<typBstZeiger> zhilfe;
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
      zhilfe()->zBst->loeseVerkettung (zmit);
}  // ENDE loeseVerkettungvonPool

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typPoolVerwaltung::InfoPoolVerkettung (typBaustein* zbst)
{
  if (InhaltsListe.isEmpty())
  {
    Meld.Ausgabe (80, zbst->i_BstNr());
    return;
  }

  LCursor<typBstZeiger> zhilfe;
  Meld.Ausgabe (35, zbst->i_BstNr());
  for (zhilfe = InhaltsListe; zhilfe; zhilfe++)
      zhilfe()->zBst->InfoVerkettung();
}  // ENDE InfoPoolVerkettung

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
typPoolVerwaltung::~typPoolVerwaltung ()
{
  while (!InhaltsListe.isEmpty())  delete InhaltsListe.removeFirst();
  while (!BetreuteListe.isEmpty()) delete BetreuteListe.removeFirst();
}  // ENDE ~typPoolVerwaltung

