Trait scale_info::prelude::fmt::Binary

1.0.0 · source · []
pub trait Binary {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
}
Expand description

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

Formats the value using the given formatter.

Implementations on Foreign Types

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.

Implementors

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

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

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

impl<R> Binary for BitTail<R> where
    R: BitRegister

impl<R> Binary for BitPos<R> where
    R: BitRegister

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

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

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

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

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

impl<T, R: Dim, C: Dim, S> Binary for Matrix<T, R, C, S> where
    T: Scalar + Binary,
    S: Storage<T, R, C>,
    DefaultAllocator: Allocator<usize, R, C>, 

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

impl<T: Binary + Clone + Integer> Binary for Ratio<T>

impl<A: Array> Binary for ArrayVec<A> where
    A::Item: Binary

impl<'s, T> Binary for SliceVec<'s, T> where
    T: Binary

impl<A: Array> Binary for TinyVec<A> where
    A::Item: Binary

impl Binary for FilterId

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

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

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

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

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

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

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

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