pub struct DebugMap<'a, 'b: 'a> { /* private fields */ }
Expand description
A struct to help with 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 debug2::{pprint, Debug, Formatter};
use std::fmt;
struct Foo(Vec<(String, i32)>);
impl Debug for Foo {
fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
fmt.debug_map()
.entries(self.0.iter().map(|&(ref k, ref v)| (k, v)))
.finish()
}
}
assert_eq!(
pprint(Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
"{\"A\": 10, \"B\": 11}",
);
Implementations
sourceimpl<'a, 'b: 'a> DebugMap<'a, 'b>
impl<'a, 'b: 'a> DebugMap<'a, 'b>
sourcepub fn entry(&mut self, key: &dyn Debug, value: &dyn Debug) -> &mut Self
pub fn entry(&mut self, key: &dyn Debug, value: &dyn Debug) -> &mut Self
Adds a new entry to the map output.
Examples
use debug2::{pprint, Debug, Formatter};
use std::fmt;
struct Foo(Vec<(String, i32)>);
impl Debug for Foo {
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
fmt.debug_map()
.entry(&"whole", &self.0) // We add the "whole" entry.
.finish()
}
}
assert_eq!(
pprint(Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
"{\"whole\": [(\"A\", 10), (\"B\", 11)]}",
);
sourcepub fn key(&mut self, key: &dyn Debug) -> &mut Self
pub fn key(&mut self, key: &dyn Debug) -> &mut Self
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 debug2::{pprint, Debug, Formatter};
use std::fmt;
struct Foo(Vec<(String, i32)>);
impl Debug for Foo {
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
fmt.debug_map()
.key(&"whole")
.value(&self.0) // We add the "whole" entry.
.finish()
}
}
assert_eq!(
pprint(Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
"{\"whole\": [(\"A\", 10), (\"B\", 11)]}",
);
sourcepub fn value(&mut self, value: &dyn Debug) -> &mut Self
pub fn value(&mut self, value: &dyn Debug) -> &mut Self
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 debug2::{pprint, Debug, Formatter};
use std::fmt;
struct Foo(Vec<(String, i32)>);
impl Debug for Foo {
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
fmt.debug_map()
.key(&"whole")
.value(&self.0) // We add the "whole" entry.
.finish()
}
}
assert_eq!(
pprint(Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
"{\"whole\": [(\"A\", 10), (\"B\", 11)]}",
);
sourcepub fn entries<K, V, I>(&mut self, entries: I) -> &mut Self where
K: Debug,
V: Debug,
I: IntoIterator<Item = (K, V)>,
pub fn entries<K, V, I>(&mut self, entries: I) -> &mut Self where
K: Debug,
V: Debug,
I: IntoIterator<Item = (K, V)>,
Adds the contents of an iterator of entries to the map output.
Examples
use debug2::{pprint, Debug, Formatter};
use std::fmt;
struct Foo(Vec<(String, i32)>);
impl Debug for Foo {
fn fmt(&self, fmt: &mut 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!(
pprint(Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
"{\"A\": 10, \"B\": 11}",
);
sourcepub fn finish(&mut self) -> Result
pub fn finish(&mut self) -> Result
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 debug2::{pprint, Debug, Formatter};
use std::fmt;
struct Foo(Vec<(String, i32)>);
impl Debug for Foo {
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
fmt.debug_map()
.entries(self.0.iter().map(|&(ref k, ref v)| (k, v)))
.finish() // Ends the struct formatting.
}
}
assert_eq!(
pprint(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
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcepub fn borrow_mut(&mut self) -> &mut T
pub fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more