icentral_label_map/
label_map.rs

1crate::ix!();
2
3#[derive(Debug)]
4pub struct LabelMap {
5
6    name:   String,
7
8    /**
9      | maps original node id to id in the the
10      | subgraph maps internal labels to original
11      |
12      */
13    in_out: Vec<NodeId>,
14
15    /**
16      | original labels to internal
17      |
18      */
19    out_in: HashMap<NodeId,NodeId>,
20}
21
22impl Clear for LabelMap {
23
24    fn clear(&mut self) {
25
26        debug!("clearing LabelMap of len: {}", self.len());
27
28        self.in_out.clear();
29        self.out_in.clear();
30    }
31}
32
33impl CreateNamedEmpty for LabelMap {
34
35    fn empty(name: &str) -> Self {
36
37        debug!("creating new empty LabelMap named {}", name);
38
39        Self {
40            name:   name.to_owned(),
41            in_out: vec![],
42            out_in: HashMap::new(),
43        }
44    }
45}
46
47impl LabelMap {
48
49    pub fn new_with_len(len: usize, name: &str) -> Self {
50
51        debug!("creating new LabelMap named {} from graph of len: {}", name, len);
52
53        let in_out = vec![NodeId::bad(); len];
54        let out_in = HashMap::new();
55
56        let mut label_map = Self {
57            name: name.to_owned(),
58            in_out,
59            out_in
60        };
61
62        // subgraph.nodeid_range()
63        for node in NodeIdRange::new(0,len) {
64            label_map.insert_outin(node,node);
65        }
66
67        label_map
68    }
69
70    pub fn len(&self) -> usize {
71
72        assert!(self.in_out.len() == self.out_in.len());
73
74        self.in_out.len()
75    }
76
77    pub fn inout(&self, node: NodeId) -> NodeId {
78        self.in_out[node.val()]
79    }
80
81    pub fn outin(&self, node: NodeId) -> NodeId {
82        self.out_in[&node]
83    }
84
85    pub fn mapped_edge(&self, theirs: &Edge) -> Edge {
86
87        let mut src: NodeId = self.out_in[&theirs.src];
88        let mut dst: NodeId = self.out_in[&theirs.dst];
89
90        let mine = Edge::new(src, dst);
91
92        debug!("remapping edge {} into map: {}", theirs, mine);
93
94        mine
95    }
96
97    pub fn projected_edge(&self, mine: &Edge) -> Edge {
98
99        let their_src = self.inout(mine.src);
100        let their_dst = self.inout(mine.dst);
101
102        let theirs = Edge::new(their_src, their_dst);
103
104        debug!("projecting edge {} into their space: {}", mine, theirs);
105
106        theirs
107    }
108
109    pub fn insert_outin(&mut self, src: NodeId, dst: NodeId) {
110        self.out_in.insert(src,dst);
111    }
112
113    pub fn resize_inout(&mut self, len: usize, default: NodeId) {
114
115        debug!("resizing LabelMap {} to len {}", self.name, len);
116
117        self.in_out.resize(len,default);
118    }
119
120    pub fn new_from_graph_ref<GH: NumNodes + MappedNodes>(
121        gh:   &GH, 
122        name: &str
123
124    ) -> Self {
125
126        debug!("creating new LabelMap named {} from GraphHash of len: {}", name, gh.num_nodes());
127
128        let mut label_map = LabelMap {
129            name: name.to_owned(),
130            in_out: vec![],
131            out_in: HashMap::new(),
132        };
133
134        let graph_len = gh.num_nodes();
135
136        label_map.in_out.resize(graph_len,NodeId::zero());
137
138        for (idx,id) in gh.mapped_nodes().iter().enumerate() {
139
140            label_map.in_out[idx] = *id;
141
142            label_map.out_in.insert(
143                *id,
144                nodeid![idx]
145            );
146        }
147
148        info!("LabelMap created\n{:#?}", label_map);
149
150        label_map 
151    }
152}