[delphi] BlockWrite

[chris]

In delphi heb je de functie BlockWrite. Deze doet het volgende:
Writes one or more records from a variable to an open file.

De syntax is als volgt:
procedure BlockWrite(var f: File; var Buf; Count: Integer [; var AmtTransferred: Integer]);

Nou kan ik dus wel een integer wegschrijven met deze procedure, of een "array of chars". Maar kan ik met deze functie ook een willekeurig bestand wegschrijven? Of, nog mooier, een record met een bestandsnaam en bestand? Telkens als ik dit probeer wil het niet. Wie weet hier een oplossing voor? Voor de delphi-liefhebbers, ik ben bezig met het volgende: Stel je hebt een exe file. Deze bestaat uit een header en nog wat shit. Nou wil ik data aan het eind van het bestand schrijven na het EOF teken. Dit lukt opzich perfect, daar ligt het niet aan, maar het probleem is dus dat ik alleen maar rijtjes met chars en nummers enzo erachter kan zetten. Nou wil ik dus hetzelfde kunnen met objecten.

[Varienaja]

Het lijkt mij dat je per object toch echt een methode moet maken, die zichzelf in een file stopt.

code:

object aap
   private
      moeder,
      vader:integer
   public writetoFile(F:file);
end;

procedure Aap.WritetoFile(F:file);
begin
   BlockWrite(F,Vader,4);
   BlockWrite(F,Moeder,4);
end;

En dan heb je ook nog een procedure nodig die de boel weer terugleest uit de file.

Het object zelf via een pointer in de file schrijven raad ik je ten zeerste af.

[Creepy]

Ik vraag me af toe wel eens af wat mensen precies willen gaan doen, als ze hier een vraag stellen

Hmm.. ff uit m'n hoofd, want heb ff geen Delphi bij de hand, maar is het niet zo dat je m.b.v. een filestream objecten kan laden en saven? Iets in deze vorm:

code:

var blaat, blaat2: TmyObject;
begin
        blaat:=TMyObject.create;
        filestream.writeobject(blaat);
        filestream.seek(0);
        filestream.loadobject(blaat2);
end;

[elevator]

/dev/null schreef op 02 augustus 2002 @ 19:39:
In delphi heb je de functie BlockWrite. Deze doet het volgende:
Writes one or more records from a variable to an open file.

De syntax is als volgt:
procedure BlockWrite(var f: File; var Buf; Count: Integer [; var AmtTransferred: Integer]);

Nou kan ik dus wel een integer wegschrijven met deze procedure, of een "array of chars". Maar kan ik met deze functie ook een willekeurig bestand wegschrijven?

Natuurlijk kan dat, je doet dan iets als volgt:

code:

var SourceF: File;
      DestF: File;
      NumRead: Cardinal;
      Dat: Array[0..1023] of Char;
begin
  AssignFile(SourceF, 'src.file');
  Reset(SourceF, 1); { read 1-byte per time, defaults to 128 }

  AssignFile(DestF, 'dest.file');
  try 
    Reset(DestF, 1);  { try to open the file }
  except
    ReWrite(DestF, 1);  { if we fail, create it... }
  end; { except }

  Seek(DestF, FileSize(DestF)); { seek to EOF }

  while NOT EOF(SourceF) do
     begin
       BlockRead(SourceF, Dat, SizeOf(Dat), numRead);
       BlockWrite(SourceF, Dat, NumRead);      
     end; { while }
  
  CloseFIle(SourceF);
  CloseFile(DestF);
end.

even uit mijn hoofd. Niet in deze vorm gebruiken, maar het geeft je een idee.

[CyeZ]

Creepy schreef op 02 augustus 2002 @ 21:59:
Ik vraag me af toe wel eens af wat mensen precies willen gaan doen, als ze hier een vraag stellen
[...]
[wat mooie coding]

Ik denk dat Creepy in de goede richting zat. Ik zou er WriteComponent voor gebruiken in ieder geval.

code:

var blaat, blaat2: TmyObject;
begin
        blaat:=TMyObject.create;
        filestream.WriteComponent(blaat);
        filestream.seek(0);
        filestream.ReadComponent(blaat2);
end;

WriteComponent en ReadComponent werken allebei prima met alle TComponent en alle afgeleiden hiervan. Echter, niet alle TPersistent componenten (die je wellicht wilt gaan wegschrijven) zijn ook afgeleid van TComponent. Een voorbeeldje hiervan bv: TStringList. Deze kun je dus niet met WriteComponent en ReadComponent wegschrijven. De meeste van deze gevallen hebben hier gelukkig wel weer SaveToStream en LoadFromStream functies voor om dit op te lossen.

Mocht je aan een van bovenstaande manier nog niet genoeg hebben, dan is het zelfs nog mogelijk om alle TPersistant afgeleides te kunnen streamen. Zelf heb ik er nog nooit behoeft aan gehad, maar in dit artikel: http://www.undu.com/Articles/990609d.html staat er wat meer (wel zeer compacte) informatie over, inclusief voorbeeld code. Het idee komt er op neer dat je een eigen classe schrijft die is afgeleid van TComponent waar de te streamen objecten dan in worden vervoerd.

[nulkelvin]

Vraag, die je je moet stellen dus: hoe kan ik een object in een buffer plaatsten, heb je die opgelost, kan je hem wegscrhijven.

[Creepy]

TComponent is een afgeleide van Tpersistent.

Hmm de oplossing die CyeZ geeft is een mooie. Een container maken met objecten erin, en die streamen naar een file.

Maar de topicstarter had het over wegschijven van records? Als je een record hebt, en een pointer naar dat record kan je dat record wegschijven naar een file m.b.v. blockwrite op deze manier:

code:

type blaat = record
               var1: int;
               var2: string;
     end;
     pblaat = ^blaat; // een pointer naar ons record;
var buffer: pblaat;
begin
   new(pblaat);
   pblaat^.var1:=100;
   pblaat^.var2:='Hallo';
   blockwrite(f, pblaat, sizeof(pblaat));
   dispose(pblaat);
end;

Let wel.. als je pointer IN je record hebt staan, dan gaat dit niet werken. Aangezien je dan de pointer terug vindt in je file, en daar heb je zo weinig aan

[CyeZ]

[quote]Creepy schreef op 06 augustus 2002 @ 08:43:
Maar de topicstarter had het over wegschijven van records?
[quote]

dat dacht ik eerst ook. Maar na zijn post 4x gelezen te hebben zag ik eindelijk deze regel erbij staan. :

Nou wil ik dus hetzelfde kunnen met objecten.

Dus vandaar de door mij gegeven oplossing. In het geval van records is jouw oplossing inderdaad de beste die ik me zo uit m'n hoofd kan bedenken. Als je pointers in je records hebt, dan zul je 2 varianten van je record moeten moeten. Een variant met pointer en een variant met een soort indexes.