Struct brainfoamkit_lib::Byte

source ·

pub struct Byte { /* private fields */ }

Expand description

A Byte is an 8-bit unsigned integer (u8).

This is a wrapper around eight Bit instances. The least significant bit is bit_0 and the most significant bit is bit_7. This struct is used to conveniently manipulate 8-bit values.

Note that the Bit instances are stored in reverse (LSB to MSB) order, but the constructor takes them in the correct order (MSB to LSB) to provide a predictable and intuitive interface.

Examples

Create a byte from primitive Bit values

An easy way create a byte is to use the Byte::new() method. This method takes eight Bit instances as arguments. The least significant bit is bit_0 and the most significant bit is bit_7. The order of the arguments is the same as the order of the bits in the byte.

use brainfoamkit_lib::{
    Bit,
    Byte,
};

let byte = Byte::new(
    Bit::one(),
    Bit::zero(),
    Bit::one(),
    Bit::zero(),
    Bit::one(),
    Bit::zero(),
    Bit::one(),
    Bit::zero(),
);
assert_eq!(u8::from(&byte), 0b10101010); // Dec: 170; Hex: 0xAA; Oct: 0o252
assert_eq!(byte.to_string(), "0xAA");

Create a byte from a primitive u8 value

use brainfoamkit_lib::Byte;

let byte = Byte::from(0b10101010); // Dec: 170; Hex: 0xAA; Oct: 0o252
assert_eq!(u8::from(&byte), 0b10101010); // Dec: 170; Hex: 0xAA; Oct: 0o252
assert_eq!(byte.to_string(), "0xAA");

Create a byte from two Nybbles

use brainfoamkit_lib::{
    Byte,
    Nybble,
};

let high_nybble = Nybble::from(0b1011); // Dec: 11; Hex: 0x0B; Oct: 0o13
let low_nybble = Nybble::from(0b0101); // Dec: 5; Hex: 0x05; Oct: 0o5
let byte = Byte::from_nybbles(high_nybble, low_nybble);
assert_eq!(u8::from(&byte), 0b10110101); // Dec: 181; Hex: 0xB5; Oct: 0o265
assert_eq!(byte.to_string(), "0xB5");

Set and Unset bits to generate desired byte

use brainfoamkit_lib::Byte;
use brainfoamkit_lib::Bit;

let mut byte = Byte::default(); // Byte: 0b00000000; Dec: 0; Hex: 0x00; Oct: 0o0
byte.set_bit(0); // Byte: 0b00000001; Dec: 1; Hex: 0x01; Oct: 0o1
byte.set_bit(1); // Byte: 0b00000011; Dec: 3; Hex: 0x03; Oct: 0o3
byte.set_bit(2); // Byte: 0b00000111; Dec: 7; Hex: 0x07; Oct: 0o7
assert_eq!(u8::from(&byte), 0b00000111); // Dec: 7; Hex: 0x07; Oct: 0o7
assert_eq!(byte.to_string(), "0x07");
byte.unset_bit(1); // Byte: 0b00000101; Dec: 5; Hex: 0x05; Oct: 0o5
assert_eq!(u8::from(&byte), 0b00000101); // Dec: 5; Hex: 0x05; Oct: 0o5
assert_eq!(byte.to_string(), "0x05");

Get the Bit value at a given index

use brainfoamkit_lib::{
    Bit,
    Byte,
};

let byte = Byte::from(0b10101010); // Dec: 170; Hex: 0xAA; Oct: 0o252
assert_eq!(byte.get_bit(0), Bit::Zero); // Least significant bit
assert_eq!(byte.get_bit(1), Bit::One);
assert_eq!(byte.get_bit(2), Bit::Zero);
assert_eq!(byte.get_bit(3), Bit::One);
assert_eq!(byte.get_bit(4), Bit::Zero);
assert_eq!(byte.get_bit(5), Bit::One);
assert_eq!(byte.get_bit(6), Bit::Zero);
assert_eq!(byte.get_bit(7), Bit::One); // Most significant bit

Flip the Bit value at a given index

use brainfoamkit_lib::Byte;
use brainfoamkit_lib::Bit;

let mut byte = Byte::default(); // Byte: 0b00000000; Dec: 0; Hex: 0x00; Oct: 0o0
byte.set_bit(0); // Byte: 0b00000001; Dec: 1; Hex: 0x01; Oct: 0o1
byte.set_bit(2); // Byte: 0b00000101; Dec: 5; Hex: 0x05; Oct: 0o5
byte.set_bit(4); // Byte: 0b00010101; Dec: 21; Hex: 0x15; Oct: 0o25
assert_eq!(u8::from(&byte), 0b00010101); // Dec: 21; Hex: 0x15; Oct: 0o25
assert_eq!(byte.to_string(), "0x15");
byte.flip_bit(2); // Byte: 0b00010001; Dec: 17; Hex: 0x11; Oct: 0o21
assert_eq!(u8::from(&byte), 0b00010001); // Dec: 17; Hex: 0x11; Oct: 0o21
assert_eq!(byte.to_string(), "0x11");
byte.flip_bit(7); // Byte: 0b10010001; Dec: 145; Hex: 0x91; Oct: 0o221
assert_eq!(u8::from(&byte), 0b10010001); // Dec: 145; Hex: 0x91; Oct: 0o221
assert_eq!(byte.to_string(), "0x91");

Panics

The methods set_bit(), unset_bit() and get_bit() will panic if the index is out of bounds.

Struct brainfoamkit_lib::Byte

Implementations§

impl Byte

pub const fn new( zeroth: Bit, first: Bit, second: Bit, third: Bit, fourth: Bit, fifth: Bit, sixth: Bit, seventh: Bit ) -> Self

pub fn from_nybbles(high_nybble: Nybble, low_nybble: Nybble) -> Self

pub fn get_high_nybble(&self) -> Nybble

pub fn get_low_nybble(&self) -> Nybble

pub fn set_bit(&mut self, index: usize)

pub fn unset_bit(&mut self, index: usize)

pub fn get_bit(&self, index: u8) -> Bit

pub fn flip_bit(&mut self, index: u8)

pub fn flip(&mut self)

pub fn increment(&mut self)

pub fn decrement(&mut self)

pub const fn iter(&self) -> IterableByte<'_> ⓘ

Trait Implementations§

impl BitAnd for Byte

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

type Output = Byte

impl BitAndAssign for Byte

fn bitand_assign(&mut self, rhs: Self)

impl BitOr for Byte

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

type Output = Byte

impl BitOrAssign for Byte

fn bitor_assign(&mut self, rhs: Self)

impl BitXor for Byte

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

type Output = Byte

impl BitXorAssign for Byte

fn bitxor_assign(&mut self, rhs: Self)

impl Clone for Byte

fn clone(&self) -> Byte

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

impl Debug for Byte

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

impl Default for Byte

fn default() -> Self

impl Display for Byte

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

impl From<&Byte> for u8

fn from(byte: &Byte) -> Self

impl From<u8> for Byte

fn from(n: u8) -> Self

impl Hash for Byte

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

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

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

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