fix(#8): the longest commit sequences are now retrieved non-recursively to prevent stack overflow

Author: AlexanderSchultheiss

src/main/java/org/variantsync/vevos/simulation/variability/sequenceextraction/LongestNonOverlappingSequences.java

@@ -83,29 +83,52 @@ public List<NonEmptyList<SPLCommit>> extract(final Collection<SPLCommit> commits
             }
         }
 
+        // Sort the sequences once more, after filtering them
+        commitSequences.sort((o1, o2) -> Integer.compare(o2.size(), o1.size()));
         return commitSequences;
     }
 
-    // Recursively build sequences
     private static Set<LinkedList<SPLCommit>> retrieveSequencesForStart(final Map<SPLCommit, Set<SPLCommit>> parentChildMap, final SPLCommit start) {
-        if (!parentChildMap.containsKey(start)) {
-            // Create a new sequence that contains the start commit
-            final Set<LinkedList<SPLCommit>> sequenceSet = new HashSet<>();
+        // Set for holding all retrieved sequences
+        Set<LinkedList<SPLCommit>> sequenceSet = new HashSet<>();
+        {
+            // We start with the 'start' commit
             final LinkedList<SPLCommit> sequence = new LinkedList<>();
             sequence.add(start);
             sequenceSet.add(sequence);
-            return sequenceSet;
-        } else {
-            // Collect the sequences of the children and prepend the commit to each of them as parent
-            final Set<LinkedList<SPLCommit>> sequences = new HashSet<>();
-            for (final SPLCommit child : parentChildMap.get(start)) {
-                final Set<LinkedList<SPLCommit>> childSequences = retrieveSequencesForStart(parentChildMap, child);
-                for (final LinkedList<SPLCommit> childSequence : childSequences) {
-                    childSequence.addFirst(start);
-                    sequences.add(childSequence);
+        }
+
+        // We continue to build sequences, going from parent to descendents, until the ends of all possible sequences have been reached
+        boolean incomplete = true;
+        while(incomplete) {
+            Set<LinkedList<SPLCommit>> updatedSet = new HashSet<>();
+            // Set to false at the start of the iteration, it is set to true if at least one sequence has been extended
+            incomplete = false;
+            // For all found sequences, check whether their last commit has more children that can be added to the sequence
+            // if multiple children exist, new sequences are created
+            for (LinkedList<SPLCommit> sequence : sequenceSet) {
+                final SPLCommit parent = sequence.getLast();
+                if (parentChildMap.containsKey(parent)) {
+                    final Set<SPLCommit> children = parentChildMap.get(parent);
+                    for (SPLCommit child : children) {
+                        // There is at least one child, we are not done yet
+                        incomplete = true;
+                        // Create a new sequence from the old sequence for each child
+                        final LinkedList<SPLCommit> anotherSequence = new LinkedList<>(sequence);
+                        anotherSequence.add(child);
+                        // Add the new sequence to the new set
+                        updatedSet.add(anotherSequence);
+                    }
+                } else {
+                    // There are no children, simply add the old sequence to the updated set
+                    updatedSet.add(sequence);
                 }
             }
-            return sequences;
+            // Update the sequence set
+            sequenceSet = updatedSet;
         }
+
+        return sequenceSet;
     }
 }
+