Refactoring :), in the middle of so please be patient

src/rsprocess/process.rs

@@ -0,0 +1,122 @@
+use super::translator::IdType;
+use std::collections::VecDeque;
+use std::hash::Hash;
+use std::rc::Rc;
+use serde::{Deserialize, Serialize};
+
+use super::set::Set;
+use super::reaction::Reaction;
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum Process {
+    Nill,
+    RecursiveIdentifier {
+	identifier: IdType,
+    },
+    EntitySet {
+	entities: Set,
+	next_process: Rc<Process>,
+    },
+    Guarded {
+	reaction: Reaction,
+	next_process: Rc<Process>,
+    },
+    WaitEntity {
+	repeat: i64,
+	repeated_process: Rc<Process>,
+	next_process: Rc<Process>,
+    },
+    Summation {
+	children: Vec<Rc<Process>>,
+    },
+    NondeterministicChoice {
+	children: Vec<Rc<Process>>,
+    },
+}
+
+impl Process {
+    // TODO: remove all the clone()
+    pub fn concat(&self, new: &Process) -> Process {
+	match (self, new) {
+	    (
+		Process::NondeterministicChoice { children: c1 },
+		Process::NondeterministicChoice { children: c2 },
+	    ) => Process::NondeterministicChoice {
+		children: [c1.clone(), c2.clone()].concat(),
+	    },
+	    (Process::NondeterministicChoice { children }, new)
+	    | (new, Process::NondeterministicChoice { children }) => {
+		let mut new_children = children.clone();
+		new_children.push(Rc::new(new.clone()));
+		Process::NondeterministicChoice {
+		    children: new_children,
+		}
+	    }
+	    (_, _) => Process::NondeterministicChoice {
+		children: vec![Rc::new(self.clone()), Rc::new(new.clone())],
+	    },
+	}
+    }
+
+    /// returns all elements used
+    pub fn all_elements(&self) -> Set {
+	let mut queue = VecDeque::from([self]);
+	let mut elements = Set::new();
+
+	while let Some(el) = queue.pop_front() {
+	    match el {
+		Self::Nill => {}
+		Self::RecursiveIdentifier { identifier: _ } => {}
+		Self::EntitySet {
+		    entities,
+		    next_process,
+		} => {
+		    elements.push(entities);
+		    queue.push_back(next_process);
+		}
+		Self::Guarded { reaction, next_process } => {
+		    elements.push(&reaction.reactants);
+		    elements.push(&reaction.inhibitors);
+		    elements.push(&reaction.products);
+		    queue.push_back(next_process);
+		}
+		Self::WaitEntity {
+		    repeat: _,
+		    repeated_process,
+		    next_process,
+		} => {
+		    queue.push_back(repeated_process);
+		    queue.push_back(next_process);
+		}
+		Self::Summation { children } => {
+		    for c in children {
+			queue.push_back(c);
+		    }
+		}
+		Self::NondeterministicChoice { children } => {
+		    for c in children {
+			queue.push_back(c);
+		    }
+		}
+	    }
+	}
+	elements
+    }
+
+
+    /// Finds only the rules X = pre(Q, rec(X)), but not only x = pre(Q, rec(x))
+    /// to use in filter_map.
+    pub fn filter_delta<'a>(
+	&'a self,
+	id: &IdType
+    ) -> Option<&'a Set> {
+	if let Self::EntitySet { entities, next_process } = self
+	    && let Self::RecursiveIdentifier { identifier } = &**next_process
+	    && identifier == id
+	{
+	    return Some(entities);
+	}
+
+	None
+    }
+}