flow-graph 0.23.0

A representation of a graph data structure for flow-based programming.
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use crate::{Node, NodeKind, PortDirection, Schematic};

pub(crate) fn render<DATA>(schematic: &Schematic<DATA>) -> String
where
  DATA: Clone,
{
  let mut lines = vec![format!("digraph \"{}\" {{", schematic.name())];
  for node in schematic.nodes() {
    lines.push(format!("subgraph \"cluster_{}\" {{", node.id()));
    lines.push(format!("label=\"{}\"", node.id()));
    let shape = match node.kind() {
      NodeKind::Input(_) => "house",
      NodeKind::Inherent(_) => "diamond",
      NodeKind::Output(_) => "invhouse",
      NodeKind::External(_) => "rectangle",
    };
    lines.push(format!("\"{}\"[shape=\"{}\"]", node.id(), shape));
    lines.append(&mut render_ports(node, PortDirection::In));
    lines.append(&mut render_ports(node, PortDirection::Out));
    lines.push("}".to_owned());
  }
  lines.append(&mut render_connections(schematic));

  render_connections(schematic);
  lines.push("}".to_owned());
  lines.join("\n")
}

fn render_connections<DATA>(schematic: &Schematic<DATA>) -> Vec<String>
where
  DATA: Clone,
{
  let mut lines = vec![];
  for conn in schematic.connections() {
    let from_node = &schematic.nodes()[conn.from().node_index()];
    let from_port = &from_node.outputs()[conn.from().port_index()];
    let to_node = &schematic.nodes()[conn.to().node_index()];
    let to_port = &to_node.inputs()[conn.to().port_index()];
    lines.push(format!(
      "\"{}.OUT.{}\" -> \"{}.IN.{}\"",
      from_node.id(),
      from_port.name(),
      to_node.id(),
      to_port.name(),
    ));
  }
  lines
}

fn render_ports<DATA>(node: &Node<DATA>, dir: PortDirection) -> Vec<String>
where
  DATA: Clone,
{
  let (label, shape, ports) = match dir {
    PortDirection::In => ("IN", "triangle", node.inputs()),
    PortDirection::Out => ("OUT", "invtriangle", node.outputs()),
  };
  let mut lines = vec![];
  for port in ports {
    match dir {
      PortDirection::In => lines.push(format!("\"{}.IN.{}\" -> \"{}\"", node.id(), port.name(), node.id(),)),
      PortDirection::Out => lines.push(format!("\"{}\" -> \"{}.OUT.{}\"", node.id(), node.id(), port.name(),)),
    };
  }
  lines.push(format!("subgraph \"{}.{}\" {{", node.id(), label));
  for port in ports {
    lines.push(format!(
      "\"{}.{}.{}\"[label=\"{}\", shape=\"{}\"]",
      node.id(),
      label,
      port.name(),
      port.name(),
      shape
    ));
  }
  lines.push("}\n".to_owned());
  lines
}