Rename method to be more generic

gnawf · gnawf · commit c4cfe05df935 · 2023-05-04T16:44:45.000+12:00
diff --git a/src/main/java/graphql/schema/diffing/DiffImpl.java b/src/main/java/graphql/schema/diffing/DiffImpl.java
@@ -204,14 +204,13 @@ private void addChildToQueue(int fixedEditorialCost,
         double[][] costMatrix = new double[costMatrixSize][costMatrixSize];
 
         Map<Vertex, Double> isolatedVerticesCache = new LinkedHashMap<>();
-
-        Map<Vertex, Vertex> parentRestrictions = getNonFixedRestrictions(parentPartialMapping, completeSourceGraph, completeTargetGraph);
+        Map<Vertex, Vertex> nonFixedParentRestrictions = getNonFixedRestrictions(parentPartialMapping, completeSourceGraph, completeTargetGraph);
 
         for (int i = parentLevel; i < allSources.size(); i++) {
             Vertex v = allSources.get(i);
             int j = 0;
             for (Vertex u : availableTargetVertices) {
-                double cost = calcLowerBoundMappingCost(v, u, parentPartialMapping, isolatedVerticesCache, parentRestrictions);
+                double cost = calcLowerBoundMappingCost(v, u, parentPartialMapping, isolatedVerticesCache, nonFixedParentRestrictions);
                 costMatrixForHungarianAlgo[i - parentLevel][j] = cost;
                 costMatrix[i - parentLevel][j] = cost;
                 j++;
@@ -399,9 +398,9 @@ private double calcLowerBoundMappingCost(Vertex v,
                                              Vertex u,
                                              Mapping partialMapping,
                                              Map<Vertex, Double> isolatedVerticesCache,
-                                             Map<Vertex, Vertex> parentRestrictions) {
-        if (parentRestrictions.containsKey(v) || partialMapping.hasParentRestriction(v)) {
-            Vertex uParentRestriction = parentRestrictions.get(v);
+                                             Map<Vertex, Vertex> nonFixedParentRestrictions) {
+        if (nonFixedParentRestrictions.containsKey(v) || partialMapping.hasParentRestriction(v)) {
+            Vertex uParentRestriction = nonFixedParentRestrictions.get(v);
             if (uParentRestriction == null) {
                 uParentRestriction = partialMapping.getParentRestriction(v);
             }
diff --git a/src/main/java/graphql/schema/diffing/SchemaGraph.java b/src/main/java/graphql/schema/diffing/SchemaGraph.java
@@ -259,11 +259,11 @@ public Vertex getAppliedDirectiveContainerForAppliedDirective(Vertex appliedDire
     }
 
     /**
-     * Assuming the child has one parent, this gets it.
+     * Gets the one inverse adjacent edge to the input and gets the other vertex.
      */
-    public Vertex getSingleParent(Vertex child) {
-        Collection<Edge> adjacentVertices = this.getAdjacentEdgesInverseNonCopy(child);
-        assertTrue(adjacentVertices.size() == 1, () -> format("No parent found for %s", child));
+    public Vertex getSingleAdjacentInverseVertex(Vertex input) {
+        Collection<Edge> adjacentVertices = this.getAdjacentEdgesInverseNonCopy(input);
+        assertTrue(adjacentVertices.size() == 1, () -> format("No parent found for %s", input));
         return adjacentVertices.iterator().next().getFrom();
     }
 
diff --git a/src/main/java/graphql/schema/diffing/SchemaParentRestrictions.java b/src/main/java/graphql/schema/diffing/SchemaParentRestrictions.java
@@ -31,7 +31,7 @@ public static Map<Vertex, Vertex> getFixedRestrictions(SchemaGraph sourceGraph,
 
         for (Vertex vertex : needsFixing) {
             if (isApplicableChildVertex(vertex)) {
-                Vertex sourceParent = sourceGraph.getSingleParent(vertex);
+                Vertex sourceParent = sourceGraph.getSingleAdjacentInverseVertex(vertex);
                 Vertex fixedTargetParent = sourceToTargetMapping.get(sourceParent);
 
                 if (fixedTargetParent != null) {
@@ -64,8 +64,8 @@ public static Map<Vertex, Vertex> getNonFixedRestrictions(Mapping parentMapping,
                     }
                 }
             } else if (isApplicableChildVertex(source) && isApplicableChildVertex(target)) {
-                Vertex sourceParent = completeSourceGraph.getSingleParent(source);
-                Vertex targetParent = completeTargetGraph.getSingleParent(target);
+                Vertex sourceParent = completeSourceGraph.getSingleAdjacentInverseVertex(source);
+                Vertex targetParent = completeTargetGraph.getSingleAdjacentInverseVertex(target);
 
                 for (Edge edge : completeSourceGraph.getAdjacentEdgesNonCopy(sourceParent)) {
                     Vertex sibling = edge.getTo();

Original file line number	Diff line number	Diff line change
`@@ -259,11 +259,11 @@ public Vertex getAppliedDirectiveContainerForAppliedDirective(Vertex appliedDire`
`259`	`259`	`}`
`260`	`260`
`261`	`261`	`/**`
`262`		`- * Assuming the child has one parent, this gets it.`
	`262`	`+ * Gets the one inverse adjacent edge to the input and gets the other vertex.`
`263`	`263`	`*/`
`264`		`- public Vertex getSingleParent(Vertex child) {`
`265`		`- Collection<Edge> adjacentVertices = this.getAdjacentEdgesInverseNonCopy(child);`
`266`		`- assertTrue(adjacentVertices.size() == 1, () -> format("No parent found for %s", child));`
	`264`	`+ public Vertex getSingleAdjacentInverseVertex(Vertex input) {`
	`265`	`+ Collection<Edge> adjacentVertices = this.getAdjacentEdgesInverseNonCopy(input);`
	`266`	`+ assertTrue(adjacentVertices.size() == 1, () -> format("No parent found for %s", input));`
`267`	`267`	`return adjacentVertices.iterator().next().getFrom();`
`268`	`268`	`}`
`269`	`269`