impl<'a, 'b: 'a> DebugMap<'a, 'b>

fn entry(self: &mut Self, key: &dyn Debug, value: &dyn Debug) -> &mut Self

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)]}"#,
);

fn key(self: &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 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)]}"#,
);

fn key_with<F>(self: &mut Self, key_fmt: F) -> &mut Self
where
    F: FnOnce(&mut Formatter<'_>) -> Result

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.

fn value(self: &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 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)]}"#,
);

fn value_with<F>(self: &mut Self, value_fmt: F) -> &mut Self
where
    F: FnOnce(&mut Formatter<'_>) -> Result

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.

fn entries<K, V, I>(self: &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 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}"#,
);

fn finish_non_exhaustive(self: &mut Self) -> Result

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

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, ..}"#,
);

fn finish(self: &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 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}"#,
);

impl<'a, 'b> Freeze for DebugMap<'a, 'b>

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>

impl<'a, 'b> UnsafeUnpin for DebugMap<'a, 'b>

impl<'a, 'b> UnwindSafe for DebugMap<'a, 'b>

impl<T> Any for DebugMap<'a, 'b>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for DebugMap<'a, 'b>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for DebugMap<'a, 'b>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> From for DebugMap<'a, 'b>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for DebugMap<'a, 'b>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for DebugMap<'a, 'b>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for DebugMap<'a, 'b>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>