Platz lassen, in binärer Datei?

[DelphiPeter]

Hallo Leute

ich kopiere byteweise kleine Dateien in eine große Datei, hierbei hat sich nun eine Frage ergeben.

Szenario:

Benutzer A fügt 3 Dateien hinzu, diese werden hintereinander in die große Datei geschrieben.

Benutzer B löscht die 2 Datei aus der großen Datei wieder raus, nun klafft eine Lücke zwischen Datei 1 und der ursprünglichen Datei 3.

Meine Frage, Problem, wie auch immer...

Wenn ich Datei 2 aus der großen Datei lösche, wie kennzeichne ich das mittels TFileStream, das ich später ermitteln kann, ob das Byte belegt ist mit Daten, oder ob es leer und verwendbar ist? Gehen wir mal davon aus, es kommt ein Benutzer C der fügt eine Datei hinzu, die ist 2 mal so groß wie die ursprüngliche Datei 2. Dann will ich erzwingen, das der eine Teil der neuen Datei zwischen Datei 1 und 3 geschrieben wird, und der Rest dann hinter Datei 3.

Ich hoffe jemand versteht was ich sagen will? :-) Ich spreche Delphi, Englisch und ein bisschen Deutsch (Muttersprache) :stupid:

Gruß,
Peter

[Teekeks]

Wie wäre es die Lücke zwischen 1 und 3 einfach entfernst?
Also so:
Wenn du einen Datensatz löscht, schreibst du die Datei ab 1 einfach neu, die Lücke wird behoben und alles ist gut :)

[Morphie]

Du willst also mehrere Daten innerhalb einer Datei fragmentieren?
Da würde ich in der Datei einen Index anlegen, quasi als Header oder so...
Dort stehen dann zu jeder "Datei" Informationen, wo welche Fragmente abgelegt sind.

[xZise]

Das wird relativ kompliziert. Um zu speichern ob da valide Daten drin sind, würde ich einfach ein entsprechendes Format wählen:

(Ohne Anspruch auf Vollständigkeit)

Code:

<1. Bit immer 0><31 bit Länge des Inhalts><1 bit valider Inhalt><2 bit ob Adresse folgt><5 bit zusätzliche Folgende Adresse><opt. 16/32/64 bit Folgende Adresse><Bis zu 2^31 Byte Inhalt>

Das kannst du dann beliebig hintereinander setzen. So kann eine Datei darin aber auch maximal 2^32 bit groß sein, oder man vergrößert die Folgeadresse.

Auch kann man überlegen ob die Folgeadresse relativ ist (also springe X. Byte weiter) oder absolut (springe an das X. Byte).

Beim Ende würde ich einfach erstmal ein Byte lesen und dann eventuell einen int64.

Beispielcode:

Delphi-Quellcode:

procedure WriteData(output : TStream; input : TStream);
var
  oldPos : Integer;
  size : Cardinal;
  parameters : Byte;
begin
  oldPos := output.Position;
  // find first free position
  output.read(size, SizeOf(size));
  // if there is enough space and marked as spacer
  if (size and $80 = 1) then
  begin
    // Enough space without follow adress.
    if (input.size + 5 < size and $7F) then
    // mit folgender Adresse wird es ein wenig schwieriger, da man nicht weiß, wie groß die sein muss
//    if (input.size + 5 < size and $7F) || (input.size + 5 + (2 bis 8) < size and $7F) then
    begin
      // It goes here
      // Write Size etc.
    end;
  end;
  output.read(parameters, SizeOf(parameters));
  if parameters and $8 = 1 then // invalid block
  begin
    // Hier jetzt reinschreiben
  end;
  output.Position := oldPos.
end;

Das wird übrigens auch etwas komplizierter: Was ist zum Beispiel, wenn die Datei so groß ist, das weniger als 5 Byte noch reinpassen? Dann muss man ja irgendwie sagen, der Rest ist ungenutzt.

Eine Möglichkeit wäre: Das erste Bit auf 1 zu setzen: Dann liest er nur ein Byte aus in der die Anzahl der übersprungenen Byte steht. Bei mindestens als 5 Byte kann man einfach eine leere invalide Datei rein schreiben. Und bei 1 Byte bis 4 Byte platz schreibt man im ersten Bit eine 1 und in den anderen 7 Bit wie viele Bytes übersprungen werden sollen.

Aber ich hoffe das bringt dich schon mal näher ans Ziel. Eventuell sollte die Folgeadresse auch nicht optional sein. So spart man sich eventuell einiges an zusätzlichen Bedingungen und kann einfach ein Block schreiben und den nächsten suchen.

MfG
Fabian

PS: @Teekeks: Wenn man aber die erste Datei löscht wird die ganze Datei verschoben ;) Und eventuell möchte man das verhindern.

[Luckie]

Das klingt so, als wenn du ein Dateisystem nachbauen wolltest. Du solltest dich mal mit den FAT-Dateisystemen befassen. Dann wirst du feststellen, dass dies nicht mit ein paar Codezeilen zu realisieren ist. Ich würde an deiner Stelle eine fertige Lösung für Dateicontainer nehmen, wie zum Beispiel irgendwelche Archive. Für Delphi würde sich da zum Beispiel die zLib anbieten.

[Blup]

Am Ende der Containerdatei ein Inhaltsverzeichnis mit Namen der Unterdatei(en) und Informationen zu den jeweils belegten Blöcken (das bei jeder Änderung neu geschrieben wird) und am Anfang der Containerdatei einen Verweis auf dieses Inhaltsverzeichnis.
Ich würde aber auch Zip-Archive empfehlen.

[DelphiPeter]

Super, danke für eure Beiträge! Ich werde mich also mal dran versuchen.

Vielleicht als kleiner Hinweis. Die eigentlich Informationen zur Datei, wie z.B. der Ursprungsname, Adresse, Größe usw wird in einer SQL Datenbank abgelegt. Ja ich weiß, das klingt krank, ist aber anspruchsvoll :cyclops: ...

Ich habe ein Problem mit Geschwindigkeit, ich kann die Datei nicht jedes mal, nach dem löschen neu fragmentieren, ich arbeite auf einem USB Stick, das ist echt übel :roll:

[Sir Rufo]

Warum speicherst du die Daten denn nicht auch gleich in der Datenbank?

Dann brauchst du dich um das ganze Geraffel nicht kümmern.

[Assarbad]

Ich würde mal Sparse Files einwerfen. Aber dann muß man TFileStream sicher ableiten. Das ist auch nur am Anfang (beim Erstellen) sinnvoll. Später muß ohnehin ein Index her. So gesehen empfehle ich SQLite :stupid: