705 lines
20 KiB
Rust
705 lines
20 KiB
Rust
//! Definitions for generating graphs from a simulation.
|
|
|
|
use petgraph::visit::{IntoEdgeReferences, IntoNodeReferences};
|
|
use petgraph::{Directed, Graph};
|
|
use std::rc::Rc;
|
|
|
|
use super::element::IdType;
|
|
use super::label::Label;
|
|
use super::set::{BasicSet, Set};
|
|
use super::system::System;
|
|
use super::translator;
|
|
|
|
pub type SystemGraph = Graph<System, Label, Directed, u32>;
|
|
|
|
fn common_system_entities(graph: &SystemGraph) -> Set {
|
|
graph
|
|
.node_references()
|
|
.fold(None, |acc, node| match acc {
|
|
None => Some(node.1.available_entities.clone()),
|
|
Some(acc) => Some(node.1.available_entities.intersection(&acc)),
|
|
})
|
|
.unwrap_or(Set::default())
|
|
}
|
|
|
|
macro_rules! common_label {
|
|
(
|
|
$name:ident,
|
|
[$edge_name:ident, $acc_name:ident],
|
|
$empty_expr:expr,
|
|
$some_expr:expr
|
|
) => {
|
|
fn $name(graph: &SystemGraph) -> Set {
|
|
graph
|
|
.edge_references()
|
|
.fold(None, |$acc_name, $edge_name| {
|
|
let $edge_name = $edge_name.weight();
|
|
match $acc_name {
|
|
None => Some($empty_expr),
|
|
Some($acc_name) => Some($some_expr),
|
|
}
|
|
})
|
|
.unwrap_or(Set::default())
|
|
}
|
|
};
|
|
}
|
|
|
|
common_label!(
|
|
common_label_products,
|
|
[edge, acc],
|
|
edge.products.clone(),
|
|
edge.products.intersection(&acc)
|
|
);
|
|
common_label!(
|
|
common_label_entities,
|
|
[edge, acc],
|
|
edge.available_entities.clone(),
|
|
edge.available_entities.intersection(&acc)
|
|
);
|
|
common_label!(
|
|
common_label_context,
|
|
[edge, acc],
|
|
edge.context.clone(),
|
|
edge.context.intersection(&acc)
|
|
);
|
|
common_label!(
|
|
common_label_union,
|
|
[edge, acc],
|
|
edge.t.clone(),
|
|
edge.t.intersection(&acc)
|
|
);
|
|
common_label!(
|
|
common_label_difference,
|
|
[edge, acc],
|
|
edge.context.subtraction(&edge.available_entities),
|
|
edge.context
|
|
.subtraction(&edge.available_entities)
|
|
.intersection(&acc)
|
|
);
|
|
common_label!(
|
|
common_label_entities_deleted,
|
|
[edge, acc],
|
|
edge.available_entities.subtraction(&edge.products),
|
|
edge.available_entities
|
|
.subtraction(&edge.products)
|
|
.intersection(&acc)
|
|
);
|
|
common_label!(
|
|
common_label_entities_added,
|
|
[edge, acc],
|
|
edge.products.subtraction(&edge.available_entities),
|
|
edge.products
|
|
.subtraction(&edge.available_entities)
|
|
.intersection(&acc)
|
|
);
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// helper functions
|
|
// -----------------------------------------------------------------------------
|
|
|
|
/// Very inelegant way to provide our graph with a map method where the edges
|
|
/// are mapped until the first error.
|
|
pub trait MapEdges<'a, N: 'a, E, Ty, Ix>
|
|
where
|
|
Ty: petgraph::EdgeType,
|
|
Ix: petgraph::graph::IndexType,
|
|
{
|
|
fn map_edges(
|
|
&self,
|
|
edge_map: &super::assert::types::Assert,
|
|
translator: &mut super::translator::Translator,
|
|
) -> Result<Graph<System, super::assert::types::AssertReturnValue, Ty, Ix>, String>;
|
|
}
|
|
|
|
impl<'a> MapEdges<'a, System, Label, Directed, u32> for SystemGraph {
|
|
fn map_edges(
|
|
&self,
|
|
edge_map: &super::assert::types::Assert,
|
|
translator: &mut super::translator::Translator,
|
|
) -> Result<Graph<System, super::assert::types::AssertReturnValue, Directed, u32>, String> {
|
|
use petgraph::graph::EdgeIndex;
|
|
|
|
let mut g = Graph::with_capacity(self.node_count(), self.edge_count());
|
|
let nodes = self.raw_nodes();
|
|
let edges = self.raw_edges();
|
|
|
|
let edges = edges
|
|
.iter()
|
|
.enumerate()
|
|
.map(
|
|
|(i, edge)| match edge_map.execute(self, &EdgeIndex::new(i), translator) {
|
|
Err(e) => Err(e),
|
|
Ok(val) => Ok((edge.source(), edge.target(), val)),
|
|
},
|
|
)
|
|
.collect::<Result<Vec<_>, _>>()?;
|
|
nodes.iter().for_each(|node| {
|
|
g.add_node(node.weight.clone());
|
|
});
|
|
|
|
edges.into_iter().for_each(|(source, target, v)| {
|
|
g.add_edge(source, target, v);
|
|
});
|
|
|
|
Ok(g)
|
|
}
|
|
}
|
|
|
|
// Nodes -----------------------------------------------------------------------
|
|
|
|
/// Helper structure that specifies what information to display for nodes.
|
|
#[derive(Clone)]
|
|
pub enum NodeDisplayBase {
|
|
String { string: String },
|
|
Hide,
|
|
Entities,
|
|
MaskEntities { mask: Set },
|
|
ExcludeEntities { mask: Set },
|
|
Context,
|
|
UncommonEntities,
|
|
MaskUncommonEntities { mask: Set },
|
|
}
|
|
|
|
pub struct NodeDisplay {
|
|
pub base: Vec<NodeDisplayBase>,
|
|
}
|
|
|
|
type GraphMapNodesFnTy<'a> = dyn Fn(petgraph::prelude::NodeIndex, &'a System) -> String + 'a;
|
|
|
|
fn match_node_display<'a>(
|
|
base: &NodeDisplayBase,
|
|
common_entities: Rc<Set>,
|
|
translator: Rc<translator::Translator>,
|
|
) -> Box<GraphMapNodesFnTy<'a>> {
|
|
use super::format_helpers::graph_map_nodes_ty_from::*;
|
|
use NodeDisplayBase::*;
|
|
|
|
match base {
|
|
String { string } => format_string(string.clone()),
|
|
Hide => format_hide(translator),
|
|
Entities => format_entities(translator),
|
|
MaskEntities { mask } => format_mask_entities(translator, mask.clone()),
|
|
ExcludeEntities { mask } => format_exclude_entities(translator, mask.clone()),
|
|
Context => format_context(translator),
|
|
UncommonEntities => format_exclude_entities(translator, (*common_entities).clone()),
|
|
MaskUncommonEntities { mask } => {
|
|
format_exclude_entities(translator, mask.intersection(&common_entities))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl NodeDisplay {
|
|
fn contains_uncommon(&self) -> bool {
|
|
self.base.iter().any(|b| {
|
|
matches!(
|
|
b,
|
|
NodeDisplayBase::UncommonEntities
|
|
| NodeDisplayBase::MaskUncommonEntities { mask: _ }
|
|
)
|
|
})
|
|
}
|
|
|
|
pub fn generate<'a>(
|
|
self,
|
|
translator: Rc<translator::Translator>,
|
|
current_graph: &SystemGraph,
|
|
) -> Box<GraphMapNodesFnTy<'a>> {
|
|
let common_entities = if self.contains_uncommon() {
|
|
Rc::new(common_system_entities(current_graph))
|
|
} else {
|
|
Rc::new(Set::default())
|
|
};
|
|
|
|
Box::new(move |i, n| {
|
|
let mut accumulator = String::new();
|
|
for b in &self.base {
|
|
let f = match_node_display(b, Rc::clone(&common_entities), Rc::clone(&translator));
|
|
|
|
accumulator.push_str(&(f)(i, n));
|
|
}
|
|
accumulator
|
|
})
|
|
}
|
|
}
|
|
|
|
// Edges -----------------------------------------------------------------------
|
|
|
|
#[derive(Clone)]
|
|
pub enum EdgeDisplayBase {
|
|
String {
|
|
string: String,
|
|
},
|
|
Hide,
|
|
Products {
|
|
mask: Option<Set>,
|
|
filter_common: bool,
|
|
},
|
|
Entities {
|
|
mask: Option<Set>,
|
|
filter_common: bool,
|
|
},
|
|
Context {
|
|
mask: Option<Set>,
|
|
filter_common: bool,
|
|
},
|
|
Union {
|
|
mask: Option<Set>,
|
|
filter_common: bool,
|
|
},
|
|
Difference {
|
|
mask: Option<Set>,
|
|
filter_common: bool,
|
|
},
|
|
EntitiesDeleted {
|
|
mask: Option<Set>,
|
|
filter_common: bool,
|
|
},
|
|
EntitiesAdded {
|
|
mask: Option<Set>,
|
|
filter_common: bool,
|
|
},
|
|
}
|
|
|
|
pub struct EdgeDisplay {
|
|
pub base: Vec<EdgeDisplayBase>,
|
|
}
|
|
|
|
type GraphMapEdgesFnTy<'a> = dyn Fn(petgraph::prelude::EdgeIndex, &'a Label) -> String + 'a;
|
|
|
|
#[derive(Default, Clone)]
|
|
struct CommonEntities {
|
|
common_products: Set,
|
|
common_entities: Set,
|
|
common_context: Set,
|
|
common_union: Set,
|
|
common_difference: Set,
|
|
common_entities_deleted: Set,
|
|
common_entities_added: Set,
|
|
}
|
|
|
|
fn match_edge_display<'a>(
|
|
base: &'a EdgeDisplayBase,
|
|
translator: Rc<translator::Translator>,
|
|
common: CommonEntities,
|
|
) -> Box<GraphMapEdgesFnTy<'a>> {
|
|
use super::format_helpers::graph_map_edges_ty_from::*;
|
|
use EdgeDisplayBase::*;
|
|
|
|
match base {
|
|
String { string } => format_string(translator, string.clone()),
|
|
Hide => format_hide(translator),
|
|
Products {
|
|
mask,
|
|
filter_common,
|
|
} => {
|
|
if *filter_common {
|
|
format_products(translator, mask.clone(), Some(common.common_products))
|
|
} else {
|
|
format_products(translator, mask.clone(), None)
|
|
}
|
|
}
|
|
Entities {
|
|
mask,
|
|
filter_common,
|
|
} => {
|
|
if *filter_common {
|
|
format_entities(translator, mask.clone(), Some(common.common_entities))
|
|
} else {
|
|
format_entities(translator, mask.clone(), None)
|
|
}
|
|
}
|
|
Context {
|
|
mask,
|
|
filter_common,
|
|
} => {
|
|
if *filter_common {
|
|
format_context(translator, mask.clone(), Some(common.common_context))
|
|
} else {
|
|
format_context(translator, mask.clone(), None)
|
|
}
|
|
}
|
|
Union {
|
|
mask,
|
|
filter_common,
|
|
} => {
|
|
if *filter_common {
|
|
format_union(translator, mask.clone(), Some(common.common_union))
|
|
} else {
|
|
format_union(translator, mask.clone(), None)
|
|
}
|
|
}
|
|
Difference {
|
|
mask,
|
|
filter_common,
|
|
} => {
|
|
if *filter_common {
|
|
format_difference(translator, mask.clone(), Some(common.common_difference))
|
|
} else {
|
|
format_difference(translator, mask.clone(), None)
|
|
}
|
|
}
|
|
EntitiesDeleted {
|
|
mask,
|
|
filter_common,
|
|
} => {
|
|
if *filter_common {
|
|
format_entities_deleted(
|
|
translator,
|
|
mask.clone(),
|
|
Some(common.common_entities_deleted),
|
|
)
|
|
} else {
|
|
format_entities_deleted(translator, mask.clone(), None)
|
|
}
|
|
}
|
|
EntitiesAdded {
|
|
mask,
|
|
filter_common,
|
|
} => {
|
|
if *filter_common {
|
|
format_entities_added(translator, mask.clone(), Some(common.common_entities_added))
|
|
} else {
|
|
format_entities_added(translator, mask.clone(), None)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
macro_rules! common_entity {
|
|
($name:ident, $match:pat, $filter_common:ident) => {
|
|
fn $name(&self) -> bool {
|
|
self.base.iter().any(|b| {
|
|
if let $match = b {
|
|
*$filter_common
|
|
} else {
|
|
false
|
|
}
|
|
})
|
|
}
|
|
};
|
|
}
|
|
|
|
impl EdgeDisplay {
|
|
common_entity!(
|
|
common_products,
|
|
EdgeDisplayBase::Products {
|
|
mask: _,
|
|
filter_common
|
|
},
|
|
filter_common
|
|
);
|
|
common_entity!(
|
|
common_entities,
|
|
EdgeDisplayBase::Entities {
|
|
mask: _,
|
|
filter_common
|
|
},
|
|
filter_common
|
|
);
|
|
common_entity!(
|
|
common_context,
|
|
EdgeDisplayBase::Context {
|
|
mask: _,
|
|
filter_common
|
|
},
|
|
filter_common
|
|
);
|
|
common_entity!(
|
|
common_union,
|
|
EdgeDisplayBase::Union {
|
|
mask: _,
|
|
filter_common
|
|
},
|
|
filter_common
|
|
);
|
|
common_entity!(
|
|
common_difference,
|
|
EdgeDisplayBase::Difference {
|
|
mask: _,
|
|
filter_common
|
|
},
|
|
filter_common
|
|
);
|
|
common_entity!(
|
|
common_entities_deleted,
|
|
EdgeDisplayBase::EntitiesDeleted {
|
|
mask: _,
|
|
filter_common
|
|
},
|
|
filter_common
|
|
);
|
|
common_entity!(
|
|
common_entities_added,
|
|
EdgeDisplayBase::EntitiesAdded {
|
|
mask: _,
|
|
filter_common
|
|
},
|
|
filter_common
|
|
);
|
|
|
|
pub fn generate<'a>(
|
|
self,
|
|
translator: Rc<translator::Translator>,
|
|
current_graph: &SystemGraph,
|
|
) -> Box<GraphMapEdgesFnTy<'a>> {
|
|
// create the structure for common entities if required
|
|
let common = {
|
|
let mut tmp = CommonEntities::default();
|
|
if self.common_products() {
|
|
tmp.common_products = common_label_products(current_graph);
|
|
}
|
|
if self.common_entities() {
|
|
tmp.common_entities = common_label_entities(current_graph);
|
|
}
|
|
if self.common_context() {
|
|
tmp.common_context = common_label_context(current_graph);
|
|
}
|
|
if self.common_union() {
|
|
tmp.common_union = common_label_union(current_graph);
|
|
}
|
|
if self.common_difference() {
|
|
tmp.common_difference = common_label_difference(current_graph);
|
|
}
|
|
if self.common_entities_deleted() {
|
|
tmp.common_entities_deleted = common_label_entities_deleted(current_graph);
|
|
}
|
|
if self.common_entities_added() {
|
|
tmp.common_entities_added = common_label_entities_added(current_graph);
|
|
}
|
|
tmp
|
|
};
|
|
|
|
Box::new(move |i, n| {
|
|
let mut accumulator = String::new();
|
|
for b in &self.base {
|
|
let f = match_edge_display(b, Rc::clone(&translator), common.clone());
|
|
accumulator.push_str(&(f)(i, n));
|
|
}
|
|
accumulator
|
|
})
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Color Nodes & Edges
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// Node ------------------------------------------------------------------------
|
|
type RSdotGraph = Graph<String, String, Directed, u32>;
|
|
type RSformatNodeTy<'a> =
|
|
dyn Fn(&'a RSdotGraph, <&'a RSdotGraph as IntoNodeReferences>::NodeRef) -> String + 'a;
|
|
type RSformatNodeTyOpt<'a> =
|
|
dyn Fn(&'a RSdotGraph, <&'a RSdotGraph as IntoNodeReferences>::NodeRef) -> Option<String> + 'a;
|
|
|
|
#[derive(Clone, Copy)]
|
|
pub enum OperationType {
|
|
Equals,
|
|
Subset,
|
|
SubsetEqual,
|
|
Superset,
|
|
SupersetEqual,
|
|
}
|
|
|
|
impl OperationType {
|
|
pub fn evaluate(&self, a: &Set, b: &Set) -> bool {
|
|
match self {
|
|
Self::Equals => a.is_subset(b) && b.is_subset(a),
|
|
Self::Subset => a.is_subset(b) && !b.is_subset(a),
|
|
Self::SubsetEqual => a.is_subset(b),
|
|
Self::Superset => b.is_subset(a) && !a.is_subset(b),
|
|
Self::SupersetEqual => b.is_subset(a),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub enum ContextColorConditional {
|
|
Nill,
|
|
RecursiveIdentifier(IdType),
|
|
EntitySet(OperationType, Set),
|
|
NonDeterministicChoice,
|
|
Summation,
|
|
WaitEntity,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub enum NodeColorConditional {
|
|
ContextConditional(ContextColorConditional),
|
|
EntitiesConditional(OperationType, Set),
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct NodeColor {
|
|
pub conditionals: Vec<(NodeColorConditional, String)>,
|
|
pub base_color: String,
|
|
}
|
|
|
|
#[inline(always)]
|
|
fn node_formatter_base_color(base_color: String) -> String {
|
|
", fillcolor=".to_string() + &base_color
|
|
}
|
|
|
|
#[inline(always)]
|
|
fn match_node_color_conditional<'a>(
|
|
rule: &'a NodeColorConditional,
|
|
color: &'a String,
|
|
original_graph: Rc<SystemGraph>,
|
|
star: Option<IdType>,
|
|
) -> Box<RSformatNodeTyOpt<'a>> {
|
|
use super::format_helpers::node_formatter::*;
|
|
match rule {
|
|
NodeColorConditional::ContextConditional(ccc) => match ccc {
|
|
ContextColorConditional::Nill => {
|
|
format_nill(Rc::clone(&original_graph), color.to_string(), star)
|
|
}
|
|
ContextColorConditional::RecursiveIdentifier(s) => {
|
|
format_recursive_identifier(Rc::clone(&original_graph), color.to_string(), star, *s)
|
|
}
|
|
ContextColorConditional::EntitySet(ot, set) => format_entity_set(
|
|
Rc::clone(&original_graph),
|
|
color.to_string(),
|
|
star,
|
|
*ot,
|
|
set.clone(),
|
|
),
|
|
ContextColorConditional::NonDeterministicChoice => {
|
|
format_non_deterministic_choice(Rc::clone(&original_graph), color.to_string(), star)
|
|
}
|
|
ContextColorConditional::Summation => {
|
|
format_summation(Rc::clone(&original_graph), color.to_string(), star)
|
|
}
|
|
ContextColorConditional::WaitEntity => {
|
|
format_wait_entity(Rc::clone(&original_graph), color.to_string(), star)
|
|
}
|
|
},
|
|
NodeColorConditional::EntitiesConditional(ot, set) => format_entities_conditional(
|
|
Rc::clone(&original_graph),
|
|
color.to_string(),
|
|
star,
|
|
*ot,
|
|
set.clone(),
|
|
),
|
|
}
|
|
}
|
|
|
|
impl NodeColor {
|
|
pub fn generate<'a>(
|
|
self,
|
|
original_graph: Rc<SystemGraph>,
|
|
star: Option<IdType>,
|
|
) -> Box<RSformatNodeTy<'a>> {
|
|
Box::new(move |i, n| {
|
|
for (rule, color) in &self.conditionals {
|
|
let f = match_node_color_conditional(rule, color, Rc::clone(&original_graph), star);
|
|
|
|
if let Some(s) = (f)(i, n) {
|
|
return s;
|
|
}
|
|
}
|
|
node_formatter_base_color(self.base_color.clone())
|
|
})
|
|
}
|
|
}
|
|
|
|
// Edge ------------------------------------------------------------------------
|
|
|
|
type RSformatEdgeTy<'a> =
|
|
dyn Fn(&'a RSdotGraph, <&'a RSdotGraph as IntoEdgeReferences>::EdgeRef) -> String + 'a;
|
|
type RSformatEdgeTyOpt<'a> =
|
|
dyn Fn(&'a RSdotGraph, <&'a RSdotGraph as IntoEdgeReferences>::EdgeRef) -> Option<String> + 'a;
|
|
|
|
#[derive(Clone)]
|
|
pub enum EdgeColorConditional {
|
|
Entities(OperationType, Set),
|
|
Context(OperationType, Set),
|
|
T(OperationType, Set),
|
|
Reactants(OperationType, Set),
|
|
ReactantsAbsent(OperationType, Set),
|
|
Inhibitors(OperationType, Set),
|
|
InhibitorsPresent(OperationType, Set),
|
|
Products(OperationType, Set),
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct EdgeColor {
|
|
pub conditionals: Vec<(EdgeColorConditional, String)>,
|
|
pub base_color: String,
|
|
}
|
|
|
|
fn edge_formatter_base_color(base_color: String) -> String {
|
|
", color=".to_string() + &base_color
|
|
}
|
|
|
|
fn match_edge_color_conditional<'a>(
|
|
rule: &'a EdgeColorConditional,
|
|
color: &'a String,
|
|
original_graph: Rc<SystemGraph>,
|
|
) -> Box<RSformatEdgeTyOpt<'a>> {
|
|
use super::format_helpers::edge_formatter::*;
|
|
match rule {
|
|
EdgeColorConditional::Entities(ot, set) => format_entities(
|
|
Rc::clone(&original_graph),
|
|
color.to_string(),
|
|
*ot,
|
|
set.clone(),
|
|
),
|
|
EdgeColorConditional::Context(ot, set) => format_context(
|
|
Rc::clone(&original_graph),
|
|
color.to_string(),
|
|
*ot,
|
|
set.clone(),
|
|
),
|
|
EdgeColorConditional::T(ot, set) => format_t(
|
|
Rc::clone(&original_graph),
|
|
color.to_string(),
|
|
*ot,
|
|
set.clone(),
|
|
),
|
|
EdgeColorConditional::Reactants(ot, set) => format_reactants(
|
|
Rc::clone(&original_graph),
|
|
color.to_string(),
|
|
*ot,
|
|
set.clone(),
|
|
),
|
|
EdgeColorConditional::ReactantsAbsent(ot, set) => format_reactants_absent(
|
|
Rc::clone(&original_graph),
|
|
color.to_string(),
|
|
*ot,
|
|
set.clone(),
|
|
),
|
|
EdgeColorConditional::Inhibitors(ot, set) => format_inhibitors(
|
|
Rc::clone(&original_graph),
|
|
color.to_string(),
|
|
*ot,
|
|
set.clone(),
|
|
),
|
|
EdgeColorConditional::InhibitorsPresent(ot, set) => format_inhibitors_present(
|
|
Rc::clone(&original_graph),
|
|
color.to_string(),
|
|
*ot,
|
|
set.clone(),
|
|
),
|
|
EdgeColorConditional::Products(ot, set) => format_products(
|
|
Rc::clone(&original_graph),
|
|
color.to_string(),
|
|
*ot,
|
|
set.clone(),
|
|
),
|
|
}
|
|
}
|
|
|
|
impl EdgeColor {
|
|
pub fn generate<'a>(self, original_graph: Rc<SystemGraph>) -> Box<RSformatEdgeTy<'a>> {
|
|
Box::new(move |i, n| {
|
|
for (rule, color) in &self.conditionals {
|
|
let f = match_edge_color_conditional(rule, color, Rc::clone(&original_graph));
|
|
|
|
if let Some(s) = (f)(i, n) {
|
|
return s;
|
|
}
|
|
}
|
|
edge_formatter_base_color(self.base_color.clone())
|
|
})
|
|
}
|
|
}
|