ReadString Bäche zeilenweise

ReadString Bäche zeilenweise

ReadString Bäche zeilenweise : Mehreren tausend Tipps, um Ihr Leben einfacher machen.

Implementierung der TLineStream-Klasse
Autor: MARTIN WALDENBURG

{+--------------------------------------------------------------------------+
| Klasse: TLineStream
| Erstellt: 8,97
| Autor: Martin Waldenburg
| Copyright 1997, alle Rechte vorbehalten.
| Beschreibung: TLineStream gibt einen gepufferten Zugriff auf die Zeilen ein
Datei.
| Jede Zeile muss mit CRLF abgeschlossen werden. Vergessen Sie nicht, Spülen der
| Speicher nach dem Schreiben.
| Version: 1.2
| Status: FreeWare
| Haftungsausschluss:
| Dies wird zur Verfügung gestellt, ausdrücklich ohne eine Garantie irgendeiner Art.
| Verwenden Sie es auf Ihr eigenes Risc.
+--------------------------------------------------------------------------+}
Einheit MwLineStream;
Schnittstelle
verwendet
SysUtils, Klassen;
Typ
TLineStream = class(TFileStream)
Private
fLineStart: PChar;
fMaxMemorySize:Longint;
fMaxLineSize:Longint;
fMemorySize: LongInt;
fLineSize:Longint;
fMemory:PChar;
fLine: PChar;
fFileEof:Boolean;
fMemoryPos: LongInt;
fEof:Boolean;
Funktion GetMemoryFull:Boolean;
Prozedur SetMaxLineSize(NewValue:Longint);
Prozedur SetMaxMemorySize(NewValue:Longint);
geschützt
öffentliche
Konstruktor erstellen (Const FileName: string; Modus: Wort);
Destruktor zerstören; außer Kraft setzen;
Verfahren FillMemory;
Funktion ReadLine:PChar;
Prozedur WriteLine(NewLine: String);
Prozedur FlushMemory;
Reset des Verfahrens;
Eigenschaft MaxMemorySize:Longint lesen fMaxMemorySize schreiben
SetMaxMemorySize;
Eigenschaft MaxLineSize:Longint lesen fMaxLineSize schreiben SetMaxLineSize;
fMemory schreiben fMemory Lesen Eigenschaft Speicher: PChar;
Eigenschaft MemoryFull:Boolean zu lesen GetMemoryFull;
Eigenschaft FileEof:Boolean zu lesen fFileEof;
Eigenschaft Eof:Boolean fEof schreiben fEof zu lesen;
veröffentlicht
Ende; {TLineStream}
Umsetzung
Konstruktor TLineStream.create (Const FileName: string; Modus: Wort);
var
fHandle: Integer;
beginnen
Wenn nicht dann FileExists(FileName)
beginnen
fHandle: = FileCreate(FileName);
FileClose(fHandle);
Ende;
geerbte erstellen (FileName, Modus);
fEof: = False;
fFileEof: = False;
MaxMemorySize: = 65535;
fMemorySize: = 0;
fMemoryPos: = 0;
MaxLineSize: = 4096;
Lage: = 0;
Ende; {schaffen}
Destruktor TLineStream.destroy;
beginnen

ReallocMem (fMemory, 0);
ReallocMem (fLine, 0);
geerbte zerstören;
Ende; {zerstören}

Prozedur TLineStream.SetMaxMemorySize(NewValue:Longint);
beginnen
fMaxMemorySize: = NewValue;
ReallocMem (fMemory, fMaxMemorySize + 1);
Ende; {SetMaxMemorySize}
Prozedur TLineStream.SetMaxLineSize(NewValue:Longint);
beginnen
fMaxLineSize: = NewValue;
ReallocMem (fLine, fMaxLineSize + 1);
Ende; {SetMaxLineSize}
Prozedur TLineStream.FillMemory;
var
Gelesene: LongInt;
beginnen
Gelesene: = Read (fMemory ^, fMaxMemorySize);
fMemorySize: = Readed;
Wenn gelesene = 0 then fFileEof: = True;
Wenn fMemorySize > 0 dann
während fMemory [fMemorySize-2] <> #13 dec(fMemorySize);
fMemory [fMemorySize]: = #0;
Lage: = Position - gelesene + fMemorySize + 1;
fLineStart: = fMemory;
Ende; {FillMemory}
Funktion TLineStream.GetMemoryFull:Boolean;
beginnen
Wenn fMemorySize > 0 then Result: = True else Result: = False;
Ende; {GetMemoryFull}
Funktion TLineStream.ReadLine:PChar;
var
Ausführung: PChar;
beginnen
Wenn (fMemorySize = 0) und nicht FileEof dann FillMemory;
Wenn fMemorySize > 0 dann
beginnen
Laufen: = fLineStart;
zwar Run ^ <> #13 inc(Run);
fLineSize: = Run - fLineStart;
Inc (laufen, 2);
StrLCopy (fLine, fLineStart, fLineSize);
fLine [fLineSize]: = #0;
Ergebnis: = fLine;
fLineStart: = Ausführen;
RS-Run ^ # 0: FillMemory Ende;
Ende;
Wenn fMemorySize = 0 then fEof: = True;
Ende; {ReadLine}
Prozedur TLineStream.WriteLine(NewLine: String);
var
Graf, Pos: Longint;
beginnen
NewLine: = NewLine + #13 #10;
Count: = Length(NewLine);
Wenn (fMemoryPos > = 0) und (Count > = 0) dann
beginnen
POS: = fMemoryPos + Count;
Wenn Pos > 0 dann
beginnen
Wenn Pos > FMaxMemorySize dann
beginnen
FlushMemory;
Ende;
StrECopy ((fMemory + fMemoryPos), PChar(NewLine));
fMemoryPos: = fMemoryPos + Count;
fMemory [fMemoryPos]: = #0;
Ende;
Ende;
Ende; {WriteLine}
Prozedur TLineStream.FlushMemory;
beginnen
Schreiben (fMemory ^, fMemoryPos);
fMemoryPos: = 0;
Ende; {FlushMemory}
Prozedur TLineStream.Reset;
beginnen
fEof: = False;
fFileEof: = False;
fMemorySize: = 0;
fMemoryPos: = 0;
Lage: = 0;
Ende; {Reset}
Ende.