Discussion :

[petitcoucou31]

Bonjour a tous, je voudrais savoir quelle méthode utiliser pour enregistrer le record si dessous:

A savoir que mes "array" ne sont pas finalisés, Afin de limiter la taille de mes fichiers.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
Type TEShape = record
  Id:Integer;
  Moved:boolean;
  Selected:boolean;
  Name:string[255];
  ...
  Pointpoly:array of tpoint;
  PointSelect:array of boolean;
  PointHit:array of boolean;
  ...
  PointMove:boolean;
  SegmentCourant:integer;
end;
Var EShape:array of TEShape;
 
 
type TfShape = record
   Image:string[255];
   Shape:array of TEShape;
end;
 
var Fshape: file of TfShape;

merci.

[sjrd]

Utilise des flux (TStream), et pour tes tableaux dynamiques, commence par stocker la taille du tableau, et ensuite son contenu.

Si tu veux une routine générique pour enregister/relire des tableaux dynamiques dans un flux, voici un jet non testé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
uses
  TypInfo;
 
procedure WriteDynArrayToStream(Stream: TStream; const DynArray; TypeInfo: PTypeInfo);
var
  TypeData: PTypeData;
  Data: Pointer;
  Count: Integer;
begin
  TypeData := GetTypeData(TypeInfo);
  if TypeData.elType <> nil then
    raise Exception.Create('Can''t serialize array of ' +
      TypeData.elType^^.Name);
 
  Data := Pointer(DynArray);
 
  if Data = nil then
  begin
    Count := 0;
    Stream.WriteBuffer(Count, SizeOf(Integer));
  end else
  begin
    Count := PInteger(Integer(Data)-SizeOf(Integer))^;
    Stream.WriteBuffer(Count, SizeOf(Integer));
    Stream.WriteBuffer(Data^, Count*TypeData.elSize);
  end;
end;
 
procedure ReadDynArrayFromStream(Stream: TStream; var DynArray; TypeInfo: PTypeInfo);
var
  TypeData: PTypeData;
  Count: Integer;
begin
  TypeData := GetTypeData(TypeInfo);
  if TypeData.elType <> nil then
    raise Exception.Create('Can''t serialize array of ' +
      TypeData.elType^^.Name);
 
  Stream.ReadBuffer(Count, SizeOf(Integer));
 
  if Count = 0 then
    DynArrayClear(Pointer(DynArray), TypeInfo)
  else
  begin
    DynArraySetLength(Pointer(DynArray), TypeInfo, 1, @Count);
    Stream.ReadBuffer(Pointer(DynArray)^, Count*TypeData.elSize);
  end;
end;

Ce que tu peux utiliser comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
type
  TPointDynArray = array of TPoint;
 
WriteDynArrayToStream(Stream, EShape.pointPoly, TypeInfo(TPointDynArray));
 
ReadDynArrayFromStream(Stream, EShape.pointPoly, TypeInfo(TPointDynArray));

Au besoin, je peux en écrire une version récursive qui peut sérialiser n'importe quel record avec des chaînes et des tableaux dynamiques dedans, avec dans ces tableau dynamiques d'autres record dans le genre etc.
Mais je ne le ferai que si tu en as besoin, parce que ça va me prendre 1 ou 2 heures quand même

[ShaiLeTroll]

Tu peux aussi transformer ton record en une classe héritant de TComponent (je sais plus lourd), ou encapsuler ton record dans une classe juste pour faire Read\Write avec des propriétés publiées, c'est les tableaux qui poseront des problèmes, il faudrait le recoder en TCollection, c'est qui est bien lourd ...

en dernier, c'est de mettre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Pointpoly[0.255]:array of tpoint;

cela va agrandir ton fichier, mais c'est se simplifier la vie !

Sinon sjrd, jolies fonctions génériques, moi je veux bien voir ce code récursrif juste pour le bonheur des yeux , ça mériterait une FAQ : "Comment écrire n'importe quel tableau dans un Stream", cela va en intéressé plus d'un ...

Perso, quand j'ai des tableaux dynamiques, j'écrivais une fonction spécifique pour chaque types de tableaux ... c'est pour cela que j'écrivais toujours un TxxxReader et TxxxWriter pour remplir mes record ...

[petitcoucou31]

re salut ..

En effet Sjrd, si tu as le temps je suis preneur du code récursif.. et comme le dis ShaiLeTroll je pense aussi que cela serait le bien venu dans ma Faq.

[sjrd]

Bon ben dans ce cas, je m'y colle

[petitcoucou31]

Merci pour le temps que tu y passes !

[sjrd]

Et voilà, intégré dans la SCL
http://sepi.svn.sourceforge.net/view...as?view=markup

[petitcoucou31]

salut et merci bcp pour ta rapidité et surtout "Chapeau" ! ,
je vais essayer ton code , mais il me manque une unité enfin je crois ! la ScTypInfo.

Ensuite n'etant pas du tout un utilisateur des streams.
Je doit utiliser tes fonctions juste pour les écriture et lecture disque , redéfinir mon record ..

Mon but etant de lire et d'ecrire un fichier du type ci dessous

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
Type TEShape = record
  Id:Integer;
  Selected:boolean;
  Name:string;
  ...
  Pointpoly:array of tpoint;
  ..
end;
Var EShape:array of TEShape;
 
 
type TfShape = record
   Image:string;
   Indice:integer;
   Shape:array of TEShape;
end;
 
var Fshape: file of TfShape;

[ShaiLeTroll]

Oublie le fichier typé (qui sont de longeurs fixe en terme de record), les fonctions de SJRD propose la même chose mais via les Streams avec des record à longueur variable ...

Mon non plus, je n'étais pas très stream avant, mais finalement, cela s'utilise comme blockRead et BlockWrite ... c'est très simple ...

[sjrd]

je vais essayer ton code , mais il me manque une unité enfin je crois ! la ScTypInfo.

Non elle est dans le même dossier :
http://sepi.svn.sourceforge.net/view...as?view=markup
Qui elle-même dépend de ScCompilerMagic :
http://sepi.svn.sourceforge.net/view...as?view=markup
Qui elle ne dépend de rien
Ces deux unités existaient déjà avant dans la SCL, c'est pour ça que je n'ai pas les liens dès le début.

Ensuite n'etant pas du tout un utilisateur des streams.

Comma l'a dit ShaiLeTroll, mets-t'y C'est vraiment beaucoup plus simple à utiliser une fois qu'on a compris comment ça fonctionne.

Je doit utiliser tes fonctions juste pour les écriture et lecture disque , redéfinir mon record ..

Mon but etant de lire et d'ecrire un fichier du type ci dessous

Alors soit tu as un tableau de TfShape, et tu fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
type
  TfShapeDynArray = array of TfShape;
 
procedure WriteToFile(const Shapes: TfShapeDynArray;
  const FileName: TFileName);
var
  Stream: TStream;
begin
  Stream := TFileStream.Create(FileName, fmCreate);
  try
    WriteDataToStream(Stream, Shapes, TypeInfo(TfShapeDynArray));
  finally
    Stream.Free;
  end;
end;
 
procedure ReadFromFile(var Shapes: TfShapeDynArray;
  const FileName: TFileName);
var
  Stream: TStream;
begin
  Stream := TFileStream.Create(FileName, fmOpenRead);
  try
    ReadDataFromStream(Stream, Shapes, TypeInfo(TfShapeDynArray));
  finally
    Stream.Free;
  end;
end;

Soit, tu travailles séquentiellement shape par shape, et alors tu préfèrereras :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
procedure WriteToFile(const FileName: TFileName);
var
  Stream: TStream;
  I, Count: Integer;
  Shape: TfShape;
begin
  Stream := TFileStream.Create(FileName, fmCreate);
  try
    for I := 0 to Count-1 do
    begin
      // Prépare Shape ici
      WriteDataToStream(Stream, Shape, TypeInfo(TfShape));
    end;
  finally
    Stream.Free;
  end;
end;
 
procedure ReadFromFile(const FileName: TFileName);
var
  Stream: TStream;
  Shape: TfShape;
begin
  Stream := TFileStream.Create(FileName, fmOpenRead);
  try
    while Stream.Position < Stream.Size do
    begin
      ReadDataFromStream(Stream, Shape, TypeInfo(TfShape));
      // Utilise Shape ici
    end;
  finally
    Stream.Free;
  end;
end;

[petitcoucou31]

Merci a tous les deux ..
Donc je vais suivre de conseil de ShaiLeTroll, et me mettre aux streams. Surtout que j'ai souvent se problème de structure de record fixe que je devrais résoudre en utilisation ton code . merci