Tfilestream : problème de lecture du fichier

Résolu
bv94 Messages postés 40 Date d'inscription dimanche 2 février 2003 Statut Membre Dernière intervention 16 décembre 2006 - 23 oct. 2005 à 22:28
bv94 Messages postés 40 Date d'inscription dimanche 2 février 2003 Statut Membre Dernière intervention 16 décembre 2006 - 24 oct. 2005 à 15:26
Bonsoir,

mon problème est le suivant : je créé un type Toperation qui hérite de Tfilestream. Mais les fonctions de tfilestream que j'utilise (read, seek...etc) dans les procedures de toperation ne rammène aucun resultat...
Le plus simple étant de vous montrer : voici mon source, peut être pourrez vous trouver où je me suis trompé.

Merci d'avance...

interface


uses Classes,Sysutils,math;


type Toperation = class(TFileStream)
private
Funite : string;
Fmodebc : string;
Fposmin : longint;
Fposmax : longint;
Fmdp : string;
Fposition : longint;
Fchaine : string;
Ftaillechaine : string;
function bintocarac(bin : string):string;
function lirecaract(caract : char):string;
function lireBread(bread : byte):string;
function Fecrire(mots:string):longint;
protected
lu : integer;
ecrit : integer;
procedure Setposmin;
procedure Setchaine(vchaine : string);
public
property posmin : longint read Fposmin;
property positionencours : longint read Fposition write Fposition;
property modebc : string read Fmodebc write Fmodebc;
property unite : string read Funite write Funite;
property chaine : string read Fchaine write Setchaine;
property mdp : string read Fmdp write Fmdp;
property taille : longint read Ftaille;
function ecrire:longint;
constructor Create(const FileName: string; Mode: Word; Vmodebc: string);
destructor Destroy;override;
end;


implementation


function Toperation.ecrire:longint;
begin
if Fmodebc = 'c' then
begin
if (Fposition >= Fposmin) and (Fchaine <> '') then
begin
Fecrire(inttostr(length(Fmdp))); // Ecriture de la longueur du mot de passe
Fecrire(mdp); // Ecriture du mot de passe
Fecrire(modebc); // Ecriture du mode. Ici : c
Fecrire(Ftaillechaine); // Ecriture de la taille de la chaine dans le fichier : longueur de chaine * 8
Fecrire(chaine); // Ecriture de la chaine à proprement parler
end;
end
else
begin
end;
end;



function Toperation.Fecrire(mots:string):longint;
var
Bread : byte;
i,j,bitains,ecrit : integer;
caracains : string;
begin
try
ecrit := 0;
Seek(Fposition,soFromBeginning); //position de depart de l'écriture
For i:=1 to length(mots) do // pour chaque octet(caractère)
begin
caracains := (lirecaract(mots[i])); // conversin du caractère en "chaine binaire" ex : 00110110
For j:=1 to length(caracains) do //pour chaque bit du caractère
begin
Read(Bread,soFromCurrent); //lecture d'un octet à partir de la position courante => Bread
bitains := strtoint(copy(caracains,j,1));
if (Bread mod 2) <> bitains then // si le dernier bit du fichier support est <> du bit du caractère
begin
case bitains of // on inverse le dernier bit de l'octet de l'image
0 : Bread := Bread - 1;
1 : Bread := Bread + 1;
end;
end;
Seek(-1,soFromCurrent); // repositionnement sur l'octet lu
ecrit := ecrit + write(Bread,1); // rééecriture de l'octet modifié + compteur d'octets ecrits
end;
end;
finally
result := ecrit; // paramètre de sortie : nb d'octets ecrits
Fposition := Fposition+ecrit+1;
end;
end;


procedure TOperation.setchaine(vchaine : string);
begin
Fchaine := vchaine;
Ftaillechaine := inttostr(length(chaine));
while length(Ftaillechaine) < 9 do
Ftaillechaine := '0'+Ftaillechaine;
end;


procedure TOperation.setposmin;
begin
// provisoire
Fposmin := 20;
end;

constructor Toperation.Create(const FileName: string; Mode: Word; Vmodebc: string);
begin
inherited Create(FileName,Mode); // Initialise les parties héritées
modebc := Vmodebc;
end;


destructor Toperation.Destroy;
begin
inherited;
end;


function Toperation.bintocarac(bin : string):string;
var
i,temp : integer;
begin
temp := 0;
For i:=1 to length(bin) do
begin
temp := temp + strtoint(copy(bin,i,1))*Trunc(Power(2,8-i));
end;
result := chr(temp);
end;


function Toperation.lirecaract(caract : char):string;
var
temp : integer; //variable de travail
sortie : string;
begin
temp := ord(caract);
sortie := '';
while temp <> 0 do
begin
sortie := Chr(temp mod 2 + Ord('0')) + sortie;
temp := temp div 2;
end;
while length(sortie) < 8 do
sortie := '0'+sortie; // pour avoir une chaine de 8 caractères
Result := sortie;
end;


function Toperation.lireBread(bread : byte):string;
var
temp : integer; //variable de travail
sortie : string;
begin
temp := bread;
sortie := '';
while temp <> 0 do
begin
sortie := Chr(temp mod 2 + Ord('0')) + sortie;
temp := temp div 2;
end;
while length(sortie) < 8 do
sortie := '0'+sortie; // pour avoir une chaine de 8 caractères
Result := sortie;
end;


end.

BV94

3 réponses

bv94 Messages postés 40 Date d'inscription dimanche 2 février 2003 Statut Membre Dernière intervention 16 décembre 2006 1
24 oct. 2005 à 15:26
C'est bon, j'ai trouvé la solution : Toperation existe deja dans l'unité Classes... Tout simplement.
Merci tout de meme
3
vaughan Messages postés 198 Date d'inscription mardi 6 août 2002 Statut Membre Dernière intervention 29 octobre 2008
24 oct. 2005 à 13:33
Dans FEcrire tu ne fait jamais de Write donc il n'écrit jamais dans ton fichier.

vaughan
0
bv94 Messages postés 40 Date d'inscription dimanche 2 février 2003 Statut Membre Dernière intervention 16 décembre 2006 1
24 oct. 2005 à 14:20
function Toperation.Fecrire(mots:string):longint;
var
Bread : byte;
i,j,bitains,ecrit : integer;
caracains : string;
begin
try
ecrit := 0;
Seek(Fposition,soFromBeginning); //position de depart de l'écriture
For i:=1 to length(mots) do // pour chaque octet(caractère)
begin
caracains := (lirecaract(mots[i])); // conversin du caractère en "chaine binaire" ex : 00110110
For j:=1 to length(caracains) do //pour chaque bit du caractère
begin
Read(Bread,soFromCurrent); //lecture d'un octet à partir de la position courante => Bread
bitains := strtoint(copy(caracains,j,1));
if (Bread mod 2) <> bitains then // si le dernier bit du fichier support est <> du bit du caractère
begin
case bitains of // on inverse le dernier bit de l'octet de l'image
0 : Bread := Bread - 1;
1 : Bread := Bread + 1;
end;
end;
Seek(-1,soFromCurrent); // repositionnement sur l'octet lu
ecrit := ecrit + write(Bread,1); // rééecriture de l'octet modifié + compteur d'octets ecrits
end;
end;
finally
result := ecrit; // paramètre de sortie : nb d'octets ecrits
Fposition := Fposition+ecrit+1;
end;
end;

Tout de même...

BV94
0
Rejoignez-nous