Struct enso_flexer::prelude::logger::prelude::fmt::DebugMap 1.2.0[−][src]
#[must_use = "must eventually call `finish()` on Debug builders"]pub struct DebugMap<'a, 'b> where
'b: 'a, { /* fields omitted */ }
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
impl<'a, 'b> DebugMap<'a, 'b> where
'b: 'a,
[src]
impl<'a, 'b> DebugMap<'a, 'b> where
'b: 'a,
[src]pub fn entry(
&mut self,
key: &dyn Debug,
value: &dyn Debug
) -> &mut DebugMap<'a, 'b>
[src]
pub fn entry(
&mut self,
key: &dyn Debug,
value: &dyn Debug
) -> &mut DebugMap<'a, 'b>
[src]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)]}", );
pub fn key(&mut self, key: &dyn Debug) -> &mut DebugMap<'a, 'b>
1.42.0[src]
pub fn key(&mut self, key: &dyn Debug) -> &mut DebugMap<'a, 'b>
1.42.0[src]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)]}", );
pub fn value(&mut self, value: &dyn Debug) -> &mut DebugMap<'a, 'b>
1.42.0[src]
pub fn value(&mut self, value: &dyn Debug) -> &mut DebugMap<'a, 'b>
1.42.0[src]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)]}", );
pub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b> where
K: Debug,
V: Debug,
I: IntoIterator<Item = (K, V)>,
[src]
pub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b> where
K: Debug,
V: Debug,
I: IntoIterator<Item = (K, V)>,
[src]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}", );
pub fn finish(&mut self) -> Result<(), Error>
[src]
pub fn finish(&mut self) -> Result<(), Error>
[src]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}", );
Auto Trait Implementations
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> where
'b: 'a,
'b: 'a,
impl<'a, 'b> !UnwindSafe for DebugMap<'a, 'b>
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T> HasRefValue for T where
T: ?Sized,
[src]
impl<T> HasRefValue for T where
T: ?Sized,
[src]type RefValue = T
impl<T> PhantomConversions for T
[src]
impl<T> PhantomConversions for T
[src]fn phantom_into<P>() -> P where
Self: PhantomInto<P>,
[src]
Self: PhantomInto<P>,
fn phantom_from<P>() -> Self where
P: PhantomInto<Self>,
[src]
P: PhantomInto<Self>,
impl<T> Same<T> for T
impl<T> Same<T> for T
type Output = T
type Output = T
Should always be Self
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
pub fn to_subset(&self) -> Option<SS>
pub fn to_subset(&self) -> Option<SS>
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
pub fn is_in_subset(&self) -> bool
pub fn is_in_subset(&self) -> bool
Checks if self
is actually part of its subset T
(and can be converted to it).
pub fn to_subset_unchecked(&self) -> SS
pub fn to_subset_unchecked(&self) -> SS
Use with care! Same as self.to_subset
but without any property checks. Always succeeds.
pub fn from_subset(element: &SS) -> SP
pub fn from_subset(element: &SS) -> SP
The inclusion map: converts self
to the equivalent element of its superset.
impl<T> TypeDisplay for T
[src]
impl<T> TypeDisplay for T
[src]pub default fn type_display() -> String
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
pub fn vzip(self) -> V
impl<T> Writer for T
[src]
impl<T> Writer for T
[src]pub default fn write_by_level(&self, message: &Array)
[src]
pub default fn write_by_level(&self, message: &Array)
[src]Write message using the appropriate console method.