Struct tracing::stdlib::fmt::DebugMap

1.2.0 · source ·
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)])),
    "{\"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,

1.2.0 · source

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)])),
    "{\"whole\": [(\"A\", 10), (\"B\", 11)]}",
);
1.42.0 · source

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)])),
    "{\"whole\": [(\"A\", 10), (\"B\", 11)]}",
);
source

pub fn key_with<F>(&mut self, key_fmt: F) -> &mut DebugMap<'a, 'b>
where F: FnOnce(&mut Formatter<'_>) -> Result<(), Error>,

🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)

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 · source

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)])),
    "{\"whole\": [(\"A\", 10), (\"B\", 11)]}",
);
source

pub fn value_with<F>(&mut self, value_fmt: F) -> &mut DebugMap<'a, 'b>
where F: FnOnce(&mut Formatter<'_>) -> Result<(), Error>,

🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)

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 · source

pub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b>
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)])),
    "{\"A\": 10, \"B\": 11}",
);
1.2.0 · source

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)])),
    "{\"A\": 10, \"B\": 11}",
);

Trait Implementations§

source§

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

source§

fn record_debug(&mut self, field: &Field, value: &dyn Debug)

Visit a value implementing fmt::Debug.
source§

fn record_f64(&mut self, field: &Field, value: f64)

Visit a double-precision floating point value.
source§

fn record_i64(&mut self, field: &Field, value: i64)

Visit a signed 64-bit integer value.
source§

fn record_u64(&mut self, field: &Field, value: u64)

Visit an unsigned 64-bit integer value.
source§

fn record_i128(&mut self, field: &Field, value: i128)

Visit a signed 128-bit integer value.
source§

fn record_u128(&mut self, field: &Field, value: u128)

Visit an unsigned 128-bit integer value.
source§

fn record_bool(&mut self, field: &Field, value: bool)

Visit a boolean value.
source§

fn record_str(&mut self, field: &Field, value: &str)

Visit a string value.
source§

fn record_bytes(&mut self, field: &Field, value: &[u8])

Visit a byte slice.
source§

fn record_error(&mut self, field: &Field, value: &(dyn Error + 'static))

Records a type implementing Error.

Auto Trait Implementations§

§

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> !UnwindSafe for DebugMap<'a, 'b>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

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

fn in_current_span(self) -> Instrumented<Self>

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

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

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

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

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

fn with_current_subscriber(self) -> WithDispatch<Self>

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