fix : calc without temporal dto changes + avoid manual handroll

Author: Math-R

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

@@ -22,6 +22,7 @@ import {
   BackwardTrainrunIterator,
   NonStopTrainrunIterator,
   TrainrunIterator,
+  ExpandedTrainrunIterator,
 } from "../util/trainrun.iterator";
 import {LogService} from "../../logger/log.service";
 import {LabelService} from "./label.service";
@@ -799,6 +800,10 @@ export class TrainrunService {
   public getBackwardNonStopIterator(node: Node, trainrunSection: TrainrunSection) {
     return new BackwardNonStopTrainrunIterator(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> {

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

@@ -1472,67 +1472,45 @@ 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;
-    }> = [];
+  groupTrainrunSectionsIntoChains(trainrunSections: TrainrunSection[]): TrainrunSection[][] {
+    const groups: TrainrunSection[][] = [];
     const visitedSections = new Set<number>();
 
     trainrunSections.forEach((section) => {
       if (visitedSections.has(section.getId())) {
         return;
       }
 
-      // Start a new group from this section
+      // Build chain using TrainrunIterator to leverage existing graph traversal
       const chain: TrainrunSection[] = [];
-      let currentSection = section;
-
-      // Add the first section
-      chain.push(currentSection);
-      visitedSections.add(currentSection.getId());
-
-      // Look for consecutive sections with collapsed intermediate nodes
-      // 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
+      const startNode = section.getSourceNode();
+      const iterator = this.trainrunService.getIterator(startNode, section);
+
+      // Traverse the trainrun and collect sections with collapsed intermediate nodes
+      while (iterator.hasNext()) {
+        const pair = iterator.next();
+
+        if (visitedSections.has(pair.trainrunSection.getId())) {
+          break; // Already processed this section
         }
 
-        // 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
+        chain.push(pair.trainrunSection);
+        visitedSections.add(pair.trainrunSection.getId());
+
+        // Stop if we reach a non-collapsed node (end of collapsed chain)
+        if (!pair.node.getIsCollapsed()) {
+          break;
         }
-        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,
-      });
+      if (chain.length > 0) {
+        groups.push(chain);
+      }
     });
 
     return groups;

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

@@ -135,3 +135,17 @@ export class BackwardNonStopTrainrunIterator extends BackwardTrainrunIterator {
     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,12 @@ export class TrainrunSectionViewObject {
     d.getPath().forEach((p) => {
       key += p.toString();
     });
+
+    key += "_SRC_" + d.getSourceNode().getPositionX() + "_" + d.getSourceNode().getPositionY();
+    key += "_TRG_" + d.getTargetNode().getPositionX() + "_" + d.getTargetNode().getPositionY();
+
     return key;
   }
+
+
 }