Working positive rs

src/rsprocess/transitions.rs

@@ -2,24 +2,27 @@
 
 use std::rc::Rc;
 
-use super::label::Label;
-use super::process::Process;
-use super::set::{BasicSet, Set};
-use super::system::System;
+use super::label::{Label, PositiveLabel};
+use super::process::{BasicProcess, PositiveProcess, Process};
+use super::set::{BasicSet, PositiveSet, Set};
+use super::system::{BasicSystem, PositiveSystem, System};
 use super::reaction::BasicReaction;
+use super::environment::BasicEnvironment;
 
 #[derive(Clone, Debug)]
-pub struct TransitionsIterator<'a> {
-    choices_iterator: std::vec::IntoIter<(Rc<Set>, Rc<Process>)>,
-    system: &'a System,
+pub struct TransitionsIterator<'a, S: BasicSet,
+			       Sys: BasicSystem<Set = S>,
+			       Proc: BasicProcess<Set = S>> {
+    choices_iterator: std::vec::IntoIter<(Rc<S>, Rc<Proc>)>,
+    system: &'a Sys,
 }
 
-impl<'a> TransitionsIterator<'a> {
+impl<'a> TransitionsIterator<'a, Set, System, Process> {
     pub fn from(
 	system: &'a System
-    ) -> Result<TransitionsIterator<'a>, String> {
-        match system.delta.unfold(&system.context_process,
-				  &system.available_entities) {
+    ) -> Result<Self, String> {
+        match system.environment().unfold(system.context(),
+					  system.available_entities()) {
             Ok(o) => Ok(TransitionsIterator {
                 choices_iterator: o.into_iter(),
                 system,
@@ -29,7 +32,7 @@ impl<'a> TransitionsIterator<'a> {
     }
 }
 
-impl<'a> Iterator for TransitionsIterator<'a> {
+impl<'a> Iterator for TransitionsIterator<'a, Set, System, Process> {
     type Item = (Label, System);
 
     /// Creates the next arc from the current system.
@@ -91,3 +94,75 @@ impl<'a> Iterator for TransitionsIterator<'a> {
         Some((label, new_system))
     }
 }
+
+// -----------------------------------------------------------------------------
+
+impl<'a> TransitionsIterator<'a, PositiveSet, PositiveSystem, PositiveProcess> {
+    pub fn from(
+	system: &'a PositiveSystem
+    ) -> Result<Self, String> {
+	match system.environment().unfold(system.context(),
+					  system.available_entities()) {
+            Ok(o) => Ok(TransitionsIterator {
+                choices_iterator: o.into_iter(),
+                system,
+	    }),
+            Err(e) => Err(e),
+        }
+    }
+}
+
+impl<'a> Iterator for
+    TransitionsIterator<'a, PositiveSet, PositiveSystem, PositiveProcess> {
+    type Item = (PositiveLabel, PositiveSystem);
+
+    /// Creates the next arc from the current system.
+    fn next(&mut self) -> Option<Self::Item> {
+	let (c, k) = self.choices_iterator.next()?;
+        let t = self.system.available_entities.union(c.as_ref());
+        let (
+	    reactants,
+	    reactants_absent,
+	    products
+	) =
+            self.system.reaction_rules.iter().fold(
+                (
+                    PositiveSet::default(), // reactants
+                    PositiveSet::default(), // reactants_absent
+                    PositiveSet::default(), // products
+                ),
+                |acc, reaction| {
+                    if reaction.enabled(&t) {
+			(
+                            acc.0.union(&reaction.reactants),
+                            acc.1,
+                            acc.2.union(&reaction.products),
+			)
+                    } else {
+                        (
+                            acc.0,
+			    // TODO is this right?
+                            acc.1.union(&reaction.reactants.intersection(&t)),
+                            acc.2,
+                        )
+                    }
+                },
+            );
+
+        let label = PositiveLabel::from(
+            self.system.available_entities.clone(),
+            (*c).clone(),
+            t,
+            reactants,
+            reactants_absent,
+            products.clone(),
+        );
+        let new_system = PositiveSystem::from(
+            Rc::clone(&self.system.delta),
+            products,
+            (*k).clone(),
+            Rc::clone(&self.system.reaction_rules),
+        );
+        Some((label, new_system))
+    }
+}