From 164e1d883c8103ecd898791993feab07e98e0dea Mon Sep 17 00:00:00 2001 From: elvis Date: Sun, 28 Sep 2025 17:11:43 +0200 Subject: [PATCH] Fix, clippy now working better --- clippy.toml | 1 + rsprocess/src/set.rs | 24 +++- rsprocess/src/system.rs | 132 +++++++++++++++-- rsprocess/src/system_test.rs | 86 +++++++++++ rsprocess/src/trace.rs | 72 +++++++--- rsprocess/src/trace_test.rs | 270 ++++++++++++++++++++++------------- rsprocess/src/transitions.rs | 15 +- 7 files changed, 461 insertions(+), 139 deletions(-) create mode 100644 clippy.toml diff --git a/clippy.toml b/clippy.toml new file mode 100644 index 0000000..098c472 --- /dev/null +++ b/clippy.toml @@ -0,0 +1 @@ +ignore-interior-mutability = ["rsprocess::system::System", "rsprocess::system::PositiveSystem", ".."] diff --git a/rsprocess/src/set.rs b/rsprocess/src/set.rs index 62bf31e..466e7d6 100644 --- a/rsprocess/src/set.rs +++ b/rsprocess/src/set.rs @@ -638,9 +638,16 @@ impl PositiveSet { /// Returns all elements that are present in self and are positive in other. pub fn mask(&self, other: &Self) -> Self { - Self::from_iter(self.iter().filter(|el| { - other.contains(&PositiveType::from((*el.0, IdState::Positive))) - }).map(|el| (*el.0, *el.1))) + Self::from_iter( + self.iter() + .filter(|el| { + other.contains(&PositiveType::from(( + *el.0, + IdState::Positive, + ))) + }) + .map(|el| (*el.0, *el.1)), + ) } fn remove_elements(&mut self, other: Vec) { @@ -664,6 +671,7 @@ impl PositiveSet { self_copy.is_empty() } + // Returns only the positive entities. pub fn positives(&self) -> Self { self.iter() .filter(|el| *el.1 == IdState::Positive) @@ -671,10 +679,20 @@ impl PositiveSet { .collect::() } + // Returns only the negative entities. pub fn negatives(&self) -> Self { self.iter() .filter(|el| *el.1 == IdState::Negative) .map(|el| (*el.0, *el.1)) .collect::() } + + pub fn add_unique(&self, other: &Self) -> Self { + other + .iter() + .filter(|e| !self.contains(&PositiveType::from((*e.0, *e.1)))) + .map(|el| (*el.0, *el.1)) + .collect::() + .union(self) + } } diff --git a/rsprocess/src/system.rs b/rsprocess/src/system.rs index c7b2c88..f78b697 100644 --- a/rsprocess/src/system.rs +++ b/rsprocess/src/system.rs @@ -18,10 +18,12 @@ use super::process::{BasicProcess, PositiveProcess, Process}; use super::reaction::{ BasicReaction, ExtensionReaction, PositiveReaction, Reaction, }; -use super::set::{BasicSet, PositiveSet, Set}; +use super::set::{BasicSet, ExtensionsSet, PositiveSet, Set}; use super::trace::Trace; use super::transitions::TransitionsIterator; use super::translator::{Formatter, PrintableWithTranslator, Translator}; +use crate::trace::{EnabledReactions, SlicingElement, SlicingTrace}; +use crate::transitions::TraceIterator; pub trait BasicSystem where @@ -49,6 +51,14 @@ where &self, ) -> Result, String>; + #[allow(clippy::type_complexity)] + fn to_slicing_iterator( + &self, + ) -> Result< + impl Iterator, Self)>, + String, + >; + fn environment(&self) -> &Self::Environment; fn available_entities(&self) -> &Self::Set; fn context(&self) -> &Self::Process; @@ -89,7 +99,12 @@ pub trait ExtensionsSystem: BasicSystem { limit: usize, ) -> Result, String>; - fn traces(self, n: usize) -> Result>, String>; + fn traces(&self, n: usize) + -> Result>, String>; + + fn slice_trace( + &self, + ) -> Result, String>; } impl ExtensionsSystem for T { @@ -242,14 +257,18 @@ impl ExtensionsSystem for T { /// Return the first n traces. Equivalent to visiting the execution tree /// depth first and returning the first n leaf nodes and their path to the /// root. - fn traces(self, n: usize) -> Result>, String> { + fn traces( + &self, + n: usize, + ) -> Result>, String> { if n == 0 { return Ok(vec![]); } + let sys = self.clone(); let mut n = n; let mut res: Vec> = vec![]; let mut current_trace: Trace = Trace::default(); - current_trace.push((None, Rc::new(self))); + current_trace.push((None, Rc::new(sys))); let mut branch = vec![0]; let mut depth = 0; let mut new_branch = true; @@ -293,6 +312,57 @@ impl ExtensionsSystem for T { Ok(res) } + + #[allow(clippy::field_reassign_with_default)] + #[allow(clippy::type_complexity)] + fn slice_trace( + &self, + ) -> Result, String> { + let mut trace = SlicingTrace::default(); + + trace.context_elements = Rc::new(self.context_elements()); + trace.products_elements = Rc::new(self.products_elements()); + trace.reactions = Rc::new(self.reactions().clone()); + trace.systems.push(Rc::new(self.clone())); + trace.elements.push(SlicingElement::from(( + Self::Set::default(), + self.available_entities().clone(), + ))); + + let current: Option<(Self::Set, Self::Set, Vec, Self)> = + self.to_slicing_iterator()?.next(); + if current.is_none() { + return Ok(trace); + } + let current = current.unwrap(); + + let (context, products, enabled_reactions, mut current) = current; + trace + .elements + .push(SlicingElement::from((context, products))); + trace + .enabled_reactions + .push(EnabledReactions::from(enabled_reactions)); + trace.systems.push(Rc::new(current.clone())); + + loop { + let t = current.to_slicing_iterator()?.next(); + if let Some((context, products, enabled_reactions, next_sys)) = t { + current = next_sys; + trace + .elements + .push(SlicingElement::from((context, products))); + trace + .enabled_reactions + .push(EnabledReactions::from(enabled_reactions)); + trace.systems.push(Rc::new(current.clone())); + } else { + break; + } + } + // trace.enabled_reactions.pop(); + Ok(trace) + } } // ----------------------------------------------------------------------------- @@ -433,6 +503,14 @@ impl BasicSystem for System { TransitionsIterator::::try_from(self) } + #[allow(refining_impl_trait)] // otherwise impl cannot be resolved to + // concrete type and the compiler complains + fn to_slicing_iterator( + &self, + ) -> Result, String> { + unimplemented!() + } + fn environment(&self) -> &Self::Environment { &self.delta } @@ -454,7 +532,8 @@ impl BasicSystem for System { if c.is_some() { c.as_ref().unwrap().clone() } else { - let all_elements_context = self.delta + let all_elements_context = self + .delta .all_elements() .union(&self.context_process.all_elements()) .subtraction(&self.products_elements()); @@ -469,10 +548,12 @@ impl BasicSystem for System { if p.is_some() { p.as_ref().unwrap().clone() } else { - let products_elements = self.reaction_rules + let products_elements = self + .reaction_rules .iter() - .fold(Self::Set::default(), |acc: Self::Set, r| - acc.union(&r.products)); + .fold(Self::Set::default(), |acc: Self::Set, r| { + acc.union(&r.products) + }); *p = Some(products_elements.clone()); products_elements @@ -729,6 +810,15 @@ impl BasicSystem for PositiveSystem { TransitionsIterator::::try_from(self) } + fn to_slicing_iterator( + &self, + ) -> Result< + impl Iterator, Self)>, + String, + > { + TraceIterator::::try_from(self) + } + fn environment(&self) -> &Self::Environment { &self.delta } @@ -750,10 +840,14 @@ impl BasicSystem for PositiveSystem { if c.is_some() { c.as_ref().unwrap().clone() } else { - let all_elements_context = self.delta + let all_elements_context = self + .delta .all_elements() .union(&self.context_process.all_elements()) - .subtraction(&self.products_elements()); + .subtraction(&self.products_elements()) + .iter() + .map(|e| (*e.0, IdState::Positive)) + .collect::(); *c = Some(all_elements_context.clone()); all_elements_context @@ -765,10 +859,15 @@ impl BasicSystem for PositiveSystem { if p.is_some() { p.as_ref().unwrap().clone() } else { - let products_elements = self.reaction_rules + let products_elements = self + .reaction_rules .iter() - .fold(Self::Set::default(), |acc: Self::Set, r| - acc.union(&r.products)); + .fold(Self::Set::default(), |acc: Self::Set, r| { + acc.union(&r.products) + }) + .iter() + .map(|e| (*e.0, IdState::Positive)) + .collect::(); *p = Some(products_elements.clone()); products_elements @@ -938,4 +1037,11 @@ impl PositiveSystem { products_elements: Rc::new(RefCell::new(None)), } } + + pub fn negated_products_elements(&self) -> PositiveSet { + self.products_elements() + .iter() + .map(|el| (*el.0, IdState::Negative)) + .collect::() + } } diff --git a/rsprocess/src/system_test.rs b/rsprocess/src/system_test.rs index b0025b0..0b9ac8a 100644 --- a/rsprocess/src/system_test.rs +++ b/rsprocess/src/system_test.rs @@ -1,5 +1,6 @@ use super::set::PositiveSet; use super::system::BasicSystem; +use crate::system::ExtensionsSystem; #[test] fn one_transition() { @@ -344,3 +345,88 @@ fn conversion_entities() { ]) ); } + +#[test] +fn slice_trace() { + use std::rc::Rc; + + use super::environment::Environment; + use super::process::Process; + use super::reaction::Reaction; + use super::set::Set; + use super::system::{PositiveSystem, System}; + + let mut translator = crate::translator::Translator::new(); + + let mut tr = |a| translator.encode(a); + + let system = System::from( + Rc::new(Environment::from([])), + Set::from([tr("a"), tr("b")]), + Process::EntitySet { + entities: Set::from([tr("c")]), + next_process: Rc::new(Process::EntitySet { + entities: Set::from([]), + next_process: Rc::new(Process::Nill), + }), + }, + Rc::new(vec![Reaction::from( + Set::from([tr("a")]), + Set::from([]), + Set::from([tr("b")]), + )]), + ); + + let system: PositiveSystem = system.into(); + + let res_slice = system.slice_trace().unwrap(); + let res_run = system.run().unwrap(); + + assert_eq!(res_slice.systems, res_run); +} + +#[test] +fn slice_trace_2() { + use std::rc::Rc; + + use super::environment::Environment; + use super::process::Process; + use super::reaction::Reaction; + use super::set::Set; + use super::system::{PositiveSystem, System}; + + let mut translator = crate::translator::Translator::new(); + + let mut tr = |a| translator.encode(a); + + let system = System::from( + Rc::new(Environment::from([])), + Set::from([tr("a"), tr("b")]), + Process::EntitySet { + entities: Set::from([tr("c")]), + next_process: Rc::new(Process::EntitySet { + entities: Set::from([]), + next_process: Rc::new(Process::Nill), + }), + }, + Rc::new(vec![ + Reaction::from( + Set::from([tr("a")]), + Set::from([tr("b")]), + Set::from([tr("b")]), + ), + Reaction::from( + Set::from([tr("b")]), + Set::from([tr("a")]), + Set::from([tr("a")]), + ), + ]), + ); + + let system: PositiveSystem = system.into(); + + let res_slice = system.slice_trace().unwrap(); + let res_run = system.run().unwrap(); + + assert_eq!(res_slice.systems, res_run); +} diff --git a/rsprocess/src/trace.rs b/rsprocess/src/trace.rs index a05d813..542666d 100644 --- a/rsprocess/src/trace.rs +++ b/rsprocess/src/trace.rs @@ -86,6 +86,15 @@ pub struct SlicingElement { pub reaction_products: S, } +impl From<(S, S)> for SlicingElement { + fn from(value: (S, S)) -> Self { + Self { + context: value.0, + reaction_products: value.1, + } + } +} + impl Debug for SlicingElement where S: Debug, @@ -126,6 +135,28 @@ pub struct EnabledReactions { pub data: Vec, } +impl From> for EnabledReactions { + fn from(value: Vec) -> Self { + Self { data: value } + } +} + +impl From<&[usize]> for EnabledReactions { + fn from(value: &[usize]) -> Self { + Self { + data: value.to_vec(), + } + } +} + +impl From<[usize; N]> for EnabledReactions { + fn from(value: [usize; N]) -> Self { + Self { + data: value.to_vec(), + } + } +} + impl PrintableWithTranslator for EnabledReactions { fn print( &self, @@ -160,10 +191,11 @@ impl EnabledReactions { } #[derive(Clone)] -pub struct SlicingTrace, - Sys: BasicSystem> -{ +pub struct SlicingTrace< + S: BasicSet, + R: BasicReaction, + Sys: BasicSystem, +> { pub elements: Vec>, pub enabled_reactions: Vec, @@ -174,10 +206,11 @@ pub struct SlicingTrace, } -impl, - Sys: BasicSystem> - Default for SlicingTrace +impl< + S: BasicSet, + R: BasicReaction, + Sys: BasicSystem, +> Default for SlicingTrace { fn default() -> Self { Self { @@ -191,10 +224,11 @@ impl, - Sys: BasicSystem> - SlicingTrace +impl< + S: BasicSet + Debug, + R: BasicReaction, + Sys: BasicSystem, +> SlicingTrace { pub fn is_empty(&self) -> bool { self.elements.is_empty() @@ -205,7 +239,6 @@ impl { pub fn slice(&self, marking: Set) -> Result { let mut reversed_elements = Vec::with_capacity(self.elements.len()); @@ -295,7 +328,8 @@ impl SlicingTrace { for r in self.enabled_reactions[i].iter() { if !reversed_elements[reverse_i - 1] .reaction_products - .intersection(self.reactions[*r].products()).is_empty() + .intersection(self.reactions[*r].products()) + .is_empty() { reversed_enabled_reactions[reverse_i - 1].data.push(*r); reversed_elements[reverse_i].context.push( @@ -328,11 +362,11 @@ impl SlicingTrace { } } - -impl, - Sys: BasicSystem,> - PrintableWithTranslator for SlicingTrace +impl< + S: BasicSet, + R: BasicReaction, + Sys: BasicSystem, +> PrintableWithTranslator for SlicingTrace { fn print( &self, diff --git a/rsprocess/src/trace_test.rs b/rsprocess/src/trace_test.rs index 945b78e..8b70034 100644 --- a/rsprocess/src/trace_test.rs +++ b/rsprocess/src/trace_test.rs @@ -2,7 +2,7 @@ use std::rc::Rc; use crate::element::IdState; use crate::reaction::{BasicReaction, PositiveReaction, Reaction}; -use crate::set::{ExtensionsSet, PositiveSet, Set, BasicSet}; +use crate::set::{BasicSet, ExtensionsSet, PositiveSet, Set}; use crate::system::{PositiveSystem, System}; use crate::trace::*; use crate::translator::Translator; @@ -82,13 +82,14 @@ fn slice_atoi() { .map(|el| translator.encode(*el)) .collect::>() .into(); - let products_elements = - ["rorgt", "stat3", "il21r", "il6r", "nfat", "stat1", "tbet", "il21", - "il23r"] - .iter() - .map(|el| translator.encode(*el)) - .collect::>() - .into(); + let products_elements = [ + "rorgt", "stat3", "il21r", "il6r", "nfat", "stat1", "tbet", "il21", + "il23r", + ] + .iter() + .map(|el| translator.encode(*el)) + .collect::>() + .into(); let trace: SlicingTrace = SlicingTrace { elements, @@ -205,72 +206,129 @@ fn slice_positive_atoi() { ); let converted_system: PositiveSystem = system.into(); - let mut reactions = Rc::try_unwrap(converted_system.reaction_rules).unwrap(); - reactions.sort_by(|a, b| a.reactants.cmp(&b.reactants) - .then(a.products.cmp(&b.products))); + let mut reactions = + Rc::try_unwrap(converted_system.reaction_rules).unwrap(); + reactions.sort_by(|a, b| { + a.reactants + .cmp(&b.reactants) + .then(a.products.cmp(&b.products)) + }); println!("Computed Reactions:"); for (pos, r) in reactions.iter().enumerate() { - println!("\t({pos}) {},", crate::translator::Formatter::from(&translator, r)); + println!( + "\t({pos}) {},", + crate::translator::Formatter::from(&translator, r) + ); } reactions }; let elements = [ - (vec![("il23r", IdState::Positive), ("il21", IdState::Positive), - ("rorgt", IdState::Negative), ("stat3", IdState::Negative), - ("il21r", IdState::Negative), ("il6r", IdState::Negative), - ("nfat", IdState::Negative), ("stat1", IdState::Negative), - ("tbet", IdState::Negative), ("tgfbr", IdState::Negative), - ("foxp3", IdState::Negative)], - vec![("tcr", IdState::Positive), ("tgfb", IdState::Negative), - ("il6", IdState::Negative), ("il27", IdState::Negative)]), - (vec![("il21r", IdState::Positive), ("stat3", IdState::Positive), - ("nfat", IdState::Positive), ("rorgt", IdState::Negative), - ("il6r", IdState::Negative), ("stat1", IdState::Negative), - ("tbet", IdState::Negative), ("il21", IdState::Negative), - ("il23r", IdState::Negative), ("tgfbr", IdState::Negative), - ("foxp3", IdState::Negative)], - vec![("il27", IdState::Positive), ("tgfb", IdState::Negative), - ("il6", IdState::Negative), ("tcr", IdState::Negative)]), - (vec![("stat1", IdState::Positive), ("rorgt", IdState::Negative), - ("stat3", IdState::Negative), ("il21r", IdState::Negative), - ("il6r", IdState::Negative), ("nfat", IdState::Negative), - ("tbet", IdState::Negative), ("il21", IdState::Negative), - ("il23r", IdState::Negative), ("tgfbr", IdState::Negative), - ("foxp3", IdState::Negative)], - vec![("il27", IdState::Negative), ("tgfb", IdState::Negative), - ("il6", IdState::Negative), ("tcr", IdState::Negative)]), - (vec![("tbet", IdState::Positive), ("rorgt", IdState::Negative), - ("stat3", IdState::Negative), ("il21r", IdState::Negative), - ("il6r", IdState::Negative), ("nfat", IdState::Negative), - ("stat1", IdState::Negative), ("il21", IdState::Negative), - ("il23r", IdState::Negative), ("tgfbr", IdState::Negative), - ("foxp3", IdState::Negative)], - vec![]), + ( + vec![ + ("il23r", IdState::Positive), + ("il21", IdState::Positive), + ("rorgt", IdState::Negative), + ("stat3", IdState::Negative), + ("il21r", IdState::Negative), + ("il6r", IdState::Negative), + ("nfat", IdState::Negative), + ("stat1", IdState::Negative), + ("tbet", IdState::Negative), + ("tgfbr", IdState::Negative), + ("foxp3", IdState::Negative), + ], + vec![ + ("tcr", IdState::Positive), + ("tgfb", IdState::Negative), + ("il6", IdState::Negative), + ("il27", IdState::Negative), + ], + ), + ( + vec![ + ("il21r", IdState::Positive), + ("stat3", IdState::Positive), + ("nfat", IdState::Positive), + ("rorgt", IdState::Negative), + ("il6r", IdState::Negative), + ("stat1", IdState::Negative), + ("tbet", IdState::Negative), + ("il21", IdState::Negative), + ("il23r", IdState::Negative), + ("tgfbr", IdState::Negative), + ("foxp3", IdState::Negative), + ], + vec![ + ("il27", IdState::Positive), + ("tgfb", IdState::Negative), + ("il6", IdState::Negative), + ("tcr", IdState::Negative), + ], + ), + ( + vec![ + ("stat1", IdState::Positive), + ("rorgt", IdState::Negative), + ("stat3", IdState::Negative), + ("il21r", IdState::Negative), + ("il6r", IdState::Negative), + ("nfat", IdState::Negative), + ("tbet", IdState::Negative), + ("il21", IdState::Negative), + ("il23r", IdState::Negative), + ("tgfbr", IdState::Negative), + ("foxp3", IdState::Negative), + ], + vec![ + ("il27", IdState::Negative), + ("tgfb", IdState::Negative), + ("il6", IdState::Negative), + ("tcr", IdState::Negative), + ], + ), + ( + vec![ + ("tbet", IdState::Positive), + ("rorgt", IdState::Negative), + ("stat3", IdState::Negative), + ("il21r", IdState::Negative), + ("il6r", IdState::Negative), + ("nfat", IdState::Negative), + ("stat1", IdState::Negative), + ("il21", IdState::Negative), + ("il23r", IdState::Negative), + ("tgfbr", IdState::Negative), + ("foxp3", IdState::Negative), + ], + vec![], + ), ] - .iter() - .map(|elements| SlicingElement { - context: Into::::into( - elements - .1 - .iter() - .map(|el| (translator.encode(el.0), el.1)) - .collect::>()), - reaction_products: Into::::into( - elements - .0 - .iter() - .map(|el| (translator.encode(el.0), el.1)) - .collect::>()), - }) - .collect::>(); - + .iter() + .map(|elements| SlicingElement { + context: Into::::into( + elements + .1 + .iter() + .map(|el| (translator.encode(el.0), el.1)) + .collect::>(), + ), + reaction_products: Into::::into( + elements + .0 + .iter() + .map(|el| (translator.encode(el.0), el.1)) + .collect::>(), + ), + }) + .collect::>(); let enabled_reactions = { let mut enabled_reactions = vec![]; for slice_el in elements.iter().rev().skip(1).rev() { - let available_enteties = slice_el.context.union(&slice_el.reaction_products); + let available_enteties = + slice_el.context.union(&slice_el.reaction_products); enabled_reactions.push(vec![]); for (pos, r) in reactions.iter().enumerate() { if r.enabled(&available_enteties) { @@ -278,28 +336,29 @@ fn slice_positive_atoi() { } } } - enabled_reactions.into_iter() - .map(|r| EnabledReactions { - data: r, - }) + enabled_reactions + .into_iter() + .map(|r| EnabledReactions { data: r }) .collect::>() }; - let context_elements = - Into::::into( - ["tgfb", "il6", "tcr", "il27"] - .iter() - .map(|el| translator.encode(*el)) - .collect::>() - ).to_positive_set(IdState::Positive); - let products_elements = - Into::::into( - ["rorgt", "stat3", "il21r", "il6r", "nfat", "stat1", "tbet", "il21", - "il23r", "tgfbr", "foxp3"] - .iter() - .map(|el| translator.encode(*el)) - .collect::>() - ).to_positive_set(IdState::Positive); + let context_elements = Into::::into( + ["tgfb", "il6", "tcr", "il27"] + .iter() + .map(|el| translator.encode(*el)) + .collect::>(), + ) + .to_positive_set(IdState::Positive); + let products_elements = Into::::into( + [ + "rorgt", "stat3", "il21r", "il6r", "nfat", "stat1", "tbet", "il21", + "il23r", "tgfbr", "foxp3", + ] + .iter() + .map(|el| translator.encode(*el)) + .collect::>(), + ) + .to_positive_set(IdState::Positive); let trace: SlicingTrace = SlicingTrace { @@ -312,13 +371,13 @@ fn slice_positive_atoi() { products_elements: Rc::new(products_elements), }; - let marking = - Into::::into( - ["tbet"] - .iter() - .map(|el| translator.encode(*el)) - .collect::>() - ).to_positive_set(IdState::Positive); + let marking = Into::::into( + ["tbet"] + .iter() + .map(|el| translator.encode(*el)) + .collect::>(), + ) + .to_positive_set(IdState::Positive); let sliced = trace.slice(marking).unwrap(); @@ -334,14 +393,19 @@ fn slice_positive_atoi() { }) .collect::>(); reaction_products.iter_mut().for_each(|x| x.sort()); - let mut correct_reaction_products: Vec> = - [vec![("foxp3", IdState::Negative)], - vec![("nfat", IdState::Positive), ("tgfbr", IdState::Negative)], - vec![("stat1", IdState::Positive), ("foxp3", IdState::Negative), - ("rorgt", IdState::Negative)], - vec![("tbet", IdState::Positive)]] - .iter().map(|x| x.iter().map(|y| (y.0.to_string(), y.1)) - .collect::>()).collect::>(); + let mut correct_reaction_products: Vec> = [ + vec![("foxp3", IdState::Negative)], + vec![("nfat", IdState::Positive), ("tgfbr", IdState::Negative)], + vec![ + ("stat1", IdState::Positive), + ("foxp3", IdState::Negative), + ("rorgt", IdState::Negative), + ], + vec![("tbet", IdState::Positive)], + ] + .iter() + .map(|x| x.iter().map(|y| (y.0.to_string(), y.1)).collect::>()) + .collect::>(); correct_reaction_products.iter_mut().for_each(|x| x.sort()); assert_eq!(reaction_products, correct_reaction_products); @@ -358,13 +422,15 @@ fn slice_positive_atoi() { }) .collect::>(); context.iter_mut().for_each(|x| x.sort()); - let mut correct_context = - [vec![("tcr", IdState::Positive)], - vec![("il27", IdState::Positive)], - vec![], - vec![]] - .iter().map(|x| x.iter().map(|y| (y.0.to_string(), y.1)) - .collect::>()).collect::>(); + let mut correct_context = [ + vec![("tcr", IdState::Positive)], + vec![("il27", IdState::Positive)], + vec![], + vec![], + ] + .iter() + .map(|x| x.iter().map(|y| (y.0.to_string(), y.1)).collect::>()) + .collect::>(); correct_context.iter_mut().for_each(|x| x.sort()); assert_eq!(context, correct_context); diff --git a/rsprocess/src/transitions.rs b/rsprocess/src/transitions.rs index d061fe9..bd9df6c 100644 --- a/rsprocess/src/transitions.rs +++ b/rsprocess/src/transitions.rs @@ -187,6 +187,7 @@ impl<'a> Iterator ); let new_system = PositiveSystem::from( Rc::clone(&self.system.delta), + // products.add_unique(&self.system.negated_products_elements()), products, (*k).clone(), Rc::clone(&self.system.reaction_rules), @@ -224,6 +225,14 @@ impl<'a> TryFrom<&'a PositiveSystem> } } +impl<'a> Iterator for TraceIterator<'a, Set, System, Process> { + type Item = (Set, Set, Vec, System); + + fn next(&mut self) -> Option { + unimplemented!() + } +} + impl<'a> Iterator for TraceIterator<'a, PositiveSet, PositiveSystem, PositiveProcess> { @@ -249,14 +258,16 @@ impl<'a> Iterator let new_system = PositiveSystem::from( Rc::clone(&self.system.delta), - all_products, + // all_products.add_unique(&self.system. + // negated_products_elements()), + all_products.clone(), (*k).clone(), Rc::clone(&self.system.reaction_rules), ); Some(( context.as_ref().clone(), - self.system.available_entities().clone(), + all_products.mask(&self.system.products_elements()), enabled_reaction_positions, new_system, ))