pub struct DebugMap<'a, 'b>where
'b: 'a,{
fmt: &'a mut Formatter<'b>,
result: Result<(), Error>,
has_fields: bool,
has_key: bool,
state: PadAdapterState,
}
Expand description
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)])),
r#"{"A": 10, "B": 11}"#,
);
Fields§
§fmt: &'a mut Formatter<'b>
§result: Result<(), Error>
§has_fields: bool
§has_key: bool
§state: PadAdapterState
Implementations§
source§impl<'a, 'b> DebugMap<'a, 'b>where
'b: 'a,
impl<'a, 'b> DebugMap<'a, 'b>where
'b: 'a,
1.2.0 · sourcepub fn entry(
&mut self,
key: &dyn Debug,
value: &dyn Debug,
) -> &mut DebugMap<'a, 'b>
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)])),
r#"{"whole": [("A", 10), ("B", 11)]}"#,
);
1.42.0 · sourcepub fn key(&mut self, key: &dyn Debug) -> &mut DebugMap<'a, 'b>
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)])),
r#"{"whole": [("A", 10), ("B", 11)]}"#,
);
sourcepub fn key_with<F>(&mut self, key_fmt: F) -> &mut DebugMap<'a, 'b>
🔬This is a nightly-only experimental API. (debug_closure_helpers
)
pub fn key_with<F>(&mut self, key_fmt: F) -> &mut DebugMap<'a, 'b>
debug_closure_helpers
)Adds the key part of a new entry to the map output.
This method is equivalent to DebugMap::key
, but formats the
key using a provided closure rather than by calling Debug::fmt
.
1.42.0 · sourcepub fn value(&mut self, value: &dyn Debug) -> &mut DebugMap<'a, 'b>
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)])),
r#"{"whole": [("A", 10), ("B", 11)]}"#,
);
sourcepub fn value_with<F>(&mut self, value_fmt: F) -> &mut DebugMap<'a, 'b>
🔬This is a nightly-only experimental API. (debug_closure_helpers
)
pub fn value_with<F>(&mut self, value_fmt: F) -> &mut DebugMap<'a, 'b>
debug_closure_helpers
)Adds the value part of a new entry to the map output.
This method is equivalent to DebugMap::value
, but formats the
value using a provided closure rather than by calling Debug::fmt
.
1.2.0 · sourcepub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b>
pub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b>
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)])),
r#"{"A": 10, "B": 11}"#,
);
sourcepub fn finish_non_exhaustive(&mut self) -> Result<(), Error>
🔬This is a nightly-only experimental API. (debug_more_non_exhaustive
)
pub fn finish_non_exhaustive(&mut self) -> Result<(), Error>
debug_more_non_exhaustive
)Marks the map as non-exhaustive, indicating to the reader that there are some other entries that are not shown in the debug representation.
§Examples
#![feature(debug_more_non_exhaustive)]
use std::fmt;
struct Foo(Vec<(String, i32)>);
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
// Print at most two elements, abbreviate the rest
let mut f = fmt.debug_map();
let mut f = f.entries(self.0.iter().take(2).map(|&(ref k, ref v)| (k, v)));
if self.0.len() > 2 {
f.finish_non_exhaustive()
} else {
f.finish()
}
}
}
assert_eq!(
format!("{:?}", Foo(vec![
("A".to_string(), 10),
("B".to_string(), 11),
("C".to_string(), 12),
])),
r#"{"A": 10, "B": 11, ..}"#,
);
1.2.0 · sourcepub fn finish(&mut self) -> Result<(), Error>
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 map formatting.
}
}
assert_eq!(
format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
r#"{"A": 10, "B": 11}"#,
);