Variable length integer?

[yanshay]

Is there a way to specify that the number of bytes (or bits) of an integer is an expression?
So for example, to specify that the length depends on a preceding bit somewhere in the structure? if it is 1 then the integer is u32 otherwise it is u8?

[wcampbell0x2a]

Something like this, where the bit read is used for an enum:

use deku::prelude::*;

#[derive(DekuRead, DekuWrite, Debug)]
pub struct A {
    #[deku(bits = 1)]
    bit: u8,
    #[deku(ctx = "*bit")]
    var: Var,
}

#[derive(DekuRead, DekuWrite, Debug)]
#[deku(id = "bit", ctx = "bit: u8")]
pub enum Var {
    #[deku(id = 0)]
    False(u8),
    #[deku(id = 1)]
    True(u32),
}

[yanshay]

The data is a vector of u8 that represents utf8 string, so easier to have it hold u8 for later processing.
But let's say I could, how would that help? I need the size of the vector to feed either the False or True option in the Var enum. I don't see how the type of the Vec elements help here?

[wcampbell0x2a]

Hm, I thought

The number contained by the enum defines the data in a Vec coming later in the struct.

meant the type of the Vec changed. I guess i'm not sure what you are using the data in Var for without an example with bytes.

[yanshay]

It will probably be clearer with different naming for the fields.
This is the structure I need to represent - its some standard data format, I must follow the spec:

They decided that length of payload data can be represented either as one byte or as four bytes, this would be marked in a single bit stating if it's short_record, and then the payload data comes later on. The payload can be multiple formats that later needs to be parsed depending on various other fields, I'm using it for now mostly as a utf8 string.

struct Record {
    #[deku(bits = 1)]
    #[deku(update = "self.payload_data.len()<=255")]
    short_record: bool,

// More fields

    #[deku(update = "self.payload_data.len()")]
    payload_length: u32, // if short record it is one byte, otherwise it is four

// More fields

    #[deku(count = "payload_length")]
    payload_data: Vec<u8>, // length as specified in payload_length
}

Eventually I solved it with reader/writer, but would prefer a more elegant and easier to maintain solution.

[wcampbell0x2a]

if I'm reading this right, you always need to be able to read the size contained in the payload_length. I would just make by own Trait that returns the size regardless of each enum member.

[yanshay]

Yes, I always need to read from bytes the payload_length, it's just that sometimes I receive it as one byte in the data and some other times as 4 bytes. And the same goes for writing, sometimes I need to write it as a single byte and sometimes as 4 bytes.

So what I wanted to achieve is:

1. When I read the data to fill the struct using deku, it will know what size the vector is to read all bytes later in the data, whether it arrived as a single byte or as 4 bytes, after it read the bit telling it whether 1 byte comes or 4 bytes. That's where the count attribute comes into play. But count from my unerstanding can't work with a field of type enum. So read the amount of bytes to read from the content of the enum whether it is Short or Large.
2. When I write the data, the field payload_length will be automatically filled based on the amount of data I had placed in the vector, not manually. That's where the update attribute comes into play. I couldn't get update to work with an enum, even though I think it should be possible to create the enum in update using some conditional code.

As for your suggestion I don't think I understand what you meant, does Deku work with Traits in some way that allows to achieve the above? I'm not concerned with my code later accessing the data, that's solvable. My issue is with expressing to deku how to serialize/deserialize the structure under the above requirements.

reader/writer solved it, but it seems like something too simple and too standard to require using these.