Hilfe bei einem Algorithmus

[Tom21]

Hallo Leute,

habe ein kleines Problem mit einem Algorythmus.

Folgendes Scenario:
Ich habe eine read-Funktion

byte[]recvBuffer = new byte[16];

read(int Blocknummer,byte[]recvBuffer);

Ich lese aus einem Speicher. welches folgende Speicherstruktur hat:

BlockNr          Byte0    Byte1      Byte2     Byte3
----------------------------------------------------------
1                   DATA0   DATA1    DATA2    DATA3
2                   DATA4   DATA5    DATA6    DATA7
3                   DATA8   DATA9    DATA10  DATA11
4                   DATA12 DATA13  DATA14  DATA15
5                   DATA16 DATA17  DATA18  DATA19
6                   DATA20 DATA21  DATA22  DATA23

Ich kann immer nur 16Bytes lesen und nur Blockweise addressieren.
zb. read(1,recvBuffer) liesst die Blöcke 1,2,3,4 in recvBuffer.

Die Daten im Speicher liegen als.
Typ Länge Wert

zb. 1 Datensatz Typ1,Länge1,Wert1..Typ2,Länge2,Wert2 ... etc . . .

Beispiel im Speicher:

BlockNr  Byte0  Byte1   Byte2    Byte3
----------------------------------------------
1           Typ1     0x04   Wert1    Wert1
2           Wert1   Wert1  Typ2      0x016
3           Wert2   Wert2  Wert2    Wert2
4           Wert2   Wert2  Wert2    Wert2
5           Wert2   Wert2  Wert2    Wert2
6           Wert2    END    DATA22 DATA23

as Problem ist, dass Länge auch größer als 16Byte sein kann.
Typ Länge Wert organisiere ich in eine Klasse

Class Data(){
byte typ;
byte länge;
byte[] wert;
.
static Parse(byte typ,byte länge, byte[]wert);

}
wenn ich also den ersten Typ1 finde. dann rufe ich einfach Parse-Methode auf und über gebe die Parameter Wert, Länge Werte.


Frage: Wie schaffe ich es alle "Typ Länge Wert" Daten aus dem Speicher zu lesen
bis ein END kommt.
Wie gesagt, ich kann nur Blockweise Adressieren und immer nur genau 16 Bytes lesen.

Ist vielleicht seh kompliziert erklärt, aber ich verzweifle dran, und hoffe dass ich irgendwie hilfe bekomme.

Gruss Tom

 

[Gast]

dass du die daten nur blockweise lesen kannst heisst ja nicht, dass du sie auch gleich blockweise verarbeiten musst. jag die blöcke doch einfach noch durch einen buffer.

eine elegante lösung wäre z.b. eine implementierung von InputStream zu schreiben, die entsprechend immer in 16 byte blöcken liest. dann kannst du einen der standard java wrapper um den stream pappen und musst dir keine gedanken über blockgrößen etc. mehr machen.

 

[Gast]

class BlockReader extends InputStream
{
    private MyOtherBlockReaderFunc reader;

    // ...

    private final byte[] buf = new byte[16];
    private int block = -1;
    private int pos = buf.length;

    public int read()
    {
       if( pos == buf.length )
       {
          this.reader.read( ++block, buf );
          pos = -1;
       }
       return this.buf[ ++pos ];
    }
}

so z.b.