diff --git a/reaction_systems_gui/src/app.rs b/reaction_systems_gui/src/app.rs index 350e01e..c35a128 100644 --- a/reaction_systems_gui/src/app.rs +++ b/reaction_systems_gui/src/app.rs @@ -100,8 +100,8 @@ pub enum BasicValue { value: (Vec, Vec), }, Graph { - value: petgraph::Graph, + value: + petgraph::Graph, }, AssertFunction { value: assert::relabel::Assert, @@ -160,8 +160,10 @@ pub enum BasicValue { value: Vec, }, PositiveGraph { - value: petgraph::Graph, + value: petgraph::Graph< + rsprocess::system::PositiveSystem, + rsprocess::label::PositiveLabel, + >, }, GroupFunction { value: assert::grouping::Assert, @@ -436,16 +438,24 @@ impl NodeInstruction { | Self::ToPositiveContext => vec![("value", Context)], | Self::ToPositiveEnvironment => vec![("value", Environment)], | Self::ToPositiveReactions => vec![("value", Reactions)], - | Self::OverwriteContextEntities => vec![("system", System), ("elements", Set)], - | Self::OverwriteReactionEntities => vec![("system", System), ("elements", Set)], - | Self::PositiveOverwriteContextEntities => vec![("system", PositiveSystem), ("elements", PositiveSet)], - | Self::PositiveOverwriteReactionEntities => vec![("system", PositiveSystem), ("elements", PositiveSet)], + | Self::OverwriteContextEntities => + vec![("system", System), ("elements", Set)], + | Self::OverwriteReactionEntities => + vec![("system", System), ("elements", Set)], + | Self::PositiveOverwriteContextEntities => + vec![("system", PositiveSystem), ("elements", PositiveSet)], + | Self::PositiveOverwriteReactionEntities => + vec![("system", PositiveSystem), ("elements", PositiveSet)], | Self::PositiveGraph => vec![("sys", PositiveSystem)], | Self::GroupFunction => vec![("value", String)], - | Self::GroupNodes => vec![("graph", Graph), ("grouping", GroupFunction)], + | Self::GroupNodes => + vec![("graph", Graph), ("grouping", GroupFunction)], | Self::PositiveAssertFunction => vec![("value", String)], | Self::PositiveGroupFunction => vec![("value", String)], - | Self::PositiveGroupNodes => vec![("graph", PositiveGraph), ("grouping", PositiveGroupFunction)], + | Self::PositiveGroupNodes => vec![ + ("graph", PositiveGraph), + ("grouping", PositiveGroupFunction), + ], | Self::PositiveDot => vec![ ("graph", PositiveGraph), ("display node", DisplayNode), @@ -548,21 +558,29 @@ impl NodeInstruction { | Self::ToPositiveReactions => vec![("out", PositiveReactions)], | Self::OverwriteContextEntities => vec![("out", System)], | Self::OverwriteReactionEntities => vec![("out", System)], - | Self::PositiveOverwriteContextEntities => vec![("out", PositiveSystem)], - | Self::PositiveOverwriteReactionEntities => vec![("out", PositiveSystem)], + | Self::PositiveOverwriteContextEntities => + vec![("out", PositiveSystem)], + | Self::PositiveOverwriteReactionEntities => + vec![("out", PositiveSystem)], | Self::PositiveGraph => vec![("out", PositiveGraph)], | Self::PositiveDot => vec![("out", String)], | Self::PositiveGraphML => vec![("out", String)], | Self::GroupFunction => vec![("out", GroupFunction)], | Self::GroupNodes => vec![("out", Graph)], - | Self::PositiveAssertFunction => vec![("out", PositiveAssertFunction)], - | Self::PositiveGroupFunction => vec![("out", PositiveGroupFunction)], + | Self::PositiveAssertFunction => + vec![("out", PositiveAssertFunction)], + | Self::PositiveGroupFunction => + vec![("out", PositiveGroupFunction)], | Self::PositiveGroupNodes => vec![("out", PositiveGraph)], - | Self::PositiveBisimilarityKanellakisSmolka => vec![("out", String)], - | Self::PositiveBisimilarityPaigeTarjanNoLabels => vec![("out", String)], + | Self::PositiveBisimilarityKanellakisSmolka => + vec![("out", String)], + | Self::PositiveBisimilarityPaigeTarjanNoLabels => + vec![("out", String)], | Self::PositiveBisimilarityPaigeTarjan => vec![("out", String)], }; - res.into_iter().map(|res| (res.0.to_string(), res.1)).collect::<_>() + res.into_iter() + .map(|res| (res.0.to_string(), res.1)) + .collect::<_>() } #[allow(clippy::type_complexity)] @@ -640,20 +658,28 @@ impl NodeInstruction { ), | BasicDataType::PositiveSet => helper!(PositiveSet, rsprocess::set::PositiveSet::default()), - | BasicDataType::PositiveEnvironment => - helper!(PositiveEnvironment, rsprocess::environment::PositiveEnvironment::default()), - | BasicDataType::PositiveContext => - helper!(PositiveContext, rsprocess::process::PositiveProcess::default()), + | BasicDataType::PositiveEnvironment => helper!( + PositiveEnvironment, + rsprocess::environment::PositiveEnvironment::default() + ), + | BasicDataType::PositiveContext => helper!( + PositiveContext, + rsprocess::process::PositiveProcess::default() + ), | BasicDataType::PositiveReactions => helper!(PositiveReactions, vec![]), | BasicDataType::PositiveGraph => helper!(PositiveGraph, petgraph::Graph::new()), | BasicDataType::GroupFunction => helper!(GroupFunction, assert::grouping::Assert::default()), - | BasicDataType::PositiveAssertFunction => - helper!(PositiveAssertFunction, assert::positive_relabel::PositiveAssert::default()), - | BasicDataType::PositiveGroupFunction => - helper!(PositiveGroupFunction, assert::positive_grouping::PositiveAssert::default()), + | BasicDataType::PositiveAssertFunction => helper!( + PositiveAssertFunction, + assert::positive_relabel::PositiveAssert::default() + ), + | BasicDataType::PositiveGroupFunction => helper!( + PositiveGroupFunction, + assert::positive_grouping::PositiveAssert::default() + ), } } @@ -699,13 +725,16 @@ impl NodeInstruction { | BasicDataType::Trace => helper!(Trace), | BasicDataType::PositiveTrace => helper!(PositiveTrace), | BasicDataType::PositiveSet => helper!(PositiveSet), - | BasicDataType::PositiveEnvironment => helper!(PositiveEnvironment), + | BasicDataType::PositiveEnvironment => + helper!(PositiveEnvironment), | BasicDataType::PositiveContext => helper!(PositiveContext), | BasicDataType::PositiveReactions => helper!(PositiveReactions), | BasicDataType::PositiveGraph => helper!(PositiveGraph), | BasicDataType::GroupFunction => helper!(GroupFunction), - | BasicDataType::PositiveAssertFunction => helper!(PositiveAssertFunction), - | BasicDataType::PositiveGroupFunction => helper!(PositiveGroupFunction), + | BasicDataType::PositiveAssertFunction => + helper!(PositiveAssertFunction), + | BasicDataType::PositiveGroupFunction => + helper!(PositiveGroupFunction), } } } @@ -895,8 +924,10 @@ impl DataTypeTrait for BasicDataType { | Self::PositiveReactions => egui::Color32::from_rgb(50, 10, 20), | Self::PositiveGraph => egui::Color32::from_rgb(100, 130, 90), | Self::GroupFunction => egui::Color32::from_rgb(0, 0, 0), - | Self::PositiveAssertFunction => egui::Color32::from_rgb(200, 150, 120), - | Self::PositiveGroupFunction => egui::Color32::from_rgb(150, 120, 200), + | Self::PositiveAssertFunction => + egui::Color32::from_rgb(200, 150, 120), + | Self::PositiveGroupFunction => + egui::Color32::from_rgb(150, 120, 200), } } @@ -924,13 +955,16 @@ impl DataTypeTrait for BasicDataType { | Self::Trace => Cow::Borrowed("trace"), | Self::PositiveTrace => Cow::Borrowed("positive trace"), | Self::PositiveSet => Cow::Borrowed("positive set"), - | Self::PositiveEnvironment => Cow::Borrowed("positive environment"), + | Self::PositiveEnvironment => + Cow::Borrowed("positive environment"), | Self::PositiveContext => Cow::Borrowed("positive context"), | Self::PositiveReactions => Cow::Borrowed("positive reactions"), | Self::PositiveGraph => Cow::Borrowed("positive graph"), | Self::GroupFunction => Cow::Borrowed("grouping function"), - | Self::PositiveAssertFunction => Cow::Borrowed("positive assert function"), - | Self::PositiveGroupFunction => Cow::Borrowed("positive group function"), + | Self::PositiveAssertFunction => + Cow::Borrowed("positive assert function"), + | Self::PositiveGroupFunction => + Cow::Borrowed("positive group function"), } } } @@ -947,7 +981,8 @@ impl NodeTemplateTrait for NodeInstruction { &self, _user_state: &mut Self::UserState, ) -> Cow<'_, str> { - Cow::Borrowed(match self { // TODO rename to something more appropriate + Cow::Borrowed(match self { + // TODO rename to something more appropriate | Self::String => "String", | Self::Path => "Path", | Self::ReadPath => "Read a file", @@ -995,7 +1030,7 @@ impl NodeTemplateTrait for NodeInstruction { | Self::ToPositiveSet => "Convert to Positive Set", | Self::PositiveComposeSystem => "Compose a positive system", | Self::DecomposeSystem => "Decompose a system", - | Self::PositiveDecomposeSystem => "Decompose a positive system", + | Self::PositiveDecomposeSystem => "Decompose a positive system", | Self::TraceToString => "Trace to string", | Self::PositiveTraceToString => "Positive trace to string", | Self::PositiveEnvironment => "Positive Environment", @@ -1006,19 +1041,26 @@ impl NodeTemplateTrait for NodeInstruction { | Self::ToPositiveReactions => "Convert to Positive Reactions", | Self::OverwriteContextEntities => "Overwrite context entities", | Self::OverwriteReactionEntities => "Overwirite reaction entities", - | Self::PositiveOverwriteContextEntities => "Overwrite context entities of Positive System", - | Self::PositiveOverwriteReactionEntities => "Overwrite reaction entities of Positive System", + | Self::PositiveOverwriteContextEntities => + "Overwrite context entities of Positive System", + | Self::PositiveOverwriteReactionEntities => + "Overwrite reaction entities of Positive System", | Self::PositiveGraph => "Graph of a Positive System", | Self::PositiveDot => "Create Dot file of Positive System", | Self::PositiveGraphML => "Create GraphML file of Positive System", | Self::GroupFunction => "Grouping Function", | Self::GroupNodes => "Group Nodes", - | Self::PositiveAssertFunction => "Positive Grouping of Edges on Graph", - | Self::PositiveGroupFunction => "Positive Grouping of Nodes on Graph", + | Self::PositiveAssertFunction => + "Positive Grouping of Edges on Graph", + | Self::PositiveGroupFunction => + "Positive Grouping of Nodes on Graph", | Self::PositiveGroupNodes => "Positive Group Nodes", - | Self::PositiveBisimilarityKanellakisSmolka => "Positive Bisimilarity Kanellakis & Smolka", - | Self::PositiveBisimilarityPaigeTarjanNoLabels => "Positive Paige & Torjan (ignore labels)", - | Self::PositiveBisimilarityPaigeTarjan => "Positive Paige & Torjan", + | Self::PositiveBisimilarityKanellakisSmolka => + "Positive Bisimilarity Kanellakis & Smolka", + | Self::PositiveBisimilarityPaigeTarjanNoLabels => + "Positive Paige & Torjan (ignore labels)", + | Self::PositiveBisimilarityPaigeTarjan => + "Positive Paige & Torjan", }) } @@ -1027,7 +1069,8 @@ impl NodeTemplateTrait for NodeInstruction { &self, _user_state: &mut Self::UserState, ) -> Vec<&'static str> { - match self { // TODO reorder? + match self { + // TODO reorder? | Self::String | Self::Path | Self::ReadPath @@ -1046,9 +1089,8 @@ impl NodeTemplateTrait for NodeInstruction { | Self::DecomposeSystem | Self::OverwriteContextEntities | Self::OverwriteReactionEntities => vec!["System"], - | Self::Frequency - | Self::LimitFrequency - | Self::FastFrequency => vec!["System", "Frequency"], + | Self::Frequency | Self::LimitFrequency | Self::FastFrequency => + vec!["System", "Frequency"], | Self::Experiment => vec!["Frequency", "Positive Frequency"], | Self::BisimilarityKanellakisSmolka | Self::BisimilarityPaigeTarjanNoLabels @@ -1065,7 +1107,8 @@ impl NodeTemplateTrait for NodeInstruction { | Self::GraphML => vec!["Graph"], | Self::PositiveFrequency | Self::PositiveLimitFrequency - | Self::PositiveFastFrequency => vec!["Positive System", "Positive Frequency"], + | Self::PositiveFastFrequency => + vec!["Positive System", "Positive Frequency"], | Self::PositiveSystem | Self::PositiveTarget | Self::PositiveRun @@ -1081,13 +1124,15 @@ impl NodeTemplateTrait for NodeInstruction { | Self::ToPositiveEnvironment | Self::ToPositiveReactions | Self::PositiveOverwriteContextEntities - | Self::PositiveOverwriteReactionEntities => vec!["Positive System"], + | Self::PositiveOverwriteReactionEntities => + vec!["Positive System"], | Self::PositiveGraph | Self::PositiveDot | Self::PositiveGraphML - | Self::PositiveAssertFunction => vec!["Positive System", "Positive Graph"], - | Self::PositiveGroupFunction - | Self::PositiveGroupNodes => vec!["Positive Graph"], + | Self::PositiveAssertFunction => + vec!["Positive System", "Positive Graph"], + | Self::PositiveGroupFunction | Self::PositiveGroupNodes => + vec!["Positive Graph"], | Self::Trace => vec!["Trace", "System"], | Self::PositiveTrace => vec!["Trace", "Positive System"], | Self::SliceTrace @@ -1096,7 +1141,8 @@ impl NodeTemplateTrait for NodeInstruction { | Self::PositiveTraceToString => vec!["Trace"], | Self::PositiveBisimilarityKanellakisSmolka | Self::PositiveBisimilarityPaigeTarjanNoLabels - | Self::PositiveBisimilarityPaigeTarjan => vec!["Positive Graph", "Positive Bisimilarity"], + | Self::PositiveBisimilarityPaigeTarjan => + vec!["Positive Graph", "Positive Bisimilarity"], } } @@ -1371,7 +1417,7 @@ impl NodeDataTrait for NodeData { match (is_active, graph[node_id].user_data.template) { | (_, ni) if ni.output().len() > 1 => { // no buttons for nodes with more than one output - } + }, | (_, NodeInstruction::SaveString) => { // no need to see the output, just write to file if ui.button("Write").clicked() { @@ -1385,20 +1431,22 @@ impl NodeDataTrait for NodeData { // file let button = egui::Button::new( egui::RichText::new("👁 Active").color(egui::Color32::BLACK), - ).fill(egui::Color32::GOLD); + ) + .fill(egui::Color32::GOLD); if ui.add(button).clicked() { responses.push(NodeResponse::User( CustomResponse::ClearActiveNode, )); } - let button = egui::Button::new(egui::RichText::new("Update file")); + let button = + egui::Button::new(egui::RichText::new("Update file")); if ui.add(button).clicked() { responses.push(NodeResponse::User( CustomResponse::FieldModified(node_id), )); } - } + }, | (false, NodeInstruction::ReadPath) => { // since no filewatcher we simply give the option to reload the // file @@ -1407,13 +1455,14 @@ impl NodeDataTrait for NodeData { CustomResponse::SetActiveNode(node_id), )); } - let button = egui::Button::new(egui::RichText::new("Update file")); + let button = + egui::Button::new(egui::RichText::new("Update file")); if ui.add(button).clicked() { responses.push(NodeResponse::User( CustomResponse::FieldModified(node_id), )); } - } + }, | (true, _) => { let button = egui::Button::new( egui::RichText::new("👁 Active").color(egui::Color32::BLACK), @@ -1630,8 +1679,10 @@ impl eframe::App for AppHandle { }, | NodeResponse::User(CustomResponse::FieldModified(node)) => { self.user_state.cache.invalidate_last_state(); - self.user_state.cache.invalidate_outputs(&self.state.graph, *node); - } + self.user_state + .cache + .invalidate_outputs(&self.state.graph, *node); + }, | NodeResponse::DisconnectEvent { output, input: _ } => { self.user_state.cache.invalidate_cache(output); }, @@ -1896,15 +1947,18 @@ fn get_layout( ), | BasicValue::PositiveSet { value } => text.append( &format!("{}", Formatter::from(translator, &value)), - 0., Default::default(), + 0., + Default::default(), ), | BasicValue::PositiveEnvironment { value } => text.append( &format!("{}", Formatter::from(translator, &value)), - 0., Default::default(), + 0., + Default::default(), ), | BasicValue::PositiveContext { value } => text.append( &format!("{}", Formatter::from(translator, &value)), - 0., Default::default(), + 0., + Default::default(), ), | BasicValue::PositiveReactions { value } => { text.append("(", 0., TextFormat { diff --git a/reaction_systems_gui/src/app_logic.rs b/reaction_systems_gui/src/app_logic.rs index 5addab5..764e1d0 100644 --- a/reaction_systems_gui/src/app_logic.rs +++ b/reaction_systems_gui/src/app_logic.rs @@ -38,15 +38,9 @@ pub fn evaluate_node( // populates the cache for node_id in to_evaluate { let node = &graph[node_id]; - let outputs = graph[node_id] - .user_data - .template - .output(); + let outputs = graph[node_id].user_data.template.output(); let output_names = - outputs - .iter() - .map(|el| el.0.as_str()) - .collect::>(); + outputs.iter().map(|el| el.0.as_str()).collect::>(); match process_template( graph, @@ -312,7 +306,6 @@ fn process_template( ); } - match template { | NodeInstruction::String => { let s = retrieve_from_cache![1]; @@ -320,7 +313,11 @@ fn process_template( if let BasicValue::String { value: _ } = s { let res = s; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -331,7 +328,11 @@ fn process_template( if let BasicValue::String { value } = s { let res = BasicValue::Path { value }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -352,7 +353,11 @@ fn process_template( })), }; let res = BasicValue::String { value: file }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a path"); } @@ -377,7 +382,11 @@ fn process_template( }, }; let res = BasicValue::System { value: sys }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -390,7 +399,11 @@ fn process_template( let res = BasicValue::String { value: value.statistics(translator), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a system"); } @@ -422,7 +435,11 @@ fn process_template( Formatter::from(translator, &limit.1) ), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::System { value: _ }, _) => anyhow::bail!("Not an integer"), @@ -462,7 +479,11 @@ fn process_template( )); } let res = BasicValue::String { value: output }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::System { value: _ }, _) => anyhow::bail!("Not an integer"), @@ -497,7 +518,11 @@ fn process_template( )); } let res = BasicValue::String { value: output }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::System { value: _ }, _) => anyhow::bail!("Not an integer"), @@ -512,7 +537,11 @@ fn process_template( if let BasicValue::String { value } = s { let res = BasicValue::Symbol { value }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -533,7 +562,11 @@ fn process_template( Formatter::from(translator, &res) ); let res = BasicValue::String { value: output }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a system"); } @@ -563,7 +596,11 @@ fn process_template( Formatter::from(translator, &l) ), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::System { value: _ }, _) => anyhow::bail!("Not an experiment"), @@ -588,7 +625,11 @@ fn process_template( })), }; let res = BasicValue::Experiment { value }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -619,7 +660,11 @@ fn process_template( Formatter::from(translator, &l) ), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::System { value: _ }, _) => anyhow::bail!("Not an experiment"), @@ -654,7 +699,11 @@ fn process_template( let res = BasicValue::String { value: format!("{l}"), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (_, _, _) => anyhow::bail!("Invalid inputs to bisimilarity."), } @@ -679,11 +728,15 @@ fn process_template( }, }; match res.typecheck() { - Ok(_) => {}, - Err(e) => anyhow::bail!(e), + | Ok(_) => {}, + | Err(e) => anyhow::bail!(e), }; let res = BasicValue::AssertFunction { value: *res }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -714,7 +767,11 @@ fn process_template( let res = BasicValue::String { value: format!("{l}"), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (_, _, _) => anyhow::bail!("Invalid inputs to bisimilarity."), } @@ -748,7 +805,11 @@ fn process_template( let res = BasicValue::String { value: format!("{l}"), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (_, _, _) => anyhow::bail!("Invalid inputs to bisimilarity."), } @@ -763,7 +824,11 @@ fn process_template( | Err(e) => anyhow::bail!(e), }; let res = BasicValue::Graph { value }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a system"); } @@ -852,7 +917,11 @@ fn process_template( let res = BasicValue::String { value: format!("{dot}"), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | _ => { anyhow::bail!("Values of wrong type"); @@ -880,7 +949,11 @@ fn process_template( }, }; let res = BasicValue::DisplayNode { value: res }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -906,7 +979,11 @@ fn process_template( }, }; let res = BasicValue::DisplayEdge { value: res }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -932,7 +1009,11 @@ fn process_template( }, }; let res = BasicValue::ColorNode { value: res }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -958,7 +1039,11 @@ fn process_template( }, }; let res = BasicValue::ColorEdge { value: res }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -997,7 +1082,11 @@ fn process_template( let res = BasicValue::String { value: format!("{graphml}"), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | _ => { anyhow::bail!("Values of wrong type"); @@ -1038,7 +1127,11 @@ fn process_template( Rc::new(reactions), ), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | _ => { anyhow::bail!("Values of wrong type"); @@ -1065,7 +1158,11 @@ fn process_template( }, }; let res = BasicValue::Environment { value: *env }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -1090,7 +1187,11 @@ fn process_template( }, }; let res = BasicValue::Set { value: set }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -1115,7 +1216,11 @@ fn process_template( }, }; let res = BasicValue::Context { value: context }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -1140,7 +1245,11 @@ fn process_template( }, }; let res = BasicValue::Reactions { value: reactions }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -1153,7 +1262,11 @@ fn process_template( let res = BasicValue::PositiveSystem { value: value.into(), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a system"); } @@ -1185,7 +1298,11 @@ fn process_template( Formatter::from(translator, &limit.1) ), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::PositiveSystem { value: _ }, _) => anyhow::bail!("Not an integer"), @@ -1225,7 +1342,11 @@ fn process_template( )); } let res = BasicValue::String { value: output }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::PositiveSystem { value: _ }, _) => anyhow::bail!("Not an integer"), @@ -1260,7 +1381,11 @@ fn process_template( )); } let res = BasicValue::String { value: output }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::PositiveSystem { value: _ }, _) => anyhow::bail!("Not an integer"), @@ -1283,7 +1408,11 @@ fn process_template( Formatter::from(translator, &res) ); let res = BasicValue::String { value: output }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a positive system"); } @@ -1314,7 +1443,11 @@ fn process_template( Formatter::from(translator, &l) ), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::PositiveSystem { value: _ }, _) => anyhow::bail!("Not an experiment"), @@ -1350,7 +1483,11 @@ fn process_template( Formatter::from(translator, &l) ), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::PositiveSystem { value: _ }, _) => anyhow::bail!("Not an experiment"), @@ -1380,7 +1517,11 @@ fn process_template( } }; let res = BasicValue::Trace { value: trace }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::System { value: _ }, _) => anyhow::bail!("Not a positive integer"), @@ -1410,7 +1551,11 @@ fn process_template( } }; let res = BasicValue::PositiveTrace { value: trace }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::PositiveSystem { value: _ }, _) => anyhow::bail!("Not a positive integer"), @@ -1434,7 +1579,11 @@ fn process_template( }; let res = BasicValue::Trace { value: new_trace }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::Trace { value: _ }, _) => anyhow::bail!("Not a set"), @@ -1458,7 +1607,11 @@ fn process_template( }; let res = BasicValue::PositiveTrace { value: new_trace }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::PositiveTrace { value: _ }, _) => anyhow::bail!("Not a set"), @@ -1487,7 +1640,11 @@ fn process_template( }, }; let res = BasicValue::PositiveSet { value: set }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -1501,7 +1658,11 @@ fn process_template( value: value .to_positive_set(rsprocess::element::IdState::Positive), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -1539,7 +1700,11 @@ fn process_template( Rc::new(reactions), ), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | _ => { anyhow::bail!("Values of wrong type"); @@ -1561,10 +1726,17 @@ fn process_template( let context = BasicValue::Context { value: context }; let reactions = BasicValue::Reactions { value: reactions }; - set_cache_output!((output_names[0], env, hash_inputs.clone())); - set_cache_output!((output_names[1], initial, hash_inputs.clone())); - set_cache_output!((output_names[2], context, hash_inputs.clone())); + set_cache_output!(( + output_names[1], + initial, + hash_inputs.clone() + )); + set_cache_output!(( + output_names[2], + context, + hash_inputs.clone() + )); set_cache_output!((output_names[3], reactions, hash_inputs)); } else { anyhow::bail!("Not a system"); @@ -1583,12 +1755,20 @@ fn process_template( let env = BasicValue::PositiveEnvironment { value: env }; let initial = BasicValue::PositiveSet { value: initial }; let context = BasicValue::PositiveContext { value: context }; - let reactions = BasicValue::PositiveReactions { value: reactions }; - + let reactions = + BasicValue::PositiveReactions { value: reactions }; set_cache_output!((output_names[0], env, hash_inputs.clone())); - set_cache_output!((output_names[1], initial, hash_inputs.clone())); - set_cache_output!((output_names[2], context, hash_inputs.clone())); + set_cache_output!(( + output_names[1], + initial, + hash_inputs.clone() + )); + set_cache_output!(( + output_names[2], + context, + hash_inputs.clone() + )); set_cache_output!((output_names[3], reactions, hash_inputs)); } else { anyhow::bail!("Not a positive system"); @@ -1602,7 +1782,11 @@ fn process_template( let res = BasicValue::String { value: format!("{}", Formatter::from(translator, &value)), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a trace"); } @@ -1615,7 +1799,11 @@ fn process_template( let res = BasicValue::String { value: format!("{}", Formatter::from(translator, &value)), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a positive trace"); } @@ -1625,7 +1813,9 @@ fn process_template( let hash_inputs = hash_inputs!(s); if let BasicValue::String { value } = s { - let res = grammar_separated::grammar::PositiveEnvironmentParser::new() + let res = + grammar_separated::grammar::PositiveEnvironmentParser::new( + ) .parse(translator, &value); let env = match res { | Ok(s) => s, @@ -1640,7 +1830,11 @@ fn process_template( }, }; let res = BasicValue::PositiveEnvironment { value: *env }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -1650,8 +1844,9 @@ fn process_template( let hash_inputs = hash_inputs!(s); if let BasicValue::String { value } = s { - let res = grammar_separated::grammar::PositiveContextParser::new() - .parse(translator, &value); + let res = + grammar_separated::grammar::PositiveContextParser::new() + .parse(translator, &value); let context = match res { | Ok(s) => s, | Err(parse_error) => { @@ -1665,7 +1860,11 @@ fn process_template( }, }; let res = BasicValue::PositiveContext { value: context }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -1675,8 +1874,9 @@ fn process_template( let hash_inputs = hash_inputs!(s); if let BasicValue::String { value } = s { - let res = grammar_separated::grammar::PositiveReactionsParser::new() - .parse(translator, &value); + let res = + grammar_separated::grammar::PositiveReactionsParser::new() + .parse(translator, &value); let reactions = match res { | Ok(s) => s, | Err(parse_error) => { @@ -1690,7 +1890,11 @@ fn process_template( }, }; let res = BasicValue::PositiveReactions { value: reactions }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -1703,7 +1907,11 @@ fn process_template( let res = BasicValue::PositiveContext { value: value.into(), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a context"); } @@ -1716,7 +1924,11 @@ fn process_template( let res = BasicValue::PositiveEnvironment { value: value.into(), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not an environment"); } @@ -1727,9 +1939,16 @@ fn process_template( if let BasicValue::Reactions { value } = s { let res = BasicValue::PositiveReactions { - value: rsprocess::reaction::PositiveReaction::from_reactions(&value), + value: + rsprocess::reaction::PositiveReaction::from_reactions( + &value, + ), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not reactions"); } @@ -1746,7 +1965,11 @@ fn process_template( let mut new_sys = sys.clone(); new_sys.overwrite_context_elements(set); let res = BasicValue::System { value: new_sys }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::System { value: _ }, _) => anyhow::bail!("Not a set"), @@ -1767,7 +1990,11 @@ fn process_template( let mut new_sys = sys.clone(); new_sys.overwrite_product_elements(set); let res = BasicValue::System { value: new_sys }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::System { value: _ }, _) => anyhow::bail!("Not a set"), @@ -1788,7 +2015,11 @@ fn process_template( let mut new_sys = sys.clone(); new_sys.overwrite_context_elements(set); let res = BasicValue::PositiveSystem { value: new_sys }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::PositiveSystem { value: _ }, _) => anyhow::bail!("Not a set"), @@ -1809,7 +2040,11 @@ fn process_template( let mut new_sys = sys.clone(); new_sys.overwrite_product_elements(set); let res = BasicValue::PositiveSystem { value: new_sys }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (BasicValue::PositiveSystem { value: _ }, _) => anyhow::bail!("Not a set"), @@ -1828,7 +2063,11 @@ fn process_template( | Err(e) => anyhow::bail!(e), }; let res = BasicValue::PositiveGraph { value }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a system"); } @@ -1853,11 +2092,15 @@ fn process_template( }, }; match res.typecheck() { - Ok(_) => {}, - Err(e) => anyhow::bail!(e), + | Ok(_) => {}, + | Err(e) => anyhow::bail!(e), }; let res = BasicValue::GroupFunction { value: *res }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -1867,21 +2110,28 @@ fn process_template( let hash_inputs = hash_inputs!(g, grouping); match (g, grouping) { - | (BasicValue::Graph { value: g }, - BasicValue::GroupFunction { value: grouping }) => - { + | ( + BasicValue::Graph { value: g }, + BasicValue::GroupFunction { value: grouping }, + ) => { use execution::data; let mut graph = g.clone(); match data::grouping(&mut graph, &grouping, translator) { - Ok(_) => {}, - Err(e) => anyhow::bail!(e), + | Ok(_) => {}, + | Err(e) => anyhow::bail!(e), }; let res = BasicValue::Graph { value: graph }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); - } - | (BasicValue::Graph { value: _ }, _) => anyhow::bail!("Not a group function"), - | (_, BasicValue::GroupFunction { value: _ }) => anyhow::bail!("Not a graph"), + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); + }, + | (BasicValue::Graph { value: _ }, _) => + anyhow::bail!("Not a group function"), + | (_, BasicValue::GroupFunction { value: _ }) => + anyhow::bail!("Not a graph"), | _ => anyhow::bail!("Inputs all wrong"), } }, @@ -1890,8 +2140,9 @@ fn process_template( let hash_inputs = hash_inputs!(s); if let BasicValue::String { value } = s { - let res = grammar_separated::positive_assert::AssertParser::new() - .parse(translator, &value); + let res = + grammar_separated::positive_assert::AssertParser::new() + .parse(translator, &value); let res = match res { | Ok(s) => s, | Err(parse_error) => { @@ -1905,11 +2156,15 @@ fn process_template( }, }; match res.typecheck() { - Ok(_) => {}, - Err(e) => anyhow::bail!(e), + | Ok(_) => {}, + | Err(e) => anyhow::bail!(e), }; let res = BasicValue::PositiveAssertFunction { value: *res }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -1919,8 +2174,9 @@ fn process_template( let hash_inputs = hash_inputs!(s); if let BasicValue::String { value } = s { - let res = grammar_separated::positive_grouping::GroupParser::new() - .parse(translator, &value); + let res = + grammar_separated::positive_grouping::GroupParser::new() + .parse(translator, &value); let res = match res { | Ok(s) => s, | Err(parse_error) => { @@ -1934,11 +2190,15 @@ fn process_template( }, }; match res.typecheck() { - Ok(_) => {}, - Err(e) => anyhow::bail!(e), + | Ok(_) => {}, + | Err(e) => anyhow::bail!(e), }; let res = BasicValue::PositiveGroupFunction { value: *res }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); } else { anyhow::bail!("Not a string"); } @@ -1948,21 +2208,30 @@ fn process_template( let hash_inputs = hash_inputs!(g, grouping); match (g, grouping) { - | (BasicValue::PositiveGraph { value: g }, - BasicValue::PositiveGroupFunction { value: grouping }) => - { + | ( + BasicValue::PositiveGraph { value: g }, + BasicValue::PositiveGroupFunction { value: grouping }, + ) => { use execution::data; let mut graph = g.clone(); - match data::positive_grouping(&mut graph, &grouping, translator) { - Ok(_) => {}, - Err(e) => anyhow::bail!(e), + match data::positive_grouping( + &mut graph, &grouping, translator, + ) { + | Ok(_) => {}, + | Err(e) => anyhow::bail!(e), }; let res = BasicValue::PositiveGraph { value: graph }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, - | (BasicValue::PositiveGraph { value: _ }, _) => anyhow::bail!("Not a positive group function"), - | (_, BasicValue::PositiveGroupFunction { value: _ }) => anyhow::bail!("Not a positive graph"), + | (BasicValue::PositiveGraph { value: _ }, _) => + anyhow::bail!("Not a positive group function"), + | (_, BasicValue::PositiveGroupFunction { value: _ }) => + anyhow::bail!("Not a positive graph"), | _ => anyhow::bail!("Inputs all wrong"), } }, @@ -1992,7 +2261,11 @@ fn process_template( let res = BasicValue::String { value: format!("{l}"), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (_, _, _) => anyhow::bail!("Invalid inputs to bisimilarity."), } @@ -2023,7 +2296,11 @@ fn process_template( let res = BasicValue::String { value: format!("{l}"), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (_, _, _) => anyhow::bail!("Invalid inputs to bisimilarity."), } @@ -2057,7 +2334,11 @@ fn process_template( let res = BasicValue::String { value: format!("{l}"), }; - set_cache_output!((output_names.first().unwrap(), res, hash_inputs)); + set_cache_output!(( + output_names.first().unwrap(), + res, + hash_inputs + )); }, | (_, _, _) => anyhow::bail!("Invalid inputs to bisimilarity."), }