Struct error_stack::Frame

pub struct Frame { /* private fields */ }

A single context or attachment inside of a Report.

Frames are organized as a singly linked list, which can be iterated by calling Report::frames(). The head contains the current context or attachment, and the tail contains the root context created by Report::new(). The next Frame can be accessed by requesting it by calling Report::request_ref().

Implementations

impl Frame

pub const fn location(&self) -> &'static Location<'static>

Returns the location where this Frame was created.

pub const fn source(&self) -> Option<&Self>

Returns a shared reference to the source of this Frame.

This corresponds to the Frame below this one in a Report.

pub fn source_mut(&mut self) -> Option<&mut Self>

Returns a mutable reference to the source of this Frame.

This corresponds to the Frame below this one in a Report.

pub fn kind(&self) -> FrameKind<'_>

Returns how the Frame was created.

Examples found in repository

examples/json_output.rs (line 62)

↕

fn main() -> Result<(), MapError> {
    // This hook will be executed instead of the default implementation when `Debug` is called
    Report::set_debug_hook(|report, fmt| {
        #[derive(Serialize)]
        struct Context {
            context: String,
            attachments: Vec<String>,
        }

        let mut output = Vec::new();
        let mut attachments = Vec::new();

        for frame in report.frames() {
            match frame.kind() {
                FrameKind::Context(context) => {
                    output.push(Context {
                        context: context.to_string(),
                        attachments: attachments.clone(),
                    });
                    attachments.clear();
                }
                FrameKind::Attachment(AttachmentKind::Printable(attachment)) => {
                    attachments.push(attachment.to_string());
                }
                FrameKind::Attachment(_) => {}
            }
        }

        if fmt.alternate() {
            fmt.write_str(&serde_json::to_string_pretty(&output).expect("Could not format report"))
        } else {
            fmt.write_str(&serde_json::to_string(&output).expect("Could not format report"))
        }
    })
    .expect("Hook was set twice");

    let mut config = HashMap::default();

    // Create an entry with "foo" as key
    create_new_entry(&mut config, "foo", 1).attach_printable("Could not create new entry")?;

    // Purposefully cause an error by attempting to create another entry with "foo" as key
    create_new_entry(&mut config, "foo", 2).attach_printable("Could not create new entry")?;

    // Will output something like
    // ```json
    // [
    //   {
    //     "context": "Entry \"foo\" is already occupied by 1",
    //     "attachments": [
    //       "Could not create new entry"
    //     ]
    //   }
    // ]
    // ```

    Ok(())
}

pub fn request_ref<T>(&self) -> Option<&T> where
    T: ?Sized + 'static, 

Available on nightly only.

Requests the reference to T from the Frame if provided.

pub fn request_value<T>(&self) -> Option<T> where
    T: 'static, 

Available on nightly only.

Requests the value of T from the Frame if provided.

pub fn is<T: Send + Sync + 'static>(&self) -> bool

Returns if T is the held context or attachment by this frame.

pub fn downcast_ref<T: Send + Sync + 'static>(&self) -> Option<&T>

Downcasts this frame if the held context or attachment is the same as T.

pub fn downcast_mut<T: Send + Sync + 'static>(&mut self) -> Option<&mut T>

Downcasts this frame if the held context or attachment is the same as T.

Trait Implementations

impl Debug for Frame

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for Frame

fn drop(&mut self)

Executes the destructor for this type.

impl Provider for Frame

Available on nightly only.

fn provide<'a>(&'a self, demand: &mut Demand<'a>)

Data providers should implement this method to provide all values they are able to provide by using demand.