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

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

/// A BFS for advanced usage, letting a closure decide how many children at each level.
pub fn make_general_bfs_skeleton<F>(
    depth: u8,
    mut decide_children: F,
    final_leaf_count: u16,
) -> Skeleton
where
    F: FnMut(u8, u16) -> usize
{
    if depth == 0 {
        return SkeletonBuilder::default().build().unwrap();
    }

    let mut nodes = Vec::new();
    let mut queue = VecDeque::new();
    let mut next_id = 0u16;

    // root => aggregator for example
    let root = SkeletonNodeBuilder::default()
        .id(next_id)
        .name("genRoot")
        .original_key("genRoot")
        .build(NodeKind::Aggregate)
        .unwrap();
    nodes.push(root);
    queue.push_back((next_id, 0u8));
    next_id += 1;

    while let Some((nid, lvl)) = queue.pop_front() {
        if lvl >= depth - 1 {
            // final => leaf_count
            for node in nodes.iter_mut() {
                if node.id() == nid {
                    node.set_leaf_count(final_leaf_count);
                }
            }
        } else {
            let ccount = decide_children(lvl, nid);
            let mut cids = vec![];
            for _ in 0..ccount {
                let cid = next_id;
                next_id += 1;
                let cnode = SkeletonNodeBuilder::default()
                    .id(cid)
                    .name(format!("Node{}", cid))
                    .original_key(format!("Node{}", cid))
                    .build(NodeKind::Dispatch)
                    .unwrap();
                nodes.push(cnode);
                cids.push(cid);
                queue.push_back((cid, lvl+1));
            }
            // attach
            for nd in nodes.iter_mut() {
                if nd.id() == nid {
                    nd.set_child_ids(cids);
                    break;
                }
            }
        }
    }

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