refactoring: Domino Sorting is now a sequence extractor; Interface for SequenceExtractors

Author: pmbittner

src/main/java/de/variantsync/evolution/Main.java

@@ -15,7 +15,11 @@
 import de.variantsync.evolution.util.functional.MonadTransformer;
 import de.variantsync.evolution.util.functional.Unit;
 import de.variantsync.evolution.util.list.NonEmptyList;
-import de.variantsync.evolution.variability.*;
+import de.variantsync.evolution.variability.EvolutionStep;
+import de.variantsync.evolution.variability.SPLCommit;
+import de.variantsync.evolution.variability.VariabilityDataset;
+import de.variantsync.evolution.variability.VariabilityHistory;
+import de.variantsync.evolution.variability.sequenceextraction.LongestNonOverlappingSequences;
 import de.variantsync.evolution.variants.VariantsRepository;
 import de.variantsync.evolution.variants.VariantsRevision;
 import de.variantsync.evolution.variants.sampling.SampleOnceAtBeginStrategy;
@@ -107,7 +111,7 @@ public static void main(final String[] args) throws IOException, Resources.Resou
         final VariabilityDatasetLoader datasetLoader = new VariabilityDatasetLoader();
         assert datasetLoader.canLoad(variabilityDatasetDir);
         variabilityDataset = datasetLoader.load(variabilityDatasetDir).getSuccess();
-        final Set<EvolutionStep<SPLCommit>> evolutionSteps = variabilityDataset.getCommitPairsForEvolutionStudy();
+        final Set<EvolutionStep<SPLCommit>> evolutionSteps = variabilityDataset.getEvolutionSteps();
         Logger.info("The dataset contains " + variabilityDataset.getSuccessCommits().size() + " commits for which the variability extraction succeeded.");
         Logger.info("The dataset contains " + variabilityDataset.getErrorCommits().size() + " commits for which the variability extraction failed.");
         Logger.info("The dataset contains " + variabilityDataset.getPartialSuccessCommits().size() + " commits that for which the file presence conditions are missing.");
@@ -118,7 +122,7 @@ public static void main(final String[] args) throws IOException, Resources.Resou
             Logger.debug("<<PARENT> " + pair.parent().id() + "> -- <<SPL_COMMIT> " + pair.parent().id() + ">");
             Logger.debug("");
         }
-        final VariabilityHistory history = variabilityDataset.getVariabilityHistory(SequenceExtractors.longestNonOverlappingSequences());
+        final VariabilityHistory history = variabilityDataset.getVariabilityHistory(new LongestNonOverlappingSequences());
         final NonEmptyList<NonEmptyList<SPLCommit>> sequencesInHistory = history.commitSequences();
         Logger.info("The dataset contains " + sequencesInHistory.size() + " sequences.");
         for (int i = 0; i < sequencesInHistory.size(); i++) {

src/main/java/de/variantsync/evolution/variability/DominoSortedEvolutionSteps.java

@@ -0,0 +1,11 @@
+package de.variantsync.evolution.variability;
+
+import de.variantsync.evolution.util.list.NonEmptyList;
+
+import java.util.Collection;
+import java.util.List;
+
+@FunctionalInterface
+public interface SequenceExtractor {
+    List<NonEmptyList<SPLCommit>> extract(final Collection<SPLCommit> commits);
+}

src/main/java/de/variantsync/evolution/variability/SequenceExtractor.java

@@ -2,10 +2,12 @@
 
 import de.variantsync.evolution.util.Logger;
 import de.variantsync.evolution.util.list.NonEmptyList;
+import de.variantsync.evolution.variability.sequenceextraction.CleaningEvolutionStepsStream;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
-import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class VariabilityDataset {
     private final Set<SPLCommit> allCommits;
@@ -67,9 +69,9 @@ public List<SPLCommit> getPartialSuccessCommits() {
      *
      * @return All sequences of commits that are usable in our evolution study.
      */
-    public VariabilityHistory getVariabilityHistory(final Function<Collection<SPLCommit>,  List<NonEmptyList<SPLCommit>>> sequenceExtractor) {
+    public VariabilityHistory getVariabilityHistory(final SequenceExtractor sequenceExtractor) {
         // Build a VariabilityHistory instance by applying the provided function to the set of success commits
-        final List<NonEmptyList<SPLCommit>> history = sequenceExtractor.apply(this.successCommits);
+        final List<NonEmptyList<SPLCommit>> history = sequenceExtractor.extract(this.successCommits);
 
         if (history.isEmpty()) {
             Logger.error("There is no valid sequence of commits from which a VariabilityHistory can be built!");
@@ -79,6 +81,33 @@ public VariabilityHistory getVariabilityHistory(final Function<Collection<SPLCom
         }
     }
 
+    /**
+     * Collects all evolution steps into a set.
+     * @see #streamEvolutionSteps()
+     */
+    public Set<EvolutionStep<SPLCommit>> getEvolutionSteps() {
+        return streamEvolutionSteps().collect(Collectors.toSet());
+    }
+
+
+    /**
+     * Streams all valid pairs of success commits of this dataset.
+     * @see #streamEvolutionSteps(Collection)
+     */
+    public Stream<EvolutionStep<SPLCommit>> streamEvolutionSteps() {
+        return streamEvolutionSteps(successCommits);
+    }
+
+    /**
+     * Returns a sorted stream of {@link EvolutionStep<SPLCommit>}. Pairs of commits that
+     * have one commits in common will be returned sequentially (similar to playing domino).
+     * Visited SPLCommit's will be cleaned via {@link SPLCommit#forget()}.
+     * @see #streamEvolutionSteps(Collection)
+     */
+    public CleaningEvolutionStepsStream<SPLCommit> tidyStreamEvolutionSteps() {
+        return new CleaningEvolutionStepsStream<>(streamEvolutionSteps()::iterator);
+    }
+
     /**
      * Return the set of commit pairs (childCommit, parentCommit) for which the following holds:
      * <ul>
@@ -95,28 +124,22 @@ public VariabilityHistory getVariabilityHistory(final Function<Collection<SPLCom
      *
      * @return Set of commit pairs that can be used in a variability evolution study
      */
-    public DominoSortedEvolutionSteps<SPLCommit> getCommitPairsForEvolutionStudy() {
-        Logger.debug("Retrieving commit pairs for study...");
-        final var steps = new DominoSortedEvolutionSteps<>(
-                successCommits.stream()
-                        .map(c -> {
-                            if (c.parents().isPresent()) {
-                                final SPLCommit[] parents = c.parents().get();
-                                // We only consider commits that did not process a merge
-                                final boolean notAMerge = parents.length == 1;
-                                final SPLCommit p = parents[0];
-                                // We only consider commits that processed an SPL commit whose parent was also processed
-                                final boolean parentSuccess = successCommits.contains(p);
-                                if (notAMerge && parentSuccess) {
-                                    return new EvolutionStep<>(p, c);
-                                }
-                            }
-                            return null;
-                        })
-                        .filter(Objects::nonNull)
-        );
-        Logger.debug("Done.");
-        return steps;
+    public static Stream<EvolutionStep<SPLCommit>> streamEvolutionSteps(final Collection<SPLCommit> successCommits) {
+        return successCommits.stream()
+                .map(c -> {
+                    if (c.parents().isPresent()) {
+                        final SPLCommit[] parents = c.parents().get();
+                        // We only consider commits that did not process a merge
+                        final boolean notAMerge = parents.length == 1;
+                        final SPLCommit p = parents[0];
+                        // We only consider commits that processed an SPL commit whose parent was also processed
+                        final boolean parentSuccess = successCommits.contains(p);
+                        if (notAMerge && parentSuccess) {
+                            return new EvolutionStep<>(p, c);
+                        }
+                    }
+                    return null;
+                })
+                .filter(Objects::nonNull);
     }
-
 }