Steps now only run when Input Socket are dirtied

Author: JLLeitschuh

core/src/main/java/edu/wpi/grip/core/Step.java

@@ -127,13 +127,20 @@ private void resetOutputSockets() {
      * default values.
      */
     protected final void runPerformIfPossible() {
+        boolean anyDirty = false; // Keeps track of if there are sockets that are dirty
         for (InputSocket<?> inputSocket : inputSockets) {
             // If there is a socket that isn't present then we have a problem.
             if (!inputSocket.getValue().isPresent()) {
                 witness.flagWarning(inputSocket.getSocketHint().getIdentifier() + MISSING_SOCKET_MESSAGE_END);
                 resetOutputSockets();
                 return;  /* Only run the perform method if all of the input sockets are present. */
             }
+            // If one value is true then this will stay true
+            anyDirty |= inputSocket.dirtied();
+        }
+        if (!anyDirty) { // If there aren't any dirty inputs
+            // Don't clear the exceptions just return
+            return;
         }
 
         try {

core/src/main/java/edu/wpi/grip/core/sockets/InputSocket.java

@@ -4,14 +4,16 @@
 import com.thoughtworks.xstream.annotations.XStreamAlias;
 import edu.wpi.grip.core.Operation;
 
+import java.util.concurrent.atomic.AtomicBoolean;
+
 /**
  * Represents the input into an {@link Operation}.
  *
  * @param <T> The type of the value that this socket stores
  */
 @XStreamAlias(value = "grip:Input")
 public class InputSocket<T> extends Socket<T> {
-
+    private final AtomicBoolean dirty = new AtomicBoolean(false);
 
     /**
      * @param eventBus   The Guava {@link EventBus} used by the application.
@@ -21,6 +23,20 @@ public InputSocket(EventBus eventBus, SocketHint<T> socketHint) {
         super(eventBus, socketHint, Direction.INPUT);
     }
 
+    @Override
+    protected void onValueChanged() {
+        dirty.set(true);
+    }
+
+    /**
+     * Checks if the socket has been dirtied and rests it to false.
+     *
+     * @return True if the socket has been dirtied
+     */
+    public boolean dirtied() {
+        return dirty.compareAndSet(true, false);
+    }
+
     /**
      * {@inheritDoc}
      */

core/src/main/java/edu/wpi/grip/core/sockets/OutputSocket.java

@@ -7,9 +7,6 @@
 import edu.wpi.grip.core.Operation;
 import edu.wpi.grip.core.events.SocketPreviewChangedEvent;
 
-import javax.annotation.Nullable;
-import java.util.Optional;
-
 /**
  * Represents the output of an {@link Operation}.
  *
@@ -31,16 +28,6 @@ public OutputSocket(EventBus eventBus, SocketHint<T> socketHint) {
         super(eventBus, socketHint, Direction.OUTPUT);
     }
 
-    @Override
-    public void setValueOptional(Optional<? extends T> optionalValue) {
-        super.setValueOptional(optionalValue);
-    }
-
-    @Override
-    public void setValue(@Nullable T value) {
-        super.setValue(value);
-    }
-
     /**
      * @param previewed If <code>true</code>, this socket will be shown in a preview in the GUI.
      */

core/src/main/java/edu/wpi/grip/core/sockets/Socket.java

@@ -61,12 +61,13 @@ public SocketHint<T> getSocketHint() {
      *
      * @param optionalValue The optional value to assign this socket to.
      */
-    public synchronized void setValueOptional(Optional<? extends T> optionalValue) {
+    public final synchronized void setValueOptional(Optional<? extends T> optionalValue) {
         checkNotNull(optionalValue, "The optional value can not be null");
         if (optionalValue.isPresent()) {
             getSocketHint().getType().cast(optionalValue.get());
         }
         this.value = optionalValue;
+        onValueChanged();
         eventBus.post(new SocketChangedEvent(this));
     }
 
@@ -75,9 +76,16 @@ public synchronized void setValueOptional(Optional<? extends T> optionalValue) {
      *
      * @param value The value to store in this socket. Nullable.
      */
-    public void setValue(@Nullable T value) {
+    public final void setValue(@Nullable T value) {
         setValueOptional(Optional.ofNullable(this.getSocketHint().getType().cast(value)));
+    }
 
+    /**
+     * Called when the value for the socket is reassigned.
+     * Can be used by an implementing class to change behaviour when the value is changed.
+     */
+    protected void onValueChanged() {
+        /* no-op */
     }
 
     /**

core/src/test/java/edu/wpi/grip/core/PipelineRunnerTest.java

@@ -11,6 +11,7 @@
 import edu.wpi.grip.core.events.StopPipelineEvent;
 import edu.wpi.grip.core.sockets.InputSocket;
 import edu.wpi.grip.core.sockets.OutputSocket;
+import edu.wpi.grip.core.sockets.SocketHints;
 import edu.wpi.grip.core.util.MockExceptionWitness;
 import net.jodah.concurrentunit.Waiter;
 import org.junit.After;
@@ -98,10 +99,11 @@ public void perform(InputSocket<?>[] inputs, OutputSocket<?>[] outputs) {
             class ExceptionEventReceiver {
                 private int callCount = 0;
                 private ExceptionEvent event;
+
                 @Subscribe
                 public void onException(ExceptionEvent event) {
                     this.event = event;
-                    callCount ++;
+                    callCount++;
                 }
             }
             final ExceptionEventReceiver exceptionEventReceiver = new ExceptionEventReceiver();
@@ -334,7 +336,14 @@ default String getDescription() {
 
         @Override
         default InputSocket<?>[] createInputSockets(EventBus eventBus) {
-            return new InputSocket<?>[0];
+            return new InputSocket<?>[]{
+                    new InputSocket<Boolean>(new EventBus(), SocketHints.createBooleanSocketHint("Test val", false)) {
+                        @Override
+                        public boolean dirtied() {
+                            return true;
+                        }
+                    }
+            };
         }
 
         @Override