Struct DebugStruct

pub struct DebugStruct<'f, 'w> { /* private fields */ }

A helper struct for debug formatting a braced struct, or braced variant.

Example

This example demonstrates how you can debug format a struct, and a braced variant.

use const_format::{Error, Formatter};
use const_format::{call_debug_fmt, coerce_to_fmt, formatc, impl_fmt, try_};

fn main() {
    const STRUC: &str = formatc!("{:?}", Foo { a: 5, b: [8, 13, 21], c: "34" });
    const ENUM_: &str = formatc!("{:?}", Bar::Baz { d: false, e: None });
     
    assert_eq!(STRUC, "Foo { a: 5, b: [8, 13, 21], c: \"34\" }");
    assert_eq!(ENUM_, "Baz { d: false, e: None }");
}

struct Foo{
    a: u32,
    b: [u32; 3],
    c: &'static str,
}

enum Bar {
    Baz{
        d: bool,
        e: Option<bool>,
    }
}

impl_fmt!{
    impl Foo;
     
    const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
        let mut f = f.debug_struct("Foo");
        try_!(coerce_to_fmt!(&self.a).const_debug_fmt(f.field("a")));
        try_!(coerce_to_fmt!(&self.b).const_debug_fmt(f.field("b")));
        try_!(coerce_to_fmt!(&self.c).const_debug_fmt(f.field("c")));
        f.finish()
    }
}

impl_fmt!{
    impl Bar;
     
    const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
        match self {
            Bar::Baz{d, e} => {
                let mut f = f.debug_struct("Baz");
                 
                // This macro allows debug formatting some generic types that
                // don't have a const_debug_fmt fn, like Options which wrap non-std types.
                call_debug_fmt!(std, d, f.field("d"));
                call_debug_fmt!(Option, e, f.field("e"));
                 
                f.finish()
            }
        }
    }
}

Implementations

impl<'f, 'w> DebugStruct<'f, 'w>

pub const fn field(&mut self, name: &str) -> &mut Formatter<'w>

Adds a field to the formatted output.

pub const fn finish(self) -> Result<(), Error>

Finishes writing the struct/variant, and if anything went wrong in the field method,returns an error.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes