elvis/ReactionSystems
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rustfmt

Browse Source
This commit is contained in:
elvis
2025-07-12 15:41:10 +02:00
parent 483260c2a3
commit 9207d588b8
1 changed files with 396 additions and 420 deletions
Download Patch File Download Diff File Expand all files Collapse all files

454
src/rsprocess/presets.rs
View File

@ -19,34 +19,36 @@ use super::structure::{RSset, RSsystem};
use super::translator::Translator;
use super::*;
// -----------------------------------------------------------------------------
// Structures
// -----------------------------------------------------------------------------
pub struct SaveOptions {
pub print: bool,
pub save: Option<Vec<String>>
pub save: Option<Vec<String>>,
}
impl SaveOptions {
pub fn combine(&mut self, other: &mut Self) {
self.print = self.print || other.print;
match (self.save.is_some(), other.save.is_some()) {
(false, false) |
(true, false) => {}
(false, false) | (true, false) => {}
(false, true) => {
self.save = other.save.to_owned();
},
}
(true, true) => {
self.save
.as_mut()
.unwrap()
.append(other.save.as_mut().unwrap());}
.append(other.save.as_mut().unwrap());
}
}
}
pub fn new() -> Self {
SaveOptions { print: false, save: None }
SaveOptions {
print: false,
save: None,
}
}
}
@ -59,23 +61,29 @@ impl Default for SaveOptions {
#[derive(Clone)]
pub enum NodeDisplay {
Separator(String),
Display(graph::GraphMapNodes)
Display(graph::GraphMapNodes),
}
#[derive(Clone)]
pub enum EdgeDisplay {
Separator(String),
Display(graph::GraphMapEdges)
Display(graph::GraphMapEdges),
}
pub enum GraphSaveOptions {
Dot { node_display: Vec<NodeDisplay>,
Dot {
node_display: Vec<NodeDisplay>,
edge_display: Vec<EdgeDisplay>,
so: SaveOptions },
GraphML { node_display: Vec<NodeDisplay>,
so: SaveOptions,
},
GraphML {
node_display: Vec<NodeDisplay>,
edge_display: Vec<EdgeDisplay>,
so: SaveOptions },
Serialize { path: String }
so: SaveOptions,
},
Serialize {
path: String,
},
}
pub enum Instruction {
@ -91,17 +99,20 @@ pub enum Instruction {
pub enum System {
Deserialize { path: String },
RSsystem { sys: RSsystem }
RSsystem { sys: RSsystem },
}
pub enum EvaluatedSystem {
Graph { graph: Graph<RSsystem, RSlabel>,
translator: Translator },
System { sys: RSsystem,
translator: Translator }
Graph {
graph: Graph<RSsystem, RSlabel>,
translator: Translator,
},
System {
sys: RSsystem,
translator: Translator,
},
}
impl System {
pub fn compute(
&self,
@ -109,14 +120,13 @@ impl System {
) -> Result<EvaluatedSystem, String>
{
match self {
Self::RSsystem { sys } => {
Ok(EvaluatedSystem::System { sys: sys.to_owned(),
translator })
},
Self::RSsystem { sys } => Ok(EvaluatedSystem::System {
sys: sys.to_owned(),
translator,
}),
Self::Deserialize { path } => {
let (graph, translator) = deserialize(path.into())?;
Ok(EvaluatedSystem::Graph { graph,
translator })
Ok(EvaluatedSystem::Graph { graph, translator })
}
}
}
@ -124,7 +134,7 @@ impl System {
pub struct Instructions {
pub system: System,
pub instructions: Vec<Instruction>
pub instructions: Vec<Instruction>,
}
// -----------------------------------------------------------------------------
@ -137,25 +147,25 @@ fn read_file<T, F>(
parser: F
) -> Result<T, String>
where
F: Fn(&mut Translator, String) -> Result<T, String>
F: Fn(&mut Translator, String) -> Result<T, String>,
{
// relative path
let mut path = match env::current_dir() {
Ok(p) => p,
Err(_) => return Err("Error getting current directory.".into())
Err(_) => return Err("Error getting current directory.".into()),
};
path = path.join(path_string);
// we read the file with a buffer
let f = match fs::File::open(path) {
Ok(f) => f,
Err(_) => return Err("Error opening file.".into())
Err(_) => return Err("Error opening file.".into()),
};
let mut buf_reader = io::BufReader::new(f);
let mut contents = String::new();
match buf_reader.read_to_string(&mut contents) {
Ok(_) => {},
Err(_) => return Err("Error reading file.".into())
Ok(_) => {}
Err(_) => return Err("Error reading file.".into()),
}
// parse
@ -168,86 +178,73 @@ fn reformat_error<T, S>(
e: ParseError<usize, T, &'static str>
) -> Result<S, String>
where
T: Display
T: Display,
{
match e {
ParseError::ExtraToken { token: (l, t, r) } => {
Err(format!(
ParseError::ExtraToken { token: (l, t, r) } => Err(format!(
"Unexpected token \"{t}\" \
between positions {l} and {r}."
))
},
ParseError::UnrecognizedEof { location: _, expected: _ } => {
Err("End of file encountered while parsing.".into())
},
)),
ParseError::UnrecognizedEof {
location: _,
expected: _,
} => Err("End of file encountered while parsing.".into()),
ParseError::InvalidToken { location } => {
Err(format!("Invalid token at position {location}."))
},
ParseError::UnrecognizedToken { token: (l, t, r), expected }
=> {
Err(format!(
}
ParseError::UnrecognizedToken {
token: (l, t, r),
expected,
} => Err(format!(
"Unrecognized token \"{t}\" \
between positions {l} and {r}. Expected: {expected:?}"
))
},
ParseError::User { error } => {
Err(error.to_string())
}
)),
ParseError::User { error } => Err(error.to_string()),
}
}
fn parser_experiment(
translator: &mut Translator,
contents: String
) -> Result<(Vec<u32>, Vec<RSset>), String>
{
match grammar::ExperimentParser::new()
.parse(translator, &contents)
{
contents: String,
) -> Result<(Vec<u32>, Vec<RSset>), String> {
match grammar::ExperimentParser::new().parse(translator, &contents) {
Ok(sys) => Ok(sys),
Err(e) => reformat_error(e)
Err(e) => reformat_error(e),
}
}
fn parser_instructions(
translator: &mut Translator,
contents: String
) -> Result<Instructions, String>
{
match grammar::RunParser::new()
.parse(translator, &contents)
{
contents: String,
) -> Result<Instructions, String> {
match grammar::RunParser::new().parse(translator, &contents) {
Ok(sys) => Ok(sys),
Err(e) => reformat_error(e)
Err(e) => reformat_error(e),
}
}
fn save_file(
contents: &String,
path_string: String
) -> Result<(), String>
{
fn save_file(contents: &String, path_string: String) -> Result<(), String> {
// relative path
let mut path = match env::current_dir() {
Ok(p) => p,
Err(_) => return Err("Error getting current directory.".into())
Err(_) => return Err("Error getting current directory.".into()),
};
path = path.join(path_string);
let mut f = match fs::File::create(&path) {
Ok(f) => f,
Err(_) => return Err(format!("Error creating file {}.",
path.to_str().unwrap()))
Err(_) =>
return Err(
format!("Error creating file {}.", path.to_str().unwrap())
),
};
match write!(f, "{contents}") {
Ok(_) => {}
Err(_) => return Err("Error writing to file.".into())
Err(_) => return Err("Error writing to file.".into()),
}
Ok(())
}
// -----------------------------------------------------------------------------
// main_do
// -----------------------------------------------------------------------------
@ -256,12 +253,10 @@ fn save_file(
/// Equivalent main_do(stat) or main_do(stat, MissingE)
pub fn stats(system: &EvaluatedSystem) -> Result<String, String> {
match system {
EvaluatedSystem::System { sys, translator } => {
Ok(statistics::of_RSsystem(translator, sys))
},
EvaluatedSystem::System { sys, translator } =>
Ok(statistics::of_RSsystem(translator, sys)),
EvaluatedSystem::Graph { graph, translator } => {
let Some(sys) = graph.node_weights().next()
else {
let Some(sys) = graph.node_weights().next() else {
return Err("No node found in graph".into());
};
Ok(statistics::of_RSsystem(translator, sys))
@ -269,18 +264,15 @@ pub fn stats(system: &EvaluatedSystem) -> Result<String, String> {
}
}
/// Prints a final set of entities in a terminating Reaction System.
/// The system needs to terminate to return.
/// Equivalent to main_do(target, E)
pub fn target(system: &EvaluatedSystem) -> Result<String, String> {
let (res, translator) = match system {
EvaluatedSystem::System { sys, translator } => {
(transitions::target(sys)?, translator)
},
EvaluatedSystem::System { sys, translator } =>
(transitions::target(sys)?, translator),
EvaluatedSystem::Graph { graph, translator } => {
let Some(sys) = graph.node_weights().next()
else {
let Some(sys) = graph.node_weights().next() else {
return Err("No node found in graph".into());
};
(transitions::target(sys)?, translator)
@ -293,7 +285,6 @@ pub fn target(system: &EvaluatedSystem) -> Result<String, String> {
))
}
/// Finds the list of traversed states in a (deterministic) terminating
/// reaction.
/// The system needs to terminate to return.
@ -302,10 +293,9 @@ pub fn traversed(system: &EvaluatedSystem) -> Result<String, String> {
let (res, translator) = match system {
EvaluatedSystem::System { sys, translator } => {
(transitions::run_separated(sys)?, translator)
},
}
EvaluatedSystem::Graph { graph, translator } => {
let Some(sys) = graph.node_weights().next()
else {
let Some(sys) = graph.node_weights().next() else {
return Err("No node found in graph".into());
};
(transitions::run_separated(sys)?, translator)
@ -316,45 +306,36 @@ pub fn traversed(system: &EvaluatedSystem) -> Result<String, String> {
output.push_str("The trace is composed by the set of entities:");
for (e, _c, _t) in res {
output.push_str(
&format!(
output.push_str(&format!(
"{}",
translator::RSsetDisplay::from(translator, &e)
)
);
));
}
Ok(output)
}
/// Finds the looping list of states in a reaction system with a perpetual
/// context. IMPORTANT: for loops, we assume Delta defines the process constant
/// x = Q.x and the context process is x .
/// equivalent to main_do(loop,Es)
pub fn hoop(
system: &EvaluatedSystem, symbol: String
) -> Result<String, String>
{
system: &EvaluatedSystem,
symbol: String
) -> Result<String, String> {
let (res, translator) = match system {
EvaluatedSystem::System { sys, translator } => {
(sys, translator)
},
EvaluatedSystem::System { sys, translator } => (sys, translator),
EvaluatedSystem::Graph { graph, translator } => {
let Some(sys) = graph.node_weights().next()
else {
let Some(sys) = graph.node_weights().next() else {
return Err("No node found in graph".into());
};
(sys, translator)
}
};
// we retrieve the id for "x" and use it to find the corresponding loop
let Some(id) = translator.encode_not_mut(&symbol)
else {
let Some(id) = translator.encode_not_mut(&symbol) else {
return Err(format!("Symbol {symbol} not found"));
};
let res =
match perpetual::lollipops_only_loop_named(res, id) {
let res = match perpetual::lollipops_only_loop_named(res, id) {
Some(o) => o,
None => {
return Err("No loop found.".into());
@ -365,9 +346,10 @@ pub fn hoop(
output.push_str("The loop is composed by the sets:");
for e in res {
output.push_str(
&format!( "{}", translator::RSsetDisplay::from(translator, &e))
);
output.push_str(&format!(
"{}",
translator::RSsetDisplay::from(translator, &e)
));
}
Ok(output)
@ -376,16 +358,11 @@ pub fn hoop(
/// Finds the frequency of each entity in the traversed states for a
/// (deterministic) terminating Reaction System.
/// equivalent to main_do(freq, PairList)
pub fn freq(
system: &EvaluatedSystem
) -> Result<String, String> {
pub fn freq(system: &EvaluatedSystem) -> Result<String, String> {
let (sys, translator) = match system {
EvaluatedSystem::System { sys, translator } => {
(sys, translator)
},
EvaluatedSystem::System { sys, translator } => (sys, translator),
EvaluatedSystem::Graph { graph, translator } => {
let Some(sys) = graph.node_weights().next()
else {
let Some(sys) = graph.node_weights().next() else {
return Err("No node found in graph".into());
};
(sys, translator)
@ -400,37 +377,35 @@ pub fn freq(
))
}
/// Finds the frequency of each entity in the limit loop of a nonterminating
/// Reaction System whose context has the form Q1 ... Q1.Q2 ... Q2 ... Qn ...
/// equivalent to main_do(limitfreq, PairList)
pub fn limit_freq(
system: &mut EvaluatedSystem,
experiment: String
) -> Result<String, String>
{
) -> Result<String, String> {
let (sys, translator): (&RSsystem, &mut Translator) = match system {
EvaluatedSystem::System { sys, translator } => {
(sys, translator)
},
EvaluatedSystem::System { sys, translator } => (sys, translator),
EvaluatedSystem::Graph { graph, translator } => {
let Some(sys) = graph.node_weights().next()
else {
let Some(sys) = graph.node_weights().next() else {
return Err("No node found in graph".into());
};
(sys, translator)
}
};
let (_, sets) = read_file(translator,
experiment,
parser_experiment)?;
let (_, sets) = read_file(translator, experiment, parser_experiment)?;
let res = match frequency::limit_frequency(&sets,
let res =
match frequency::limit_frequency(
&sets,
&sys.reaction_rules,
&sys.available_entities) {
&sys.available_entities)
{
Some(e) => e,
None => {return Err("Error calculating frequency.".into());}
None => {
return Err("Error calculating frequency.".into());
}
};
Ok(format!(
@ -439,7 +414,6 @@ pub fn limit_freq(
))
}
/// Finds the frequency of each entity in the traversed loops of a terminating
/// reaction system whose context has the form
/// Q1 ... Q1.Q2 ... Q2 ... Qn ... Qn.nil and each Qi is repeated Wi times
@ -451,28 +425,27 @@ pub fn fast_freq(
) -> Result<String, String>
{
let (sys, translator): (&RSsystem, &mut Translator) = match system {
EvaluatedSystem::System { sys, translator } => {
(sys, translator)
},
EvaluatedSystem::System { sys, translator } => (sys, translator),
EvaluatedSystem::Graph { graph, translator } => {
let Some(sys) = graph.node_weights().next()
else {
let Some(sys) = graph.node_weights().next() else {
return Err("No node found in graph".into());
};
(sys, translator)
}
};
let (weights, sets) = read_file(translator,
experiment,
parser_experiment)?;
let (weights, sets) = read_file(translator, experiment, parser_experiment)?;
let res = match frequency::fast_frequency(&sets,
let res = match frequency::fast_frequency(
&sets,
&sys.reaction_rules,
&sys.available_entities,
&weights) {
&weights,
) {
Some(e) => e,
None => {return Err("Error calculating frequency.".into());}
None => {
return Err("Error calculating frequency.".into());
}
};
Ok(format!(
@ -483,13 +456,11 @@ pub fn fast_freq(
/// Computes the LTS.
/// equivalent to main_do(digraph, Arcs) or to main_do(advdigraph, Arcs)
pub fn digraph(
system: &mut EvaluatedSystem
) -> Result<(), String> {
pub fn digraph(system: &mut EvaluatedSystem) -> Result<(), String> {
*system = if let EvaluatedSystem::System { sys, translator } = system {
EvaluatedSystem::Graph {
graph: graph::digraph(sys.clone())?,
translator: translator.to_owned()
translator: translator.to_owned(),
}
} else {
return Ok(());
@ -497,7 +468,6 @@ pub fn digraph(
Ok(())
}
// -----------------------------------------------------------------------------
// Output Functions
// -----------------------------------------------------------------------------
@ -505,33 +475,28 @@ pub fn digraph(
#[allow(clippy::type_complexity)]
fn generate_node_pringting_fn<'a>(
node_display: &'a Vec<NodeDisplay>,
translator: Rc<Translator>
translator: Rc<Translator>,
) -> Box<dyn Fn(petgraph::prelude::NodeIndex, &'a RSsystem) -> String + 'a> {
// The type cannot be aliased since rust doesnt like generics.
// We are iterating over the node_display and constructing a function
// (accumulator) that prints out our formatted nodes. So at each step we
// call the previous function and add the next string or function.
let mut accumulator:
Box<dyn Fn(petgraph::prelude::NodeIndex, &RSsystem) -> String>
= Box::new(|_, _| String::new());
let mut accumulator: Box<dyn Fn(petgraph::prelude::NodeIndex, &RSsystem) -> String> =
Box::new(|_, _| String::new());
for nd in node_display {
accumulator =
match nd {
NodeDisplay::Display(d) => { // retrieve from the graph module
// the correct formatting function
accumulator = match nd {
NodeDisplay::Display(d) => {
// retrieve from the graph module the correct formatting
// function
let val = translator.clone();
Box::new(
move |i, n| (accumulator)(i, n) +
&graph::GraphMapNodesTy::from(
d.clone(),
val.clone()
).get()(i, n))
},
NodeDisplay::Separator(s) => { // we have a string so simply
// add it at the end
Box::new(
move |i, n| (accumulator)(i, n) + s
)
Box::new(move |i, n| {
(accumulator)(i, n)
+ &graph::GraphMapNodesTy::from(d.clone(), val.clone()).get()(i, n)
})
}
NodeDisplay::Separator(s) => {
// we have a string so simply add it at the end
Box::new(move |i, n| (accumulator)(i, n) + s)
}
};
}
@ -541,33 +506,28 @@ fn generate_node_pringting_fn<'a>(
#[allow(clippy::type_complexity)]
fn generate_edge_pringting_fn<'a>(
edge_display: &'a Vec<EdgeDisplay>,
translator: Rc<Translator>
translator: Rc<Translator>,
) -> Box<dyn Fn(petgraph::prelude::EdgeIndex, &'a RSlabel) -> String + 'a> {
// The type cannot be aliased since rust doesnt like generics.
// We are iterating over the edge_display and constructing a function
// (accumulator) that prints out our formatted nodes. So at each step we
// call the previous function and add the next string or function.
let mut accumulator:
Box<dyn Fn(petgraph::prelude::EdgeIndex, &RSlabel) -> String>
= Box::new(|_, _| String::new());
let mut accumulator: Box<dyn Fn(petgraph::prelude::EdgeIndex, &RSlabel) -> String> =
Box::new(|_, _| String::new());
for nd in edge_display {
accumulator =
match nd {
EdgeDisplay::Display(d) => { // retrieve from the graph module
// the correct formatting function
accumulator = match nd {
EdgeDisplay::Display(d) => {
// retrieve from the graph module the correct formatting
// function
let val = translator.clone();
Box::new(
move |i, n| (accumulator)(i, n) +
&graph::GraphMapEdgesTy::from(
d.clone(),
val.clone()
).get()(i, n))
},
EdgeDisplay::Separator(s) => { // we have a string so simply
// add it at the end
Box::new(
move |i, n| (accumulator)(i, n) + s
)
Box::new(move |i, n| {
(accumulator)(i, n)
+ &graph::GraphMapEdgesTy::from(d.clone(), val.clone()).get()(i, n)
})
}
EdgeDisplay::Separator(s) => {
// we have a string so simply add it at the end
Box::new(move |i, n| (accumulator)(i, n) + s)
}
};
}
@ -578,30 +538,31 @@ fn generate_edge_pringting_fn<'a>(
pub fn dot(
system: &EvaluatedSystem,
node_display: Vec<NodeDisplay>,
edge_display: Vec<EdgeDisplay>
) -> Result<String, String>
{
edge_display: Vec<EdgeDisplay>,
) -> Result<String, String> {
match system {
EvaluatedSystem::System { sys:_, translator:_ } =>
Err("Supplied system is not a graph".into()),
EvaluatedSystem::System {
sys: _,
translator: _,
} => Err("Supplied system is not a graph".into()),
EvaluatedSystem::Graph { graph, translator } => {
let rc_translator = Rc::new(translator.clone());
// map each value to the corresponding value we want to display
// this is awful but rust is not a functional language so its all
// fine...
let modified_graph = graph.map(
generate_node_pringting_fn(&node_display, Rc::clone(&rc_translator)),
generate_edge_pringting_fn(&edge_display, rc_translator)
generate_node_pringting_fn(&node_display,
Rc::clone(&rc_translator)),
generate_edge_pringting_fn(&edge_display,
rc_translator),
);
let graph = Rc::new(graph.to_owned());
let edge_formatter = graph::default_edge_formatter(
Rc::clone(&graph)
);
let node_formatter = graph::default_node_formatter(
Rc::clone(&graph)
);
let edge_formatter =
graph::default_edge_formatter(Rc::clone(&graph));
let node_formatter =
graph::default_node_formatter(Rc::clone(&graph));
let dot = rsdot::RSDot::with_attr_getters(
&modified_graph,
@ -618,25 +579,33 @@ pub fn dot(
/// Writes the specified graph to a file in .graphml format.
pub fn graphml(system: &EvaluatedSystem) -> Result<String, String> {
match system {
EvaluatedSystem::System { sys:_, translator:_ } =>
Err("Supplied system is not a graph".into()),
EvaluatedSystem::System {
sys: _,
translator: _,
} => Err("Supplied system is not a graph".into()),
EvaluatedSystem::Graph { graph, translator } => {
let rc_translator = Rc::new(translator.to_owned());
// map each value to the corresponding value we want to display
let modified_graph = graph.map(
|id, node|
|id, node| {
graph::GraphMapNodesTy::from(
graph::GraphMapNodes::Entities,
Rc::clone(&rc_translator)
).get()(id, node)
+ "; " +
&graph::GraphMapNodesTy::from(
Rc::clone(&rc_translator),
)
.get()(id, node)
+ "; "
+ &graph::GraphMapNodesTy::from(
graph::GraphMapNodes::Context,
Rc::clone(&rc_translator)
).get()(id, node),
graph::GraphMapEdgesTy::from(graph::GraphMapEdges::EntitiesAdded,
Rc::clone(&rc_translator)).get()
Rc::clone(&rc_translator),
)
.get()(id, node)
},
graph::GraphMapEdgesTy::from(
graph::GraphMapEdges::EntitiesAdded,
Rc::clone(&rc_translator),
)
.get(),
);
use petgraph_graphml::GraphMl;
@ -653,14 +622,12 @@ pub fn graphml(system: &EvaluatedSystem) -> Result<String, String> {
/// Writes the specified graph, translator tuple to file.
/// N.B. graph size in memory might be much larger after serialization and
/// deserialization.
pub fn serialize(
system: &EvaluatedSystem,
path: String
) -> Result<(), String>
{
pub fn serialize(system: &EvaluatedSystem, path: String) -> Result<(), String> {
match system {
EvaluatedSystem::System { sys:_, translator:_ } =>
Err("Supplied system is not a graph".into()),
EvaluatedSystem::System {
sys: _,
translator: _,
} => Err("Supplied system is not a graph".into()),
EvaluatedSystem::Graph { graph, translator } => {
// relative path
let mut path = std::path::PathBuf::from(path);
@ -669,12 +636,12 @@ pub fn serialize(
let f = match fs::File::create(&path) {
Ok(f) => f,
Err(_) => return Err(format!("Error creating file {}.",
path.to_str().unwrap()))
path.to_str().unwrap())),
};
match serialize::ser(f, graph, translator) {
Ok(_) => Ok(()),
Err(_) => Err("Error during serialization.".into())
Err(_) => Err("Error during serialization.".into()),
}
}
}
@ -690,7 +657,7 @@ pub fn deserialize(
// relative path
let mut path = match env::current_dir() {
Ok(p) => p,
Err(_) => return Err("Error getting current directory.".into())
Err(_) => return Err("Error getting current directory.".into()),
};
path = path.join(input_path);
path.set_extension("cbor");
@ -698,16 +665,15 @@ pub fn deserialize(
let f = match fs::File::open(&path) {
Ok(f) => f,
Err(_) => return Err(format!("Error opening file {}.",
path.to_str().unwrap()))
path.to_str().unwrap())),
};
match serialize::de(f) {
Ok(a) => Ok(a),
Err(_) => Err("Error during deserialization.".into())
Err(_) => Err("Error during deserialization.".into()),
}
}
//------------------------------------------------------------------------------
// Interpreting Instructions
//------------------------------------------------------------------------------
@ -737,32 +703,40 @@ fn execute(
}
Instruction::Target { so } => {
save_options!(target(system)?, so);
},
}
Instruction::Run { so } => {
save_options!(traversed(system)?, so);
},
}
Instruction::Loop { symbol, so } => {
save_options!(hoop(system, symbol)?, so);
},
}
Instruction::Frequency { so } => {
save_options!(freq(system)?, so);
},
}
Instruction::LimitFrequency { experiment, so } => {
save_options!(limit_freq(system, experiment)?, so);
},
}
Instruction::FastFrequency { experiment, so } => {
save_options!(fast_freq(system, experiment)?, so);
},
}
Instruction::Digraph { gso } => {
for save in gso {
digraph(system)?;
match save {
GraphSaveOptions::Dot { node_display, edge_display, so } => {
save_options!(dot(system, node_display, edge_display)?, so);
},
GraphSaveOptions::GraphML { node_display:_, edge_display:_, so } => {
GraphSaveOptions::Dot {
node_display: nd,
edge_display: ed,
so,
} => {
save_options!(dot(system, nd, ed)?, so);
}
GraphSaveOptions::GraphML {
node_display: _,
edge_display: _,
so,
} => {
save_options!(graphml(system)?, so);
},
}
GraphSaveOptions::Serialize { path } => {
serialize(system, path)?;
}
@ -776,8 +750,10 @@ fn execute(
pub fn run(path: String) -> Result<(), String> {
let mut translator = Translator::new();
let Instructions { system, instructions } =
read_file(&mut translator, path, parser_instructions)?;
let Instructions {
system,
instructions,
} = read_file(&mut translator, path, parser_instructions)?;
let mut system = system.compute(translator)?;