graphql-java · andimarek · Nov 29, 2022 · Nov 12, 2021 · Nov 14, 2021 · Nov 16, 2021
diff --git a/src/main/java/graphql/Mutable.java b/src/main/java/graphql/Mutable.java
@@ -4,12 +4,13 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import static java.lang.annotation.ElementType.METHOD;
 import static java.lang.annotation.ElementType.TYPE;
 
 /**
  * This marks a type as mutable which means after constructing it can be changed.
  */
 @Retention(RetentionPolicy.RUNTIME)
-@Target(value = {TYPE})
+@Target(value = {TYPE,METHOD})
 public @interface Mutable {
 }
diff --git a/src/main/java/graphql/schema/diffing/DiffImpl.java b/src/main/java/graphql/schema/diffing/DiffImpl.java
diff --git a/src/main/java/graphql/schema/diffing/Edge.java b/src/main/java/graphql/schema/diffing/Edge.java
@@ -0,0 +1,62 @@
+package graphql.schema.diffing;
+
+import graphql.Internal;
+
+import java.util.Objects;
+
+@Internal
+public class Edge {
+    private Vertex from;
+    private Vertex to;
+
+    private String label = "";
+
+    public Edge(Vertex from, Vertex to) {
+        this.from = from;
+        this.to = to;
+    }
+
+    public Edge(Vertex from, Vertex to, String label) {
+        this.from = from;
+        this.to = to;
+        this.label = label;
+    }
+
+    public Vertex getFrom() {
+        return from;
+    }
+
+    public void setFrom(Vertex from) {
+        this.from = from;
+    }
+
+    public Vertex getTo() {
+        return to;
+    }
+
+    public void setTo(Vertex to) {
+        this.to = to;
+    }
+
+
+    public void setLabel(String label) {
+        this.label = label;
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    @Override
+    public String toString() {
+        return "Edge{" +
+                "from=" + from +
+                ", to=" + to +
+                ", label='" + label + '\'' +
+                '}';
+    }
+
+    public boolean isEqualTo(Edge other) {
+        return Objects.equals(this.label, other.label);
+    }
+}
diff --git a/src/main/java/graphql/schema/diffing/EditOperation.java b/src/main/java/graphql/schema/diffing/EditOperation.java
@@ -0,0 +1,107 @@
+package graphql.schema.diffing;
+
+import graphql.Internal;
+
+import java.util.Objects;
+
+@Internal
+public class EditOperation {
+
+    private EditOperation(Operation operation,
+                          String description,
+                          Vertex sourceVertex,
+                          Vertex targetVertex,
+                          Edge sourceEdge,
+                          Edge targetEdge) {
+        this.operation = operation;
+        this.description = description;
+        this.sourceVertex = sourceVertex;
+        this.targetVertex = targetVertex;
+        this.sourceEdge = sourceEdge;
+        this.targetEdge = targetEdge;
+    }
+
+    public static EditOperation deleteVertex(String description, Vertex sourceVertex,Vertex targetVertex) {
+        return new EditOperation(Operation.DELETE_VERTEX, description, sourceVertex, targetVertex, null, null);
+    }
+
+    public static EditOperation insertVertex(String description,Vertex sourceVertex, Vertex targetVertex) {
+        return new EditOperation(Operation.INSERT_VERTEX, description, sourceVertex, targetVertex, null, null);
+    }
+
+    public static EditOperation changeVertex(String description, Vertex sourceVertex, Vertex targetVertex) {
+        return new EditOperation(Operation.CHANGE_VERTEX, description, sourceVertex, targetVertex, null, null);
+    }
+
+    public static EditOperation deleteEdge(String description, Edge sourceEdge) {
+        return new EditOperation(Operation.DELETE_EDGE, description, null, null, sourceEdge, null);
+    }
+
+    public static EditOperation insertEdge(String description, Edge targetEdge) {
+        return new EditOperation(Operation.INSERT_EDGE, description, null, null, null, targetEdge);
+    }
+
+    public static EditOperation changeEdge(String description, Edge sourceEdge, Edge targetEdge) {
+        return new EditOperation(Operation.CHANGE_EDGE, description, null, null, sourceEdge, targetEdge);
+    }
+
+    private Operation operation;
+    private String description;
+    private Vertex sourceVertex;
+    private Vertex targetVertex;
+    private Edge sourceEdge;
+    private Edge targetEdge;
+
+
+    public enum Operation {
+        CHANGE_VERTEX, DELETE_VERTEX, INSERT_VERTEX, CHANGE_EDGE, INSERT_EDGE, DELETE_EDGE
+    }
+
+    public Operation getOperation() {
+        return operation;
+    }
+
+
+    public Vertex getSourceVertex() {
+        return sourceVertex;
+    }
+
+    public Vertex getTargetVertex() {
+        return targetVertex;
+    }
+
+    public Edge getSourceEdge() {
+        return sourceEdge;
+    }
+
+    public Edge getTargetEdge() {
+        return targetEdge;
+    }
+
+    @Override
+    public String toString() {
+        return "EditOperation{" +
+                "operation=" + operation +
+                ", description='" + description + '\'' +
+                '}';
+    }
+
+
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        EditOperation that = (EditOperation) o;
+        return operation == that.operation && Objects.equals(description, that.description) && Objects.equals(sourceVertex, that.sourceVertex) && Objects.equals(targetVertex, that.targetVertex) && Objects.equals(sourceEdge, that.sourceEdge) && Objects.equals(targetEdge, that.targetEdge);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(operation, description, sourceVertex, targetVertex, sourceEdge, targetEdge);
+    }
+}
diff --git a/src/main/java/graphql/schema/diffing/EditorialCostForMapping.java b/src/main/java/graphql/schema/diffing/EditorialCostForMapping.java
@@ -0,0 +1,70 @@
+package graphql.schema.diffing;
+
+import graphql.Internal;
+
+import java.util.List;
+
+@Internal
+public class EditorialCostForMapping {
+
+    /**
+     * a mapping introduces a subgraph consisting of all vertices and all edges between these vertices
+     */
+    public static int editorialCostForMapping(Mapping mapping, // can be a partial mapping
+                                              SchemaGraph sourceGraph, // the whole graph
+                                              SchemaGraph targetGraph, // the whole graph
+                                              List<EditOperation> editOperationsResult) {
+        int cost = 0;
+        for (int i = 0; i < mapping.size(); i++) {
+            Vertex sourceVertex = mapping.getSource(i);
+            Vertex targetVertex = mapping.getTarget(i);
+            // Vertex changing (relabeling)
+            boolean equalNodes = sourceVertex.getType().equals(targetVertex.getType()) && sourceVertex.getProperties().equals(targetVertex.getProperties());
+            if (!equalNodes) {
+                if (sourceVertex.isIsolated()) {
+                    editOperationsResult.add(EditOperation.insertVertex("Insert" + targetVertex, sourceVertex, targetVertex));
+                } else if (targetVertex.isIsolated()) {
+                    editOperationsResult.add(EditOperation.deleteVertex("Delete " + sourceVertex, sourceVertex, targetVertex));
+                } else {
+                    editOperationsResult.add(EditOperation.changeVertex("Change " + sourceVertex + " to " + targetVertex, sourceVertex, targetVertex));
+                }
+                cost++;
+            }
+        }
+        List<Edge> edges = sourceGraph.getEdges();
+        // edge deletion or relabeling
+        for (Edge sourceEdge : edges) {
+            // only edges relevant to the subgraph
+            if (!mapping.containsSource(sourceEdge.getFrom()) || !mapping.containsSource(sourceEdge.getTo())) {
+                continue;
+            }
+            Vertex targetFrom = mapping.getTarget(sourceEdge.getFrom());
+            Vertex targetTo = mapping.getTarget(sourceEdge.getTo());
+            Edge targetEdge = targetGraph.getEdge(targetFrom, targetTo);
+            if (targetEdge == null) {
+                editOperationsResult.add(EditOperation.deleteEdge("Delete edge " + sourceEdge, sourceEdge));
+                cost++;
+            } else if (!sourceEdge.getLabel().equals(targetEdge.getLabel())) {
+                editOperationsResult.add(EditOperation.changeEdge("Change " + sourceEdge + " to " + targetEdge, sourceEdge, targetEdge));
+                cost++;
+            }
+        }
+
+        //TODO: iterates over all edges in the target Graph
+        for (Edge targetEdge : targetGraph.getEdges()) {
+            // only subgraph edges
+            if (!mapping.containsTarget(targetEdge.getFrom()) || !mapping.containsTarget(targetEdge.getTo())) {
+                continue;
+            }
+            Vertex sourceFrom = mapping.getSource(targetEdge.getFrom());
+            Vertex sourceTo = mapping.getSource(targetEdge.getTo());
+            if (sourceGraph.getEdge(sourceFrom, sourceTo) == null) {
+                editOperationsResult.add(EditOperation.insertEdge("Insert edge " + targetEdge, targetEdge));
+                cost++;
+            }
+        }
+        return cost;
+    }
+
+
+}