[noob question] Conditional Type in Struct (u32/u64)

[seanlacey]

I'm working on learning rust and as a first project decided to work on data type parser (specifically sas7bdat). Right now I'm parsing the header and had a question:

#[derive(BinRead, Debug)]
#[br(little)]
struct Properties {
    //Capturing magic number here to do custom error check
    #[br(count = 32)]
    magic_number: Vec<u8>,

    //Header Alignment Variable. Corresponds to 64-bit check
    #[br(map = |x: u8| if x == 0x33 { 4 } else { 0 })]
    a2: usize,
    
    //Creating separate bool for ease of use
    #[br(calc = if a2 == 4 { true } else { false })]
    adjust64: bool,

    //Other Alignment Variable (for padding around timestamps)
    #[br(align_before = 35)]
    #[br(map = |x: u8| if x == 0x33 { 4 } else { 0 }, pad_after = 1)]
    a1: usize,

    //Endian Checker. Will use for is_little later on
    #[br(map = |x: u8| if x == 1 { false } else { true })]
    is_big_end: bool,

    //Header Length
    #[br(is_big = is_big_end)]
    #[br(align_before = 196 + a1)]
    hl: u32,

    //Page Length
    #[br(is_big = is_big_end)]
    pl: u32,
}

After page length (pl) I'm looking to capture page count which is either an i32 or i64 depending on the value of a2 (if a2 == 4 then i64). What's the best way to do this? I could use the binrw conditional twice but is that the most idiomatic way to do it? Should I just set the type to be isize? (As an aside, I'm realizing hl and pl should be i32 types since they won't be negative).

[csnover]

Hi, thanks for your question!

Generally, the best way to handle a file format where there are different versions of the same data is to create one “master” format that you expose to application code, write one struct for each different version of the serialised data, and write impl From<VariantStruct> for MasterStruct implementations to convert the variant structs to/from the master format.

For a format where data is either 32-bit or 64-bit in a consistent way, you can write a single generic struct Data<T>, use T for those 32/64 fields, and then parse either Data<u32> or Data<u64> according to the header. It might look something like this:

struct Properties {
  /* … existing stuff … */
  #[br(parse_with = |r, e, a| if a2 == 4 {
    Data<u64>::read_options(r, e, a)
  } else {
    Data<u32>::read_options(r, e, a).map(Data<u64>::from)
  }]
  data: Data<u64>

It’s not correct to use usize/isize here because those types are dependent on the target architecture, whereas the field sizes are dependent on the file format.

Hopefully this makes sense (and hopefully I didn’t screw anything up, writing advice very late at night :-)).

[seanlacey]

I really appreciate the response. Before I read your reply I had come up with the following.

#[derive(BinRead, Debug)]
#[br(import { adjust64: bool })]
enum PageCount {
    #[br(pre_assert(adjust64 == false))] 
    I32(i32),
    #[br(pre_assert(adjust64 == true))] 
    I64(i64),
}

#[derive(BinRead, Debug)]
#[br(little)]
struct Properties {
    //Capturing magic number here to do custom error check
    #[br(count = 32)]
    magic_number: Vec<u8>,

    //Header Alignment Variable. Corresponds to 64-bit check
    #[br(map = |x: u8| if x == 0x33 { 4 } else { 0 })]
    a2: isize,
    
    //Creating separate bool for ease of use
    #[br(calc = if a2 == 4 { true } else { false })]
    adjust64: bool,

    //Other Alignment Variable (for padding around timestamps)
    #[br(align_before = 35)]
    #[br(map = |x: u8| if x == 0x33 { 4 } else { 0 }, pad_after = 1)]
    a1: isize,

    //Endian Checker. Will use for is_little later on
    #[br(map = |x: u8| if x == 1 { false } else { true })]
    is_big_end: bool,

    //Header Length
    #[br(is_big = is_big_end)]
    #[br(align_before = 196 + a1)]
    hl: i32,

    //Page Length
    #[br(is_big = is_big_end)]
    pl: i32,

    //Page Count
    #[br(is_big = is_big_end)]
    #[br(args { adjust64 })]
    page_size: PageCount,
}

It works, but wasn't sure if it would be more idiomatic to do it the way you suggested. So is the code you wrote checking a2, then if 4 it's u64, else it reads as u32 then casts to u64?

Really appreciate the response.

EDIT: Removing question about read_options, I'm reading through the binrw documentation right now and just figured out it's coming from binrw.

[csnover]

It works, but wasn't sure if it would be more idiomatic to do it the way you suggested.

Using a two-variant enum works, but it means extra work is being done every time you use that type. If it is the case that the entire file after a certain point is consistently either 32-bit or 64-bit based on that header value, then you can save yourself a lot of hassle by just branching once and converting to a single type instead. You aren’t saving any memory using the two-variant enum, so whatever edge case might exist to prefer that approach is unlikely to be true here.

So is the code you wrote checking a2, then if 4 it's u64, else it reads as u32 then casts to u64?

Yes, basically. Technically it is assuming that you have some struct similar to struct Data<T> where for<'a> T: BinRead<Args<'a> = ()> { field1: T, field2: T, fieldN: T }, but you could also use a non-generic struct, or just raw u32/u64, and do the same thing. The reason to use a generic struct + From implementation is for DRY and to central boilerplate instead of having to annotate every single field with extra parse_with junk.