Struct Bits

pub struct Bits<const N: usize>(/* private fields */);

The Bits type is a fixed-sized bit vector. It is meant to imitate the behavior of bit vectors in hardware. Due to the design of the Bits type, you can only create a Bits type of up to 128 bits in length for now. However, you can easily express larger constructs in hardware using arrays, tuples and structs. The only real limitation of the Bits type being 128 bits is that you cannot perform arbitrary arithmetic on longer bit values in your hardware designs. I don’t think this is a significant issue, but the Bits design of the rust-hdl crate was much slower and harder to maintain and use. I think this is a good trade-off.

Note that the Bits type implements 2’s complement arithmetic. See https://en.wikipedia.org/wiki/Two%27s_complement for more information.

Note also that the Bits kind is treated as an unsigned value for the purposes of comparisons. If you need signed comparisons, you will need the SignedBits type.

Implementations

impl<const N: usize> Bits<N>

pub const MASK: Self

Defines a constant Bits value with all bits set to 1.

pub const fn mask() -> Self

Return a Bits value with all bits set to 1.

let bits = Bits::<8>::mask();
assert_eq!(bits, 0xFF);

pub fn set_bit(&mut self, bit: usize, value: bool)

Set a specific bit of a Bits value to 1 or 0. Panics if the index of the bit is outside the range of the Bits value.

let mut bits = Bits::<8>::mask();
bits.set_bit(0, false);
assert_eq!(bits, 0xFE);
bits.set_bit(0, true);
assert_eq!(bits, 0xFF);

pub fn get_bit(&self, bit: usize) -> bool

Get the value of a specific bit of a Bits value. Panics if the index of the bit is outside the range of the Bits value.

let bits : Bits<8> = 0b1101_1010.into();
assert!(!bits.get_bit(0));
assert!(bits.get_bit(7));
assert!(bits.get_bit(6));

pub fn any(self) -> bool

Returns true if any of the bits are set to 1.

let bits : Bits<8> = 0b1101_1010.into();
assert!(bits.any());
let bits : Bits<8> = 0.into();
assert!(!bits.any());

pub fn all(self) -> bool

Returns true if all of the bits are set to 1.

let bits : Bits<8> = 0b1101_1010.into();
assert!(!bits.all());
let bits : Bits<8> = Bits::mask();
assert!(bits.all());

pub fn xor(self) -> bool

Computes the xor of all of the bits in the value.

pub fn slice<const M: usize>(&self, start: usize) -> Bits<M>

Extracts a range of bits from the Bits value.

pub fn as_signed(self) -> SignedBits<N>

Reinterpret the Bits value as a SignedBits value.

Trait Implementations

impl<const N: usize> Add<Bits<N>> for u128

type Output = Bits<N>

The resulting type after applying the + operator.

fn add(self, rhs: Bits<N>) -> Self::Output

Performs the + operation.

impl<const N: usize> Add<u128> for Bits<N>

type Output = Bits<N>

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> Self::Output

Performs the + operation.

impl<const N: usize> Add for Bits<N>

type Output = Bits<N>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const N: usize> AddAssign<u128> for Bits<N>

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

impl<const N: usize> AddAssign for Bits<N>

fn add_assign(&mut self, rhs: Bits<N>)

Performs the += operation.

impl<const N: usize> Binary for Bits<N>

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

Formats the value using the given formatter.

impl<const N: usize> BitAnd<Bits<N>> for u128

type Output = Bits<N>

The resulting type after applying the & operator.

fn bitand(self, rhs: Bits<N>) -> Self::Output

Performs the & operation.

impl<const N: usize> BitAnd<u128> for Bits<N>

type Output = Bits<N>

The resulting type after applying the & operator.

fn bitand(self, rhs: u128) -> Self::Output

Performs the & operation.

impl<const N: usize> BitAnd for Bits<N>

type Output = Bits<N>

The resulting type after applying the & operator.

fn bitand(self, rhs: Bits<N>) -> Bits<N>

Performs the & operation.

impl<const N: usize> BitAndAssign<u128> for Bits<N>

fn bitand_assign(&mut self, rhs: u128)

Performs the &= operation.

impl<const N: usize> BitAndAssign for Bits<N>

fn bitand_assign(&mut self, rhs: Bits<N>)

Performs the &= operation.

impl<const N: usize> BitOr<Bits<N>> for u128

type Output = Bits<N>

The resulting type after applying the | operator.

fn bitor(self, rhs: Bits<N>) -> Self::Output

Performs the | operation.

impl<const N: usize> BitOr<u128> for Bits<N>

type Output = Bits<N>

The resulting type after applying the | operator.

fn bitor(self, rhs: u128) -> Self::Output

Performs the | operation.

impl<const N: usize> BitOr for Bits<N>

type Output = Bits<N>

The resulting type after applying the | operator.

fn bitor(self, rhs: Bits<N>) -> Bits<N>

Performs the | operation.

impl<const N: usize> BitOrAssign<u128> for Bits<N>

fn bitor_assign(&mut self, rhs: u128)

Performs the |= operation.

impl<const N: usize> BitOrAssign for Bits<N>

fn bitor_assign(&mut self, rhs: Bits<N>)

Performs the |= operation.

impl<const N: usize> BitXor<Bits<N>> for u128

type Output = Bits<N>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Bits<N>) -> Self::Output

Performs the ^ operation.

impl<const N: usize> BitXor<u128> for Bits<N>

type Output = Bits<N>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u128) -> Self::Output

Performs the ^ operation.

impl<const N: usize> BitXor for Bits<N>

type Output = Bits<N>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Bits<N>) -> Bits<N>

Performs the ^ operation.

impl<const N: usize> BitXorAssign<u128> for Bits<N>

fn bitxor_assign(&mut self, rhs: u128)

Performs the ^= operation.

impl<const N: usize> BitXorAssign for Bits<N>

fn bitxor_assign(&mut self, rhs: Bits<N>)

Performs the ^= operation.

impl<const N: usize> Clone for Bits<N>

fn clone(&self) -> Bits<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for Bits<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for Bits<N>

The default value for a Bits value is 0.

fn default() -> Self

Returns the “default value” for a type.

impl<const N: usize> Display for Bits<N>

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

Formats the value using the given formatter.

impl<const N: usize> From<u128> for Bits<N>

Provide conversion from a u128 to a Bits value. This will panic if you try to convert a value that is larger than the Bits value can hold.

fn from(value: u128) -> Self

Converts to this type from the input type.

impl<const N: usize> Hash for Bits<N>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const N: usize> LowerHex for Bits<N>

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

Formats the value using the given formatter.

impl<const N: usize> Not for Bits<N>

type Output = Bits<N>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const N: usize> Ord for Bits<N>

fn cmp(&self, other: &Bits<N>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<const N: usize> PartialEq<u128> for Bits<N>

fn eq(&self, other: &u128) -> 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<const N: usize> PartialEq for Bits<N>

fn eq(&self, other: &Bits<N>) -> 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<const N: usize> PartialOrd for Bits<N>

fn partial_cmp(&self, other: &Bits<N>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const M: usize, const N: usize> Shl<Bits<M>> for Bits<N>

type Output = Bits<N>

The resulting type after applying the << operator.

fn shl(self, rhs: Bits<M>) -> Self::Output

Performs the << operation.

impl<const M: usize, const N: usize> Shl<Bits<M>> for SignedBits<N>

type Output = SignedBits<N>

The resulting type after applying the << operator.

fn shl(self, rhs: Bits<M>) -> Self::Output

Performs the << operation.

impl<const N: usize> Shl<Bits<N>> for i128

type Output = SignedBits<N>

The resulting type after applying the << operator.

fn shl(self, rhs: Bits<N>) -> Self::Output

Performs the << operation.

impl<const N: usize> Shl<Bits<N>> for u128

type Output = Bits<N>

The resulting type after applying the << operator.

fn shl(self, rhs: Bits<N>) -> Self::Output

Performs the << operation.

impl<const N: usize> Shl<u128> for Bits<N>

type Output = Bits<N>

The resulting type after applying the << operator.

fn shl(self, rhs: u128) -> Self::Output

Performs the << operation.

impl<const M: usize, const N: usize> ShlAssign<Bits<M>> for Bits<N>

fn shl_assign(&mut self, rhs: Bits<M>)

Performs the <<= operation.

impl<const M: usize, const N: usize> ShlAssign<Bits<M>> for SignedBits<N>

fn shl_assign(&mut self, rhs: Bits<M>)

Performs the <<= operation.

impl<const N: usize> ShlAssign<u128> for Bits<N>

fn shl_assign(&mut self, rhs: u128)

Performs the <<= operation.

impl<const M: usize, const N: usize> Shr<Bits<M>> for Bits<N>

type Output = Bits<N>

The resulting type after applying the >> operator.

fn shr(self, rhs: Bits<M>) -> Self::Output

Performs the >> operation.

impl<const M: usize, const N: usize> Shr<Bits<M>> for SignedBits<N>

type Output = SignedBits<N>

The resulting type after applying the >> operator.

fn shr(self, rhs: Bits<M>) -> Self::Output

Performs the >> operation.

impl<const N: usize> Shr<Bits<N>> for u128

type Output = Bits<N>

The resulting type after applying the >> operator.

fn shr(self, rhs: Bits<N>) -> Self::Output

Performs the >> operation.

impl<const N: usize> Shr<u128> for Bits<N>

type Output = Bits<N>

The resulting type after applying the >> operator.

fn shr(self, rhs: u128) -> Self::Output

Performs the >> operation.

impl<const M: usize, const N: usize> ShrAssign<Bits<M>> for Bits<N>

fn shr_assign(&mut self, rhs: Bits<M>)

Performs the >>= operation.

impl<const M: usize, const N: usize> ShrAssign<Bits<M>> for SignedBits<N>

fn shr_assign(&mut self, rhs: Bits<M>)

Performs the >>= operation.

impl<const N: usize> ShrAssign<u128> for Bits<N>

fn shr_assign(&mut self, rhs: u128)

Performs the >>= operation.

impl<const N: usize> Sub<Bits<N>> for u128

type Output = Bits<N>

The resulting type after applying the - operator.

fn sub(self, rhs: Bits<N>) -> Self::Output

Performs the - operation.

impl<const N: usize> Sub<u128> for Bits<N>

type Output = Bits<N>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> Self::Output

Performs the - operation.

impl<const N: usize> Sub for Bits<N>

type Output = Bits<N>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const N: usize> SubAssign<u128> for Bits<N>

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl<const N: usize> SubAssign for Bits<N>

fn sub_assign(&mut self, rhs: Bits<N>)

Performs the -= operation.

impl<const N: usize> UpperHex for Bits<N>

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

Formats the value using the given formatter.

impl<const N: usize> Copy for Bits<N>

impl<const N: usize> Eq for Bits<N>

impl<const N: usize> StructuralPartialEq for Bits<N>