Refactor Operation Interface

- Operations now use local state variables for input and output sockets rather than regenerating them on the fly
- Moved name, description, category, icon, and aliases to a separate description object
- Socket classes are now interfaces
- Refactors Generated Operations to be in source code
- Changed socket get methods to return List<FooSocket> instead of FooSocket<?>[]

Author: SamCarlberg

buildSrc/src/main/java/edu/wpi/gripgenerator/FileParser.java

@@ -76,14 +76,14 @@ public void removeConnection(StepRemovedEvent e) {
         // Remove this connection if one of the steps it was connected to was removed
         for (OutputSocket socket : e.getStep().getOutputSockets()) {
             if (socket == this.outputSocket) {
-                this.eventBus.post(new ConnectionRemovedEvent(this));
+                this.remove();
                 return;
             }
         }
 
         for (InputSocket socket : e.getStep().getInputSockets()) {
             if (socket == this.inputSocket) {
-                this.eventBus.post(new ConnectionRemovedEvent(this));
+                this.remove();
                 return;
             }
         }
@@ -94,9 +94,16 @@ public void removeConnection(SourceRemovedEvent e) {
         // Remove this connection if it's from a source that was removed
         for (OutputSocket socket : e.getSource().getOutputSockets()) {
             if (socket == this.outputSocket) {
-                this.eventBus.post(new ConnectionRemovedEvent(this));
+                this.remove();
                 return;
             }
         }
     }
+
+    /**
+     * Removes this connection from the pipeline.
+     */
+    public void remove() {
+        eventBus.post(new ConnectionRemovedEvent(this));
+    }
 }

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

@@ -12,6 +12,10 @@
 import edu.wpi.grip.core.events.UnexpectedThrowableEvent;
 import edu.wpi.grip.core.serialization.Project;
 import edu.wpi.grip.core.settings.SettingsProvider;
+import edu.wpi.grip.core.sockets.InputSocket;
+import edu.wpi.grip.core.sockets.InputSocketImpl;
+import edu.wpi.grip.core.sockets.OutputSocket;
+import edu.wpi.grip.core.sockets.OutputSocketImpl;
 import edu.wpi.grip.core.sources.CameraSource;
 import edu.wpi.grip.core.sources.ImageFileSource;
 import edu.wpi.grip.core.sources.MultiImageFileSource;
@@ -109,6 +113,9 @@ public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
 
         bind(ConnectionValidator.class).to(Pipeline.class);
         bind(Source.SourceFactory.class).to(Source.SourceFactoryImpl.class);
+
+        bind(InputSocket.Factory.class).to(InputSocketImpl.FactoryImpl.class);
+        bind(OutputSocket.Factory.class).to(OutputSocketImpl.FactoryImpl.class);
         install(new FactoryModuleBuilder()
                 .implement(CameraSource.class, CameraSource.class)
                 .build(CameraSource.Factory.class));

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

@@ -6,18 +6,19 @@
 import com.google.inject.Injector;
 import edu.wpi.grip.core.events.ExceptionClearedEvent;
 import edu.wpi.grip.core.events.ExceptionEvent;
+import edu.wpi.grip.core.operations.CVOperations;
 import edu.wpi.grip.core.operations.Operations;
 import edu.wpi.grip.core.operations.network.GRIPNetworkModule;
 import edu.wpi.grip.core.serialization.Project;
 import edu.wpi.grip.core.sources.GRIPSourcesHardwareModule;
-import edu.wpi.grip.generated.CVOperations;
 
 import javax.inject.Inject;
 import java.io.File;
 import java.io.IOException;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+
 /**
  * Main driver class for headless mode
  */
@@ -27,6 +28,7 @@ public class Main {
     @Inject private PipelineRunner pipelineRunner;
     @Inject private EventBus eventBus;
     @Inject private Operations operations;
+    @Inject private CVOperations cvOperations;
     @Inject private Logger logger;
 
     @SuppressWarnings("PMD.SystemPrintln")
@@ -45,7 +47,7 @@ public void start(String[] args) throws IOException, InterruptedException {
         }
 
         operations.addOperations();
-        CVOperations.addOperations(eventBus);
+        cvOperations.addOperations();
 
         final String projectPath = args[0];
 

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

@@ -1,112 +1,40 @@
 package edu.wpi.grip.core;
 
-import com.google.common.collect.ImmutableSet;
-import com.google.common.eventbus.EventBus;
 import edu.wpi.grip.core.sockets.InputSocket;
 import edu.wpi.grip.core.sockets.OutputSocket;
-import edu.wpi.grip.core.sockets.SocketsProvider;
 
-import java.io.InputStream;
-import java.util.Optional;
+import java.util.List;
 
 /**
- * The common interface used by <code>Step</code>s in a pipeline to call various operations.  There is usually only one
- * instance of any class that implements <code>Operation</code>, which is called whenever that operation is used.
+ * The common interface used by <code>Step</code>s in a pipeline to call various operations. Each instance of an
+ * operation in the pipeline is handled by a unique instance of that {@code Operation} class.
  */
 public interface Operation {
 
-    enum Category {
-        IMAGE_PROCESSING,
-        FEATURE_DETECTION,
-        NETWORK,
-        LOGICAL,
-        OPENCV,
-        MISCELLANEOUS,
-    }
-
-    /**
-     * @return The unique user-facing name of the operation, such as "Gaussian Blur"
-     */
-    String getName();
-
-    /**
-     * @return Any old unique user-facing names of the operation. This is used to preserve compatibility with
-     * old versions of GRIP if the operation name changes.
-     */
-    default ImmutableSet<String> getAliases() {
-        return ImmutableSet.of();
-    }
-
-
-    /**
-     * @return A description of the operation.
-     */
-    String getDescription();
-
-    /**
-     * @return What category the operation falls under.  This is used to organize them in the GUI
-     */
-    default Category getCategory() {
-        return Category.MISCELLANEOUS;
-    }
-
     /**
-     * @return An {@link InputStream} of a 128x128 image to show the user as a representation of the operation.
-     */
-    default Optional<InputStream> getIcon() {
-        return Optional.empty();
-    }
-
-    default SocketsProvider createSockets(EventBus eventBus) {
-        return new SocketsProvider(createInputSockets(eventBus), createOutputSockets(eventBus));
-    }
-    /**
-     * @param eventBus The Guava {@link EventBus} used by the application.
-     * @return An array of sockets for the inputs that the operation expects.
-     */
-    InputSocket<?>[] createInputSockets(EventBus eventBus);
-
-    /**
-     * @param eventBus The Guava {@link EventBus} used by the application.
-     * @return An array of sockets for the outputs that the operation produces.
+     * @return A list of sockets for the inputs that the operation expects.
+     *
+     * @implNote The returned list should be immutable (i.e. read-only)
      */
-    OutputSocket<?>[] createOutputSockets(EventBus eventBus);
+    List<InputSocket> getInputSockets();
 
     /**
-     * Override this to provide persistent per-step data
+     * @return A list of sockets for the outputs that the operation produces.
+     *
+     * @implNote The returned list should be immutable (i.e. read-only)
      */
-    default Optional<?> createData() {
-        return Optional.empty();
-    }
+    List<OutputSocket> getOutputSockets();
 
     /**
-     * Perform the operation on the specified inputs, storing the results in the specified outputs.
-     *
-     * @param inputs  An array obtained from {@link #createInputSockets(EventBus)}. The caller can set the value of
-     *                each socket to an actual parameter for the operation.
-     * @param outputs An array obtained from {@link #createOutputSockets(EventBus)}. The outputs of the operation will
-     *                be stored in these sockets.
-     * @param data    Optional data to be passed to the operation
+     * Performs this {@code Operation}.
      */
-    default void perform(InputSocket<?>[] inputs, OutputSocket<?>[] outputs, Optional<?> data) {
-        perform(inputs, outputs);
-    }
-
-    default void perform(InputSocket<?>[] inputs, OutputSocket<?>[] outputs) {
-        throw new UnsupportedOperationException("Perform was not overridden");
-    }
+    void perform();
 
     /**
      * Allows the step to clean itself up when removed from the pipeline.
      * This should only be called by {@link Step#setRemoved()} to ensure correct synchronization.
-     *
-     * @param inputs  An array obtained from {@link #createInputSockets(EventBus)}. The caller can set the value of
-     *                each socket to an actual parameter for the operation.
-     * @param outputs An array obtained from {@link #createOutputSockets(EventBus)}. The outputs of the operation will
-     *                be stored in these sockets.
-     * @param data    Optional data to be passed to the operation
      */
-    default void cleanUp(InputSocket<?>[] inputs, OutputSocket<?>[] outputs, Optional<?> data) {
+    default void cleanUp() {
         /* no-op */
     }
 }