icentral_edges/
edges.rs

1crate::ix!();
2
3//-------------------------------------------------
4#[derive(Clone)]
5pub struct Edges {
6    name:  String,
7    inner: HashSet<Edge>,
8}
9
10impl fmt::Debug for Edges {
11
12    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13
14        let mut entries: Vec<&Edge> = self.inner.iter().collect();
15
16        entries.sort();
17
18        let binding = f.debug_list();
19
20        let mut builder = binding;
21
22        builder.entries(entries.iter());
23
24        builder.finish()
25    }
26}
27
28impl HasEdge for Edges {
29
30    delegate!{
31        to self.inner {
32            #[call(contains)]
33            fn has_edge(&self, edge: &Edge) -> bool;
34        }
35    }
36}
37
38impl SetName for Edges {
39
40    fn set_name(&mut self, name: &str) -> Result<(),NameError> {
41        self.name = name.to_owned();
42        Ok(())
43    }
44}
45
46impl CreateNamedEmpty for Edges {
47
48    fn empty(name: &str) -> Self {
49        Self {
50            inner: HashSet::new(),
51            name:  name.to_owned(),
52        }
53    }
54}
55
56impl Edges {
57
58    pub fn new_from_graph_ref<G: GetEdges>(g: &G, name: &str) -> Self {
59
60        debug!("creating new Edges named {} from graph with {} edges", name, g.edges().len());
61
62        let mut edges = g.edges().clone();
63
64        edges.set_name(name);
65
66        edges
67    }
68
69    delegate!{
70        to self.inner {
71            pub fn len(&self) -> usize;
72
73            pub fn clear(&mut self);
74
75            #[call(insert)]
76            pub fn insert_edge(&mut self, edge: Edge);
77
78            #[call(remove)]
79            pub fn remove_edge(&mut self, edge: &Edge);
80        }
81    }
82
83    pub fn new_remapped<GH: GetEdges + NumNodes>(
84        label_map: &LabelMap, 
85        gh:        &GH, 
86        name:      &str
87
88    ) -> Self {
89
90        debug!(
91            "creating new Edges named {} from LabelMap of len {} and GraphHash of len {}", 
92            name,
93            label_map.len(), 
94            gh.num_nodes()
95        );
96
97        let mut edges = Self::empty(name);
98
99        for their_edge in gh.edges().iter() {
100
101            let my_edge = label_map.mapped_edge(&their_edge);
102
103            edges.insert_edge(my_edge);
104        }
105
106        edges
107    }
108
109    pub fn iter(&self) 
110    -> std::collections::hash_set::Iter<'_, Edge> 
111    {
112        self.inner.iter()
113    }
114
115    pub fn extend(&mut self, other: &Edges) {
116        self.inner.extend(other.inner.clone());
117    }
118
119    pub fn connects(&self, src: NodeId, dst: NodeId) -> bool {
120
121        debug!("from Edges, check whether we have an edge connection between {} and {}", src, dst);
122
123        let mut e1: Edge = Edge::new(src,dst);
124        let mut e2: Edge = Edge::new(dst,src);
125
126        self.has_edge(&e1) || self.has_edge(&e2)
127    }
128
129    pub fn unlink_all(&mut self, src: NodeId, dst: NodeId) {
130
131        debug!("from Edges, unlink_all edges between src {} and dst {}", src, dst);
132
133        let mut e0 = Edge::new(src,dst);
134        let mut e1 = Edge::new(dst,src);
135
136        self.remove_edge(&e0);
137        self.remove_edge(&e1);
138    }
139
140    pub fn edges_to_node(&self, src: NodeId) -> Vec<Edge> {
141
142        let edges_to = self.inner.iter().cloned().filter(|e| e.dst == src).collect();
143
144        debug!("computed edges_to_node {:?} for node: {}", edges_to, src);
145
146        edges_to
147    }
148
149    pub fn edges_from_node(&self, src: NodeId) -> Vec<Edge> {
150
151        let edges_from = self.inner.iter().cloned().filter(|e| e.src == src).collect();
152
153        debug!("computed edges_from_node {:?} for node: {}", edges_from, src);
154
155        edges_from
156    }
157
158    pub fn new_from_vec(x: Vec<Edge>, name: &str) -> Edges {
159
160        debug!("creating new Edges named {} by collecting Vec<Edge> with {} Edges", name, x.len());
161
162        let set: HashSet<Edge> 
163        = x.into_iter().collect();
164
165        Edges {
166            inner: set,
167            name:  name.to_owned(),
168        }
169    }
170
171    pub fn new_from_set_ref(x: &HashSet<Edge>, name: &str) -> Self {
172
173        debug!("creating new Edges named {} by cloning HashSet<Edge> with {} Edges", name, x.len());
174
175        Edges {
176            inner: x.clone(),
177            name:  name.to_owned(),
178        }
179    }
180
181    pub fn new_from_set(x: HashSet<Edge>, name: &str) -> Self {
182
183        debug!("creating new Edges named {} by moving HashSet<Edge> with {} Edges", name, x.len());
184
185        Edges {
186            inner: x,
187            name:  name.to_owned(),
188        }
189    }
190
191    pub fn adjacency_list_for_dachshund(&self) -> Vec<(usize,usize)> {
192        self.inner.iter().map(|e| (e.src.val(), e.dst.val())).collect()
193    }
194}
icentral_edges/edges.rs

icentral_edges/
edges.rs
