fips-core 0.3.89

Reusable FIPS mesh, endpoint, transport, and protocol library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

fn order_open_discovery_candidates(
    candidates: Vec<OpenDiscoveryCandidate>,
    trust_scores: &std::collections::HashMap<String, i64>,
    enqueue_budget: usize,
    newcomer_probe_slots: usize,
) -> Vec<OpenDiscoveryCandidate> {
    if candidates.len() <= 1 || enqueue_budget == 0 {
        return candidates;
    }

    let mut positive = Vec::new();
    let mut unknown = Vec::new();
    let mut negative = Vec::new();
    for candidate in candidates {
        match trust_scores.get(&candidate.0).copied() {
            Some(score) if score > 0 => positive.push((score, candidate)),
            Some(score) if score < 0 => negative.push((score, candidate)),
            _ => unknown.push(candidate),
        }
    }

    positive.sort_by(|(left_score, left), (right_score, right)| {
        right_score
            .cmp(left_score)
            .then_with(|| right.2.cmp(&left.2))
            .then_with(|| left.0.cmp(&right.0))
    });
    unknown.sort_by(|left, right| right.2.cmp(&left.2).then_with(|| left.0.cmp(&right.0)));
    negative.sort_by(|(left_score, left), (right_score, right)| {
        right_score
            .cmp(left_score)
            .then_with(|| right.2.cmp(&left.2))
            .then_with(|| left.0.cmp(&right.0))
    });

    let reserved_newcomers = newcomer_probe_slots.min(enqueue_budget).min(unknown.len());
    let trusted_slots = enqueue_budget.saturating_sub(reserved_newcomers);

    let mut ordered = Vec::new();
    let mut positive = positive.into_iter();
    for _ in 0..trusted_slots {
        let Some((_, candidate)) = positive.next() else {
            break;
        };
        ordered.push(candidate);
    }
    let mut unknown = unknown.into_iter();
    for _ in 0..reserved_newcomers {
        let Some(candidate) = unknown.next() else {
            break;
        };
        ordered.push(candidate);
    }
    ordered.extend(positive.map(|(_, candidate)| candidate));
    ordered.extend(unknown);
    ordered.extend(negative.into_iter().map(|(_, candidate)| candidate));
    ordered
}