Trait DisplayHex 

pub trait DisplayHex {
    type Display<'a>: Display + Debug + LowerHex + UpperHex
       where Self: 'a;

    // Required methods
    fn as_hex<'a>(&'a self) -> Self::Display<'a>;
    fn hex_reserve_suggestion(&self) -> usize;

    // Provided methods
    fn to_lower_hex_string(&self) -> String { ... }
    fn to_upper_hex_string(&self) -> String { ... }
    fn to_hex_string(&self, case: Case) -> String { ... }
    fn append_hex_to_string<'a>(&'a self, case: Case, string: &mut String) { ... }
}

Extension trait for types that can be displayed as hex.

Types that have a single, obvious text representation being hex should not implement this trait and simply implement Display instead.

Required Associated Types

type Display<'a>: Display + Debug + LowerHex + UpperHex where Self: 'a

The type providing fmt::Display implementation.

This is a wrapper type holding a reference to Self.

Required Methods

fn as_hex<'a>(&'a self) -> Self::Display<'a>

Display Self as a continuous sequence of ASCII hex chars.

fn hex_reserve_suggestion(&self) -> usize

Hints how many bytes to reserve when creating a String.

If you don’t know you can just return 0 and take the perf hit.

Provided Methods

fn to_lower_hex_string(&self) -> String

Available on crate feature alloc only.

Create a lower-hex-encoded string.

A shorthand for to_hex_string(Case::Lower), so that Case doesn’t need to be imported.

This may be faster than .display_hex().to_string() because it uses reserve_suggestion.

Examples found in repository

examples/wrap_array.rs (line 39)

fn main() {
    let hex = "deadbeefcafebabedeadbeefcafebabedeadbeefcafebabedeadbeefcafebabe";
    println!("\nParse from hex: {}\n", hex);

    let array = hex::decode_to_array::<32>(hex).expect("failed to parse array");
    let wrap = Wrap::from_str(hex).expect("failed to parse wrapped array from hex string");

    println!("Print an array using traits from the standard libraries `fmt` module along with the provided implementation of `DisplayHex`:\n");
    println!("LowerHex: {:x}", array.as_hex());
    println!("UpperHex: {:X}", array.as_hex());
    println!("Display: {}", array.as_hex());
    println!("Debug: {:?}", array.as_hex());
    println!("Debug pretty: {:#?}", array.as_hex());

    println!("\n");

    println!(
        "Print the wrapped array directly using traits from the standard libraries `fmt` module:\n"
    );
    println!("LowerHex: {:x}", wrap);
    println!("UpperHex: {:X}", wrap);
    println!("Display: {}", wrap);
    println!("Debug: {:?}", wrap);
    println!("Debug pretty: {:#?}", wrap);

    #[cfg(feature = "alloc")]
    {
        let array_hex = array.to_lower_hex_string();
        let other = array.as_hex().to_string();
        assert_eq!(array_hex, other);

        let wrap_hex = wrap.to_string();
        assert_eq!(array_hex, wrap_hex);
    }
}

fn to_upper_hex_string(&self) -> String

Available on crate feature alloc only.

Create an upper-hex-encoded string.

A shorthand for to_hex_string(Case::Upper), so that Case doesn’t need to be imported.

This may be faster than .display_hex().to_string() because it uses reserve_suggestion.

fn to_hex_string(&self, case: Case) -> String

Available on crate feature alloc only.

Create a hex-encoded string.

This may be faster than .display_hex().to_string() because it uses reserve_suggestion.

fn append_hex_to_string<'a>(&'a self, case: Case, string: &mut String)

Available on crate feature alloc only.

Appends hex-encoded content to an existing String.

This may be faster than write!(string, "{:x}", self.as_hex()) because it uses hex_reserve_sugggestion.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl DisplayHex for [u8]

type Display<'a> = DisplayByteSlice<'a>

fn as_hex<'a>(&'a self) -> Self::Display<'a>

fn hex_reserve_suggestion(&self) -> usize

Implementors