update to new functjional namespace

pmbittner · pmbittner · commit de9059e3caf9 · 2022-04-13T10:44:50.000+02:00
diff --git a/pom.xml b/pom.xml
@@ -70,8 +70,8 @@
         </dependency>
 
         <dependency>
-            <groupId>de.variantsync</groupId>
-            <artifactId>Functjonal</artifactId>
+            <groupId>org.variantsync</groupId>
+            <artifactId>functjonal</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
 
diff --git a/src/main/java/datasets/Repository.java b/src/main/java/datasets/Repository.java
@@ -1,17 +1,15 @@
 package datasets;
 
-import de.variantsync.functjonal.Lazy;
 import diff.DiffFilter;
-import diff.difftree.DiffNode;
 import load.GitLoader;
 import org.eclipse.jgit.api.Git;
 import org.tinylog.Logger;
+import org.variantsync.functjonal.Lazy;
 import util.IO;
 
 import java.net.URI;
 import java.nio.file.Path;
 import java.util.Optional;
-import java.util.function.Predicate;
 
 /**
  * Representation of git repositories used as datasets for DiffDetective.
diff --git a/src/main/java/diff/GitDiffer.java b/src/main/java/diff/GitDiffer.java
@@ -2,10 +2,6 @@
 
 import datasets.ParseOptions;
 import datasets.Repository;
-import de.variantsync.functjonal.Result;
-import de.variantsync.functjonal.iteration.MappedIterator;
-import de.variantsync.functjonal.iteration.SideEffectIterator;
-import de.variantsync.functjonal.iteration.Yield;
 import diff.difftree.DiffTree;
 import diff.difftree.parse.DiffTreeParser;
 import diff.result.CommitDiffResult;
@@ -27,6 +23,10 @@
 import org.eclipse.jgit.treewalk.TreeWalk;
 import org.eclipse.jgit.treewalk.filter.PathFilter;
 import org.tinylog.Logger;
+import org.variantsync.functjonal.Result;
+import org.variantsync.functjonal.iteration.MappedIterator;
+import org.variantsync.functjonal.iteration.SideEffectIterator;
+import org.variantsync.functjonal.iteration.Yield;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
diff --git a/src/main/java/diff/difftree/DiffTree.java b/src/main/java/diff/difftree/DiffTree.java
@@ -21,7 +21,7 @@
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 
-import static de.variantsync.functjonal.Functjonal.when;
+import static org.variantsync.functjonal.Functjonal.when;
 
 /**
  * Implementation of the diff tree.
diff --git a/src/main/java/diff/difftree/filter/ExplainedFilter.java b/src/main/java/diff/difftree/filter/ExplainedFilter.java
@@ -1,7 +1,7 @@
 package diff.difftree.filter;
 
-import de.variantsync.functjonal.category.InplaceSemigroup;
-import de.variantsync.functjonal.category.SemigroupCannotAppend;
+import org.variantsync.functjonal.category.InplaceSemigroup;
+import org.variantsync.functjonal.category.SemigroupCannotAppend;
 
 import java.util.Arrays;
 import java.util.List;
diff --git a/src/main/java/diff/difftree/render/DiffTreeRenderer.java b/src/main/java/diff/difftree/render/DiffTreeRenderer.java
@@ -1,6 +1,5 @@
 package diff.difftree.render;
 
-import de.variantsync.functjonal.Product;
 import diff.GitPatch;
 import diff.PatchDiff;
 import diff.difftree.DiffTree;
@@ -10,6 +9,7 @@
 import diff.difftree.serialize.DiffTreeSerializeDebugData;
 import diff.difftree.serialize.LineGraphExport;
 import org.tinylog.Logger;
+import org.variantsync.functjonal.Pair;
 import shell.PythonCommand;
 import shell.ShellException;
 import shell.ShellExecutor;
@@ -102,7 +102,7 @@ private boolean render(final DiffTree tree, final String treeAndFileName, final
 
         final Path tempFile = directory.resolve(treeAndFileName + ".lg");
 
-        final Product<DiffTreeSerializeDebugData, String> result = LineGraphExport.toLineGraphFormat(tree, lgoptions);
+        final Pair<DiffTreeSerializeDebugData, String> result = LineGraphExport.toLineGraphFormat(tree, lgoptions);
         Assert.assertNotNull(result);
         final String lg = treeHeader.apply(treeAndFileName, tree.getSource()) + StringUtils.LINEBREAK + result.second();
 
diff --git a/src/main/java/diff/difftree/serialize/DiffTreeSerializeDebugData.java b/src/main/java/diff/difftree/serialize/DiffTreeSerializeDebugData.java
@@ -1,8 +1,8 @@
 package diff.difftree.serialize;
 
-import de.variantsync.functjonal.category.InplaceSemigroup;
 import metadata.Metadata;
 import mining.MetadataKeys;
+import org.variantsync.functjonal.category.InplaceSemigroup;
 
 import java.util.LinkedHashMap;
 
diff --git a/src/main/java/diff/difftree/serialize/LineGraphExport.java b/src/main/java/diff/difftree/serialize/LineGraphExport.java
@@ -1,6 +1,5 @@
 package diff.difftree.serialize;
 
-import de.variantsync.functjonal.Product;
 import diff.CommitDiff;
 import diff.PatchDiff;
 import diff.difftree.DiffNode;
@@ -10,29 +9,30 @@
 import metadata.ExplainedFilterSummary;
 import mining.DiffTreeMiningResult;
 import org.tinylog.Logger;
+import org.variantsync.functjonal.Pair;
 import util.StringUtils;
 
 public class LineGraphExport {
 
-    public static Product<DiffTreeSerializeDebugData, String> toLineGraphFormat(final DiffTree diffTree, final DiffTreeLineGraphExportOptions options) {
+    public static Pair<DiffTreeSerializeDebugData, String> toLineGraphFormat(final DiffTree diffTree, final DiffTreeLineGraphExportOptions options) {
         DiffTreeTransformer.apply(options.treePreProcessing(), diffTree);
         diffTree.assertConsistency();
 
         if (options.treeFilter().test(diffTree)) {
             final DiffTreeLineGraphExporter exporter = new DiffTreeLineGraphExporter(diffTree);
             final String result = exporter.export(options);
-            return new Product<>(exporter.getDebugData(), result);
+            return new Pair<>(exporter.getDebugData(), result);
         }
 
         return null;
     }
 
-    public static Product<DiffTreeMiningResult, String> toLineGraphFormat(final String repoName, final Iterable<DiffTree> trees, final DiffTreeLineGraphExportOptions options) {
+    public static Pair<DiffTreeMiningResult, String> toLineGraphFormat(final String repoName, final Iterable<DiffTree> trees, final DiffTreeLineGraphExportOptions options) {
         final DiffTreeMiningResult result = new DiffTreeMiningResult(repoName);
 
         final StringBuilder lineGraph = new StringBuilder();
         for (final DiffTree t : trees) {
-            final Product<DiffTreeSerializeDebugData, String> lg = toLineGraphFormat(t, options);
+            final Pair<DiffTreeSerializeDebugData, String> lg = toLineGraphFormat(t, options);
 
             if (lg != null) {
                 result.debugData.append(lg.first());
@@ -44,10 +44,10 @@ public static Product<DiffTreeMiningResult, String> toLineGraphFormat(final Stri
         result.exportedCommits = 1;
         result.filterHits = new ExplainedFilterSummary(options.treeFilter());
 
-        return new Product<>(result, lineGraph.toString());
+        return new Pair<>(result, lineGraph.toString());
     }
 
-    public static Product<DiffTreeMiningResult, String> toLineGraphFormat(final Iterable<DiffTree> trees, final DiffTreeLineGraphExportOptions options) {
+    public static Pair<DiffTreeMiningResult, String> toLineGraphFormat(final Iterable<DiffTree> trees, final DiffTreeLineGraphExportOptions options) {
         return toLineGraphFormat(DiffTreeMiningResult.NO_REPO, trees, options);
     }
 
@@ -68,7 +68,7 @@ public static DiffTreeMiningResult toLineGraphFormat(final String repoName, fina
         for (final PatchDiff patchDiff : commitDiff.getPatchDiffs()) {
             if (patchDiff.isValid()) {
                 //Logger.info("  Exporting DiffTree #" + treeCounter);
-                final Product<DiffTreeSerializeDebugData, String> patchDiffLg;
+                final Pair<DiffTreeSerializeDebugData, String> patchDiffLg;
                 try {
                     patchDiffLg = toLineGraphFormat(patchDiff.getDiffTree(), options);
                 } catch (Exception e) {
diff --git a/src/main/java/diff/difftree/serialize/LineGraphImport.java b/src/main/java/diff/difftree/serialize/LineGraphImport.java
@@ -1,7 +1,7 @@
 package diff.difftree.serialize;
 
-import de.variantsync.functjonal.Product;
 import diff.difftree.*;
+import org.variantsync.functjonal.Pair;
 import util.Assert;
 import util.FileUtils;
 
@@ -69,7 +69,7 @@ public static List<DiffTree> fromLineGraph(final String lineGraph, final DiffTre
 				// the line represents a DiffNode
 				
 				// parse node from input line
-				final Product<Integer, DiffNode> idAndNode = options.nodeFormat().fromLineGraphLine(ln);
+				final Pair<Integer, DiffNode> idAndNode = options.nodeFormat().fromLineGraphLine(ln);
 			
 				// add DiffNode to lists of current DiffTree
 				diffNodeList.add(idAndNode.second());
diff --git a/src/main/java/diff/difftree/serialize/edgeformat/DefaultEdgeLabelFormat.java b/src/main/java/diff/difftree/serialize/edgeformat/DefaultEdgeLabelFormat.java
@@ -1,8 +1,8 @@
 package diff.difftree.serialize.edgeformat;
 
-import de.variantsync.functjonal.Functjonal;
 import diff.difftree.DiffNode;
 import diff.difftree.LineGraphConstants;
+import org.variantsync.functjonal.Functjonal;
 
 public class DefaultEdgeLabelFormat extends EdgeLabelFormat {
     public DefaultEdgeLabelFormat() {
diff --git a/src/main/java/diff/difftree/serialize/edgeformat/EdgeLabelFormat.java b/src/main/java/diff/difftree/serialize/edgeformat/EdgeLabelFormat.java
@@ -1,9 +1,9 @@
 package diff.difftree.serialize.edgeformat;
 
-import de.variantsync.functjonal.Product;
 import diff.difftree.DiffNode;
 import diff.difftree.LineGraphConstants;
 import diff.difftree.serialize.LinegraphFormat;
+import org.variantsync.functjonal.Pair;
 import util.StringUtils;
 
 import java.util.Map;
@@ -27,11 +27,11 @@ public enum Direction {
 
         public static final Direction Default = ChildToParent;
 
-        <A> Product<A, A> sort(A child, A parent) {
+        <A> Pair<A, A> sort(A child, A parent) {
             if (this == ChildToParent) {
-                return new Product<>(child, parent);
+                return new Pair<>(child, parent);
             } else {
-                return new Product<>(parent, child);
+                return new Pair<>(parent, child);
             }
         }
     }
@@ -78,7 +78,7 @@ public void connect(final String lineGraphLine, final Map<Integer, DiffNode> nod
 
         // first is the id of the child DiffNode
         // second the id of the parent DiffNode
-        final Product<String, String> fromAndToIds = edgeDirection.sort(edge[1], edge[2]);
+        final Pair<String, String> fromAndToIds = edgeDirection.sort(edge[1], edge[2]);
 
         // Both child and parent DiffNode should exist since all DiffNodes have been read in before. Otherwise, the line graph input is faulty
         DiffNode childNode = nodes.get(Integer.parseInt(fromAndToIds.first()));
@@ -129,7 +129,7 @@ public String getParentEdgeLines(final DiffNode node) {
     }
 
     private String edgeToLineGraphSorted(DiffNode desiredFrom, DiffNode desiredTo, final String labelPrefix) {
-        final Product<DiffNode, DiffNode> sorted = edgeDirection.sort(desiredFrom, desiredTo);
+        final Pair<DiffNode, DiffNode> sorted = edgeDirection.sort(desiredFrom, desiredTo);
         return edgeToLineGraph(sorted.first(), sorted.second(), labelPrefix);
     }
 
diff --git a/src/main/java/diff/difftree/serialize/nodeformat/DiffNodeLabelFormat.java b/src/main/java/diff/difftree/serialize/nodeformat/DiffNodeLabelFormat.java
@@ -1,10 +1,10 @@
 package diff.difftree.serialize.nodeformat;
 
-import de.variantsync.functjonal.Product;
 import diff.difftree.DiffNode;
 import diff.difftree.DiffTreeSource;
 import diff.difftree.LineGraphConstants;
 import diff.difftree.serialize.LinegraphFormat;
+import org.variantsync.functjonal.Pair;
 
 /**
  * Reads and writes {@link DiffNode DiffNodes} from and to line graph.
@@ -39,7 +39,7 @@ default DiffNode fromLabelAndId(final String lineGraphNodeLabel, final int nodeI
      * @return A pair with the first element being the id of the node specified in the given lineGrapLine.
      *         The second entry is the parsed {@link DiffNode} described by the label of this line.
      */
-    default Product<Integer, DiffNode> fromLineGraphLine(final String lineGraphLine) {
+    default Pair<Integer, DiffNode> fromLineGraphLine(final String lineGraphLine) {
         if (!lineGraphLine.startsWith(LineGraphConstants.LG_NODE)) throw new RuntimeException("Failed to parse DiffNode: Expected \"v ...\" but got \"" + lineGraphLine + "\"!"); // check if encoded DiffNode
 
         final int idBegin = LineGraphConstants.LG_NODE.length() + 1;
@@ -53,7 +53,7 @@ default Product<Integer, DiffNode> fromLineGraphLine(final String lineGraphLine)
         }
 
         final String label = lineGraphLine.substring(idEnd + 1);
-        return new Product<>(nodeId, fromLabelAndId(label, nodeId));
+        return new Pair<>(nodeId, fromLabelAndId(label, nodeId));
     }
 
     /**
diff --git a/src/main/java/diff/difftree/transform/NaiveMovedCodeDetection.java b/src/main/java/diff/difftree/transform/NaiveMovedCodeDetection.java
@@ -1,10 +1,10 @@
 package diff.difftree.transform;
 
-import de.variantsync.functjonal.Product;
 import diff.DiffLineNumber;
 import diff.difftree.DiffNode;
 import diff.difftree.DiffTree;
 import diff.difftree.DiffType;
+import org.variantsync.functjonal.Pair;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -18,9 +18,9 @@
 public class NaiveMovedCodeDetection implements DiffTreeTransformer {
     @Override
     public void transform(final DiffTree diffTree) {
-        final List<Product<DiffNode, DiffNode>> twins = findCodeTwins(diffTree);
+        final List<Pair<DiffNode, DiffNode>> twins = findCodeTwins(diffTree);
 
-        for (final Product<DiffNode, DiffNode> twin : twins) {
+        for (final Pair<DiffNode, DiffNode> twin : twins) {
             final DiffNode added;
             final DiffNode removed;
 
@@ -45,9 +45,9 @@ public void transform(final DiffTree diffTree) {
         }
     }
 
-    private static List<Product<DiffNode, DiffNode>> findCodeTwins(final DiffTree diffTree) {
+    private static List<Pair<DiffNode, DiffNode>> findCodeTwins(final DiffTree diffTree) {
         final List<DiffNode> codeNodes = diffTree.computeCodeNodes();
-        final List<Product<DiffNode, DiffNode>> twins = new ArrayList<>();
+        final List<Pair<DiffNode, DiffNode>> twins = new ArrayList<>();
 
         while (!codeNodes.isEmpty()) {
             // Always inspect last element as it's the cheapest to remove.
@@ -59,7 +59,7 @@ private static List<Product<DiffNode, DiffNode>> findCodeTwins(final DiffTree di
                 // ... check if the opposite operation was applied to the same code somewhere else.
                 final DiffNode twin = findTwinOf(code, codeNodes);
                 if (twin != null) {
-                    twins.add(new Product<>(code, twin));
+                    twins.add(new Pair<>(code, twin));
                     codeNodes.remove(twin);
                 }
             }
diff --git a/src/main/java/diff/result/DiffResult.java b/src/main/java/diff/result/DiffResult.java
@@ -1,8 +1,8 @@
 package diff.result;
 
-import de.variantsync.functjonal.Result;
 import diff.difftree.parse.IllFormedAnnotationException;
 import org.tinylog.Logger;
+import org.variantsync.functjonal.Result;
 
 import java.util.function.Function;
 
diff --git a/src/main/java/feature/BooleanAbstraction.java b/src/main/java/feature/BooleanAbstraction.java
@@ -1,6 +1,6 @@
 package feature;
 
-import de.variantsync.functjonal.Functjonal;
+import org.variantsync.functjonal.Functjonal;
 
 import java.util.Map;
 import java.util.function.Function;
diff --git a/src/main/java/metadata/AtomicPatternCount.java b/src/main/java/metadata/AtomicPatternCount.java
@@ -1,9 +1,9 @@
 package metadata;
 
-import de.variantsync.functjonal.Functjonal;
-import de.variantsync.functjonal.category.InplaceSemigroup;
-import de.variantsync.functjonal.map.MergeMap;
 import diff.CommitDiff;
+import org.variantsync.functjonal.Functjonal;
+import org.variantsync.functjonal.category.InplaceSemigroup;
+import org.variantsync.functjonal.map.MergeMap;
 import pattern.atomic.AtomicPattern;
 import pattern.atomic.AtomicPatternCatalogue;
 import pattern.atomic.proposed.ProposedAtomicPatterns;
diff --git a/src/main/java/metadata/ExplainedFilterSummary.java b/src/main/java/metadata/ExplainedFilterSummary.java
@@ -1,9 +1,9 @@
 package metadata;
 
-import de.variantsync.functjonal.Functjonal;
-import de.variantsync.functjonal.category.InplaceSemigroup;
-import de.variantsync.functjonal.map.MergeMap;
 import diff.difftree.filter.ExplainedFilter;
+import org.variantsync.functjonal.Functjonal;
+import org.variantsync.functjonal.category.InplaceSemigroup;
+import org.variantsync.functjonal.map.MergeMap;
 
 import java.util.LinkedHashMap;
 import java.util.List;
diff --git a/src/main/java/metadata/Metadata.java b/src/main/java/metadata/Metadata.java
@@ -1,8 +1,8 @@
 package metadata;
 
-import de.variantsync.functjonal.Cast;
-import de.variantsync.functjonal.category.InplaceSemigroup;
 import org.tinylog.Logger;
+import org.variantsync.functjonal.Cast;
+import org.variantsync.functjonal.category.InplaceSemigroup;
 import util.IO;
 
 import java.io.IOException;
diff --git a/src/main/java/mining/AutomationResult.java b/src/main/java/mining/AutomationResult.java
@@ -1,8 +1,8 @@
 package mining;
 
-import de.variantsync.functjonal.category.InplaceSemigroup;
 import metadata.Metadata;
 import mining.strategies.CommitProcessTime;
+import org.variantsync.functjonal.category.InplaceSemigroup;
 
 import java.util.LinkedHashMap;
 
diff --git a/src/main/java/mining/DiffTreeMiner.java b/src/main/java/mining/DiffTreeMiner.java
@@ -3,8 +3,6 @@
 import datasets.ParseOptions;
 import datasets.Repository;
 import datasets.predefined.StanciulescuMarlin;
-import de.variantsync.functjonal.iteration.ClusteredIterator;
-import de.variantsync.functjonal.iteration.MappedIterator;
 import diff.GitDiffer;
 import diff.difftree.filter.DiffTreeFilter;
 import diff.difftree.filter.ExplainedFilter;
@@ -29,6 +27,8 @@
 import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.tinylog.Logger;
+import org.variantsync.functjonal.iteration.ClusteredIterator;
+import org.variantsync.functjonal.iteration.MappedIterator;
 import parallel.ScheduledTasksIterator;
 import util.Assert;
 import util.Clock;
diff --git a/src/main/java/mining/DiffTreeMiningResult.java b/src/main/java/mining/DiffTreeMiningResult.java
diff --git a/src/main/java/mining/formats/DebugMiningDiffNodeFormat.java b/src/main/java/mining/formats/DebugMiningDiffNodeFormat.java
diff --git a/src/main/java/mining/formats/DirectedEdgeLabelFormat.java b/src/main/java/mining/formats/DirectedEdgeLabelFormat.java
diff --git a/src/main/java/mining/formats/MiningNodeFormat.java b/src/main/java/mining/formats/MiningNodeFormat.java
diff --git a/src/main/java/mining/formats/ReleaseMiningDiffNodeFormat.java b/src/main/java/mining/formats/ReleaseMiningDiffNodeFormat.java
diff --git a/src/main/java/mining/postprocessing/MiningPostprocessing.java b/src/main/java/mining/postprocessing/MiningPostprocessing.java
diff --git a/src/test/java/LinuxParsingTest.java b/src/test/java/LinuxParsingTest.java
diff --git a/src/test/java/TestLineNumbers.java b/src/test/java/TestLineNumbers.java
diff --git a/src/test/java/TestMultiLineMacros.java b/src/test/java/TestMultiLineMacros.java
