Separate streaming of enum variant to index records and the actual data

[marxin]

Hey! First of all, thanks for the amazing library! I'm really enjoying fiddling with it.

I'm trying to stream out RPM Header Structure where I need to serialize basically something like this:

#[derive(BinWrite)]
enum Entry {
    #[bw(magic = 0u8)]
    Null,
    #[bw(magic = 1u8)]
    String(NullString),
    #[bw(magic = 2u8)]
    Values(Vec<u8>),
}

which can be easily serialized in place as:

        let mut cursor = Cursor::new(Vec::<u8>::new());
        [
            Entry::Null,
            Entry::String("ok".into()),
            Entry::Values(vec![1, 2, 3, 4]),
        ]
        .write_le(&mut cursor)
        .unwrap();
        assert_eq!(cursor.into_inner(), b"\0\x01ok\0\x02\x01\x02\x03\x04");

But it's not the case for RPM format which first streams the Header Index as Vec<EntryHeader>:

#[derive(BinWrite)]
struct EntryHeader {
    magic: u32,
    offset: u32,
    count: u32,
}

followed by Vec<EntryBody>:

#[derive(BinWrite)]
struct EntryBody(Vec<u8>);

So the serialized equivalent for the original Entry enum would look like this:

 let mut separated_data = Cursor::<Vec<u8>>::default();
        [
            EntryHeader {
                // Entry::Null
                magic: 0,
                offset: 0,
                count: 0,
            },
            EntryHeader {
                // Entry::String("ok".into())
                magic: 1,
                offset: 0,
                count: 3,
            },
            EntryHeader {
                // Entry::Values(vec![1, 2, 3, 4])
                magic: 2,
                offset: 3,
                count: 4,
            },
        ]
        .write_le(&mut separated_data)
        .unwrap();
        [
            EntryBody(Vec::new()),       // Entry::Null
            EntryBody(b"ok\0".to_vec()), // Entry::String("ok".into())
            EntryBody(vec![1, 2, 3, 4]), // // Entry::Values(vec![1, 2, 3, 4])
        ]
        .write_le(&mut separated_data)
        .unwrap();

Do you have a suggestion on how to achieve such a separate serialization?

[csnover]

There is currently no good way to transform a collection of enums into a split offset table and data, though this is a known use case that needs to be handled by something eventually, see #4. Probably the easiest and most readable way right now is to just create a custom writer using #[binrw::writer] that tracks the offset position manually and loops over the collection twice, first to write the index table and second for the data.