Trait frame_support::dispatch::fmt::LowerHex

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

x formatting.

The LowerHex trait should format its output as a number in hexadecimal, with a through f in lower case.

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

The alternate flag, #, adds a 0x 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 '2a' in hex

assert_eq!(format!("{x:x}"), "2a");
assert_eq!(format!("{x:#x}"), "0x2a");

assert_eq!(format!("{:x}", -16), "fffffff0");

Implementing LowerHex on a type:

use std::fmt;

struct Length(i32);

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

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

let l = Length(9);

assert_eq!(format!("l as hex is: {l:x}"), "l as hex is: 9");

assert_eq!(format!("l as hex is: {l:#010x}"), "l as hex is: 0x00000009");

Required Methods§

Formats the value using the given formatter.

Implementors§

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.

impl<T> LowerHex for BitFlags<T>where
    T: BitFlag,
    T::Numeric: LowerHex,

impl<Frac: LeEqU8> LowerHex for FixedU8<Frac>

impl<Frac: LeEqU16> LowerHex for FixedU16<Frac>

impl<Frac: LeEqU32> LowerHex for FixedU32<Frac>

impl<Frac: LeEqU64> LowerHex for FixedU64<Frac>

impl<Frac: LeEqU128> LowerHex for FixedU128<Frac>

impl<Frac: LeEqU8> LowerHex for FixedI8<Frac>

impl<Frac: LeEqU16> LowerHex for FixedI16<Frac>

impl<Frac: LeEqU32> LowerHex for FixedI32<Frac>

impl<Frac: LeEqU64> LowerHex for FixedI64<Frac>

impl<Frac: LeEqU128> LowerHex for FixedI128<Frac>

impl LowerHex for bf16

impl LowerHex for f16

impl<T: AsRef<[u8]>> LowerHex for HexFmt<T>

impl<T> LowerHex for HexList<T>where
    T: Clone + IntoIterator,
    T::Item: AsRef<[u8]>,

impl LowerHex for BigInt

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

impl LowerHex for AtFlags

impl LowerHex for OFlag

impl LowerHex for FdFlag

impl LowerHex for MsFlags

impl LowerHex for SaFlags

impl LowerHex for SFlag

impl LowerHex for Mode

impl LowerHex for FsFlags

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

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