capability-skeleton-mock 0.1.0

A Rust crate for constructing and managing hierarchical skeleton structures with diverse node types, enabling advanced testing and simulation scenarios.
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

// ---------------- [ File: capability-skeleton-mock/src/build_random_skeleton.rs ]
crate::ix!();

/// A random skeleton generator for “stress” tests. The BFS might only produce
/// 1 or 2 levels, so it’s not guaranteed to have early leaves, etc.—that’s a random approach.
pub fn build_random_skeleton(
    seed: u64,
    total_nodes: usize,
    p_aggregator: f32,
    p_dispatch: f32,
) -> Skeleton {
    let mut rng = StdRng::seed_from_u64(seed);

    // Decide root kind
    let root_kind = if p_aggregator >= p_dispatch && p_aggregator >= 0.3 {
        NodeKind::Aggregate
    } else if p_dispatch >= 0.3 {
        NodeKind::Dispatch
    } else {
        NodeKind::LeafHolder
    };

    let root = SkeletonNodeBuilder::default()
        .id(0)
        .name("rootRand")                       // CHANGED
        .original_key("rootRand")               // CHANGED
        .build(root_kind)
        .unwrap();

    let mut nodes = vec![root];

    // Create nodes
    for i in 1..(total_nodes as u16) {
        let r: f32 = rng.r#gen::<f32>();          // CHANGED - escaped the `gen`
        let kind = if r < p_aggregator {
            NodeKind::Aggregate
        } else if r < p_aggregator + p_dispatch {
            NodeKind::Dispatch
        } else {
            NodeKind::LeafHolder
        };
        let node = SkeletonNodeBuilder::default()
            .id(i)
            .name(format!("node_{}", i))        // CHANGED
            .original_key(format!("node_{}", i))
            .build(kind)
            .unwrap();
        nodes.push(node);
    }

    // Attempt a multi‐level BFS approach, but random:
    let max_depth = 10;
    let mut levels: Vec<Vec<u16>> = vec![vec![0]]; // root at level0
    let mut current_depth = 1u8;
    let mut next_node_idx = 1u16;

    while current_depth < max_depth && next_node_idx < total_nodes as u16 {
        let pick_count = rng.gen_range(1..=5).min((total_nodes as u16) - next_node_idx);
        if pick_count == 0 { break; }

        let mut this_level = Vec::new();
        for _ in 0..pick_count {
            this_level.push(next_node_idx);
            next_node_idx += 1;
            if next_node_idx >= total_nodes as u16 {
                break;
            }
        }
        levels.push(this_level);
        current_depth += 1;
    }

    // Link each level to the next
    for d in 0..(levels.len().saturating_sub(1)) {
        let parent_ids = &levels[d];
        let child_ids  = &levels[d+1];
        for &pid in parent_ids {
            // pick random subset of child_ids
            let mut chosen = vec![];
            for &cid in child_ids {
                let prob: f64 = rng.r#gen::<f64>();   // CHANGED
                if prob < 0.3 {
                    chosen.push(cid);
                }
            }
            // attach chosen as children
            if let Some(node_ref) = nodes.iter_mut().find(|n| n.id() == pid) {
                match node_ref {
                    SkeletonNode::Aggregate { child_ids, .. } => {
                        *child_ids = chosen;
                    },
                    SkeletonNode::Dispatch  { child_ids, .. } => {
                        *child_ids = chosen;
                    },
                    SkeletonNode::LeafHolder { .. } => { /* no children anyway */ }
                }
            }
        }
    }

    SkeletonBuilder::default()
        .nodes(nodes)
        .root_id(Some(0))
        .build()
        .unwrap()
}