Struct Field 

pub struct Field { /* private fields */ }

Defines a region of bits.

Each field has a unit, size, and a flag indicating if the field represents a signed integer. The unit is the minimum number of bits extracted by the field. The size is the total number of units extracted by the field.

The flag comes into play when a field extracts more bits than are available. If at least one bit is still available and the flag is true, the bit string is sign extended to the length of the field.

Constants

Common field types.

Constant	Unit	Size	Signed
BIT	1	1
BYTES	8	UNBOUND
SIGNED	1	UNBOUND	X
SIGNED_2	1	2	X
SIGNED_4	1	4	X
SIGNED_8	1	8	X
SIGNED_16	1	16	X
SIGNED_32	1	32	X
SIGNED_64	1	64	X
UNSIGNED	1	UNBOUND
UNSIGNED_2	1	2
UNSIGNED_4	1	4
UNSIGNED_8	1	8
UNSIGNED_16	1	16
UNSIGNED_32	1	32
UNSIGNED_64	1	64

Implementations

impl Field

pub const BIT: Field

pub const BYTES: Field

pub const SIGNED: Field

pub const SIGNED_2: Field

pub const SIGNED_4: Field

pub const SIGNED_8: Field

pub const SIGNED_16: Field

pub const SIGNED_32: Field

pub const SIGNED_64: Field

pub const UNSIGNED: Field

pub const UNSIGNED_2: Field

pub const UNSIGNED_4: Field

pub const UNSIGNED_8: Field

pub const UNSIGNED_16: Field

pub const UNSIGNED_32: Field

pub const UNSIGNED_64: Field

pub fn aligned(unit: usize, size: isize, signed: bool) -> Self

Bit field aligned to a given unit

When m and n are negative Bits::aligned(m, signed) == Bits::aligned(n, signed), even if m != n.

Example

let field = Field::aligned(7, 48, false);

assert_eq!(field.unit(), 7);
assert_eq!(field.size(), 48);
assert_eq!(field.len(), 48 * 7);

let mfield = Field::aligned(7, -1, true);
let nfield = Field::aligned(7, isize::MIN, true);

assert_eq!(mfield, nfield);
assert_eq!(mfield.size(), -1);
assert_eq!(nfield.size(), -1);
assert!(mfield.is_signed());

pub fn bytes(size: isize, signed: bool) -> Self

Byte-aligned bit field

When m and n are negative Bits::bytes(m, signed) == Bits::bytes(n, signed), even if m != n.

Example

let field = Field::bytes(48, false);

assert_eq!(field.unit(), 8);
assert_eq!(field.size(), 48);
assert_eq!(field.len(), 48 * 8);

let mfield = Field::bytes(-1, true);
let nfield = Field::bytes(isize::MIN, true);

assert_eq!(mfield, nfield);
assert_eq!(mfield.size(), -1);
assert_eq!(nfield.size(), -1);
assert!(mfield.is_signed());

pub fn signed(size: isize) -> Self

Bit field

When m and n are negative Bits::bits(m, signed) == Bits::bits(n, signed), even if m != n.

Example

let field = Field::signed(96);

assert_eq!(field.unit(), 1);
assert_eq!(field.size(), 96);
assert_eq!(field.len(), 96);
assert!(field.is_signed());

let mfield = Field::signed(-1);
let nfield = Field::signed(isize::MIN);

assert_eq!(mfield, nfield);
assert_eq!(mfield.size(), -1);
assert_eq!(nfield.size(), -1);
assert!(mfield.is_signed());

pub fn unsigned(size: isize) -> Self

Bit field

When m and n are negative Bits::bits(m, signed) == Bits::bits(n, signed), even if m != n.

Example

let field = Field::unsigned(96);

assert_eq!(field.unit(), 1);
assert_eq!(field.size(), 96);
assert_eq!(field.len(), 96);
assert!(!field.is_signed());

let mfield = Field::unsigned(-1);
let nfield = Field::unsigned(isize::MIN);

assert_eq!(mfield, nfield);
assert_eq!(mfield.size(), -1);
assert_eq!(nfield.size(), -1);
assert!(!mfield.is_signed());

pub fn is_signed(&self) -> bool

Whether this field represents a signed integer.

Example

assert!(Field::aligned(7, 48, true).is_signed());
assert!(!Field::aligned(7, 48, false).is_signed());
assert!(Field::bytes(-1, true).is_signed());
assert!(!Field::bytes(-1, false).is_signed());
assert!(Field::signed(96).is_signed());
assert!(!Field::unsigned(96).is_signed());

pub fn len(&self) -> isize

Number of bits extracted by the field

-1 means that the field extracts the maximum number of bits that can be divided by the unit of the field. Extraction never exceeds the remaining the number of bits.

Example

assert_eq!(Field::aligned(0, -1, true).len(), 0);
assert_eq!(Field::aligned(7, 0, false).len(), 0);
assert_eq!(Field::aligned(7, 48, true).len(), 48 * 7);
assert_eq!(Field::aligned(7, -1, false).len(), -1);
assert_eq!(Field::aligned(7, isize::MIN, true).len(), -1);
assert_eq!(Field::bytes(48, true).len(), 48 * 8);
assert_eq!(Field::bytes(-1, false).len(), -1);
assert_eq!(Field::bytes(isize::MIN, true).len(), -1);
assert_eq!(Field::signed(48).len(), 48);
assert_eq!(Field::signed(-1).len(), -1);
assert_eq!(Field::signed(isize::MIN).len(), -1);
assert_eq!(Field::unsigned(48).len(), 48);
assert_eq!(Field::unsigned(-1).len(), -1);
assert_eq!(Field::unsigned(isize::MIN).len(), -1);

pub fn size(&self) -> isize

Number of units in the field

Example

assert_eq!(Field::aligned(7, 48, true).size(), 48);
assert_eq!(Field::aligned(7, -1, false).size(), -1);
assert_eq!(Field::aligned(7, isize::MIN, true).size(), -1);
assert_eq!(Field::bytes(48, true).size(), 48);
assert_eq!(Field::bytes(-1, false).size(), -1);
assert_eq!(Field::bytes(isize::MIN, true).size(), -1);
assert_eq!(Field::signed(48).size(), 48);
assert_eq!(Field::signed(-1).size(), -1);
assert_eq!(Field::signed(isize::MIN).size(), -1);
assert_eq!(Field::unsigned(48).size(), 48);
assert_eq!(Field::unsigned(-1).size(), -1);
assert_eq!(Field::unsigned(isize::MIN).size(), -1);

pub fn unit(&self) -> usize

Minimum number of bits extracted by the field.

Example

assert_eq!(Field::aligned(7, 48, true).unit(), 7);
assert_eq!(Field::aligned(7, -1, false).unit(), 7);
assert_eq!(Field::aligned(7, isize::MIN, true).unit(), 7);
assert_eq!(Field::bytes(48, true).unit(), 8);
assert_eq!(Field::bytes(-1, false).unit(), 8);
assert_eq!(Field::bytes(isize::MIN, true).unit(), 8);
assert_eq!(Field::signed(48).unit(), 1);
assert_eq!(Field::signed(-1).unit(), 1);
assert_eq!(Field::signed(isize::MIN).unit(), 1);
assert_eq!(Field::unsigned(48).unit(), 1);
assert_eq!(Field::unsigned(-1).unit(), 1);
assert_eq!(Field::unsigned(isize::MIN).unit(), 1);

Trait Implementations

impl Clone for Field

fn clone(&self) -> Field

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Field

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Field

fn eq(&self, other: &Field) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Field

impl Eq for Field