Allow bitfields for tuple structs with one value

[robamu]

This might be a nice feature, because I have a lot of cases where I just want to constrain the bit range of an inner value, but the name/meaning does not change, so I do not really require a named field.

Example:

#[bitbybit::bitfield(u32)]
pub struct TransferSize(#[bits(0..=7, rw)] u8);

[danlehmann]

Wouldn't it be easier to skip bitbybit for tuples and directly use the underlying arbitrary-ints?

For example this would be a struct that overall needs 1 byte but allows 7 bits of data: pub struct TransferSize(u7).

u7 is an alias to UInt<u8, 7>. So if you want a larger overall struct (like in your example), you can also specify a larger base data type, like pub struct TransferSize(UInt<u32, 7>), which would still allow 7 bits of data but is 32 bits overall.

[robamu]

I have not used arbitrary_int like this yet, thanks a lot for the suggestions. This is definitely the easier solution. I will try to apply that to my bitbybit structures which only have one field.

[danlehmann]

Great, please let me know if it works for you. And please close the bug if you feel this is sufficient :)

[robamu]

Hmm, with the arbitrary_int solution, you don´t have access control though. I guess it is always rw then.

[robamu]

I think the feature might still be useful:

1. Allows access control
2. Consistent API: When all of the API uses mostly bitbybit bitfields, having a consistent API is nice.

[robamu]

#[derive(Debug)]
pub struct FifoWrite(arbitrary_int::UInt<u32, 8>);

impl FifoWrite {
    pub fn new_with_raw_value(data: u8) -> Self {
        Self(data.into())
    }

    pub fn value(&self) -> u8 {
        self.0.as_u8()
    }

    pub fn write(&mut self, value:u8) {
        self.0 = value.into();
    }
}

I actually like this, had to write some boilerplate code though. Would generating an API like this with bitbybit still be a viable feature? This would allow to only generate write for rw and w , and value only for rw and r