Function topological_sort

src/ccsr/src/client.rs:342–388

(
    graph: &std::collections::HashMap<T, Vec<T>>,
)

/// This can operator on a disconnected graph containing multiple DAGs.
#[allow(clippy::disallowed_types)]
pub fn topological_sort<T: Hash + Eq>(
    graph: &std::collections::HashMap<T, Vec<T>>,
) -> Result<std::collections::HashMap<&T, i32>, anyhow::Error> {
    let mut referenced_by: std::collections::HashMap<&T, std::collections::HashSet<&T>> =
        std::collections::HashMap::new();
    for (subject, references) in graph.iter() {
        for reference in references {
            referenced_by.entry(reference).or_default().insert(subject);
        }
    }

    // Start with nodes that have no incoming edges (empty referenced_by sets).
    // Also include nodes in graph that aren't in referenced_by at all (roots).
    let mut queue: Vec<_> = graph
        .keys()
        .filter(|key| {
            referenced_by
                .get(*key)
                .map_or(true, |subjects| subjects.is_empty())
        })
        .collect();

    let mut ordered = std::collections::HashMap::new();
    let mut n = 0;
    while let Some(subj_ver) = queue.pop() {
        if let Some(refs) = graph.get(subj_ver) {
            for ref_ver in refs {
                let Some(subjects) = referenced_by.get_mut(ref_ver) else {
                    continue;
                };
                subjects.remove(&subj_ver);
                if subjects.is_empty() {
                    referenced_by.remove_entry(ref_ver);
                    queue.push(ref_ver);
                }
            }
        }
        ordered.insert(subj_ver, n);
        n += 1;
    }

    if referenced_by.is_empty() {
        Ok(ordered)
    } else {
        Err(anyhow!("Cycled detected during topoligical sort"))
    }
}

async fn send_request<T>(req: reqwest::RequestBuilder) -> Result<T, UnhandledError>
where