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 AccessRights
impl Binary for BigInt
impl Binary for BigUint
impl<M> Binary for BitIdx<M>where
M: BitMemory,
impl<O, T> Binary for BitSlice<O, T>
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 as0
or1
,Octal
renders clusters of three bits as the numbers0
through7
,- and
UpperHex
andLowerHex
render clusters of four bits as the numbers0
through9
andA
throughF
.
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.