Function find_next

libs/error-stack/src/serde.rs:111–151

find the next applicable context and return the serializer

(head: &[&'a Frame], mut current: &'a Frame)

// find the next applicable context and return the serializer
fn find_next<'a>(head: &[&'a Frame], mut current: &'a Frame) -> Vec<SerializeContext<'a>> {
    let mut attachments = vec![];
    attachments.extend(head);

    loop {
        match current.kind() {
            FrameKind::Context(context) => {
                // found the context, return all attachments (reversed)
                attachments.reverse();

                return vec![SerializeContext {
                    attachments,
                    context,
                    sources: current.sources(),
                }];
            }
            FrameKind::Attachment(_) => match current.sources() {
                [] => {
                    // there are no more frames, therefore we need to abandon
                    // this is theoretically impossible (the bottom is always a context), but not
                    // enforced
                    return vec![];
                }
                [source] => {
                    attachments.push(current);

                    current = source;
                }
                sources => {
                    // there are multiple sources, we need to recursively probe each of them
                    attachments.push(current);

                    return sources
                        .iter()
                        .flat_map(|source| find_next(&attachments, source))
                        .collect();
                }
            },
        }
    }
}

impl<C: Error + Send + Sync + 'static> Serialize for Report<C> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>