libpitust 0.1.0

libpitust implements random utility functions I tend to use a lot
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

//! Module `mapgraph` implements an BTreeMap-based graph

use std::collections::{BTreeMap, BTreeSet};

use crate::graph::{GraphBase, GraphSucc};

pub struct MapGraph<Node: Copy + Ord> {
    nodes: BTreeMap<Node, BTreeSet<Node>>,
}
impl<Node: Copy + Ord> MapGraph<Node> {
    pub fn new() -> MapGraph<Node> {
        MapGraph {
            nodes: BTreeMap::new(),
        }
    }
    pub fn add_node(&mut self, node: Node) {
        let _ = self.nodes.try_insert(node, BTreeSet::new());
    }
    pub fn add_edge(&mut self, src: Node, dst: Node) {
        self.add_node(src);
        self.add_node(dst);
        self.nodes.get_mut(&src).unwrap().insert(dst);
    }

    pub fn from_graph<G: GraphBase<Node = Node> + GraphSucc>(graph: G) -> MapGraph<Node> {
        let mut mg = MapGraph::new();
        for node in graph.nodes() {
            mg.nodes
                .insert(node, BTreeSet::from_iter(graph.succ_of(node)));
        }
        mg
    }
}
impl<'a, Node: Copy + Ord> GraphBase for &'a MapGraph<Node> {
    type Node = Node;
    type NodeMapImpl<Value> = BTreeMap<Node, Value>;

    fn clear_nodemap<Value>(
        self,
        map: &mut BTreeMap<Node, Value>,
        mut init: impl FnMut(Self::Node) -> Value,
    ) {
        map.clear();
        for node in self.nodes() {
            map.insert(node, init(node));
        }
    }
    fn nodes(self) -> impl Iterator<Item = Self::Node> {
        self.nodes.keys().copied()
    }
}