Method edges_row

tangle/src/select.rs:478–529

(&self, region: &Region)

impl PatternManager {
    fn edges_row(&self, region: &Region) -> (
        Vec<(crate::port::PortEdge, Option<NodeIdx>, Option<NodeIdx>, usize, VReg)>,
        Vec<(crate::port::PortEdge, Option<NodeIdx>, Option<NodeIdx>, Option<usize>, Option<usize>, u16)>
    ) {
        let Region { nodes, ports, sinks, .. } = region;
        let mut edges = Vec::with_capacity(nodes.edge_count());
        let mut states = Vec::new();
        // hook up all the edges to node inputs. this includes from the region sources
        for local in nodes.node_indices() {
            for (i, p) in nodes[local].inputs.iter().enumerate() {
                let vreg: Result<VReg, u16> = match ports[*p].storage{
                    OptionalStorage(Some(Storage::Immaterial(Some(state)))) => Err(state),
                    OptionalStorage(Some(Storage::Virtual(vreg))) => Ok(VReg(vreg)),
                    _ => panic!(),
                };
                for e in ports.edges_directed(*p, Direction::Outgoing) {
                    let neighbor_port = &ports[e.target()];
                    match vreg {
                        Ok(vreg) => {
                            let new_edge = (e.id(), neighbor_port.node, Some(local), i, vreg);
                            println!("new edge {:?}", new_edge);
                            edges.push(new_edge);
                        },
                        Err(state) => {
                            let output_idx = neighbor_port.node.map(|node| {
                                nodes[node].outputs.iter().enumerate().find(|(i, p)| **p == e.target())
                                .unwrap().0
                            });
                            let new_state = (e.id(), neighbor_port.node, Some(local), output_idx, Some(i), state);
                            println!("new state {:?}", new_state);
                            states.push(new_state);
                        },
                    }
                }
            }
        }
        // we also hook up edges to the region sinks
        for (i, output) in sinks.iter().enumerate() {
            let vreg: VReg = match ports[*output].storage{
                OptionalStorage(Some(Storage::Immaterial(state))) => continue,
                OptionalStorage(Some(Storage::Virtual(vreg))) => VReg(vreg),
                _ => panic!(),
            };
            for e in ports.edges_directed(*output, Direction::Outgoing) {
                let neighbor_port = &ports[e.target()];
                let new_edge = (e.id(), neighbor_port.node, None, i, vreg);
                println!("new sink edge {:?}", new_edge);
                edges.push(new_edge);
             }
        }
        (edges, states)
    }

    pub fn run(&mut self, token: &NodeOwner, region: &mut Region, virt_map: &mut VirtualRegisterMap) {
        let (mut edges, states) = self.edges_row(region);