Stream vers un Array of String

Version imprimable

18/09/2023, 09h36
SergioMaster

Stream vers un Array of String

Bonjour
Comment traiter ce contenu de stream (<bh:00> remplace 00)

Citation:

DATEC=20230914121613<bh:00>FORMAT=tif<bh:00>FILENAME=F2022-6045.tif<bh:00>FTDATEM=20230116091534<bh:00>FTDATEA=20230914121602<bh:00>FTDATEC=20230116083700<bh:00>

je pensais mettre ceci dans un Array of String, mais la manipulation entre le stream et sa destination m'échappe :roll:
18/09/2023, 10h13
Paul TOTH

Citation:

Envoyé par SergioMaster

Bonjour
Comment traiter ce contenu de stream (<bh:00> remplace 00)

je pensais mettre ceci dans un Array of String, mais la manipulation entre le stream et sa destination m'échappe :roll:

je n'ai pas compris ton "(<bh:00> remplace 00)"...c'est une série de PChar ?

ton stream c'est quel type de stream ?
18/09/2023, 10h42
SergioMaster

Bonjour,

c'est un TFileStream et le <bh:00> est là pour indiquer qu'il s'agit d'un octet de valeur 00
18/09/2023, 10h52
ShaiLeTroll

Tu peux le voir comme un array de chaine à zéro terminal

Sinon, il faut lire le fichier en buffer
Regarde ReadLineRaw c'est la même chose en CRLF mais avec un 0x00 ça fonctionne aussi ce type d'algo, c'est juste une lecture binaire bufferisé (le ReadLn standard de Delphi fait pareil)

pour résumer
- Position du début de la chaine
- Position du séparateur
- Extraction entre les deux
- Position du début de la chaine devient la position du séparateur + longueur du séparateur

Cela boucle jusqu'au dernier Zéro
A chaque boucle, faut gérer en plus la possibilité que la chaine souhaitée soit à cheval sur deux buffers ou sur plus encore (là faut relire généralement la section complète)

J'ai fait une analyse caractère par caractère qui fonctionne

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
procedure getinfos(const FileName : String; const M : Tmemo);
var FS : TFileStream;
    Pos, long : Integer;
    S : String;
    B : TArray<Byte>;
    C : Char;
begin
  M.Lines.Clear;
  if (not FileExists(FileName)) then exit;
  pos :=GetSize(FileName); // pour obtenir la position de début des infos (6 infos de type xxxxxx=xxxxxxx)
  FS := TFileStream.create(FileName, fmOpenRead or fmShareDenyWrite);
  FS.Position:=pos;
  long:=FS.Size-pos; // infos de taille variable, situées à la fin du fichier  
  SetLength(B,long);
  FS.Read(B,Long);
  S:=EmptyStr;
  for var i := low(b) to high(b) do
   begin
     if (B[i]=0)
      then begin
       if not S.IsEmpty then m.Lines.Add(S);
       S:=EmptyStr;
      end
      else S:=S+Char(B[i]);
   end;
  FS.Free;
end;

mais je me demande s'il n'y a pas plus simple

18/09/2023, 12h30
ShaiLeTroll

Plus simple, surement avec un fichier minuscule
Chargement du fichier entier dans un RawByteString puis conversion vers String et recherche via System.Classes.ExtractStrings (non le 0x00 ça ne lui plaira pas)
Le zéro comme séparateur, il faut tout de même se méfier de fonction à base de PChar qui pourrait ne pas comprendre que c'est un séparateur :aie:

Regarde ExplodeLazy cela fait la même chose, idem, petit fichier chargé en entier
J'avais écrit les versions binaires de ExplodeLazy et SearchString pour lire les fichiers DUMP, si je le retrouve ... d'ailleurs à peu de chose près, la découpe de plusieurs buffer consécutif reçu par Socket, cela y ressemble beaucoup

Plus rapide mais moins lisible, certains aussi

Code:

S:=S+Char(B[i]);

Mémoriser les positions c'est plus rapide qu'un concat en boucle mais FastMM te sauve en perf à ce sujet.

Je te propose ce genre de code réutilisable

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
procedure SetDelimitedText(const Value: string; AStrings: TStrings; const Delimiter: Char);
var
  P, PEnd, P1: PChar;
  S: string;
begin
  AStrings.BeginUpdate;
  try
    AStrings.Clear;
    P := PChar(Value);
    PEnd := PChar(NativeUInt(P) + Length(Value) * SizeOf(Char));
 
    while P < PEnd do
    begin
      P1 := P;
      while (P^ <> Delimiter) do
        Inc(P);
      SetString(S, P1, P - P1);
 
      AStrings.Add(S);
      Inc(P);
    end;
  finally
    AStrings.EndUpdate;
  end;
end;
 
const
  DATA: RawByteString =
      'HEADER'
    + 'DATEC=20230914121613'#0
    + 'FORMAT=tif'#0
    + 'FILENAME=F2022-6045.tif'#0
    + 'FTDATEM=20230116091534'#0
    + 'FTDATEA=20230914121602'#0
    + 'FTDATEC=20230116083700'#0;
 
procedure TForm1.Button3Click(Sender: TObject);
var
  S: TStringList;
  B: TBytes;
  Len: Integer;
begin  
   // construction du fichier tel que je l'ai compris
  SetLength(B, Length(DATA));
  Move(DATA[1], B[0], Length(DATA));
  with TFileStream.Create('test.dat', fmCreate) do
  try
    Write(B, Length(B));
  finally
    Free();
  end;
 
 
  SetLength(B, 0);
 
 
  // Ici le vrai code
  with TFileStream.Create('test.dat', fmOpenRead or fmShareDenyWrite) do
  try
    Len := Size - Length('HEADER');
    SetLength(B, Len);
    Seek(Length('HEADER'), soBeginning);
    Read(B, Len);
  finally
    Free();
  end;
 
  SetDelimitedText(TEncoding.ANSI.GetString(B), Memo1.Lines, #0);
end;

Et sa version binaire ( décodage ANSI après découpe )

Code:

SetDelimitedTextFromBytes(B, Memo1.Lines, 0);

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
procedure SetDelimitedTextFromBytes(const Value: TBytes; AStrings: TStrings; const Delimiter: Byte);
var
  P, PEnd, P1: PAnsiChar;
  S: AnsiString;
begin
  AStrings.BeginUpdate;
  try
    AStrings.Clear;
    P := PAnsiChar(Value);
    PEnd := PAnsiChar(NativeUInt(P) + Length(Value));
 
    while P < PEnd do
    begin
      P1 := P;
      while (P^ <> AnsiChar(Delimiter)) do
        Inc(P);
      SetString(S, P1, P - P1);
 
      AStrings.Add(String(S));
      Inc(P);
    end;
  finally
    AStrings.EndUpdate;
  end;
end;

Et pourquoi pas juste Split ?

Code:

1
2
3
4
const Text = 'DATEC=20230914121613'#0'FORMAT=tif'#0'FILENAME=F2022-6045.tif'#0'FTDATEM=20230116091534'#0'FTDATEA=20230914121602'#0'FTDATEC=20230116083700'#0;
const List = Text.Split([#0]);
 
Memo1.Lines.AddStrings(List);

18/09/2023, 14h38
ShaiLeTroll

Split existe et fonctionne en D10 Seattle, on n'y pense pas au StringHelper
18/09/2023, 16h21
SergioMaster

Oui, Split pour un string, j'y avais pensé. Le hic, c'est qu'il ne s'agit pas d'un string, mais d'une partie d'un fichier.dat.

j'aime bien la solution de Shai, même si je l'aurais écrite un peu différemment :)

sans avoir testé, ça donnerait ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
procedure SetDelimitedTextFromBytes(const Value: TBytes; AStrings: TStrings; const Delimiter: Byte);
var
  P, PEnd, P1: PAnsiChar;
  S: AnsiString;
begin
  AStrings.BeginUpdate;
  try
    AStrings.Clear;
    P := PAnsiChar(Value);
    PEnd := @P[Length(Value) - 1];
 
    while P < PEnd do
    begin
      S := AnsiString(P);
      AStrings.Add(String(S));
      Inc(P, Length(S) + 1); 
    end;
  finally
    AStrings.EndUpdate;
  end;
end;

Citation:

Envoyé par SergioMaster

Oui, Split pour un string, j'y avais pensé. Le hic, c'est qu'il ne s'agit pas d'un string, mais d'une partie d'un fichier.dat.

Grossièrement en imaginant un fichier avec HEADER au début voir le code de création du fichier ici, ce code inclu SetDelimitedText avec au préalable un décodage du binaire supposé ANSI en UNICODE puis découpe comme le ferait Split

Alors que SetDelimitedTextFromBytes utilise le binaire, découpe chaque chaine ANSI et converti en UNICODE une par une.

AnsiString n'a pas de Helper semble-t-il
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 with TFileStream.Create('test.dat', fmOpenRead or fmShareDenyWrite) do try Len := Size - Length('HEADER'); SetLength(B, Len); Seek(Length('HEADER'), soBeginning); Read(B, Len); finally Free(); end; //SetDelimitedTextFromBytes(B, Memo1.Lines, 0); Memo1.Lines.AddStrings(TEncoding.ANSI.GetString(B).Split([#0])); end;

19/09/2023, 11h08
SergioMaster

Merci, voilà ce que je cherchais

Code:

Memo1.Lines.AddStrings(TEncoding.ANSI.GetString(B).Split([#0]));

Encore plus simple que ce que j'avais pu coder aujourd'hui en passant par un TStringStream