Is it possible to have something like try_as_mut_bytes(&mut self) for types like enums that only implement TryFromBytes?

[kairoswater-jason]

I've got a large number of enums with less than 256 variants where I don't want to implement FromBytes.
They are used in structs that implement TryFromBytes as well.

I recently realized that as_mut_bytes(&mut self) required FromBytes.

Is there a way to get something similar with types that only implement TryFromBytes and not FromBytes?

5095 |     fn as_mut_bytes(&mut self) -> &mut [u8]
     |        ------------ required by a bound in this associated function
5096 |     where
5097 |         Self: FromBytes,
     |               ^^^^^^^^^ required by this bound in `IntoBytes::as_mut_bytes`

[joshlf]

Can you describe a bit about your specific use case? What are you doing with the &mut [u8] that is returned from as_mut_bytes?

[kairoswater-jason]

Low level message parsing.

I had a struct type containing enums with less than 256 variants, and declared an instance of the struct to produce a buffer of the correct size (as if it was a [u8; 123] or whatever size). I wanted to write data into it and then call try_as_ref() or similar to see if the received data parsed correctly. (ie. all the enum fields were valid)

It's not hard to work around using size_of::<...>() and a buffer, but it would be nice to just let mut my_buffer: MyStruct = ... ; rather than let mut my_buffer = [0u8; size_of::<MyStruct>];

Perhaps what I wanted was not semantically valid now that I think about it. I suppose forcing the use of a u8 buffer rather than MyStruct makes it impossible to accidentally skip the checking step that is performed by try_from_ref.

[joshlf]

Yeah I think what you'll likely want is to populate a [u8; N] and then use some method on TryFromBytes or try_transmute_ref! (which has the advantage of doing size and alignment checking at compile time) to go from &[u8; N] to &MyStruct.

EDIT: It's worth pointing out that alignment may be a concern. If so, just do the following:

#[derive(FromBytes, IntoBytes, Immutable)]
#[repr(C, align(N))]
struct Buffer
    bytes: [u8; size_of::<MyStruct>()],
}

let buffer: Buffer = ...;
let s: &MyStruct = try_transmute_ref(&buffer).unwrap(); // TODO: Better error handling than `.unwrap()`

...where N = align_of::<MyStruct>(). try_transmute_ref will be satisfied that the alignment of Buffer is at least as large as the alignment of MyStruct.