fix : calc without temporal dto changes + avoid manual handroll

Author: Math-R

src/app/services/data/trainrun.service.ts

@@ -17,7 +17,11 @@ import {DataService} from "./data.service";
 import {Node} from "../../models/node.model";
 import {TrainrunSection} from "../../models/trainrunsection.model";
 import {GeneralViewFunctions} from "../../view/util/generalViewFunctions";
-import {NonStopTrainrunIterator, TrainrunIterator} from "../util/trainrun.iterator";
+import {
+  NonStopTrainrunIterator,
+  TrainrunIterator,
+  ExpandedTrainrunIterator,
+} from "../util/trainrun.iterator";
 import {LogService} from "../../logger/log.service";
 import {LabelService} from "./label.service";
 import {FilterService} from "../ui/filter.service";
@@ -760,6 +764,10 @@ export class TrainrunService {
     return new NonStopTrainrunIterator(this.logService, node, trainrunSection);
   }
 
+  public getExpandedIterator(node: Node, trainrunSection: TrainrunSection) {
+    return new ExpandedTrainrunIterator(this.logService, node, trainrunSection);
+  }
+
   // For each trainrun, get iterator from the smallest consecutiveTime.
   public getRootIterators(): Map<number, TrainrunIterator> {
     const trainrunSections = this.trainrunSectionService.getTrainrunSections();

src/app/services/data/trainrunsection.service.ts

@@ -1472,19 +1472,16 @@ export class TrainrunSectionService implements OnDestroy {
 
   /**
    * Groups consecutive TrainrunSections that have collapsed nodes between them
-   * into chains with start and end nodes. Each chain starts and ends with a non-collapsed node.
+   * into chains. Each chain starts and ends with a non-collapsed node.
+   * Start and end nodes can be accessed via: sections[0].getSourceNode() and sections[sections.length - 1].getTargetNode()
    * @param trainrunSections List of TrainrunSections to group
-   * @returns Array of section groups with start/end nodes
+   * @returns Array of section chains
    */
   groupTrainrunSectionsIntoChains(trainrunSections: TrainrunSection[]): Array<{
     sections: TrainrunSection[];
-    startNode: Node;
-    endNode: Node;
   }> {
     const groups: Array<{
       sections: TrainrunSection[];
-      startNode: Node;
-      endNode: Node;
     }> = [];
     const visitedSections = new Set<number>();
 
@@ -1494,44 +1491,34 @@ export class TrainrunSectionService implements OnDestroy {
       }
 
       // Start a new group from this section
-      const chain: TrainrunSection[] = [];
-      let currentSection = section;
+      const chain: TrainrunSection[] = [section];
+      visitedSections.add(section.getId());
 
-      // Add the first section
-      chain.push(currentSection);
-      visitedSections.add(currentSection.getId());
+      const startNode = this.nodeService.getNodeFromId(section.getSourceNodeId());
+      let currentSection = section;
 
-      // Look for consecutive sections with collapsed intermediate nodes
+      // Continue traversing to find consecutive sections with collapsed intermediate nodes
+      // Use the node's getNextTrainrunSection method instead of manual search
       // eslint-disable-next-line no-constant-condition
       while (true) {
         const targetNode = this.nodeService.getNodeFromId(currentSection.getTargetNodeId());
         if (!targetNode || !targetNode.getIsCollapsed()) {
           break; // End of chain if target node is not collapsed
         }
 
-        // Find next section starting from this collapsed node
-        const nextSection = trainrunSections.find(
-          (ts) =>
-            ts.getSourceNodeId() === currentSection.getTargetNodeId() &&
-            ts.getTrainrunId() === currentSection.getTrainrunId() &&
-            !visitedSections.has(ts.getId()),
-        );
-        if (!nextSection) {
-          break; // No further section found, end of chain
+        // Use the node's getNextTrainrunSection method to find the connected section
+        const nextSection = targetNode.getNextTrainrunSection(currentSection);
+        if (!nextSection || visitedSections.has(nextSection.getId())) {
+          break; // No further section found or already visited, end of chain
         }
+
         chain.push(nextSection);
         visitedSections.add(nextSection.getId());
         currentSection = nextSection;
       }
 
-      // Create group with start and end nodes
-      const startNode = this.nodeService.getNodeFromId(chain[0].getSourceNodeId());
-      const endNode = this.nodeService.getNodeFromId(chain[chain.length - 1].getTargetNodeId());
-
       groups.push({
         sections: chain,
-        startNode: startNode,
-        endNode: endNode,
       });
     });
 

src/app/services/util/trainrun.iterator.ts

@@ -84,3 +84,17 @@ export class NonStopTrainrunIterator extends TrainrunIterator {
     return super.next();
   }
 }
+
+export class ExpandedTrainrunIterator extends TrainrunIterator {
+  public next(): TrainrunSectionNodePair {
+    // Continue traversing only if the current node is collapsed
+    // Stop when we reach an expanded (non-collapsed) node
+    if (!this.pointerElement.node.getIsCollapsed()) {
+      // The trainrun has reached an expanded (non-collapsed) node and break the forward iteration
+      this.currentElement = Object.assign({}, this.pointerElement);
+      this.pointerElement = new TrainrunSectionNodePair(undefined, undefined);
+      return this.currentElement;
+    }
+    return super.next();
+  }
+}

src/app/view/editor-main-view/data-views/trainrunSectionViewObject.ts

@@ -156,6 +156,17 @@ export class TrainrunSectionViewObject {
     d.getPath().forEach((p) => {
       key += p.toString();
     });
+
+    // Include source and target node positions to detect when they move
+    key += "_SRC_" + d.getSourceNode().getPositionX() + "_" + d.getSourceNode().getPositionY();
+    key += "_TRG_" + d.getTargetNode().getPositionX() + "_" + d.getTargetNode().getPositionY();
+
+    // Disable cache for collapsed chains to ensure proper recalculation
+    // TODO: Optimize by including only relevant node positions
+    if (d.getSourceNode().getIsCollapsed() || d.getTargetNode().getIsCollapsed()) {
+      key += "_NOCACHE_" + Date.now();
+    }
+
     return key;
   }
 }