Trait tract_pulse::internal::fmt::Binary

pub trait Binary {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
}

b formatting.

The Binary trait should format its output as a number in binary.

For primitive signed integers (i8 to i128, and isize), negative values are formatted as the two’s complement representation.

The alternate flag, #, adds a 0b in front of the output.

For more information on formatters, see the module-level documentation.

Examples

Basic usage with i32:

let x = 42; // 42 is '101010' in binary

assert_eq!(format!("{:b}", x), "101010");
assert_eq!(format!("{:#b}", x), "0b101010");

assert_eq!(format!("{:b}", -16), "11111111111111111111111111110000");

Implementing Binary on a type:

use std::fmt;

struct Length(i32);

impl fmt::Binary for Length {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let val = self.0;

        fmt::Binary::fmt(&val, f) // delegate to i32's implementation
    }
}

let l = Length(107);

assert_eq!(format!("l as binary is: {:b}", l), "l as binary is: 1101011");

assert_eq!(
    format!("l as binary is: {:#032b}", l),
    "l as binary is: 0b000000000000000000000001101011"
);

Required methods

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

Formats the value using the given formatter.

Implementations on Foreign Types

impl Binary for isize

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

impl<'_, T> Binary for &'_ T where
    T: Binary + ?Sized, 

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

impl Binary for u8

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

impl<'_, T> Binary for &'_ mut T where
    T: Binary + ?Sized, 

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

impl Binary for i8

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

impl Binary for usize

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

impl Binary for u32

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

impl Binary for i32

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

impl Binary for u64

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

impl Binary for i64

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

impl Binary for u16

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

impl Binary for u128

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

impl Binary for i128

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

impl Binary for i16

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

impl<T> Binary for Complex<T> where
    T: Binary + Num + PartialOrd<T> + Clone, 

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

impl Binary for f16

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

impl Binary for bf16

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

impl<O, V> Binary for BitArray<O, V> where
    O: BitOrder,
    V: BitView, 

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

impl<O, T> Binary for BitSlice<O, T> where
    O: BitOrder,
    T: BitStore, 

Render the contents of a BitSlice in a numeric format.

These implementations render the bits of memory contained in a BitSlice as one of the three numeric bases that the Rust format system supports:

• Binary renders each bit individually as 0 or 1,
• Octal renders clusters of three bits as the numbers 0 through 7,
• and UpperHex and LowerHex render clusters of four bits as the numbers 0 through 9 and A through F.

The formatters produce a “word” for each element T of memory. The chunked formats (octal and hexadecimal) operate somewhat peculiarly: they show the semantic value of the memory, as interpreted by the ordering parameter’s implementation rather than the raw value of memory you might observe with a debugger. In order to ease the process of expanding numbers back into bits, each digit is grouped to the right edge of the memory element. So, for example, the byte 0xFF would be rendered in as 0o377 rather than 0o773.

Rendered words are chunked by memory elements, rather than by as clean as possible a number of digits, in order to aid visualization of the slice’s place in memory.

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

impl<'_, T> Binary for Domain<'_, T> where
    T: BitStore, 

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

impl<R> Binary for BitSel<R> where
    R: BitRegister, 

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

impl<R> Binary for BitMask<R> where
    R: BitRegister, 

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

impl<R> Binary for BitIdx<R> where
    R: BitRegister, 

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

impl<O, T> Binary for BitBox<O, T> where
    O: BitOrder,
    T: BitStore, 

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

impl<O, T> Binary for BitVec<O, T> where
    O: BitOrder,
    T: BitStore, 

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

impl<T> Binary for FmtLowerExp<T> where
    T: LowerExp + Binary, 

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

impl<T> Binary for FmtUpperHex<T> where
    T: UpperHex + Binary, 

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

impl<T> Binary for FmtLowerHex<T> where
    T: LowerHex + Binary, 

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

impl<T> Binary for FmtOctal<T> where
    T: Octal + Binary, 

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

impl<T> Binary for FmtUpperExp<T> where
    T: UpperExp + Binary, 

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

impl<T> Binary for FmtBinary<T> where
    T: Binary, 

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

impl<T> Binary for FmtDisplay<T> where
    T: Display + Binary, 

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

impl<T> Binary for FmtPointer<T> where
    T: Pointer + Binary, 

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

Implementors

impl Binary for NonZeroI8

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

impl Binary for NonZeroI16

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

impl Binary for NonZeroI32

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

impl Binary for NonZeroI64

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

impl Binary for NonZeroI128

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

impl Binary for NonZeroIsize

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

impl Binary for NonZeroU8

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

impl Binary for NonZeroU16

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

impl Binary for NonZeroU32

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

impl Binary for NonZeroU64

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

impl Binary for NonZeroU128

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

impl Binary for NonZeroUsize

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

impl<'a, A, S, D> Binary for ArrayBase<S, D> where
    S: Data<Elem = A>,
    D: Dimension,
    A: Binary, 

Format the array using Binary and apply the formatting parameters used to each element.

The array is shown in multiline style.

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

impl<'a, I> Binary for Format<'a, I> where
    I: Iterator,
    <I as Iterator>::Item: Binary, 

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

impl<T> Binary for Wrapping<T> where
    T: Binary, 

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