Struct DebugMap 

pub struct DebugMap<'a, 'b: 'a> { /* private fields */ }

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

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

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

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

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

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

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