Struct Field 

pub struct Field<T, const LO: u32, const HI: u32>(/* private fields */);

One value packed into bits LO..=HI of a panel, inclusive, MSB-first from byte 0.

Never instantiated — it names a position plus a conversion, used as MyField::get(&raw) / MyField::set(&mut raw, v).

use nord_format::bits::Field;
let _ = Field::<u8, 0, 15>::read(&[0; 2]);

A one-bit type cannot decode a wider field:

use nord_format::bits::Field;
let _ = Field::<bool, 0, 1>::read(&[0]);

A Packed implementation cannot advertise more value bits than it can decode:

use nord_format::bits::{Field, Packed};
use std::convert::Infallible;
struct Invalid;
impl Packed for Invalid {
    const MAX_BITS: u32 = 2;
    const DECODE_BITS: u32 = 1;
    type Error = Infallible;
    fn from_bits(_: u64) -> Result<Self, Infallible> { Ok(Self) }
    fn to_bits(&self) -> u64 { 0 }
}
let _ = Field::<Invalid, 0, 1>::get::<1>(&[0]);

Implementations

impl<T: Packed, const LO: u32, const HI: u32> Field<T, LO, HI>

pub const WIDTH: u32

Width of the field in bits.

pub fn get<const N: usize>(raw: &[u8; N]) -> Result<T, T::Error>

Decode the field out of raw.

pub fn set<const N: usize>(raw: &mut [u8; N], value: T)

Write value, leaving every other bit of raw as it was.

Only compiles when no value of T can overrun the field: a u8 in a 7-bit slot is a compile error.

impl<T: Packed<Error = Infallible>, const LO: u32, const HI: u32> Field<T, LO, HI>

pub fn read<const N: usize>(raw: &[u8; N]) -> T

Decode, when every bit pattern is a valid value.