Struct std::fmt::DebugMap
pub struct DebugMap<'a, 'b> where 'b: 'a, { /* fields omitted */ }
A struct to help with fmt::Debug implementations.
This is useful when you wish to output a formatted map as a part of your Debug::fmt implementation.
This can be constructed by the Formatter::debug_map method.
Examples
use std::fmt;
struct Foo(Vec<(String, i32)>);
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt.debug_map().entries(self.0.iter().map(|&(ref k, ref v)| (k, v))).finish()
}
}
assert_eq!(
format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
"{\"A\": 10, \"B\": 11}",
);Implementations
impl<'a, 'b> DebugMap<'a, 'b> where
'b: 'a,
pub fn entry(
&mut self,
key: &dyn Debug,
value: &dyn Debug
) -> &mut DebugMap<'a, 'b>
Adds a new entry to the map output.
Examples
use std::fmt;
struct Foo(Vec<(String, i32)>);
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_map()
.entry(&"whole", &self.0) // We add the "whole" entry.
.finish()
}
}
assert_eq!(
format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
"{\"whole\": [(\"A\", 10), (\"B\", 11)]}",
);pub fn key(&mut self, key: &dyn Debug) -> &mut DebugMap<'a, 'b>
Adds the key part of a new entry to the map output.
This method, together with value, is an alternative to entry that can be used when the complete entry isn’t known upfront. Prefer the entry method when it’s possible to use.
Panics
key must be called before value and each call to key must be followed by a corresponding call to value. Otherwise this method will panic.
Examples
use std::fmt;
struct Foo(Vec<(String, i32)>);
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_map()
.key(&"whole").value(&self.0) // We add the "whole" entry.
.finish()
}
}
assert_eq!(
format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
"{\"whole\": [(\"A\", 10), (\"B\", 11)]}",
);pub fn value(&mut self, value: &dyn Debug) -> &mut DebugMap<'a, 'b>
Adds the value part of a new entry to the map output.
This method, together with key, is an alternative to entry that can be used when the complete entry isn’t known upfront. Prefer the entry method when it’s possible to use.
Panics
key must be called before value and each call to key must be followed by a corresponding call to value. Otherwise this method will panic.
Examples
use std::fmt;
struct Foo(Vec<(String, i32)>);
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_map()
.key(&"whole").value(&self.0) // We add the "whole" entry.
.finish()
}
}
assert_eq!(
format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
"{\"whole\": [(\"A\", 10), (\"B\", 11)]}",
);Adds the contents of an iterator of entries to the map output.
Examples
use std::fmt;
struct Foo(Vec<(String, i32)>);
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_map()
// We map our vec so each entries' first field will become
// the "key".
.entries(self.0.iter().map(|&(ref k, ref v)| (k, v)))
.finish()
}
}
assert_eq!(
format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
"{\"A\": 10, \"B\": 11}",
);pub fn finish(&mut self) -> Result<(), Error>
Finishes output and returns any error encountered.
Panics
key must be called before value and each call to key must be followed by a corresponding call to value. Otherwise this method will panic.
Examples
use std::fmt;
struct Foo(Vec<(String, i32)>);
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_map()
.entries(self.0.iter().map(|&(ref k, ref v)| (k, v)))
.finish() // Ends the struct formatting.
}
}
assert_eq!(
format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
"{\"A\": 10, \"B\": 11}",
);Auto Trait Implementations
impl<'a, 'b> !RefUnwindSafe for DebugMap<'a, 'b>
impl<'a, 'b> !Send for DebugMap<'a, 'b>
impl<'a, 'b> !Sync for DebugMap<'a, 'b>
impl<'a, 'b> Unpin for DebugMap<'a, 'b> where
'b: 'a,
impl<'a, 'b> !UnwindSafe for DebugMap<'a, 'b>
Blanket Implementations
impl<T> From<T> for T
pub fn from(t: T) -> T
Performs the conversion.
pub fn into(self) -> U
Performs the conversion.
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/fmt/struct.DebugMap.html