Optimized flow node execution by only trying to execute flow nodes that have incoming tokens

core/src/bpmn/collaboration.rs

@@ -170,8 +170,20 @@ impl Collaboration {
                     panic!("No process found for snapshot with id \"{}\"", snapshot.id)
                 }
                 Some(process) => {
-                    // TODO: Would be nice to only try to execute flow nodes that have incoming tokens/messages. But currently sfs are contained in flow nodes not in the process itself.
-                    for flow_node in process.flow_nodes.iter() {
+                    // Only try to execute flow nodes that have incoming tokens.
+                    let mut flow_node_indexes: Vec<&usize> = snapshot
+                        .tokens
+                        .iter()
+                        .filter_map(|(&token_position, _)| {
+                            process.sequence_flow_index.get(token_position)
+                        })
+                        .collect();
+                    flow_node_indexes.sort();
+                    flow_node_indexes.dedup(); // Do not try to execute a flow node twice.
+                    for flow_node in flow_node_indexes
+                        .iter()
+                        .filter_map(|&flow_node_idx| process.flow_nodes.get(*flow_node_idx))
+                    {
                         let new_states = flow_node.try_execute(
                             snapshot,
                             state,

core/src/bpmn/process.rs

@@ -1,9 +1,11 @@
 use crate::bpmn::flow_node::{FlowNode, SequenceFlow};
+use std::collections::HashMap;
 
 #[derive(Debug, PartialEq)]
 pub struct Process {
     pub id: String,
     pub flow_nodes: Vec<FlowNode>,
+    pub sequence_flow_index: HashMap<String, usize>, // Map from sf_id to target flow node index.
 }
 
 impl Process {
@@ -16,6 +18,8 @@ impl Process {
         let target_idx = self.find_flow_node_idx_by_id(target_ref);
         match (source_idx, target_idx) {
             (Some(source_idx), Some(target_idx)) => {
+                self.sequence_flow_index.insert(id.clone(), target_idx);
+
                 let source = self.flow_nodes.get_mut(source_idx).unwrap();
                 source.add_outgoing_flow(SequenceFlow {
                     id: id.clone(),

core/src/bpmn/reader.rs

@@ -3,6 +3,7 @@ use crate::bpmn::flow_node::{EventType, FlowNode, FlowNodeType, TaskType};
 use crate::bpmn::process::Process;
 use quick_xml::events::{BytesStart, Event};
 use quick_xml::reader::Reader;
+use std::collections::HashMap;
 use std::{fmt, fs};
 
 #[derive(Debug)]
@@ -50,8 +51,7 @@ pub fn read_bpmn_from_string(
             Ok(Event::Start(e)) => match e.local_name().as_ref() {
                 b"process" => {
                     add_participant(&mut collaboration, &e);
-                    current_participant =
-                        Some(get_attribute_value_or_panic(&e, &String::from("id")));
+                    current_participant = Some(get_attribute_value_or_panic(&e, "id"));
                 }
                 b"subProcess" => {
                     if has_true_attribute_value(&e, "triggeredByEvent") {
@@ -192,7 +192,7 @@ pub fn read_bpmn_from_string(
     if !unsupported_elements.is_empty() {
         let unsupported_elements: Vec<String> = unsupported_elements
             .iter()
-            .map(|e| get_attribute_value_or_panic(e, &String::from("id")))
+            .map(|e| get_attribute_value_or_panic(e, "id"))
             .collect();
         return Err(UnsupportedBpmnElementsError {
             unsupported_elements,
@@ -218,10 +218,11 @@ fn read_file(path: &str) -> String {
 }
 
 fn add_participant(collaboration: &mut Collaboration, p_bytes: &BytesStart) {
-    let id = get_attribute_value_or_panic(p_bytes, &String::from("id"));
+    let id = get_attribute_value_or_panic(p_bytes, "id");
     collaboration.add_participant(Process {
         id,
-        flow_nodes: Vec::new(),
+        flow_nodes: vec![],
+        sequence_flow_index: HashMap::new(),
     });
 }
 
@@ -245,7 +246,7 @@ fn add_flow_node(
     flow_node_bytes: &BytesStart,
     flow_node_type: FlowNodeType,
 ) {
-    let id = get_attribute_value_or_panic(flow_node_bytes, &String::from("id"));
+    let id = get_attribute_value_or_panic(flow_node_bytes, "id");
     let last_participant = collaboration.participants.last_mut();
     match last_participant {
         None => {

core/src/bpmn/reader_test.rs

@@ -5,6 +5,7 @@ mod tests {
     use crate::bpmn::flow_node::{EventType, FlowNode, TaskType};
     use crate::bpmn::process::Process;
     use crate::bpmn::reader::read_bpmn_from_file;
+    use std::collections::HashMap;
 
     const PATH: &str = "tests/resources/unit/";
 
@@ -36,7 +37,8 @@ mod tests {
         };
         let mut process = Process {
             id: String::from("process_id"),
-            flow_nodes: Vec::new(),
+            flow_nodes: vec![],
+            sequence_flow_index: HashMap::new(),
         };
         process.add_flow_node(FlowNode::new(
             String::from("start"),