Est-ce la façon la plus naturelle de lire des structures à partir d'un fichier binaire ?

Question

Je viens de réaliser que cela ressemble beaucoup à Quelle est la meilleure façon d'analyser les protocoles binaires avec Rust ?

Est-ce la façon la plus naturelle de lire des structures à partir d'un fichier binaire en utilisant Rust ? Cela fonctionne mais semble un peu bizarre (pourquoi ne puis-je pas simplement remplir la structure en gros ?).

extern crate byteorder;
use byteorder::{ByteOrder, LittleEndian};

struct Record {
    latch: u32,
    total_energy: f32,
    x_cm: f32,
    y_cm: f32,
    x_cos: f32,
    y_cos: f32,
    weight: f32
}

impl Record {
    fn make_from_bytes(buffer: &[u8]) -> Record {
        Record {
            latch: LittleEndian::read_u32(&buffer[0..4]),
            total_energy: LittleEndian::read_f32(&buffer[4..8]),
            x_cm: LittleEndian::read_f32(&buffer[8..12]),
            y_cm: LittleEndian::read_f32(&buffer[12..16]),
            x_cos: LittleEndian::read_f32(&buffer[16..20]),
            y_cos: LittleEndian::read_f32(&buffer[20..24]),
            weight: LittleEndian::read_f32(&buffer[24..28]),
        }
    }
}

Answer 1

Jetez un coup d'œil à la nom crate : il est très utile pour analyser les données binaires.

Avec nom vous pourriez écrire votre analyseur avec quelque chose comme ce qui suit (non testé) :

named!(record<Record>, chain!
    ( latch: le_u32
    ~ total_energy: le_f32
    ~ x_cm: le_f32
    ~ y_cm: le_f32
    ~ x_cos: le_f32
    ~ y_cos: le_f32
    ~ weight: le_f32
    , {
        Record {
            latch: latch,
            total_energy: total_energy,
            x_cm: x_cm,
            y_cm: y_cm,
            x_cos: x_cos,
            y_cos: y_cos,
            weight: weight,
        }
    }
    )
);