Stream-Problem

[amigage]

Hallo,

ich habe mal wieder ein ganz spezielles Problem ;-)

Ich muss im Stream eine Variable übergeben, die z.B. durch eine Codierungsfunktion den Wert "#$1F'ÇøẢx߬" enthält.

Mit

Delphi-Quellcode:

Buffer := TMemoryStream.Create;
size := Length(xyz^.Wert);
Buffer.Write(size, SizeOf(Size));
Buffer.Write(PChar(Trim(xyz.Wert))^, size);

gibt es aber Probleme.
Die

Delphi-Quellcode:

PChar(Trim(xyz.Wert))^

ergibt nämlich statt #$1F'ÇøẢx߬ nur noch #$1F

Lass ich die Dereferenzierung ^ weg, klappt es. Wie kann ich jetzt aber den Wert in den Stream schreiben?

Danke für jeden mögliche Hinweis.
Schon einmal ein schönes Wochenende
wünscht Amigage

[Muetze1]

PChar hört bei einem Nullbyte auf. Wenn du also einen String kodierst und ein Nullbyte drinne vorkommt, dann vergiss es mit PChar.

Delphi-Quellcode:

Var
  s : String;
  lSize: Integer;
  lBuffer: TStream;
Begin
  lBuffer := TMemoryStream.Create;
  Try
    s := Trim(xyz.Wert);
    lSize := Length(s);

    lBuffer.Write(lSize, SizeOf(lSize));
    lBuffer.Write(s[1], lSize);
  Finally
    lBuffer.Free;
  End;
End;

/EDIT: Fehler beseitigt. Mensch ist das peinlich - noch so dumme Fehler...

Anmerkung: Das Trim bei einem verschlüsselten String, der wahrscheinlich mehr binäre Daten enthält als lesbaren Text, war für mich auch schon unverständlich - aber wenn der "Kunde" es so wünscht...

[Hawkeye219]

Hallo,

du schreibst einen durch Trim möglicherweise gekürzten String in seiner Originallänge in den Stream? :gruebel:

Ich würde es folgendermaßen versuchen:

Delphi-Quellcode:

Buffer := TMemoryStream.Create;
s := Trim(xyz.Wert);
size := Length(s);
Buffer.Write(size, SizeOf(size));
if (size > 0) then
  Buffer.Write(s[1], size);

Der Code zum Lesen sieht dann so aus:

Delphi-Quellcode:

Buffer.Read(size, SizeOf(Size));
SetLength (xyz^.Wert, size);
if (size > 0) then
  Buffer.Read(xyz^.Wert[1], size);

@Muetze1
Das erste Zeichen im String hat den Index 1. :wink:

Gruß Hawkeye

[sniper_w]

IMO, ist das, das Beste lösung:

Delphi-Quellcode:

type
  TmyFileStream = class(TFileStream)
    procedure WriteString( myString:string );
    procedure WriteInteger( myInteger:Integer );
    procedure WriteSingle( mySingle:Single );
    procedure WriteDouble( myDouble:Double);
    function ReadSingle():Single;
    function ReadDouble():Double;
    function ReadString():string;
    function ReadInteger():Integer;
  end;

implementation

{ TmyFileStream }

function TmyFileStream.ReadDouble: Double;
begin
  Read( Result, SizeOf( Double ) );
end;

function TmyFileStream.ReadInteger: Integer;
begin
  Read( Result, SizeOf( Integer ) );
end;

function TmyFileStream.ReadSingle: Single;
begin
  Read( Result, SizeOf( Single ) );
end;

function TmyFileStream.ReadString: string;
var
  len:Integer;
begin
  Read( len, SizeOf(len) );
  SetLength( Result, len );
  Read( Result[1], len );
end;

procedure TmyFileStream.WriteDouble(myDouble: Double);
begin
  Write( myDouble, SizeOf(myDouble) );
end;

procedure TmyFileStream.WriteInteger(myInteger: Integer);
begin
  Write( myInteger, SizeOf(myInteger) );
end;

procedure TmyFileStream.WriteSingle(mySingle: Single);
begin
  Write( mySingle, SizeOf(mySingle) );
end;

procedure TmyFileStream.WriteString(myString: string);
var
  len:Integer;
begin
  len := Length( myString );
  Write( len, SizeOf(len) );
  Write( myString[1], Len );
end;

[pszopp]

Zitat:

Zitat von sniper_w

IMO, ist das, das Beste lösung:

Nicht ganz:
Die Methoden "ReadString" und "WriteString" machen Probleme, falls der String leer ist.
Deswegen die Größe vor dem Laden und Speichern nochmal kontrollieren:

Delphi-Quellcode:

function TmyFileStream.ReadString: string;
var
  len:Integer;
begin
  Read( len, SizeOf(len) );
  SetLength( Result, len );
  if (len > 0) then
    Read( Result[1], len );
end; 


procedure TmyFileStream.WriteString(myString: string);
var
  len:Integer;
begin
  len := Length( myString );
  Write( len, SizeOf(len) );
  if (len > 0) then
    Write( myString[1], Len );
end;

So sollte es besser sein.

Gruß,
pszopp

[sniper_w]

Zitat:

So sollte es besser sein.

Die Abfrage ist überflussig:

Delphi-Quellcode:

if len > 0 then

, denn falls len = 0 wird in Stream sowieso nichts geschrieben/gelesen.

[Muetze1]

Jo, die Überprüfung ist unnötig.

Noch eine Anmerkung: Alle Routinen die man hier sieht, sind eigentlich unnötig. Nutzt doch einfach den TReader/TWriter.

Delphi-Quellcode:

Begin
  lStream := TFileStream.Create(...);
  Try
    lHandler := TWriter.Create(lStream, 4096);
    Try
      lHandler.WriteIdent(s);
      lHandler.WriteInteger(24);
      ...
    Finally
      lHandler.Free;
    End;
  Finally
    lStream.Free;
  End;
End;

beim TReader entsprechend.

[pszopp]

Zitat:

Zitat von sniper_w

Die Abfrage ist überflussig:

Aber wird es bei Result[1] nicht trotzdem u.U. eine Zugriffsverletzung geben?
Schließlich wird dieser Pointer der Methode übergeben.
Auch wenn dann nichts gestreamt wird.

Gruß,
pszopp

[Muetze1]

Ok, ich nehme alles zurück und behaupte das Gegenteil: Die Abfrage ist doch nicht überflüssig. Der Pointer wäre illegal und der Index ist auch zu groß. Bei eingeschalteter Bereichsprüfung würde somit schon eine Exception kommen.

[amigage]

Zitat:

Zitat von Hawkeye219

Delphi-Quellcode:

Buffer := TMemoryStream.Create;
s := Trim(xyz.Wert);
size := Length(s);
Buffer.Write(size, SizeOf(size));
if (size > 0) then
  Buffer.Write(s[1], size);

Ich habe mich hierfür entschieden und es funktioniert.
Danke für die schnelle Hilfe.