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 `indexgraph` implements an IndexVec-based graph

use crate::{
    graph::{GraphBase, GraphSucc},
    index::{Idx, vec::IndexVec},
};

pub struct IndexGraph<Node: Idx> {
    nodes: IndexVec<Node, Vec<Node>>,
}
impl<Node: Idx> IndexGraph<Node> {
    pub fn new() -> IndexGraph<Node> {
        IndexGraph {
            nodes: IndexVec::new(),
        }
    }
    pub fn resize(&mut self, num_nodes: usize) {
        self.nodes.resize(num_nodes, |_| vec![]);
    }
    pub fn edge(&mut self, src: Node, dst: Node) {
        self.nodes[src].push(dst);
    }
}
impl<Node: Idx> From<IndexVec<Node, Vec<Node>>> for IndexGraph<Node> {
    fn from(nodes: IndexVec<Node, Vec<Node>>) -> IndexGraph<Node> {
        IndexGraph { nodes }
    }
}
impl<'a, Node: Idx> GraphBase for &'a IndexGraph<Node> {
    type Node = Node;
    type NodeMapImpl<Value> = IndexVec<Node, Value>;

    fn clear_nodemap<Value>(
        self,
        map: &mut IndexVec<Node, Value>,
        mut init: impl FnMut(Self::Node) -> Value,
    ) {
        map.clear();
        for node in self.nodes() {
            map.push(init(node));
        }
    }
    fn nodes(self) -> impl Iterator<Item = Self::Node> {
        self.nodes.index_iter()
    }
}
impl<'a, Node: Idx> GraphSucc for &'a IndexGraph<Node> {
    fn succ_of(self, node: Self::Node) -> impl Iterator<Item = Self::Node> {
        self.nodes[node].iter().copied()
    }
}