Adds Dynamic Typed Operations Valve & Switch

Adds two operations to allow for control flow of data
in a GRIP application.
 - Switch allows you to switch between to arbatrarily
typed inputs
 - Valve can stop the flow of data through a connection
for an arbatrarily typed input

Author: JLLeitschuh

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

@@ -20,21 +20,21 @@ public class Connection<T> {
     private final InputSocket<T> inputSocket;
 
 
-    public interface Factory <T> {
+    public interface Factory<T> {
         Connection<T> create(OutputSocket<? extends T> outputSocket, InputSocket<T> inputSocket);
     }
 
     /**
-     * @param pipeline     The pipeline to create the connection inside of.
-     * @param outputSocket The socket to listen for changes in.
-     * @param inputSocket  A different socket to update when a change occurs in the first.
+     * @param connectionValidator An object to validate that the connection can be made
+     * @param outputSocket        The socket to listen for changes in.
+     * @param inputSocket         A different socket to update when a change occurs in the first.
      */
     @Inject
-    Connection(EventBus eventBus, Pipeline pipeline, @Assisted OutputSocket<? extends T> outputSocket, @Assisted InputSocket<T> inputSocket) {
+    Connection(EventBus eventBus, ConnectionValidator connectionValidator, @Assisted OutputSocket<? extends T> outputSocket, @Assisted InputSocket<T> inputSocket) {
         this.eventBus = eventBus;
         this.outputSocket = outputSocket;
         this.inputSocket = inputSocket;
-        checkArgument(pipeline.canConnect(outputSocket, inputSocket), "Cannot connect sockets");
+        checkArgument(connectionValidator.canConnect(outputSocket, inputSocket), "Cannot connect sockets");
     }
 
     public OutputSocket<? extends T> getOutputSocket() {

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

@@ -0,0 +1,44 @@
+package edu.wpi.grip.core;
+
+/**
+ * Allows {@link Connection Connections} to be validated to ensure that the pipeline will remain valid.
+ */
+public interface ConnectionValidator {
+
+    /**
+     * Resolves which {@link Socket} is the {@link OutputSocket} and which is the {@link InputSocket}
+     * and calls {@link #canConnect(OutputSocket, InputSocket)}
+     * @param socket1 The first socket
+     * @param socket2 The second socket
+     * @return The return value of {@link #canConnect(OutputSocket, InputSocket)}
+     */
+    default boolean canConnect(Socket socket1, Socket socket2) {
+        final OutputSocket<?> outputSocket;
+        final InputSocket<?> inputSocket;
+
+        // One socket must be an input and one must be an output
+        if (socket1.getDirection() == socket2.getDirection()) {
+            return false;
+        }
+
+        if (socket1.getDirection().equals(Socket.Direction.OUTPUT)) {
+            outputSocket = (OutputSocket) socket1;
+            inputSocket = (InputSocket) socket2;
+        } else {
+            inputSocket = (InputSocket) socket1;
+            outputSocket = (OutputSocket) socket2;
+        }
+
+        // DO NOT DO ANY OTHER SORT OF VALIDATION HERE. We just want to resolve the types.
+
+        return canConnect(outputSocket, inputSocket);
+    }
+
+    /**
+     * Determines if an output socket can be connected to an input socket
+     * @param outputSocket The output socket to connect to the input socket
+     * @param inputSocket The input socket to accept the output value of the output socket
+     * @return True if a valid connection can be made from these two Sockets
+     */
+    boolean canConnect(OutputSocket<?> outputSocket, InputSocket<?> inputSocket);
+}

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

@@ -103,7 +103,7 @@ public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
         install(new FactoryModuleBuilder().build(new TypeLiteral<Connection.Factory<Object>>() {
         }));
 
-
+        bind(ConnectionValidator.class).to(Pipeline.class);
         bind(Source.SourceFactory.class).to(Source.SourceFactoryImpl.class);
         bind(CameraSource.FrameGrabberFactory.class).to(CameraSource.FrameGrabberFactoryImpl.class);
         install(new FactoryModuleBuilder()

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

@@ -0,0 +1,109 @@
+package edu.wpi.grip.core;
+
+import com.google.common.eventbus.EventBus;
+import edu.wpi.grip.core.events.ConnectionRemovedEvent;
+
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * A {@link SocketHint} that's type is linked between many other sockets and who's type is defined by
+ * whatever {@link InputSocket} was connected to it first.
+ */
+public final class LinkedSocketHint extends SocketHint.SocketHintDecorator {
+    /**
+     * Keeps track of the sockets that control the type of this socket hint
+     */
+    private final Set<InputSocket> controllingSockets = new HashSet<>();
+    private final Set<OutputSocket> controlledOutputSockets = new HashSet<>();
+    private final EventBus eventBus;
+    private Optional<Class> connectedType = Optional.empty();
+
+    @SuppressWarnings("unchecked")
+    public LinkedSocketHint(EventBus eventBus) {
+        super(new Builder<>(Object.class).identifier("").build());
+        this.eventBus = checkNotNull(eventBus, "EventBus cannot be null");
+    }
+
+    /**
+     * Creates an {@link InputSocket} that is linked to this SocketHint
+     *
+     * @param hintIdentifier The identifier for this socket's SocketHint
+     * @return A socket hint that's socket type is determined by this SocketHint
+     */
+    @SuppressWarnings("unchecked")
+    public InputSocket linkedInputSocket(String hintIdentifier) {
+        // Our own custom implementation of socket hint that interacts on this class when connections are
+        // added and removed
+        return new InputSocket(eventBus, new IdentiferOverridingSocketHintDecorator(this, hintIdentifier)) {
+            @Override
+            public void addConnection(Connection connection) {
+                synchronized (this) {
+                    controllingSockets.add(this);
+                    connectedType = Optional.of(connection.getOutputSocket().getSocketHint().getType());
+                }
+                super.addConnection(connection);
+            }
+
+            @Override
+            public void onDisconnected() {
+                synchronized (this) {
+                    // Remove this socket because it is no longer controlling the type of socket
+                    controllingSockets.remove(this);
+                    if (controllingSockets.isEmpty()) { // When the set is empty, the socket can support any type again
+                        connectedType = Optional.empty();
+                        // XXX: TODO: This is breaking the law of Demeter fix this
+                        controlledOutputSockets.forEach(outputSocket -> {
+                            final Set<Connection<?>> connections = outputSocket.getConnections();
+                            connections.stream().map(ConnectionRemovedEvent::new).forEach(this.eventBus::post);
+                            outputSocket.setPreviewed(false);
+                            outputSocket.setValueOptional(Optional.empty());
+                        });
+                    }
+                }
+                super.onDisconnected();
+            }
+        };
+    }
+
+    /**
+     * Creates an input socket that is linked to this SocketHint.
+     * This output socket will automatically be disconnected when there is no longer an input socket to guarantee the type
+     * of this SocketHint
+     *
+     * @param hintIdentifier The identifier for this socket's SocketHint
+     * @return An OutputSocket that's type is dynamically linked to this SocketHint
+     */
+    @SuppressWarnings("unchecked")
+    public OutputSocket linkedOutputSocket(String hintIdentifier) {
+        final OutputSocket outSocket = new OutputSocket(eventBus, new IdentiferOverridingSocketHintDecorator(this, hintIdentifier));
+        controlledOutputSockets.add(outSocket);
+        return outSocket;
+    }
+
+    @Override
+    public String getTypeLabel() {
+        return "<Generic>";
+    }
+
+    @Override
+    public Class getType() {
+        // If the type is known because one of the input sockets is connected then return that. Otherwise, return Object
+        return connectedType.orElse(Object.class);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public boolean isCompatibleWith(SocketHint other) {
+        if (connectedType.isPresent()) { // If the type is present
+            // Then use this socket hint to determine if this socket can be connected
+            return connectedType.get().isAssignableFrom(other.getType());
+        } else {
+            // Otherwise use the socket hint we are decorating to determine the supported type
+            return getDecorated().isCompatibleWith(other);
+        }
+    }
+}

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

@@ -16,6 +16,7 @@ enum Category {
         IMAGE_PROCESSING,
         FEATURE_DETECTION,
         NETWORK,
+        LOGICAL,
         OPENCV,
         MISCELLANEOUS,
     }
@@ -53,6 +54,9 @@ 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.

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

@@ -7,7 +7,6 @@
 import edu.wpi.grip.core.events.SocketPreviewChangedEvent;
 
 import javax.annotation.Nullable;
-import java.util.NoSuchElementException;
 import java.util.Optional;
 
 /**
@@ -29,7 +28,6 @@ public class OutputSocket<T> extends Socket<T> {
      */
     public OutputSocket(EventBus eventBus, SocketHint<T> socketHint) {
         super(eventBus, socketHint, Direction.OUTPUT);
-        getValue().orElseThrow(()-> new NoSuchElementException("The SocketHint for an output socket must have an initial value to be valid"));
     }
 
     @Override

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

@@ -30,7 +30,7 @@
  */
 @Singleton
 @XStreamAlias(value = "grip:Pipeline")
-public class Pipeline {
+public class Pipeline implements ConnectionValidator {
 
     @Inject
     @XStreamOmitField
@@ -176,28 +176,13 @@ public ProjectSettings getProjectSettings() {
      * @return true if a connection can be made from the given output socket to the given input socket
      */
     @SuppressWarnings("unchecked")
-    public boolean canConnect(Socket socket1, Socket socket2) {
-        final OutputSocket<?> outputSocket;
-        final InputSocket<?> inputSocket;
-
-        // One socket must be an input and one must be an output
-        if (socket1.getDirection() == socket2.getDirection()) {
-            return false;
-        }
-
-        if (socket1.getDirection().equals(Socket.Direction.OUTPUT)) {
-            outputSocket = (OutputSocket) socket1;
-            inputSocket = (InputSocket) socket2;
-        } else {
-            inputSocket = (InputSocket) socket1;
-            outputSocket = (OutputSocket) socket2;
-        }
-
-        final SocketHint outputHint = socket1.getSocketHint();
-        final SocketHint inputHint = socket2.getSocketHint();
+    @Override
+    public boolean canConnect(OutputSocket<?> outputSocket, InputSocket<?> inputSocket) {
+        final SocketHint outputHint = outputSocket.getSocketHint();
+        final SocketHint inputHint = inputSocket.getSocketHint();
 
         // The input socket must be able to hold the type of value that the output socket contains
-        if (!inputHint.getType().isAssignableFrom(outputHint.getType())) {
+        if (!inputHint.isCompatibleWith(outputHint)) {
             return false;
         }
 

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

@@ -32,7 +32,7 @@ public enum Direction {INPUT, OUTPUT}
     private final Direction direction;
     private final Set<Connection> connections = new HashSet<>();
     private final SocketHint<T> socketHint;
-    private Optional<? extends T> value;
+    private Optional<? extends T> value = Optional.empty();
 
 
     /**
@@ -43,7 +43,6 @@ public enum Direction {INPUT, OUTPUT}
     public Socket(EventBus eventBus, SocketHint<T> socketHint, Direction direction) {
         this.eventBus = checkNotNull(eventBus, "EventBus can not be null");
         this.socketHint = checkNotNull(socketHint, "Socket Hint can not be null");
-        this.value = socketHint.createInitialValue();
         this.direction = checkNotNull(direction, "Direction can not be null");
     }
 
@@ -82,6 +81,9 @@ public void setValue(@Nullable T value) {
      * @return The value currently stored in this socket.
      */
     public Optional<T> getValue() {
+        if(!this.value.isPresent()) {
+            this.value = socketHint.createInitialValue();
+        }
         return (Optional<T>) this.value;
     }