pub struct DebugMap<'a, 'b> where
    'b: 'a, 
{ /* private fields */ }
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)])),
    "{\"A\": 10, \"B\": 11}",
);

Implementations

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

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

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

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

Trait Implementations

Visit a value implementing fmt::Debug.

Visit a double-precision floating point value.

Visit a signed 64-bit integer value.

Visit an unsigned 64-bit integer value.

Visit a signed 128-bit integer value.

Visit an unsigned 128-bit integer value.

Visit a boolean value.

Visit a string value.

Records a type implementing Error. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait. Read more

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait. Read more

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s. Read more

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s. Read more

Use this to cast from one trait object type to another. Read more

Use this to upcast a trait to one of its supertraits. Read more

Use this to cast from one trait object type to another. This method is more customizable than the dyn_cast method. Here you can also specify the “source” trait from which the cast is defined. This can for example allow using casts from a supertrait of the current trait object. Read more

Use this to cast from one trait object type to another. With this method the type parameter is a config type that uniquely specifies which cast should be preformed. Read more

Returns the argument unchanged.

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Calls U::from(self).

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

Should always be Self

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more