Einlesen einer FORTRAN Binärdatei mit Delphi

[Uwe Raabe]

Zitat von BUG:

Zitat von Uwe Raabe:

Die $13 sind offensichtlich die Länge des Records (19 Zeichen). Warum die am Ende nochmal kommt, weiß ich auch nicht.

Ein Suchergebnis hat Rückwärtsspringen über Records vermutet ... würde Sinn machen.

Das wäre denkbar. Ein ähnliches Format hatte ich schon mal bei Daten für Magnetbänder.

[Mavarik]

Also für mich sieht das ganz und gar nicht nach eine Binärdatei aus...

Schau Dir mal das hier an...

Mavarik

[Sir Rufo]

Zitat von Mavarik:

Also für mich sieht das ganz und gar nicht nach eine Binärdatei aus...

Schau Dir mal das hier an...

Mavarik

Jede Datei ist eine Binär-Datei. Alles andere sind Unterklassen mit einem vereinbarten Format

[Mavarik]

Zitat von Sir Rufo:

Jede Datei ist eine Binär-Datei. Alles andere sind Unterklassen mit einem vereinbarten Format

Logisch... Solange wir Informationen noch nicht in Bio-neuronalen-Gel Packs abspeichern...

Siehe...

Mavarik

[Uwe Raabe]

Der Wiki-Eintrag ist an dieser Stelle irreführend. Es ist wirklich jede Datei eine Binärdatei. Textdateien sind eine Untermenge davon und auch davon gibt es wieder verschiedene Untermengen mit diversen Encodings und Line-Endings.

Fragte doch neulich jemand, warum denn beim Einlesen mit TEncoding.ANSI keine Fehlermeldung käme, wenn man dem Programm eine Unicode-Datei unterjubelt.

Dein BlockRead-Record-Ansatz ist zwar ziemlich Old-School, aber würde hier durchaus funktionieren - wenn die Datensätze wirklich alle gleich lang sind. Das ist aber nicht zwingend der Fall. Unter der Annahme, daß das eine Byte vor und nach den Nutzdaten wirklich die Recordlänge angibt (255 Byte Maximum - unglaublich!), dann würde sich eigentlich eher ein Stream-Wrapper oder ein class helper for TStream anbieten.

[Mavarik]

Zitat von Uwe Raabe:

Dein BlockRead-Record-Ansatz ist zwar ziemlich Old-School, aber würde hier durchaus funktionieren

Old-School = Good-School;

Eine Binärdatei ist für mich eine 1:1 Entsprechungen eine Speicher-Datenstruktur ohne ausgerichtete Felder -{$A1}. Keine längen Bytes, Trennzeichen, kein ^Z am Ende usw.

Wenn ich ein Byte in eine Datei schreibe, muss die Datei auch nur ein Byte lang sein.
Wenn ich 100 Datensätze mit je 15 Byte weg schreibe muss die Datei auch 1500 Bytes enthalten. Nicht mehr und nicht weniger.

Dann ist es in meinem Sprachgebrauch eine Binärdatei...

Mavarik

[Tenobaal]

Danke euch, ihr habt mir schon sehr weitergeholfen
Ich bin heute auf den Beitrag gestoßen http://stackoverflow.com/questions/8...ed-file-format
Zumindest verstehe ich nun, wie die Struktur der Dateien aufgebaut ist.

[Blup]

ich würde das im Prinzip so aufbauen:

Delphi-Quellcode:

unit FortranWriter;

interface

type
  TFortranObjectWriter = abstract class(TObject)
  protected
    class procedure GetDataObjectClass: TClass; virtual; abstract;
    class procedure WriteToBuffer(ABuffer: TCustomStream; AValue: Double); overload:
    class procedure WriteToBuffer(ABuffer: TCustomStream; AValue: Integer); overload:
    class procedure Register;
    class procedure UnRegister;
  public
    class property DataObjectClass: TClass read GetDataObjectClass;
    class procedure WriteObjectToBuffer(ABuffer: TCustomStream; AObject: TObject); virtual; abstract;
  end;

  TFortranObjectWriterClass = class of TFortranObjectWriter;

  TFortranWriter = class(TObject)
    constructor Create(AStream: TCustomStream);
    destructor Destroy;
  private
    FBuffer: TMemmoryStream;
    FStream: TCustomStream;
    class var FObjectWriter: TClassList;
  protected
    class procedure RegisterObjectWriter(AClass: TFortranObjectWriterClass);
    class procedure UnRegisterObjectWriter(AClass: TFortranObjectWriterClass);
    class procedure GetObjectWriter(AClass: TClass): TFortranObjectWriterClass;
  public
    procedure Write(AObject: TObject); virtual;
  end;

implementation

constructor TFortranWriter.Create(AStream: TCustomStream);
begin
  inherited Create;
  
  FStream := AStream;
  FBuffer := TMemmoryStream.Create;
end;

destructor TFortranWriter.Destroy;
begin
  FBuffer.Free;

  inherited;
end;

procedure TFortranWriter.Write(AObject: TObject);
var
  ObjectWriter: TFortranObjectWriterClass;
  ByteSize: Byte;
begin
  FBuffer.Clear;
  ObjectWriter := GetObjectWriter(AObject.Class);
  if not Assigned(ObjectWriter) then
    raise Exception.Create('...');

  ObjectWriter.WriteObjectToBuffer(FBuffer, AObject);
  if FBuffer.Size = 0 then
    raise Exception.Create('...');
  if FBuffer.Size > 255 then
    raise Exception.Create('...');

  ByteSize := FBuffer.Size;

  FStream.Write(ByteSize, SizeOf(ByteSize));
  FBuffer.WriteToStream(FStream);
  FStream.Write(ByteSize, SizeOf(ByteSize));
end;

class procedure TFortranWriter.RegisterObjectWriter(AClass: TFortranObjectWriterClass);
begin
  if not Assigned(FObjectWriter) then
    FObjectWriter := TClassList.Create;

  FObjectWriter.Add(AClass);
end;

class procedure TFortranWriter.UnregisterObjectWriter(AClass: TFortranObjectWriterClass);
begin
  if not Assigned(FObjectWriter) then
    Exit;

  FObjectWriter.Remove(AClass); 

  if FObjectWriter.Count = 0 then
    FreeAndNil(FObjectWriter);
end;

class procedure TFortranWriter.GetObjectWriter(AClass: TClass): TFortranObjectWriterClass;
begin
  if Assigned(FObjectWriter) then
  begin
    for i := FObjectWriter.Count - 1 downto 0 do
    begin
      Result := TFortranObjectWriter(FObjectWriter[i]);
      if AClass is Result.DataObjectClass then
        Exit;
    end;
  end;
  Result := nil;
end;

class procedure TFortranObjectWriter.WriteToBuffer(ABuffer: TCustomStream; AValue: Double); 
begin
  ABuffer.Write(AValue, SizeOf(AValue));
end;

class procedure TFortranObjectWriter.WriteToBuffer(ABuffer: TCustomStream; AValue: Integer);
begin
  ABuffer.Write(AValue, SizeOf(AValue));
end;

class procedure TFortranObjectWriter.Register;
begin
  TFortranWriter.Register(Self);
end;

class procedure TFortranObjectWriter.UnRegister;
begin
  TFortranWriter.UnRegister(Self);
end;

end.

Delphi-Quellcode:

unit MyDataObject;

interface

type
  TMyDataObject = class(TObject)
  private
    FA: Double;
    FB: Integer;
    FC: Integer;
  published
    property A: Double  read FA write FA;
    property B: Integer read FB wirte FB;
    property C: Integer read FC write FC;
  end;

Delphi-Quellcode:

unit FortranMyDataObject;

interface

implementation

type
  TMyDataObjectFortranWriter = class(TFortranObjectWriter)
  protected
    class procedure GetDataObjectClass: TClass; override;
  public
    class procedure WriteObjectToBuffer(ABuffer: TCustomStream; AObject: TObject); override;
  end;

class procedure TMyDataObjectFortranWriter.GetDataObjectClass: TClass;
begin
  Result := TMyDataObject;
end;

class procedure TMyDataObjectFortranWriter.WriteObjectToBuffer(ABuffer: TCustomStream; AObject: TObject);
begin
  with TMyDataObject(AObject) do
  begin
    WriteToBuffer(ABuffer, A);
    WriteToBuffer(ABuffer, B);
    WriteToBuffer(ABuffer, C);
  end;
end;

initialization
  TMyDataObjectFortranWriter.Register;

finalization
  TMyDataObjectFortranWriter.UnRegister;

end.

Delphi-Quellcode:

MyObject := nil;
Stream   := nil;
Writer   := nil;
try
  Stream := TFileStream.Create('MyFortranFile.bin');
  Writer := TFortranWriter.Create(Stream);
  MyObject := TMyDataObject.Create;
  MyObject.A := 1;
  MyObject.B := 2;
  MyObject.C := 3;
  Writer.Write(MyObject);
  MyObject.A := 4;
  MyObject.B := 5;
  MyObject.C := 6;
  Writer.Write(MyObject);
finally
  Writer.Free;
  Stream.Free;
  MyObject.Free;
end;