Trait hex_conservative::display::DisplayHex
source · pub trait DisplayHex: Copy + IsRef {
type Display: Display + Debug + LowerHex + UpperHex;
// Required method
fn as_hex(self) -> Self::Display;
// 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(self, case: Case, string: &mut String) { ... }
fn hex_reserve_suggestion(self) -> usize { ... }
}Expand description
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.
This trait should be generally implemented for references only. We would prefer to use GAT but
that is beyond our MSRV. As a lint we require the IsRef trait which is implemented for all
references.
Required Associated Types§
Required Methods§
Provided Methods§
sourcefn to_lower_hex_string(self) -> String
fn to_lower_hex_string(self) -> String
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?
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
fn main() {
let s = "deadbeefcafebabedeadbeefcafebabedeadbeefcafebabedeadbeefcafebabe";
println!("Parse from hex: {}", s);
let hexy = ALittleBitHexy::from_hex(s).expect("the correct number of valid hex digits");
println!("Display ALittleBitHexy as string: {}", hexy);
println!("Display ALittleBitHexy as a hex: {:x}", hexy.as_hex());
#[cfg(feature = "alloc")]
{
let hex = hexy.to_lower_hex_string();
let from_hex = ALittleBitHexy::from_hex(&hex).expect("failed to parse hex");
assert_eq!(from_hex, hexy);
}
}More examples
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
fn main() {
let hex = "00000000cafebabedeadbeefcafebabedeadbeefcafebabedeadbeefcafebabe";
println!("\nParse from hex: {}\n", hex);
let array = <[u8; 32] as FromHex>::from_hex(hex).expect("failed to parse array");
let wrap = Wrap::from_hex(hex).expect("failed to parse wrapped array");
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.as_hex());
println!("UpperHex: {:X}", wrap.as_hex());
println!("Display: {}", wrap.as_hex());
println!("Debug: {:?}", wrap.as_hex());
println!("Debug pretty: {:#?}", wrap.as_hex());
#[cfg(feature = "alloc")]
{
// We cannot call `to_string` on the wrapped type to allocate a string, if you wish to
// use that trait method see `./wrap_array_fmt_traits.rs`.
let array_hex = array.to_lower_hex_string();
let wrap_hex = wrap.to_lower_hex_string();
assert_eq!(array_hex, wrap_hex);
}
}sourcefn to_upper_hex_string(self) -> String
fn to_upper_hex_string(self) -> String
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.
sourcefn to_hex_string(self, case: Case) -> String
fn to_hex_string(self, case: Case) -> String
Create a hex-encoded string.
This may be faster than .display_hex().to_string() because it uses reserve_suggestion.
sourcefn append_hex_to_string(self, case: Case, string: &mut String)
fn append_hex_to_string(self, case: Case, string: &mut String)
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.
sourcefn hex_reserve_suggestion(self) -> usize
fn hex_reserve_suggestion(self) -> usize
Hints how much bytes to reserve when creating a String.
Implementors that know the number of produced bytes upfront should override this. Defaults to 0.