Getting/Writing byte size of BinWrite types?

[brecert]

I'm writing a reader/writer for a format similar to unreal engine's gvas save files.

Each property in the save file has a format that can be (heavily) simplified to something like.

struct SimpleProperty {
  // size in bytes
  size: u64,
  field_1: String,
  field_2: String, 
  ...
  separator: u8,
  // everything after the separator counts as part of the size
  value_1: Type1,
  value_2: Type2,
  ...
}

When writing and working with these properties I don't want to manually specify the size, or implement BinWrite by hand.

Something similar to #[bw(calc = size_of(Type1) + size_of(Type2))] size: u64 sounds ideal to me, but any insights and feedback would be appreciated.

[kitlith]

assuming there are multiple kinds of properties with different values, we could save some work no matter what approach we take by adding generics. i.e.

struct PropertyImpl<V> {
    size: u64,
    field_1: String,
    // ...
    // if fields are also tied to values somehow (i'm not familiar with gvas), additional generics or a trait + associated type could turn it into:
    // fields: <V as SomeTrait>::Fields,
    separator: u8,
    values: V,
}

In general though, there's more than one way to skin a cat here. binrw does not currently have a mechanism for getting the serialized lengths of values, but here's a few ways I came up with off the top of my head that you could use to proceed:

• Implement your own size tracking solution, which would get you something like size_of (i.e. manual impls for base types, then a quick macro to sum the sizes of fields for structs)
• Get the writer position before the size field, after the separator, and at the end of the struct. Then seek back to the size field and write a computed size using the recorded position of the separator and end of the struct. Seek back to the end of the struct afterwards.
• Indirect the serialization of the latter part of the struct through a Vec, use the length of the Vec for the size field, write the contents later.
  • This might require a manual implementing of BinWrite, but only one if you use the Generic strategy above.

All of these approaches have their own tradeoffs, and maybe I'm making bad assumptions about the format, because I'm not familiar with gvas. For instance, if the value of field_1 determines the type/size of value_1, and separator is actually the terminator for the list of fields, then I'd probably go for parsing the list of fields into a vec w/ until or until_exclusive, then use args_iter to read the values into a Vec<ValueTypeEnum> or something.