pub trait Binary {
// Required method
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!("{x:b}"), "101010");
assert_eq!(format!("{x:#b}"), "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: {l:b}"), "l as binary is: 1101011");
assert_eq!(
// Note that the `0b` prefix added by `#` is included in the total width, so we
// need to add two to correctly display all 32 bits.
format!("l as binary is: {l:#034b}"),
"l as binary is: 0b00000000000000000000000001101011"
);Required Methods§
Implementors§
impl Binary for i8
impl Binary for i16
impl Binary for i32
impl Binary for i64
impl Binary for i128
impl Binary for isize
impl Binary for u8
impl Binary for u16
impl Binary for u32
impl Binary for u64
impl Binary for u128
impl Binary for usize
impl Binary for NonZeroI8
impl Binary for NonZeroI16
impl Binary for NonZeroI32
impl Binary for NonZeroI64
impl Binary for NonZeroI128
impl Binary for NonZeroIsize
impl Binary for NonZeroU8
impl Binary for NonZeroU16
impl Binary for NonZeroU32
impl Binary for NonZeroU64
impl Binary for NonZeroU128
impl Binary for NonZeroUsize
impl<'a, T, O> Binary for Domain<'a, Const, T, O>where
O: BitOrder,
T: BitStore,
impl<A, O> Binary for BitArray<A, O>where
O: BitOrder,
A: BitViewSized,
impl<R> Binary for BitEnd<R>where
R: BitRegister,
impl<R> Binary for BitIdx<R>where
R: BitRegister,
impl<R> Binary for BitMask<R>where
R: BitRegister,
impl<R> Binary for BitPos<R>where
R: BitRegister,
impl<R> Binary for BitSel<R>where
R: BitRegister,
impl<T> Binary for &T
impl<T> Binary for &mut T
impl<T> Binary for Saturating<T>where
T: Binary,
impl<T> Binary for Wrapping<T>where
T: Binary,
impl<T> Binary for FmtBinary<T>where
T: Binary,
impl<T> Binary for FmtDisplay<T>
impl<T> Binary for FmtList<T>
impl<T> Binary for FmtLowerExp<T>
impl<T> Binary for FmtLowerHex<T>
impl<T> Binary for FmtOctal<T>
impl<T> Binary for FmtPointer<T>
impl<T> Binary for FmtUpperExp<T>
impl<T> Binary for FmtUpperHex<T>
impl<T, O> Binary for BitBox<T, O>where
O: BitOrder,
T: BitStore,
impl<T, O> Binary for BitSlice<T, O>where
T: BitStore,
O: BitOrder,
§Bit-Slice Rendering
This implementation prints the contents of a &BitSlice in one of binary,
octal, or hexadecimal. It is important to note that this does not render the
raw underlying memory! They render the semantically-ordered contents of the
bit-slice as numerals. This distinction matters if you use type parameters that
differ from those presumed by your debugger (which is usually <u8, Msb0>).
The output separates the T elements as individual list items, and renders each
element as a base- 2, 8, or 16 numeric string. When walking an element, the bits
traversed by the bit-slice are considered to be stored in
most-significant-bit-first ordering. This means that index [0] is the high bit
of the left-most digit, and index [n] is the low bit of the right-most digit,
in a given printed word.
In order to render according to expectations of the Arabic numeral system, an
element being transcribed is chunked into digits from the least-significant end
of its rendered form. This is most noticeable in octal, which will always have a
smaller ceiling on the left-most digit in a printed word, while the right-most
digit in that word is able to use the full 0 ..= 7 numeral range.
§Examples
use bitvec::prelude::*;
let data = [
0b000000_10u8,
// digits print LTR
0b10_001_101,
// significance is computed RTL
0b01_000000,
];
let bits = &data.view_bits::<Msb0>()[6 .. 18];
assert_eq!(format!("{:b}", bits), "[10, 10001101, 01]");
assert_eq!(format!("{:o}", bits), "[2, 215, 1]");
assert_eq!(format!("{:X}", bits), "[2, 8D, 1]");The {:#} format modifier causes the standard 0b, 0o, or 0x prefix to be
applied to each printed word. The other format specifiers are not interpreted by
this implementation, and apply to the entire rendered text, not to individual
words.