OSZ Handel I
Informatik

PAT 01 -  V. 2.2
Musterlösung

S. Spolwig

[Home | Wirtschaftsgymnasium | Informatik | Unterrichtsmaterialien | PAT 01]

UNIT uSListe;
(* ******************************************************************** *)
(* K L A S S E   : TListe                                               *)
(* -------------------------------------------------------------------- *)
(* Version       : 1.1                                                  *)
(* Autor         : (c) S. Spolwig, OSZ-Handel I, 10997 Berlin           *)
(*                                                                      *)
(* Aufgabe       : Allgemeine statische Liste zur Verwaltung beliebiger *)
(*                 Objekte.                                             *)
(*                 Zum Bewegen in der Liste ist intern eine Listenmarke *)
(*                 mitgefuehrt, die die jeweils aktuelle Listenposition *)
(*                 bezeichnet. Alle Operationen werden auf der aktuellen*)
(*                 Position ausgefuehrt.                                *)
(*                 (SLISTE entspricht SLISTEN in Turbo-Pascal.)         *)
(*                                                                      *)
(* Compiler      : MSDOS - Turbo-Pascal 7.0 - Delphi 4.0                *)
(* Aenderung     : V. 1.0   - 20-AUG-97                                 *)
(*                    1.02  - 03-SEP-98   Load, Store                   *)
(*                    1.03  - 06-Okt-98   SearchElement                 *)
(*                    1.04  - 17-JUL-99   Init, IsFull, Append,         *)
(*                                        First,Last,Next,Prev neu spez.*)
(*                    1.1   - 12-NOV-01   SetElement statt Put.         *)
(* ******************************************************************** *)
INTERFACE
(* ==================================================================== *)
USES  Classes,
      Sysutils,
      uPatient;
const
   MAXLAENGE = 100;
type
  TElement = TPatient;  // der allg. Elementtyp wird zu TPatient!   
  TListe  = class (TObject)
             private
              Kollektion  : array [0..MAXLAENGE + 1] of TElement;
              ListenLaenge,             // Anzahl der belegten Elemente
              AktuellePos : word;       // aktives Element oder EoList
             public
              constructor Create;  virtual;
              procedure Init;      virtual;
              procedure First;     virtual;
              procedure Next ;     virtual;
              procedure previous;  virtual;
              procedure Last ;     virtual;
              function  GetElement : TElement;         virtual;
              procedure SetElement (Elem : TElement);  virtual;
              procedure Append (Elem : TElement);      virtual;
              function  EoList  : boolean;             virtual;
              function  IsFirst : boolean;             virtual;
              function  IsLast  : boolean;             virtual;
              function  IsEmpty : boolean;             virtual;
              function  IsFull  : boolean;             virtual;
              procedure Load (Dateiname : string);     virtual;
              procedure Store(Dateiname : string);     virtual;
            end;
(*  ----------------- B e s c h r e i b u n g -------------------------
Oberklasse     : TObject
Bezugsklassen  : TPatient
                 Classes - import: TFilstream, read, write
                 Sysutils        : Fileexists
Methoden
--------
Create
  Auftrag : Leere L. erzeugen
  vorher  : -
  nachher : Listenobjekt ist erzeugt und initialisiert.
Init
  Auftrag : L. mit default-Werten versehen.
  vorher  : L. ist vorhanden
  nachher : ListenLaenge ist 0, AktuellePos ist 0.
First
  Auftrag : Listenmarke auf das 1. (vorhandene) Element setzen
  vorher  : Die Liste ist nicht leer
  nachher : Aktuelle Position ist 1.
            Ist die Liste leer , geschieht nichts
Next
  Auftrag : Die Listenmarke auf das naechste Element setzen.
  vorher  : Die Liste ist nicht leer und akt. Pos ist nicht letztes El.
  nachher : Die Marke steht auf der neuen aktuellen Position
            ist die Liste leer oder EoList erreicht, geschieht nichts.
Previous
  Auftrag : Die Listenmarke um eins auf das vorhergehende Element zuruecksetzen
  vorher  : Die Liste ist nicht leer und akt. Pos ist nicht 1. Element.
  nachher : Die Marke steht auf der neuen aktuellen Position.
            Ist die Liste leer oder die aktuelle Position war 1, geschieht nichts.
Last
  Auftrag : Listenmarke auf das letzte Element der Liste setzen
  vorher  : Die Liste ist nicht leer.
  nachher : Letztes vorhandenes Element ist aktuelle Position
GetElement
  Anfrage : Zugriff auf das aktuelle Element zum Lesen
  vorher  : Die Liste ist nicht leer.
  nachher : GetElement liefert das aktuelle Element.
SetElement (Elem : TElement)
  Auftrag : Zugriff auf die aktuelle Position zum Schreiben
  vorher  : Die Liste ist initialisiert.
  nachher : Elem ist an aktueller Position uebergeben
Append (Elem : TElement)
  Auftrag : Neues Element an das Ende der Liste anhaengen.
            Wenn die Liste leer war, ist das neue El. das erste.
  vorher  : Die Liste ist initialisiert
  nachher : Listenlaenge ist um eins erhoeht. Ist die Liste voll,
            geschieht nichts.
EoList
  Anfrage: ob das Ende der Liste erreicht ist.
  vorher : Die Liste ist initialisiert.
  nachher: True, wenn Ende der Liste erreicht ist. Die Listenmarke
           steht hinter dem letzten belegten Element.
IsEmpty
  Anfrage: ob Liste leer ist
  vorher : Die Liste ist initialisiert.
  nachher: True, wenn die Liste leer ist.
GetLen
  Anfrage: gibt Listenlaenge zurueck
  vorher : Liste ist initialisiert
  nachher: -
SearchElement (suchElem : TElement) : TElement;
  Anfrage: ob suchElem in der Liste gefunden wurde
  vorher : -
  nachher: Gefundenes Element wird zurückgegeben. Wenn Liste leer ist oder
           nicht gefunden wird EoList zurückgegeben.
Load (dateiname : string);
  Auftrag: Liste aus externer Datei laden. Wenn keine Datei existiert,
           dann neue Datei mit der Laenge 0 anlegen.
  vorher : Die Liste ist initialisiert.
  nachher: Die Liste ist in den Arbeitsspeicher geladen. Datei ist geschlossen.
Store (dateiname : string);
  Auftrag: Liste in externe Datei speichern
  vorher : -
  nachher: Die Liste ist gespeichert. Ist die Liste leer, wird nichts
          gespeichert. Datei ist geschlossen.
----------------------------------------------------------------------- *)
IMPLEMENTATION
(* ==================================================================== *)
constructor TListe.Create;
(* -------------------------------------------------------------------- *)
begin
  inherited Create;
  Init;
end;
procedure TListe.Init;
(* -------------------------------------------------------------------- *)
var i : integer;
begin
  for i := 0 to MAXLAENGE +1 do
  begin
    Kollektion[i] := NIL;
  end;
  ListenLaenge    := 0;
  AktuellePos     := 0;
end;
procedure TListe.First;
(* -------------------------------------------------------------------- *)
begin
  If NOT IsEmpty
  then AktuellePos := 1;
end;
procedure TListe.Next;
(* -------------------------------------------------------------------- *)
Begin
  if NOT (IsEmpty OR IsLast)  // EoList
  then AktuellePos := AktuellePos + 1;
end;
procedure TListe.Previous;
(* -------------------------------------------------------------------- *)
begin
  if NOT (IsEmpty or IsFirst)
  then AktuellePos := AktuellePos - 1;
end;
procedure TListe.Last;
(* -------------------------------------------------------------------- *)
begin
  if NOT (IsEmpty)
  then AktuellePos := ListenLaenge ;
end;
function TListe.GetElement : TElement;
(* -------------------------------------------------------------------- *)
begin
  Result := Kollektion[AktuellePos];
end;
procedure TListe.SetElement (Elem : TElement);
(* -------------------------------------------------------------------- *)
begin
  Kollektion[AktuellePos] := Elem;
end;
procedure TListe.Append (Elem : TElement);
(* -------------------------------------------------------------------- *)
begin
  if NOT IsFull
  then
    begin
      AktuellePos := Listenlaenge + 1;
      SetElement(Elem);
      inc (ListenLaenge);
    end;
end;
function TListe.EoList : boolean;
(* -------------------------------------------------------------------- *)
begin
  if Kollektion[AktuellePos] = NIL
  then Result := true
  else Result := false;
end;
function TListe.IsFirst : boolean;
(* -------------------------------------------------------------------- *)
begin
  if AktuellePos = 1
  then Result := true
  else Result := false;
end;
function TListe.IsLast : boolean;
(* -------------------------------------------------------------------- *)
begin
  if AktuellePos = ListenLaenge
  then Result := true
  else Result := false;
end;
function TListe.IsEmpty : boolean ;
(* -------------------------------------------------------------------- *)
begin
  Result := false;
  if ListenLaenge = 0
  then Result := true;
end;
function TListe.IsFull : boolean ;
(* -------------------------------------------------------------------- *)
begin
  Result := false;
  if ListenLaenge = MAXLAENGE
  then Result := true;
end;
procedure TListe.Load (Dateiname : string);
(* -------------------------------------------------------------------- *)
var
    Elem  : TElement;
    Fs    : TFilestream;
    i,
    Anzahl: integer;
begin
  Anzahl := 0 ;
  if NOT FileExists(Dateiname)
  then Fs := TFilestream.Create(Dateiname, fmCreate)
  else Fs := TFilestream.Create(Dateiname, fmOpenRead);
  if Fs.Size > 0
  then
    begin
      Fs.Read(Anzahl, SizeOf(ListenLaenge));
      for i := 1 to Anzahl do
      begin
        elem := Telement.Create;
        Elem.AusDateiLesen(Fs);
        Append(Elem);
      end;
      AktuellePos := 0;
    end;
  Fs.Free;
end;
procedure TListe.Store(Dateiname : string);
(* -------------------------------------------------------------------- *)
var Elem  : TElement;
    Fs    : TFilestream;
begin
  DeleteFile(Dateiname);
  Fs := TFilestream.Create(Dateiname, fmCreate);
  if not IsEmpty
  then
  begin
    Fs.Write(ListenLaenge, SizeOf(ListenLaenge));
    First;
    while NOT EoList do
    begin
      Elem := GetElement;
      Elem.InDateiSchreiben (Fs);
      inc(AktuellePos); //Next;
    end;
  end;
  Fs.Free;
end;

END.



©    27. August 2005    Siegfried Spolwig

page_top