Avoid executing unnecessary operations (#253)

- Filter empty change bounds and change routing points operations
- Filter empty compound commands

Relates to eclipse-glsp/glsp#1477

Author: martin-fleck-at

plugins/org.eclipse.glsp.graph/src/org/eclipse/glsp/graph/util/GraphUtil.java

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2025 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,7 +24,7 @@ public final class GraphUtil {
 
    private GraphUtil() {}
 
-   public static GBounds bounds(double x, double y, double width, double height) {
+   public static GBounds bounds(final double x, final double y, final double width, final double height) {
       GBounds bounds = GraphFactory.eINSTANCE.createGBounds();
       bounds.setX(x);
       bounds.setY(y);
@@ -33,29 +33,48 @@ public static GBounds bounds(double x, double y, double width, double height) {
       return bounds;
    }
 
-   public static GBounds copy(GBounds toCopy) {
+   public static GBounds copy(final GBounds toCopy) {
       return bounds(toCopy.getX(), toCopy.getY(), toCopy.getWidth(), toCopy.getHeight());
    }
 
-   public static GPoint point(double x, double y) {
+   public static GPoint point(final double x, final double y) {
       GPoint point = GraphFactory.eINSTANCE.createGPoint();
       point.setX(x);
       point.setY(y);
       return point;
    }
 
-   public static GPoint copy(GPoint toCopy) {
+   public static GPoint copy(final GPoint toCopy) {
       return point(toCopy.getX(), toCopy.getY());
    }
 
-   public static GDimension dimension(double width, double height) {
+   public static int compare(final GPoint left, final GPoint right) {
+      int xCompare = Double.compare(left.getX(), right.getX());
+      return xCompare != 0 ? xCompare : Double.compare(left.getY(), right.getY());
+   }
+
+   public static boolean equals(final GPoint left, final GPoint right) {
+      return compare(left, right) == 0;
+   }
+
+   public static GDimension dimension(final double width, final double height) {
       GDimension dimension = GraphFactory.eINSTANCE.createGDimension();
       dimension.setWidth(width);
       dimension.setHeight(height);
       return dimension;
    }
 
-   public static GDimension copy(GDimension toCopy) {
+   public static GDimension copy(final GDimension toCopy) {
       return dimension(toCopy.getWidth(), toCopy.getHeight());
    }
+
+   public static int compare(final GDimension left, final GDimension right) {
+      int widthCompare = Double.compare(left.getWidth(), right.getWidth());
+      return widthCompare != 0 ? widthCompare : Double.compare(left.getHeight(), right.getHeight());
+   }
+
+   public static boolean equals(final GDimension left, final GDimension right) {
+      return compare(left, right) == 0;
+   }
+
 }

plugins/org.eclipse.glsp.server/src/org/eclipse/glsp/server/gmodel/GModelChangeBoundsOperationHandler.java

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2023 EclipseSource and others.
+ * Copyright (c) 2019-2025 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -17,11 +17,13 @@
 
 import static org.eclipse.glsp.server.types.GLSPServerException.getOrThrow;
 
+import java.util.List;
 import java.util.Optional;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.eclipse.emf.common.command.Command;
+import org.eclipse.glsp.graph.GBoundsAware;
 import org.eclipse.glsp.graph.GDimension;
 import org.eclipse.glsp.graph.GModelElement;
 import org.eclipse.glsp.graph.GModelIndex;
@@ -43,7 +45,20 @@ public class GModelChangeBoundsOperationHandler extends GModelOperationHandler<C
 
    @Override
    public Optional<Command> createCommand(final ChangeBoundsOperation operation) {
-      return commandOf(() -> executeChangeBounds(operation));
+      List<ElementAndBounds> changedElementAndBounds = operation.getNewBounds().stream().filter(this::hasChanged)
+         .toList();
+      return changedElementAndBounds.isEmpty()
+         ? doNothing()
+         : commandOf(() -> executeChangeBounds(new ChangeBoundsOperation(changedElementAndBounds)));
+   }
+
+   protected boolean hasChanged(final ElementAndBounds elementAndBounds) {
+      Optional<GModelElement> element = this.modelState.getIndex().get(elementAndBounds.getElementId());
+      if (element.isEmpty() || !(element.get() instanceof GBoundsAware boundsAware)) {
+         return true;
+      }
+      return !GraphUtil.equals(boundsAware.getSize(), elementAndBounds.getNewSize()) ||
+         !GraphUtil.equals(boundsAware.getPosition(), elementAndBounds.getNewPosition());
    }
 
    protected void executeChangeBounds(final ChangeBoundsOperation operation) {

plugins/org.eclipse.glsp.server/src/org/eclipse/glsp/server/gmodel/GModelChangeRoutingPointsHandler.java

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2023 EclipseSource and others.
+ * Copyright (c) 2019-2025 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -15,12 +15,18 @@
  ********************************************************************************/
 package org.eclipse.glsp.server.gmodel;
 
+import java.util.Arrays;
+import java.util.List;
 import java.util.Optional;
 
 import org.eclipse.emf.common.command.Command;
+import org.eclipse.glsp.graph.GEdge;
 import org.eclipse.glsp.graph.GModelIndex;
+import org.eclipse.glsp.graph.GPoint;
+import org.eclipse.glsp.graph.util.GraphUtil;
 import org.eclipse.glsp.server.operations.ChangeRoutingPointsOperation;
 import org.eclipse.glsp.server.operations.GModelOperationHandler;
+import org.eclipse.glsp.server.types.ElementAndRoutingPoints;
 import org.eclipse.glsp.server.utils.LayoutUtil;
 
 /**
@@ -30,14 +36,25 @@ public class GModelChangeRoutingPointsHandler extends GModelOperationHandler<Cha
 
    @Override
    public Optional<Command> createCommand(final ChangeRoutingPointsOperation operation) {
-      return commandOf(() -> executeChangeRoutingPoints(operation));
+      List<ElementAndRoutingPoints> changedRoutingPoints = operation.getNewRoutingPoints().stream()
+         .filter(this::hasChanged)
+         .toList();
+      return changedRoutingPoints.isEmpty()
+         ? doNothing()
+         : commandOf(() -> executeChangeRoutingPoints(new ChangeRoutingPointsOperation(changedRoutingPoints)));
    }
 
-   protected void executeChangeRoutingPoints(final ChangeRoutingPointsOperation operation) {
-      if (operation.getNewRoutingPoints() == null) {
-         throw new IllegalArgumentException("Incomplete change routingPoints  action");
+   protected boolean hasChanged(final ElementAndRoutingPoints routingPoints) {
+      Optional<GEdge> edge = this.modelState.getIndex().getByClass(routingPoints.getElementId(),
+         GEdge.class);
+      if (edge.isEmpty() || edge.get().getRoutingPoints().size() != routingPoints.getNewRoutingPoints().size()) {
+         return true;
       }
+      return !Arrays.equals(edge.get().getRoutingPoints().toArray(new GPoint[0]),
+         routingPoints.getNewRoutingPoints().toArray(new GPoint[0]), GraphUtil::compare);
+   }
 
+   protected void executeChangeRoutingPoints(final ChangeRoutingPointsOperation operation) {
       GModelIndex index = modelState.getIndex();
       operation.getNewRoutingPoints().forEach(routingPoints -> LayoutUtil.applyRoutingPoints(routingPoints, index));
    }