Feature request: Provide compile time size hint when derive DekuRead & DekuWrite

[KmolYuan]

It would be great if a constant size-hint value could calculate the static buffer size when derived from DekuRead, DekuWrite, or a new macro.

pub trait DekuSizeOf {
    /// Compile time size hint in bits (since deku supports bits)
    const SIZE_HINT_BITS: Option<usize>; // `None` if dynamic read/write length detected
                                         // `Some(n)` for static-size type
}

#[doc(hidden)]
pub const fn eval_size<T: DekuSizeOf>(rhs: Option<usize>) -> Option<usize> {
    option_size_add(T::SIZE_HINT_BITS, rhs)
}

#[doc(hidden)]
pub const option_size_add(a: Option<usize>, b: Option<usize>) -> Option<usize> {
    match (a, b) {
        (Some(a), Some(b)) => Some(a + b),
        (None, _) | (_, None) => None,
    }
}

// SIZE_HINT_BITS = Some(24) = eval_size::<u8>(eval_size::<u8>(eval_size::<u8>(Some(0))));
struct Rgb {
    r: u8,
    g: u8,
    b: u8,
}

// SIZE_HINT_BITS = Some(24) = eval_size::<u16>(option_size_add(Some(4), Some(4)));
struct U4Test {
    #[deku(bits = 4)]
    field_a: u8,
    #[deku(bits = 4)]
    field_b: u8,
    field_c: u16,
}

// SIZE_HINT_BITS = Some(8) = eval_size::<u8>(Some(0));
struct Header(u8);

// SIZE_HINT_BITS = Some(16) = eval_size::<u16>(Some(0));
struct Data(u16);

// SIZE_HINT_BITS = Some(24) = eval_size::<Header>(eval_size::<Data>(Some(0)));
struct SubTypeTest {
    header: Header,
    data: Data,
}

// SIZE_HINT_BITS = None = eval_size::<Vec<u8>>(option_size_add(Some(4), eval_size::<u8>(Some(0))));
struct VecTest {
    #[deku(update = "self.data.len()")]
    count: u8,
    #[deku(count = 4)]
    data_static: Vec<u8>,
    #[deku(count = "count")] // "count" is dynamic, so put `Vec<u8>::SIZE_HINT_BITS = None`
    data: Vec<u8>,
}

Attributes:

• Field size, if it's SIZE_HINT_BITS is known.
• magic
• bits/bytes
• count
• bits_read/bytes_read
• skip
• pad_bits_before/pad_bytes_before
• pad_bits_after/pad_bytes_after

Not allowed: (for examples)

• seek_rewind
• until
• read_all
• reader/writer

If we could support enums, the SIZE_HINT_BITS can be defined as the maximum byte size and all enum attributes should be supported.