Changeset 254:4111d8583c56 in finroc_tools_finstruct-java

Timestamp:

08.06.2017 03:33:29 (6 years ago)

Author:

Max Reichardt <mreichardt@…>

Branch:

17.03

Phase:

public

Message:

Makes finstruct support new Finroc 17 features: type conversion, and connector objects with options in particular. Adapts to changes in dependencies.

Files:

• Finstruct.java (modified) (1 diff)
• FinstructConnectionPanel.java (modified) (23 diffs)
• FinstructInterfaceTreeModel.java (modified) (3 diffs)
• FinstructRightPanel.java (modified) (13 diffs)
• SmartConnecting.java (modified) (17 diffs)
• actions/AddPortsToInterfaceAction.java (modified) (6 diffs)
• actions/CompositeAction.java (modified) (1 diff)
• actions/ConnectAction.java (modified) (5 diffs)
• actions/DisconnectAction.java (modified) (4 diffs)
• actions/FinstructAction.java (modified) (2 diffs)
• dialogs/CreateConnectorOptionsDialog.java (added)
• dialogs/CreateInterfacesDialog.java (modified) (6 diffs)
• dialogs/CreateModuleDialog.java (modified) (14 diffs)
• dialogs/LoadModuleLibraryDialog.java (modified) (2 diffs)
• dialogs/ParameterEditDialog.java (modified) (5 diffs)
• propertyeditor/FinrocComponentFactory.java (modified) (4 diffs)
• propertyeditor/PortAccessor.java (modified) (3 diffs)
• propertyeditor/StaticParameterAccessor.java (modified) (6 diffs)
• views/AbstractGraphView.java (modified) (5 diffs)
• views/StandardViewGraphViz.java (modified) (9 diffs)

Finstruct.java

@@ -260 +260 @@
 
         // settings menu
-        miAllowDirectConnecting = new JCheckBoxMenuItem("Allow direct connecting of ports across component boundaries (deprecated)");
+        miAllowDirectConnecting = new JCheckBoxMenuItem("Allow direct connecting of ports across component boundaries");
         miAllowDirectConnecting.setMnemonic(KeyEvent.VK_A);
+        miAllowDirectConnecting.setEnabled(true);
         getSettingsMenu().add(miAllowDirectConnecting);
         menuBar.setVisible(true);

FinstructConnectionPanel.java

@@ -26 +26 @@
 import java.awt.Graphics;
 import java.awt.Point;
+import java.awt.Rectangle;
 import java.awt.event.ActionEvent;
 import java.awt.event.MouseEvent;
@@ -48 +49 @@
 import org.finroc.core.port.AbstractPort;
 import org.finroc.core.port.ThreadLocalCache;
-import org.finroc.core.port.net.NetPort;
-import org.finroc.core.portdatabase.FinrocTypeInfo;
+import org.finroc.core.remote.Definitions;
 import org.finroc.core.remote.HasUid;
 import org.finroc.core.remote.ModelNode;
 import org.finroc.core.remote.PortWrapper;
+import org.finroc.core.remote.RemoteConnector;
 import org.finroc.core.remote.RemoteFrameworkElement;
 import org.finroc.core.remote.RemotePort;
 import org.finroc.core.remote.RemoteRuntime;
+import org.finroc.core.remote.RemoteUriConnector;
+import org.finroc.tools.finstruct.SmartConnecting.MayConnectResult;
 import org.finroc.tools.finstruct.actions.AddPortsToInterfaceAction;
 import org.finroc.tools.finstruct.actions.CompositeAction;
+import org.finroc.tools.finstruct.actions.ConnectAction;
 import org.finroc.tools.finstruct.actions.FinstructAction;
+import org.finroc.tools.finstruct.dialogs.CreateConnectorOptionsDialog;
 import org.finroc.tools.gui.ConnectionPanel;
 import org.finroc.tools.gui.ConnectorIcon;
@@ -65 +70 @@
 import org.rrlib.logging.Log;
 import org.rrlib.logging.LogLevel;
+import org.rrlib.serialization.rtti.DataTypeBase;
 
 /**
@@ -85 +91 @@
     private final JMenuItem miOpenInNewWindow;
 
-    /** Temporary storage for edge destinations - used only by AWT Thread for painting connections */
-    private final ArrayList<AbstractPort> tempDestinationList = new ArrayList<AbstractPort>();
-
     /** Temporary storage hypotheticalConnections - used only by AWT Thread */
     private final ArrayList<RemotePort> tempConnectList1 = new ArrayList<RemotePort>();
     private final ArrayList<ModelNode> tempConnectList2 = new ArrayList<ModelNode>();
+    private final ArrayList<RemoteConnector> tempConnectorList = new ArrayList<RemoteConnector>();
 
     /** More colors */
@@ -96 +100 @@
     public static final Color rootViewColor = new Color(211, 211, 211);
     public static final Color inactiveTextColor = new Color(160, 160, 160);
+    public static final ConnectorIcon.IconColor errorColor = connectionPartnerMissingColor;
+    public static final ConnectorIcon.IconColor connectorNoConversion = connectedColor;
+    public static final Color connectorImplicitConversion = new Color(80, 200, 30);
+    public static final Color connectorExplicitConversion = new Color(160, 230, 30);
+    public static final Color connectorDeprecatedConversion = new Color(230, 140, 30);
+    public static final Color connectorNetwork = new Color(40, 40, 200);
+
+    public static final ConnectorIcon.IconColor portSelected20 = createConnectionCandidateColor(0.2);
+    public static final ConnectorIcon.IconColor portSelected40 = createConnectionCandidateColor(0.4);
+    public static final ConnectorIcon.IconColor portSelected60 = createConnectionCandidateColor(0.6);
+    public static final ConnectorIcon.IconColor portSelected80 = createConnectionCandidateColor(0.8);
+
+    public static final ConnectorIcon.IconColor[] candidatePortRatingColors = new ConnectorIcon.IconColor[] {
+        defaultColor,
+        portSelected20,
+        portSelected40,
+        portSelected60,
+        portSelected60,
+        portSelected60,
+        portSelected60,
+        portSelected80,
+        portSelected80,
+        selectedColor
+    };
 
     /** Tooltip-related */
@@ -132 +160 @@
                     ((o2 instanceof RemoteFrameworkElement) && ((RemoteFrameworkElement)o2).getAnnotation(ParameterInfo.TYPE) != null && o1.getClass() == ConfigFileModel.ConfigEntryWrapper.class));
         } else if (o1 instanceof RemotePort && o2 instanceof RemotePort) {
-            return canConnectPorts((RemotePort)o1, (RemotePort)o2).length() == 0;
+            return canConnectPorts((RemotePort)o1, (RemotePort)o2).isConnectingPossible();
         }
         return false;
@@ -142 +170 @@
      * @param p1 Port 1
      * @param p2 Port 2
-     * @return "" if they can be connected. Otherwise the reason why not.
-     */
-    private String canConnectPorts(RemotePort p1, RemotePort p2) {
-        if (p1.isConnectedTo(p2)) {
-            return "Ports are connected already";
+     * @return If connecting is possible: SmartConnecting.CAN_CONNECT, CAN_CONNECT_IMPLICIT_CAST, or CAN_CONNECT_EXPLICIT_CAST (all 'possible' strings start with CAN_CONNECT). If connecting is not possible, reason for this.
+     */
+    private SmartConnecting.MayConnectResult canConnectPorts(RemotePort p1, RemotePort p2) {
+        if (RemoteRuntime.arePortsConnected(p1, p2)) {
+            return new SmartConnecting.MayConnectResult("Ports are connected already");
         }
 
@@ -157 +185 @@
         tempConnectList2.add(p2);
         return SmartConnecting.mayConnect(tempConnectList1, tempConnectList2, finstruct.allowDirectConnectingAcrossGroupBoundaries()); // TODO: this can be optimized
+    }
+
+    /**
+     * Create color for candidate ports for connections
+     *
+     * @param redFactor The amount of red in color (0...1)
+     * @return Color
+     */
+    private static ConnectorIcon.IconColor createConnectionCandidateColor(double redFactor) {
+        ConnectorIcon.IconColor base = defaultColor;
+        ConnectorIcon.IconColor red = selectedColor;
+        double baseFactor = 1 - redFactor;
+        return new ConnectorIcon.IconColor((int)(baseFactor * base.getRed() + redFactor * red.getRed()), (int)(baseFactor * base.getGreen() + redFactor * red.getGreen()), (int)(baseFactor * base.getBlue() + redFactor * red.getBlue()));
     }
 
@@ -203 +244 @@
 
     @Override
-    protected Object hypotheticalConnectionImplementation(Object tn) {
+    protected CheckConnectResult checkConnect(Object other, CheckConnectResult resultBuffer) {
         if (getRightTree() instanceof ConfigFileModel) {
-            return super.hypotheticalConnectionImplementation(tn);
-        }
-
-        MJTree<Object> selTree = selectionFromRight ? rightTree : leftTree;
+            return super.checkConnect(other, resultBuffer);
+        }
+
+        // Init objects
+        resultBuffer.partnerNodes.clear();
+        resultBuffer.connectionScores.clear();
+        resultBuffer.minScore = Definitions.TypeConversionRating.IMPOSSIBLE;
+        resultBuffer.impossibleHint = "";
+        if (other == null) {
+            resultBuffer.impossibleHint = "Partner object is null";
+            return resultBuffer;
+        }
+
+        MJTree<Object> selectionTree = selectionFromRight ? rightTree : leftTree;
 
         // scan nodes to connect
-        RemoteFrameworkElement nonPortNode = processSourceNodesToConnect(tempConnectList1, selTree.getSelectedObjects());
+        RemoteFrameworkElement nonPortNode = processSourceNodesToConnect(tempConnectList1, selectionTree.getSelectedObjects());
         if (tempConnectList1.size() == 0) {
-            return nonPortNode != null && nonPortNode.isInterface() ? "Selected interface in other tree is empty" : "Only ports and interfaces can be connected (dragged)";
+
+            resultBuffer.impossibleHint = nonPortNode != null && nonPortNode.isInterface() ? "Selected interface in other tree is empty" : "Only ports and interfaces can be connected (dragged)";
+            return resultBuffer;
         }
 
         if (nonPortNode != null) {
             // only connect to other non-port nodes
-            if (tn instanceof RemotePort) {
-                return "Interfaces cannot be connected to ports (you may try the other way round)";
+            if (other instanceof RemotePort) {
+                resultBuffer.impossibleHint = "Interfaces cannot be connected to ports (you may try the other way round)";
+                return resultBuffer;
             }
 
             tempConnectList2.clear();
             for (int i = 0; i < tempConnectList1.size(); i++) {
-                tempConnectList2.add((ModelNode)tn);
-            }
-            String reason = SmartConnecting.mayConnect(tempConnectList1, tempConnectList2, finstruct.allowDirectConnectingAcrossGroupBoundaries());
-            if (reason.length() > 0) {
-                return reason;
-            }
-            ArrayList<Object> result = new ArrayList<Object>();
-            result.add(tn);
-            return result;
-        }
-
-        if (tn instanceof RemotePort) {
+                tempConnectList2.add((ModelNode)other);
+            }
+            MayConnectResult mayConnect = SmartConnecting.mayConnect(tempConnectList1, tempConnectList2, finstruct.allowDirectConnectingAcrossGroupBoundaries());
+            if (!mayConnect.isConnectingPossible()) {
+                resultBuffer.impossibleHint = mayConnect.impossibleHint;
+                return resultBuffer;
+            }
+            resultBuffer.partnerNodes.add(other);
+            resultBuffer.connectionScores.add(mayConnect.rating);
+            resultBuffer.minScore = mayConnect.rating;
+            return resultBuffer;
+        }
+
+        if (other instanceof RemotePort) {
             if (tempConnectList1.size() == 1) {
                 // Optimized implementation for only one selected port
-                String reason = canConnectPorts(tempConnectList1.get(0), (RemotePort)tn);
-                if (reason.length() > 0) {
-                    return reason;
-                }
-                ArrayList<Object> result = new ArrayList<Object>();
-                result.add(tn);
-                return result;
+                SmartConnecting.MayConnectResult mayConnect = canConnectPorts(tempConnectList1.get(0), (RemotePort)other);
+                if (!mayConnect.isConnectingPossible()) {
+                    resultBuffer.impossibleHint = mayConnect.impossibleHint;
+                    return resultBuffer;
+                }
+                resultBuffer.partnerNodes.add(other);
+                resultBuffer.connectionScores.add(mayConnect.rating);
+                resultBuffer.minScore = mayConnect.rating;
+                return resultBuffer;
             }
 
             // Standard hypotheticalConnectionImplementation from base class
-            return super.hypotheticalConnectionImplementation(tn);
+            return super.checkConnect(other, resultBuffer);
         } else {
             // Connect all ports to non-port tree node
             tempConnectList2.clear();
             for (int i = 0; i < tempConnectList1.size(); i++) {
-                tempConnectList2.add((ModelNode)tn);
-            }
-            String reason = SmartConnecting.mayConnect(tempConnectList1, tempConnectList2, finstruct.allowDirectConnectingAcrossGroupBoundaries());
-            if (reason.length() > 0) {
-                return reason;
-            }
-            ArrayList<Object> result = new ArrayList<Object>();
-            result.addAll(tempConnectList2);
-            return result;
+                tempConnectList2.add((ModelNode)other);
+            }
+            MayConnectResult mayConnect = SmartConnecting.mayConnect(tempConnectList1, tempConnectList2, finstruct.allowDirectConnectingAcrossGroupBoundaries());
+            if (!mayConnect.isConnectingPossible()) {
+                resultBuffer.impossibleHint = mayConnect.impossibleHint;
+                return resultBuffer;
+            }
+            resultBuffer.partnerNodes.add(other);
+            resultBuffer.connectionScores.add(mayConnect.rating);
+            resultBuffer.minScore = mayConnect.rating;
+            return resultBuffer;
         }
     }
@@ -309 +369 @@
                 int choice = JOptionPane.showConfirmDialog(finstruct, "This will create " + createConnectionPortCreationString(action) + ". Continue?", "Create Ports?", JOptionPane.YES_NO_OPTION);
                 if (choice == JOptionPane.NO_OPTION) {
+                    return;
+                }
+            }
+
+            // Query for any type conversions
+            boolean showCreateConnectorDialog = false;
+            for (FinstructAction a : ((CompositeAction)action).getActions()) {
+                if (a instanceof ConnectAction) {
+                    showCreateConnectorDialog |= ((ConnectAction)a).getConnectOptions().requiresOperationSelection() || FinstructAction.findRemoteRuntime(((ConnectAction)a).getSourceLink()) != FinstructAction.findRemoteRuntime(((ConnectAction)a).getDestinationLink());
+                }
+            }
+            if (showCreateConnectorDialog) {
+                CreateConnectorOptionsDialog dialog = new CreateConnectorOptionsDialog(finstruct);
+                dialog.show(((CompositeAction)action).getActions());
+                if (dialog.cancelled()) {
                     return;
                 }
@@ -354 +429 @@
                 AdminClient ac = rr.getAdminInterface();
                 pi.setConfigEntry("/" + ((HasUid)configNode).getUid(), true);
-                ac.setAnnotation(((RemotePort)parameter).getRemoteHandle(), pi);
+                ac.setAnnotation(((RemotePort)parameter).getRemoteHandle(), ParameterInfo.TYPE.getName(), pi);
                 return;
             }
@@ -362 +437 @@
 
     @Override
-    protected List<Object> getConnectionPartners(Object port) {
-        return getConnectionPartners(port, false);
-    }
-
-    /** Implementation of getConnectionPartners */
-    protected List<Object> getConnectionPartners(final Object treeNode, boolean includeSourcePorts) {
+    protected List<Object> getConnectionPartners(Object treeNode) {
         final List<Object> result = new ArrayList<Object>();
         if (!(treeNode instanceof RemotePort)) {
@@ -383 +453 @@
             return result;
         } else {
-            result.addAll(port.getOutgoingConnections());
-
-            if (includeSourcePorts) { // computationally expensive
-                result.addAll(port.getIncomingConnections());
+            RemoteRuntime runtime = RemoteRuntime.find(port);
+            ArrayList<RemoteConnector> connectors = new ArrayList<>();
+            runtime.getConnectors(connectors, port);
+            for (RemoteConnector connector : connectors) {
+                result.add(connector.getPartnerPort(port, runtime));
             }
             return result;
@@ -413 +484 @@
                             AdminClient ac = rr.getAdminInterface();
                             pi.setConfigEntry("");
-                            ac.setAnnotation(remotePort.getRemoteHandle(), pi);
+                            ac.setAnnotation(remotePort.getRemoteHandle(), ParameterInfo.TYPE.getName(), pi);
                         }
                     }
@@ -421 +492 @@
                     ParameterInfo pi = (ParameterInfo)((RemotePort)object).getAnnotation(ParameterInfo.TYPE);
                     pi.setConfigEntry("");
-                    ac.setAnnotation(((RemotePort)object).getRemoteHandle(), pi);
+                    ac.setAnnotation(((RemotePort)object).getRemoteHandle(), ParameterInfo.TYPE.getName(), pi);
                 }
                 return;
             } else if (object instanceof RemotePort) {
                 RemotePort port = (RemotePort)object;
-                List<Object> partners = getConnectionPartners(port, true);
-                NetPort np1 = port.getPort().asNetPort();
-                AdminClient ac = RemoteRuntime.find(np1).getAdminInterface();
+                RemoteRuntime runtime = RemoteRuntime.find(port);
+                if (runtime == null || runtime.getAdminInterface() == null) {
+                    return;
+                }
+                ArrayList<RemoteConnector> connectors = new ArrayList<>();
+                runtime.getConnectors(connectors, port);
                 MJTree<Object> otherTree = popupOnRight ? leftTree : rightTree;
 
-                if (ac != null) {
-                    if (visibleConnectionsOnly) {
-                        for (Object partner : partners) {
-                            if (otherTree.isVisible(partner) && (partner instanceof RemotePort)) {
-                                ac.disconnect(np1, ((RemotePort)partner).getPort().asNetPort());
-                            }
-                        }
-                    } else {
-                        ac.disconnectAll(np1);
-                    }
-                    timer.restart();
-                }
-
-
-                // Remove any network connections in reverse direction
-                for (Object partner : partners) {
-                    ArrayList<AbstractPort> result = new ArrayList<AbstractPort>();
-                    NetPort partnerNetPort = ((RemotePort)partner).getPort().asNetPort();
-                    int reverseIndex = partnerNetPort.getRemoteEdgeDestinations(result);
-                    for (int i = 0; i < reverseIndex; i++) {
-                        AdminClient partnerClient = RemoteRuntime.find(partnerNetPort).getAdminInterface();
-                        if (partnerClient != null && ac != partnerClient && result.get(i) == np1.getPort() && ((!visibleConnectionsOnly) || otherTree.isVisible(partner))) {
-                            partnerClient.networkConnect(partnerNetPort, "", RemoteRuntime.find(np1).uuid, ((RemotePort)port).getRemoteHandle(), ((HasUid)port).getUid(), true);
-                            timer.restart();
+                if (visibleConnectionsOnly) {
+                    for (RemoteConnector connector : connectors) {
+                        RemotePort partnerPort = connector.getPartnerPort(port, runtime);
+                        if (otherTree.isVisible(partnerPort)) {
+                            runtime.getAdminInterface().disconnect(connector);
                         }
                     }
-                }
+                } else {
+                    runtime.getAdminInterface().disconnectAll(port);
+                }
+                timer.restart();
+
+
+                // Remove any network connections in reverse direction
+//                for (Object partner : partners) {
+//                    ArrayList<AbstractPort> result = new ArrayList<AbstractPort>();
+//                    NetPort partnerNetPort = ((RemotePort)partner).getPort().asNetPort();
+//                    int reverseIndex = partnerNetPort.getRemoteEdgeDestinations(result);
+//                    for (int i = 0; i < reverseIndex; i++) {
+//                        AdminClient partnerClient = RemoteRuntime.find(partnerNetPort).getAdminInterface();
+//                        if (partnerClient != null && ac != partnerClient && result.get(i) == np1.getPort() && ((!visibleConnectionsOnly) || otherTree.isVisible(partner))) {
+//                            partnerClient.networkConnect(partnerNetPort, "", RemoteRuntime.find(np1).uuid, ((RemotePort)port).getRemoteHandle(), ((HasUid)port).getUid(), true);
+//                            timer.restart();
+//                        }
+//                    }
+//                }
                 return;
             }
@@ -475 +548 @@
             tooltip = null;
         } else {
-            Object result = hypotheticalConnectionImplementation(element);
-            if (result != null && result.getClass().equals(String.class)) {
-                tooltip = result.toString();
+            CheckConnectResult result = new CheckConnectResult();
+            checkConnect(element, result);
+            if (result.minScore == Definitions.TypeConversionRating.IMPOSSIBLE) {
+                tooltip = result.impossibleHint;
             }
         }
@@ -559 +633 @@
     @Override
     protected void drawConnections(Graphics g) {
-        drawConnectionsHelper(g, leftTree, rightTree);
-        if (!(getRightTree() instanceof ConfigFileModel)) {
-            drawConnectionsHelper(g, rightTree, leftTree);
+        if (getRightTree() instanceof ConfigFileModel) {
+            drawConnectionsHelper(g, leftTree, rightTree);
+        } else if (showRightTree) {
+
+            Rectangle visible = this.getVisibleRect();
+            List<Object> visibleNodesLeft = leftTree.getVisibleObjects();
+            ArrayList<RemoteConnector> connectorList = new ArrayList<RemoteConnector>();
+            finstruct.getIoInterface().updateUriConnectors();
+
+            for (Object node : visibleNodesLeft) {
+                if (node instanceof RemotePort) {
+                    RemotePort portLeft = (RemotePort)node;
+                    RemoteRuntime runtime = RemoteRuntime.find(portLeft);
+                    runtime.getConnectors(connectorList, portLeft);
+                    for (RemoteConnector connector : connectorList) {
+                        RemotePort portRight = connector.getPartnerPort(portLeft, runtime);
+                        if (portRight != null && rightTree.isVisible(portRight)) {
+                            Point p1 = getLineStartPoint(leftTree, portLeft, getLineStartPosition(connector, portLeft, portRight));
+                            Point p2 = getLineStartPoint(rightTree, portRight, getLineStartPosition(connector, portRight, portLeft));
+                            RemoteRuntime runtimeRight = RemoteRuntime.find(portRight);
+                            Color color = connectedColor;
+                            if (runtime != runtimeRight) {
+                                color = connectorNetwork;
+                            } else {
+                                boolean leftIsSource = connector.getSourceHandle() == portLeft.getRemoteHandle();
+                                Definitions.TypeConversionRating rating = connector.getRemoteConnectOptions().getTypeConversionRating(leftIsSource ? portLeft : portRight, runtime, leftIsSource ? portRight : portLeft);
+                                switch (rating) {
+                                case NO_CONVERSION:
+                                    color = connectorNoConversion;
+                                    break;
+                                case IMPOSSIBLE:
+                                case DEPRECATED_CONVERSION:
+                                    color = connectorDeprecatedConversion;
+                                    break;
+                                case IMPLICIT_CAST:
+                                case TWO_IMPLICIT_CASTS:
+                                    color = connectorImplicitConversion;
+                                    break;
+                                default:
+                                    color = connectorExplicitConversion;
+                                    break;
+                                }
+                            }
+                            if (mouseOver != null) {
+                                if (mouseOver == portLeft || mouseOver == portRight) {
+                                    color = color.brighter();
+                                }
+                            }
+                            if (visible.contains(p1) && visible.contains(p2)) {
+                                drawLine(g, p1, p2, color, true, false);
+                            } else if (g.getClipBounds().intersectsLine(p1.x, p1.y, p2.x, p2.y)) {
+                                drawLine(g, p1, p2, color, false, false);
+                            }
+                        }
+                    }
+                }
+            }
         }
     }
@@ -659 +787 @@
                 MJTree<Object> otherTree = popupOnRight ? leftTree : rightTree;
                 Object portWrapper = getTreeNodeFromPos(ptree);
-                List<Object> partners = getConnectionPartners(portWrapper, true);
+                List<Object> partners = getConnectionPartners(portWrapper);
 
                 for (Object partner : partners) {
@@ -688 +816 @@
     }
 
-
-
     @Override
     protected NodeRenderingStyle getNodeAppearance(Object node, MJTree<Object> tree, boolean selected) {
@@ -707 +833 @@
                 result.iconType |= ConnectorIcon.OUTPUT & (mouseOverFlag ? ConnectorIcon.BRIGHTER_COLOR : 0);
             }
-        } else if (node instanceof RemotePort) {
-            RemotePort port = (RemotePort)node;
-            result.textColor = tree.getBackground();
-            boolean rpc = FinrocTypeInfo.isMethodType(port.getDataType(), true);
-            boolean mouseOverFlag = (mouseOver instanceof RemotePort) && ((port.getPort() == ((RemotePort)mouseOver).getPort()) || port.isConnectedTo((RemotePort)mouseOver));
-            result.nodeColor = selected ? selectedColor : defaultColor;
-            if (getRightTree() instanceof ConfigFileModel) {
-                ParameterInfo pi = (ParameterInfo)port.getAnnotation(ParameterInfo.TYPE);
-                if (pi != null) {
-                    mouseOverFlag |= pi != null && pi.getConfigEntry() != null && pi.getConfigEntry().length() > 0 && ((ConfigFileModel)getRightTree()).get(pi.getConfigEntry()) == mouseOver;
-                } else {
-                    result.nodeColor = lightGrayColor;
-                }
-            }
-            result.iconType = (port.getFlag(FrameworkElementFlags.OUTPUT_PORT) ? ConnectorIcon.OUTPUT : 0) |
-                              (port.isProxy() ? ConnectorIcon.PROXY : 0) |
-                              (rpc ? ConnectorIcon.RPC : 0) |
-                              (mouseOverFlag ? ConnectorIcon.BRIGHTER_COLOR : 0);
-        } else {
-            if (node.getClass().equals(RemoteFrameworkElement.class)) {
-                RemoteFrameworkElement element = (RemoteFrameworkElement)node;
+        } else if (node instanceof RemoteFrameworkElement) {
+            // erroneous element?
+            RemoteFrameworkElement element = (RemoteFrameworkElement)node;
+            RemoteRuntime runtime = RemoteRuntime.find(element);
+            boolean configFileMode = getRightTree() instanceof ConfigFileModel;
+            if (runtime != null && (!configFileMode)) {
+                for (RemoteFrameworkElement errorElement : runtime.getElementsInErrorState()) {
+                    if (element.isNodeAncestor(errorElement)) {
+                        result.nodeColor = errorColor;
+                        break;
+                    }
+                }
+            }
+
+            if (node.getClass().equals(RemotePort.class)) {
+                RemotePort port = (RemotePort)element;
+                result.textColor = tree.getBackground();
+                boolean rpc = (port.getDataType().getTypeTraits() & DataTypeBase.IS_RPC_TYPE) != 0;
+                boolean mouseOverFlag = (mouseOver instanceof RemotePort) && ((port.getPort() == ((RemotePort)mouseOver).getPort()) || RemoteRuntime.arePortsConnected(port, (RemotePort)mouseOver));
+                result.nodeColor = selected ? selectedColor : (result.nodeColor != errorColor ? defaultColor : errorColor);
+                if (otherTreeSelection) {
+                    Definitions.TypeConversionRating rating = highlightedElementRatings.get(node);
+                    if (rating != null) {
+                        result.nodeColor = candidatePortRatingColors[rating.ordinal()];
+                    }
+                }
+                if (configFileMode) {
+                    ParameterInfo pi = (ParameterInfo)port.getAnnotation(ParameterInfo.TYPE);
+                    if (pi != null) {
+                        mouseOverFlag |= pi != null && pi.getConfigEntry() != null && pi.getConfigEntry().length() > 0 && ((ConfigFileModel)getRightTree()).get(pi.getConfigEntry()) == mouseOver;
+                    } else {
+                        result.nodeColor = lightGrayColor;
+                    }
+                }
+                result.iconType = (port.getFlag(FrameworkElementFlags.OUTPUT_PORT) ? ConnectorIcon.OUTPUT : 0) |
+                                  (port.isProxy() ? ConnectorIcon.PROXY : 0) |
+                                  (rpc ? ConnectorIcon.RPC : 0) |
+                                  (mouseOverFlag ? ConnectorIcon.BRIGHTER_COLOR : 0);
+            } else {
                 if (element.isInterface()) {
                     result.nodeColor = otherTreeSelection ? selectedColor : (element.isSensorInterface() ? sensorInterfaceColor : (element.isControllerInterface() ? controllerInterfaceColor : interfaceColor));
@@ -739 +883 @@
                 }
             }
-            if ((!otherTreeSelection) && node instanceof ModelNode && finstruct.getCurrentView() != null && !((ModelNode)node).isNodeAncestor(finstruct.getCurrentView().getRootElement()) && node != finstruct.getCurrentView().getRootElement()) {
-                result.textColor = inactiveTextColor;
-            }
+        }
+        if (result.textColor == null && (!otherTreeSelection) && node instanceof ModelNode && finstruct.getCurrentView() != null && !((ModelNode)node).isNodeAncestor(finstruct.getCurrentView().getRootElement()) && node != finstruct.getCurrentView().getRootElement()) {
+            result.textColor = inactiveTextColor;
         }
 
@@ -765 +909 @@
             return ConnectorIcon.LineStart.Default;
         }
-        NetPort np = port instanceof RemotePort ? ((RemotePort)port).getPort().asNetPort() : null;
-        if (np != null && partner instanceof RemotePort) {
+        if (port instanceof RemotePort && partner instanceof RemotePort) {
+            RemotePort remotePort = (RemotePort)port;
             RemotePort partnerPort = (RemotePort)partner;
-            int firstReverse = np.getRemoteEdgeDestinations(tempDestinationList);
-            int partnerIndex = tempDestinationList.indexOf(partnerPort.getPort());
-            if (partnerIndex >= 0) {
-                return partnerIndex < firstReverse ? ConnectorIcon.LineStart.Outgoing : ConnectorIcon.LineStart.Incoming;
-            } else if (partnerPort.getPort().asNetPort() != null) {
-                NetPort npPartner = partnerPort.getPort().asNetPort();
-                firstReverse = npPartner.getRemoteEdgeDestinations(tempDestinationList);
-                partnerIndex = tempDestinationList.indexOf(np.getPort());
-                if (partnerIndex >= 0) {
-                    return partnerIndex < firstReverse ? ConnectorIcon.LineStart.Incoming : ConnectorIcon.LineStart.Outgoing;
-                }
-                // Ok, there's no connection yet
+            RemoteRuntime runtime = RemoteRuntime.find(remotePort);
+            runtime.getConnectors(tempConnectorList, remotePort);
+            for (RemoteConnector connector : tempConnectorList) {
+                if (connector.getPartnerPort(remotePort, runtime) == partner) {
+                    return getLineStartPosition(connector, remotePort, partnerPort);
+                }
             }
         }
         return ConnectorIcon.LineStart.Default;
+    }
+
+    /**
+     * Get line start position for remote connector
+     *
+     * @param connector Remote connector
+     * @param port Port in question
+     * @param partner Partner port
+     * @return Line starting position
+     */
+    protected LineStart getLineStartPosition(RemoteConnector connector, RemotePort port, RemotePort partner) {
+        if (connector instanceof RemoteUriConnector) {
+            return SmartConnecting.inferConnectDirection(port, partner) == AbstractPort.ConnectDirection.TO_TARGET ? ConnectorIcon.LineStart.Outgoing : ConnectorIcon.LineStart.Incoming;
+        } else {
+            return connector.getSourceHandle() == port.getRemoteHandle() ? ConnectorIcon.LineStart.Outgoing : ConnectorIcon.LineStart.Incoming;
+        }
     }
 
@@ -794 +948 @@
 
         // Check whether port has any visible connections
-        List<Object> partners = getConnectionPartners(treeNode, true);
+        List<Object> partners = getConnectionPartners(treeNode);
         MJTree<Object> otherTree = popupOnRight ? leftTree : rightTree;
         boolean hasVisibleConnections = false;

FinstructInterfaceTreeModel.java

@@ -29 +29 @@
 import org.finroc.core.remote.ModelNode;
 import org.finroc.core.remote.RemoteFrameworkElement;
+import org.finroc.core.remote.RemoteRuntime;
 import org.finroc.tools.gui.util.treemodel.InterfaceTreeModel;
 
@@ -93 +94 @@
     private void processSubtree(ModelNode node) {
         if (node instanceof RemoteFrameworkElement && ((RemoteFrameworkElement)node).isCompositeComponent()) {
-            frameworkElementsToCheckForInterface.add((RemoteFrameworkElement)node);
+            RemoteRuntime r = RemoteRuntime.find((RemoteFrameworkElement)node);
+            if (r != null && r.getSerializationInfo().getRevision() == 0) {
+                frameworkElementsToCheckForInterface.add((RemoteFrameworkElement)node);
+            }
         }
         for (int i = 0; i < node.getChildCount(); i++) {
@@ -99 +103 @@
         }
     }
+
+    /**
+     * Update/resolve URI connector connection partners using current model.
+     * When model changes, this needs to be computed again (suggestion: do before redraw)
+     * May only be called by thread that builds remote model
+     */
+    public void updateUriConnectors() {
+        // TODO: make this more general when required (handle runtimes that are not two levels below root)
+        for (int i = 0; i < getRoot().getChildCount(); i++) {
+            ModelNode transportRoot = getRoot().getChildAt(i);
+            for (int j = 0; j < transportRoot.getChildCount(); j++) {
+                ModelNode node = transportRoot.getChildAt(j);
+                if (node instanceof RemoteRuntime) {
+                    ((RemoteRuntime)node).updateUriConnectors();
+                }
+            }
+        }
+    }
+
 }

FinstructRightPanel.java

@@ -65 +65 @@
 import org.finroc.core.FrameworkElementFlags;
 import org.finroc.core.datatype.CoreString;
-import org.finroc.core.parameter.ConstructorParameters;
 import org.finroc.core.parameter.StaticParameterList;
-import org.finroc.core.plugin.RemoteCreateModuleAction;
 import org.finroc.core.portdatabase.FinrocTypeInfo;
 import org.finroc.core.remote.ModelNode;
+import org.finroc.core.remote.RemoteCreateAction;
 import org.finroc.core.remote.RemoteFrameworkElement;
 import org.finroc.core.remote.RemotePort;
 import org.finroc.core.remote.RemoteRuntime;
-import org.finroc.core.remote.RemoteType;
+import org.finroc.core.remote.RemoteStaticParameterList;
 import org.finroc.tools.finstruct.propertyeditor.ConnectingPortAccessor;
 import org.finroc.tools.finstruct.propertyeditor.FinrocComponentFactory;
@@ -87 +86 @@
 import org.finroc.tools.gui.util.propertyeditor.PropertyAccessor;
 import org.finroc.tools.gui.util.propertyeditor.StandardComponentFactory;
+import org.rrlib.logging.Log;
+import org.rrlib.logging.LogLevel;
+import org.rrlib.serialization.Register;
 import org.rrlib.serialization.rtti.DataTypeBase;
 
@@ -133 +135 @@
 
     /** UI elements for component creation panel */
-    private RemoteCreateModuleAction selectedCreateAction;
+    private RemoteCreateAction selectedCreateAction;
     private JPanel componentCreationPanel = new JPanel();
     private JLabel componentInfoText = new JLabel(); //"", SwingConstants.CENTER);
@@ -140 +142 @@
     private JLabel componentDescription = new JLabel(); //"", SwingConstants.CENTER);
     private CoreString componentCreateName = new CoreString();
-    private ConstructorParameters componentConstructorParameters;
+    private RemoteStaticParameterList componentConstructorParameters;
 
     /** UI elements for component properties */
     private RemoteFrameworkElement selectedComponent;
-    private StaticParameterList selectedComponentStaticParameterList;
+    private RemoteStaticParameterList selectedComponentStaticParameterList;
     private JPanel componentPropertyPanel = new JPanel();
     private JLabel componentPropertyPanelText = new JLabel();
@@ -285 +287 @@
         if (runtime != null) {
             // TODO: transform to asynchronous call in order to increase GUI responsiveness (furthermore, we can be sure that all subelements have been added)
-            selectedComponentStaticParameterList = (StaticParameterList)runtime.getAdminInterface().getAnnotation(element.getRemoteHandle(), StaticParameterList.TYPE);
-            if (selectedComponentStaticParameterList != null) {
-                for (int i = 0; i < selectedComponentStaticParameterList.size(); i++) {
-                    selectedComponentStaticParameterList.get(i).resetChanged();
-                    //System.out.println(i + ":" + selectedComponentStaticParameterList.get(i).hasChanged());
-                }
+            selectedComponentStaticParameterList = new RemoteStaticParameterList();
+            try {
+                selectedComponentStaticParameterList.deserialize(runtime.getAdminInterface().getAnnotation(element.getRemoteHandle(), StaticParameterList.TYPE.getName(), runtime));
+            } catch (Exception e) {
+                Log.log(LogLevel.ERROR, e);
             }
 
@@ -353 +354 @@
                 RemoteRuntime runtime = RemoteRuntime.find(rootElement);
                 if (runtime != null) {
-                    runtime.getAdminInterface().setAnnotation(selectedComponent.getRemoteHandle(), selectedComponentStaticParameterList);
+                    runtime.getAdminInterface().setAnnotation(selectedComponent.getRemoteHandle(), StaticParameterList.TYPE.getName(), selectedComponentStaticParameterList);
                 } else {
                     Finstruct.showErrorMessage("Cannot set static parameter: connection to remote runtime lost", false, false);
@@ -401 +402 @@
                     RemotePort port = (RemotePort)interfaceElement.getChildAt(i);
                     DataTypeBase type = port.getPort().getDataType();
-                    if (type.getJavaClass() != null && (FinrocTypeInfo.isCCType(type) || FinrocTypeInfo.isStdType(type) || ((type instanceof RemoteType) && ((RemoteType)type).isAdaptable()))) {
+                    if (type.getJavaClass() != null && (FinrocTypeInfo.isCCType(type) || FinrocTypeInfo.isStdType(type))) {
                         ConnectingPortAccessor portAccess = new ConnectingPortAccessor((RemotePort)interfaceElement.getChildAt(i), prefix ? interfaceElement.getParent().getQualifiedName('/') : interfaceElement.getQualifiedName('/'));
                         componentPropertyAccessPorts.add(portAccess);
@@ -430 +431 @@
         String shortName; // library name without prefix
         boolean loaded; // Is this a loaded library?
-        ArrayList<RemoteCreateModuleAction> actions = new ArrayList<RemoteCreateModuleAction>(); // Create actions in this library (temporary)
+        ArrayList<RemoteCreateAction> actions = new ArrayList<RemoteCreateAction>(); // Create actions in this library (temporary)
 
         @Override
@@ -466 +467 @@
         if (runtime != null) {
             try {
-                ArrayList<RemoteCreateModuleAction> createActions = runtime.getAdminInterface().getRemoteModuleTypes();
+                Register<RemoteCreateAction> createActions = runtime.getCreateActions();
                 if (createActions.size() == 0) {
                     DefaultMutableTreeNode root = new DefaultMutableTreeNode();
@@ -486 +487 @@
 
                 // Add all existing components
-                for (RemoteCreateModuleAction action : createActions) {
-                    SharedLibraryCategoryAndName categoryAndName = getSharedLibraryCategoryAndName(action.groupName);
+                for (int i = 0, n = createActions.size(); i < n; i++) {
+                    RemoteCreateAction action = createActions.get(i);
+                    SharedLibraryCategoryAndName categoryAndName = getSharedLibraryCategoryAndName(action.getGroupName());
                     HashMap<String, SharedLibrary> categoryMap = categoryMaps[categoryAndName.category.ordinal()];
                     SharedLibrary library = categoryMap.get(categoryAndName.name);
                     if (library == null) {
                         library = new SharedLibrary();
-                        library.name = action.groupName;
+                        library.name = action.getGroupName();
                         library.shortName = categoryAndName.name;
                         library.loaded = true;
@@ -518 +520 @@
                         categoryNodes[i].add(node);
                         Collections.sort(sharedLibrary.actions);
-                        for (RemoteCreateModuleAction action : sharedLibrary.actions) {
+                        for (RemoteCreateAction action : sharedLibrary.actions) {
                             node.add(new DefaultMutableTreeNode(action));
                         }
@@ -574 +576 @@
                 this.validate();
 
-            } else if (selectedElement.getUserObject() instanceof RemoteCreateModuleAction) {
+            } else if (selectedElement.getUserObject() instanceof RemoteCreateAction) {
 
                 // show creation info
-                selectedCreateAction = (RemoteCreateModuleAction)selectedElement.getUserObject();
-                componentInfoText.setText("<html><b>" + simpleHtmlEscape(selectedCreateAction.name) + "</b></html>");
+                selectedCreateAction = (RemoteCreateAction)selectedElement.getUserObject();
+                componentInfoText.setText("<html><b>" + simpleHtmlEscape(selectedCreateAction.getName()) + "</b></html>");
 
                 // unique component name by default
-                componentCreateName.set(selectedCreateAction.name);
+                componentCreateName.set(selectedCreateAction.getName());
                 int i = 0;
                 while (rootElement.getChildByName(componentCreateName.toString()) != null) {
                     i++;
-                    componentCreateName.set(selectedCreateAction.name + " (" + i + ")");
-                }
-                componentConstructorParameters = selectedCreateAction.parameters != null ? selectedCreateAction.parameters.instantiate() : null;
+                    componentCreateName.set(selectedCreateAction.getName() + " (" + i + ")");
+                }
+                componentConstructorParameters = selectedCreateAction.getParameters() != null ? selectedCreateAction.getParameters().instantiate() : null;
 
                 // Create property accessor list
@@ -617 +619 @@
                 try {
                     TreePath selectedPath = componentLibraryTree.getSelectionPath();
-                    runtime.getAdminInterface().loadModuleLibrary(selectedLibrary.name);
+                    runtime.loadModuleLibrary(selectedLibrary.name);
                     new PanelUpdateThread((RemoteFrameworkElement)rootElement).run();  // note that we are calling run() here to execute update synchronously
                     TreePath newSelectedPath = componentLibraryTree.findPath(selectedPath.getPath());

SmartConnecting.java

@@ -24 +24 @@
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -33 +34 @@
 import org.finroc.core.datatype.DataTypeReference;
 import org.finroc.core.datatype.PortCreationList;
-import org.finroc.core.portdatabase.FinrocTypeInfo;
+import org.finroc.core.port.AbstractPort;
+import org.finroc.core.remote.Definitions;
+import org.finroc.core.remote.Definitions.TypeConversionRating;
 import org.finroc.core.remote.ModelNode;
+import org.finroc.core.remote.RemoteConnectOptions;
 import org.finroc.core.remote.RemoteFrameworkElement;
 import org.finroc.core.remote.RemotePort;
 import org.finroc.core.remote.RemoteRuntime;
+import org.finroc.core.remote.RemoteType;
 import org.finroc.tools.finstruct.actions.AddPortsToInterfaceAction;
 import org.finroc.tools.finstruct.actions.CompositeAction;
 import org.finroc.tools.finstruct.actions.ConnectAction;
 import org.finroc.tools.finstruct.actions.FinstructAction;
+import org.rrlib.serialization.Register;
+import org.rrlib.serialization.rtti.DataTypeBase;
 
 /**
@@ -53 +60 @@
 public class SmartConnecting {
 
+//    public static final String CAN_CONNECT = "Yes";
+//    public static final String CAN_CONNECT_IMPLICIT_CAST = "Yes - Implicit Cast";
+//    public static final String CAN_CONNECT_EXPLICIT_CAST = "Yes - Explicit Cast";
+
+    /**
+     * Result of mayConnect* methods
+     * Used like a struct -> public fields.
+     */
+    public static class MayConnectResult {
+
+        /** Connection rating */
+        public Definitions.TypeConversionRating rating;
+
+        /** If there is no suitable combination to connect source nodes to partner nodes: contains hint/reason why not (as may be displayed as tool tip atop tree node) */
+        public String impossibleHint;
+
+        /**
+         * @return Whether connecting is possible
+         */
+        public boolean isConnectingPossible() {
+            return rating != Definitions.TypeConversionRating.IMPOSSIBLE;
+        }
+
+        public MayConnectResult(String impossibleHint) {
+            rating = TypeConversionRating.IMPOSSIBLE;
+            this.impossibleHint = impossibleHint;
+        }
+
+        public MayConnectResult(TypeConversionRating rating) {
+            this.rating = rating;
+            this.impossibleHint = null;
+        }
+    }
+
+    /**
+     * Result of getStreamableTypes method
+     */
+    public static class StreamableType implements Comparable<StreamableType> {
+
+        /** Rating of connection */
+        public Definitions.TypeConversionRating rating;
+
+        /** Name of type (in both runtimes) */
+        public String name;
+
+        @Override
+        public int compareTo(StreamableType o) {
+            int c = Integer.compare(o.rating.ordinal(), rating.ordinal());
+            return c != 0 ? c : name.compareTo(o.name);
+        }
+
+        @Override
+        public String toString() {
+            return name;
+        }
+    }
+
     /**
      * Checks whether remote ports can be connected directly (ignoring component boundaries)
@@ -59 +123 @@
      * @param destinationPort Second remote port
      * @param alsoCheckReverse If false, only checks one direction (from source to destination). If true, checks both directions.
-     * @return Empty string if connecting is possible. If connecting is not possible, reason for this.
-     */
-    public static String mayConnectDirectly(RemotePort sourcePort, RemotePort destinationPort, boolean alsoCheckReverse) {
+     * @return Result: if and how connecting is possible
+     */
+    public static MayConnectResult mayConnectDirectly(RemotePort sourcePort, RemotePort destinationPort, boolean alsoCheckReverse) {
+        MayConnectResult result = new MayConnectResult(Definitions.TypeConversionRating.IMPOSSIBLE);
+        boolean forwardPossible = true, reversePossible = alsoCheckReverse;
         RemoteRuntime sourceRuntime = RemoteRuntime.find(sourcePort);
         if (sourceRuntime == null) {
-            return "No runtime found for '" + sourcePort.getQualifiedLink() + "'";
+            result.impossibleHint = "No runtime found for '" + sourcePort.getQualifiedLink() + "'";
+            return result;
         }
         RemoteRuntime destinationRuntime = RemoteRuntime.find(destinationPort);
         if (destinationRuntime == null) {
-            return "No runtime found for '" + destinationPort.getQualifiedLink() + "'";
+            result.impossibleHint = "No runtime found for '" + destinationPort.getQualifiedLink() + "'";
+            return result;
         }
 
         if (alsoCheckReverse) {
             if (!(sourcePort.getFlag(FrameworkElementFlags.EMITS_DATA) || destinationPort.getFlag(FrameworkElementFlags.EMITS_DATA))) {
-                return "Neither port emits data ('" + sourcePort.getQualifiedLink() + "' and '" + destinationPort.getQualifiedLink() + "')";
+                result.impossibleHint = "Neither port emits data ('" + sourcePort.getQualifiedLink() + "' and '" + destinationPort.getQualifiedLink() + "')";
+                return result;
             }
             if (!(sourcePort.getFlag(FrameworkElementFlags.ACCEPTS_DATA) || destinationPort.getFlag(FrameworkElementFlags.ACCEPTS_DATA))) {
-                return "Neither port accepts data ('" + sourcePort.getQualifiedLink() + "' and '" + destinationPort.getQualifiedLink() + "')";
-            }
+                result.impossibleHint = "Neither port accepts data ('" + sourcePort.getQualifiedLink() + "' and '" + destinationPort.getQualifiedLink() + "')";
+                return result;
+            }
+            if (!(sourcePort.getFlag(FrameworkElementFlags.ACCEPTS_DATA) || sourcePort.getFlag(FrameworkElementFlags.EMITS_DATA))) {
+                result.impossibleHint = sourcePort.getQualifiedLink() + " neither emits nor accepts data";
+                return result;
+            }
+            if (!(destinationPort.getFlag(FrameworkElementFlags.ACCEPTS_DATA) || destinationPort.getFlag(FrameworkElementFlags.EMITS_DATA))) {
+                result.impossibleHint = destinationPort.getQualifiedLink() + " neither emits nor accepts data";
+                return result;
+            }
+            forwardPossible = sourcePort.getFlag(FrameworkElementFlags.EMITS_DATA) && destinationPort.getFlag(FrameworkElementFlags.ACCEPTS_DATA);
+            reversePossible = destinationPort.getFlag(FrameworkElementFlags.EMITS_DATA) && sourcePort.getFlag(FrameworkElementFlags.ACCEPTS_DATA);
         } else if (!sourcePort.getFlag(FrameworkElementFlags.EMITS_DATA)) {
-            return "Source port (" + sourcePort.getQualifiedLink() + ") does not emit data";
+            result.impossibleHint = "Source port (" + sourcePort.getQualifiedLink() + ") does not emit data";
+            return result;
         } else if (!destinationPort.getFlag(FrameworkElementFlags.ACCEPTS_DATA)) {
-            return "Destination port (" + sourcePort.getQualifiedLink() + ") does not accept data";
-        }
-
-        if (sourcePort.getDataType() != destinationPort.getDataType()) {
-            return "Ports have different types ('" + sourcePort.getQualifiedLink() + "' has type '" + sourcePort.getDataType().getName() + "' and '" + destinationPort.getQualifiedLink() + "' has type '" + destinationPort.getDataType().getName() + "')";
+            result.impossibleHint = "Destination port (" + sourcePort.getQualifiedLink() + ") does not accept data";
+            return result;
         }
 
         if (sourceRuntime != destinationRuntime) {
             if ((!sourcePort.getFlag(FrameworkElementFlags.SHARED)) && (!destinationPort.getFlag(FrameworkElementFlags.SHARED))) {
-                return "Neither port is shared ('" + sourcePort.getQualifiedLink() + "' and '" + destinationPort.getQualifiedLink() + "')";
-            }
-            if (!((sourceRuntime.getAdminInterface() != null && destinationPort.getFlag(FrameworkElementFlags.SHARED)) || (destinationRuntime.getAdminInterface() != null && sourcePort.getFlag(FrameworkElementFlags.SHARED)))) {
-                return "One non-shared port needs admin interface";
+                result.impossibleHint = "Neither port is shared ('" + sourcePort.getQualifiedLink() + "' and '" + destinationPort.getQualifiedLink() + "')";
+                return result;
             }
 
             ModelNode commonParent = findCommonParent(sourcePort, destinationPort);
             if (commonParent == Finstruct.getInstance().getIoInterface().getRoot()) {
-                return "Ports need to be connected to the same protocol/interface. Are parts connected to each other.";
-            }
-        }
-
-        return "";
+                result.impossibleHint = "Ports need to be connected to the same protocol/interface. Are parts connected to each other?";
+                return result;
+            }
+
+            if (forwardPossible) {
+                result.rating = getInterRuntimeTypeConversionRating(sourceRuntime, sourcePort.getDataType(), destinationRuntime, destinationPort.getDataType());
+            } else {
+                result.rating = getBestRating(result.rating, getInterRuntimeTypeConversionRating(destinationRuntime, destinationPort.getDataType(), sourceRuntime, sourcePort.getDataType()));
+            }
+
+        } else {
+            result.rating = getBestRating(forwardPossible ? sourceRuntime.getTypeConversionRating(sourcePort.getDataType(), destinationPort.getDataType()) : Definitions.TypeConversionRating.IMPOSSIBLE,
+                                          reversePossible ? sourceRuntime.getTypeConversionRating(sourcePort.getDataType(), destinationPort.getDataType()) : Definitions.TypeConversionRating.IMPOSSIBLE);
+        }
+
+        if (result.rating == Definitions.TypeConversionRating.IMPOSSIBLE) {
+            if (forwardPossible && reversePossible) {
+                result.impossibleHint = "Types " + sourcePort.getDataType().getName() + " and " + destinationPort.getDataType().getName() + " cannot be converted to each other in either way";
+            } else if (forwardPossible) {
+                result.impossibleHint = "Type " + sourcePort.getDataType().getName() + " cannot be converted to " + destinationPort.getDataType().getName();
+            } else if (reversePossible) {
+                result.impossibleHint = "Type " + destinationPort.getDataType().getName() + " cannot be converted to " + sourcePort.getDataType().getName();
+            }
+        }
+        result.impossibleHint = "";
+        return result;
     }
 
@@ -113 +210 @@
      * @param nodes2 Second collection (possibly containing interface and components)
      * @param allowDirectConnecting Allow direct connecting across component boundaries?
-     * @return Empty string if connecting is possible. If connecting is not possible, reason for this.
-     */
-    public static String mayConnect(List<RemotePort> nodes1, List<ModelNode> nodes2, boolean allowDirectConnecting) {
+     * @return Result: if and how connecting is possible
+     */
+    public static MayConnectResult mayConnect(List<RemotePort> nodes1, List<ModelNode> nodes2, boolean allowDirectConnecting) {
+        MayConnectResult result = new MayConnectResult(Definitions.TypeConversionRating.IMPOSSIBLE);
         try {
             // TODO: can be optimized
-            getConnectActionImplementation(nodes1, nodes2, allowDirectConnecting, false, false);
+            List<CompositeAction> actions = getConnectActionImplementation(nodes1, nodes2, allowDirectConnecting, false, false);
+            for (CompositeAction compositeAction : actions) {
+                Definitions.TypeConversionRating minRating = Definitions.TypeConversionRating.NO_CONVERSION;
+                for (FinstructAction action : compositeAction.getActions()) {
+                    if (action instanceof ConnectAction) {
+                        Definitions.TypeConversionRating actionRating = ((ConnectAction)action).getConversionRating();
+                        if (actionRating.ordinal() < minRating.ordinal()) {
+                            minRating = actionRating;
+                        }
+                    }
+                }
+                if (minRating.ordinal() > result.rating.ordinal()) {
+                    result.rating = minRating;
+                }
+            }
         } catch (Exception e) {
-            return e.getMessage();
-        }
-        return "";
-    }
+            result.impossibleHint = e.getMessage();
+        }
+        return result;
+    }
+
+    /**
+     * Infer direction in which remote ports ought to be connected.
+     *
+     * @param port1 First port
+     * @param port2 Second port
+     * @return Returns TO_TARGET if port2 should be destination port - otherwise TO_SOURCE. In doubt, returns TO_TARGET.
+     */
+    public static AbstractPort.ConnectDirection inferConnectDirection(RemotePort port1, RemotePort port2) {
+        ModelNode commonParent = SmartConnecting.findCommonParent(port1, port2);
+
+        // Inner-group connection to group's interface port
+        if (port1.getParent() != null && port1.getParent().isInterface() && port1.getParent().getParent() == commonParent) {
+            return port1.getFlag(FrameworkElementFlags.IS_OUTPUT_PORT) ? AbstractPort.ConnectDirection.TO_SOURCE : AbstractPort.ConnectDirection.TO_TARGET;
+        }
+        if (port2.getParent() != null && port2.getParent().isInterface() && port2.getParent().getParent() == commonParent) {
+            return port2.getFlag(FrameworkElementFlags.IS_OUTPUT_PORT) ? AbstractPort.ConnectDirection.TO_TARGET : AbstractPort.ConnectDirection.TO_SOURCE;
+        }
+
+        // Standard case
+        return port1.getFlag(FrameworkElementFlags.IS_OUTPUT_PORT) ? AbstractPort.ConnectDirection.TO_TARGET : AbstractPort.ConnectDirection.TO_SOURCE;
+    }
+
+    /**
+     * If two ports to be connected are in different runtime environments, returns type conversion rating of best conversion option
+     *
+     * @param sourceRuntime Source runtime
+     * @param sourceType Source port data type
+     * @param destinationRuntime Destination runtime
+     * @param destinationType Destination port data type
+     * @return List of all streamable types together with connection rating of the best option
+     * @throws Throws exception if runtimes are identical
+     */
+    public static Definitions.TypeConversionRating getInterRuntimeTypeConversionRating(RemoteRuntime sourceRuntime, RemoteType sourceType, RemoteRuntime destinationRuntime, RemoteType destinationType) {
+        if (sourceRuntime == destinationRuntime) {
+            throw new RuntimeException("Runtimes are identical");
+        }
+
+        RemoteType.CachedConversionRatings ratings = sourceRuntime.getTypeConversionRatings(sourceType);
+        Register<RemoteType> types = sourceRuntime.getTypes();
+        Definitions.TypeConversionRating result = Definitions.TypeConversionRating.IMPOSSIBLE;
+        for (int j = 0; j < ratings.size(); j++) {
+            RemoteType interTypeSource = types.get(j);
+            Definitions.TypeConversionRating rating = ratings.getRating(interTypeSource);
+            if (interTypeSource != sourceType && rating.ordinal() > result.ordinal()) {
+                RemoteType interTypeDestination = destinationRuntime.getRemoteType(interTypeSource.getName());
+                if (interTypeDestination != null) {
+                    Definitions.TypeConversionRating rating2 = destinationRuntime.getTypeConversionRating(interTypeDestination, destinationType);
+                    if ((rating == Definitions.TypeConversionRating.EXPLICIT_CONVERSION_TO_GENERIC_TYPE && rating2 == Definitions.TypeConversionRating.EXPLICIT_CONVERSION_FROM_GENERIC_TYPE) ||
+                            (rating == Definitions.TypeConversionRating.EXPLICIT_CONVERSION_FROM_GENERIC_TYPE && rating2 == Definitions.TypeConversionRating.EXPLICIT_CONVERSION_TO_GENERIC_TYPE)) {
+                        rating2 = Definitions.TypeConversionRating.DEPRECATED_CONVERSION;
+                    }
+                    if (rating2.ordinal() > result.ordinal()) {
+                        result = getWorstRating(rating, rating2);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * If two ports to be connected are in different runtime environments, returns types that would be suitable for serialization/deserialization over the network
+     *
+     * @param sourceRuntime Source runtime
+     * @param sourceType Source port data type
+     * @param destinationRuntime Destination runtime
+     * @param destinationType Destination port data type
+     * @return List of all streamable types together with connection rating of the best option
+     * @throws Throws exception if runtimes are identical
+     */
+    public static List<StreamableType> getStreamableTypes(RemoteRuntime sourceRuntime, RemoteType sourceType, RemoteRuntime destinationRuntime, RemoteType destinationType) {
+        if (sourceRuntime == destinationRuntime) {
+            throw new RuntimeException("Runtimes are identical");
+        }
+
+        ArrayList<StreamableType> result = new ArrayList<StreamableType>();
+        RemoteType.CachedConversionRatings ratings = sourceRuntime.getTypeConversionRatings(sourceType);
+        Register<RemoteType> types = sourceRuntime.getTypes();
+        for (int i = 0; i < ratings.size(); i++) {
+            RemoteType interTypeSource = types.get(i);
+            Definitions.TypeConversionRating rating = ratings.getRating(interTypeSource);
+            if (interTypeSource != sourceType && rating != Definitions.TypeConversionRating.IMPOSSIBLE) {
+                RemoteType interTypeDestination = destinationRuntime.getRemoteType(interTypeSource.getName());
+                if (interTypeDestination != null) {
+                    Definitions.TypeConversionRating rating2 = destinationRuntime.getTypeConversionRating(interTypeDestination, destinationType);
+                    if (rating2 != Definitions.TypeConversionRating.IMPOSSIBLE) {
+                        StreamableType option = new StreamableType();
+                        option.name = interTypeSource.getName();
+                        option.rating = getWorstRating(rating, rating2);
+                        if ((rating == Definitions.TypeConversionRating.EXPLICIT_CONVERSION_TO_GENERIC_TYPE && rating2 == Definitions.TypeConversionRating.EXPLICIT_CONVERSION_FROM_GENERIC_TYPE) ||
+                                (rating == Definitions.TypeConversionRating.EXPLICIT_CONVERSION_FROM_GENERIC_TYPE && rating2 == Definitions.TypeConversionRating.EXPLICIT_CONVERSION_TO_GENERIC_TYPE)) {
+                            option.rating = Definitions.TypeConversionRating.DEPRECATED_CONVERSION;
+                        }
+                        result.add(option);
+                    }
+                }
+            }
+        }
+        Collections.sort(result);
+        return result;
+    }
+
+    /**
+     * @param rating1 First rating
+     * @param rating2 Second rating
+     * @return Maximum (best) rating of the two
+     */
+    public static Definitions.TypeConversionRating getBestRating(Definitions.TypeConversionRating rating1, Definitions.TypeConversionRating rating2) {
+        return Definitions.TypeConversionRating.values()[Math.max(rating1.ordinal(), rating2.ordinal())];
+    }
+
+    /**
+     * @param rating1 First rating
+     * @param rating2 Second rating
+     * @return Minimum (worst) rating of the two
+     */
+    public static Definitions.TypeConversionRating getWorstRating(Definitions.TypeConversionRating rating1, Definitions.TypeConversionRating rating2) {
+        return Definitions.TypeConversionRating.values()[Math.min(rating1.ordinal(), rating2.ordinal())];
+    }
+
 
     /**
@@ -131 +364 @@
         RemotePort port;
         String portName;
+        RemoteType portDataType;
+        PortCreationList.Entry createEntry;
         RemoteFrameworkElement interface_;
         RemoteFrameworkElement component;
@@ -228 +463 @@
             for (int i = 0; i < nodes1.size(); i++) {
 
+                RemoteRuntime node1Runtime = RemoteRuntime.find(nodes1.get(i));
+                RemoteRuntime node2Runtime = RemoteRuntime.find(nodes2.get(i));
+
                 // Initialize ports
                 TraceElement element1 = new TraceElement(), element2 = new TraceElement();
@@ -237 +475 @@
                 element1.port = nodes1.get(i);
                 element1.portName = element1.port.getName();
+                element1.portDataType = element1.port.getDataType();
                 if ((!(element1.port.getParent() instanceof RemoteFrameworkElement)) || (!(element1.port.getParent().getParent() instanceof RemoteFrameworkElement))) {
                     throw new Exception("Port must be below two framework elements");
@@ -244 +483 @@
 
                 // Element 2
+                element2.portDataType = element1.portDataType;
                 if (nodes2.get(i) instanceof RemotePort) {
                     element2.port = (RemotePort)nodes2.get(i);
                     element2.portName = element2.port.getName();
+                    element2.portDataType = element2.port.getDataType();
                     if ((!(element2.port.getParent() instanceof RemoteFrameworkElement)) || (!(element2.port.getParent().getParent() instanceof RemoteFrameworkElement))) {
                         throw new Exception("Port must be below two framework elements");
@@ -328 +569 @@
                 for (int j = 0; j < 2; j++) {
                     ArrayList<TraceElement> trace = j == 0 ? outwardTrace1 : outwardTrace2;
+                    RemoteRuntime traceRuntime = j == 0 ? node1Runtime : node2Runtime;
                     for (int k = 0; k < trace.size(); k++) {
                         TraceElement currentElement = trace.get(k);
@@ -347 +589 @@
                                 for (RemoteFrameworkElement candidate : currentElement.component.getEditableInterfaces()) {
                                     int score = 0;
-                                    boolean rpcType = FinrocTypeInfo.isMethodType(element1.port.getDataType(), true);
+                                    boolean rpcType = (element1.portDataType.getTypeTraits() & DataTypeBase.IS_RPC_TYPE) != 0;
                                     boolean rpcPortInDataInterface = rpcType && (!element1.interface_.getFlag(FrameworkElementFlags.INTERFACE_FOR_RPC_PORTS));
                                     boolean checkForRpcType = rpcType && (!rpcPortInDataInterface);
@@ -395 +637 @@
                         // Check or create port
                         ModelNode childElement = currentElement.interface_.getChildByName(lastElement.portName);
+                        Definitions.TypeConversionRating conversionRating = Definitions.TypeConversionRating.NO_CONVERSION;
                         if (childElement != null) {
                             // Check port
@@ -407 +650 @@
                                 throw new Exception("Relevant interface has port with same name which is no proxy '" + port.getQualifiedLink() + "'");
                             }
-                            if (port.getDataType() != outwardTrace1.get(0).port.getDataType()) {
-                                throw new Exception("Relevant interface has port with same name and wrong data type '" + port.getQualifiedLink() + "'");
+                            if (port.getDataType() != lastElement.portDataType) {
+                                conversionRating = traceRuntime.getTypeConversionRating(outputPorts ? lastElement.portDataType : port.getDataType(), outputPorts ? port.getDataType() : lastElement.portDataType);
+                                if (conversionRating == Definitions.TypeConversionRating.IMPOSSIBLE) {
+                                    throw new Exception("Relevant interface has port with same name and incompatible data types '" + port.getQualifiedLink() + "'");
+                                }
                             }
                             currentElement.port = port;
                             currentElement.portName = port.getName();
+                            currentElement.portDataType = port.getDataType();
                         } else {
                             // Create port (?)
                             currentElement.portName = lastElement.portName;
+                            currentElement.portDataType = lastElement.portDataType;
                             AddPortsToInterfaceAction addPortAction = addPortActions.get(currentElement.component);
                             if (addPortAction == null) {
@@ -430 +678 @@
                             for (PortCreationList.Entry entry : addList) {
                                 if (entry.name.equals(currentElement.portName)) {
-                                    if (entry.type.get() != outwardTrace1.get(0).port.getDataType()) {
-                                        throw new Exception("Existing port '" + currentElement.getPortLink() + "' needs same data type");
-                                    } else {
-                                        found = true;
+                                    RemoteType existingEntryType = traceRuntime.getRemoteType(entry.type.toString());
+                                    if (existingEntryType == null) {
+                                        throw new Exception("Remote type in PortCreationList not found (logic error)");
                                     }
+                                    if (existingEntryType != currentElement.portDataType) {
+                                        conversionRating = traceRuntime.getTypeConversionRating(outputPorts ? lastElement.portDataType : existingEntryType, outputPorts ? existingEntryType : lastElement.portDataType);
+                                        if (conversionRating == Definitions.TypeConversionRating.IMPOSSIBLE) {
+                                            throw new Exception("Relevant interface has port (to be created) with same name and incompatible data types '" + existingEntryType + "'");
+                                        }
+                                        currentElement.portDataType = existingEntryType;
+                                    }
+                                    currentElement.createEntry = entry;
+                                    found = true;
                                     break;
                                 }
@@ -440 +696 @@
 
                             if (!found) {
-                                addList.add(new PortCreationList.Entry(currentElement.portName, new DataTypeReference(outwardTrace1.get(0).port.getDataType()), outputPorts ? PortCreationList.CREATE_OPTION_OUTPUT : 0));
+                                currentElement.createEntry = new PortCreationList.Entry(currentElement.portName, new DataTypeReference(outwardTrace1.get(0).port.getDataType()), outputPorts ? PortCreationList.CREATE_OPTION_OUTPUT : 0);
+                                addList.add(currentElement.createEntry);
                             }
                         }
 
                         // Create connection?
-                        if (k > 0 && (lastElement.port == null || currentElement.port == null || (!lastElement.port.isConnectedTo(currentElement.port)))) {
-                            ConnectAction connectAction = new ConnectAction(lastElement.getPortLink(), currentElement.getPortLink());
+                        if (k > 0 && (lastElement.port == null || currentElement.port == null || (!RemoteRuntime.arePortsConnected(lastElement.port, currentElement.port)))) {
+                            ConnectAction connectAction = new ConnectAction(lastElement.getPortLink(), currentElement.getPortLink(), lastElement.portDataType.getName(), currentElement.portDataType.getName(), new RemoteConnectOptions(conversionRating), !outputPorts);
                             action.getActions().add(connectAction);
                         }
@@ -456 +713 @@
                 TraceElement lastElement2 = outwardTrace2.get(outwardTrace2.size() - 1);
                 if (lastElement1.port instanceof RemotePort && lastElement2.port instanceof RemotePort) {
-                    String result = mayConnectDirectly((RemotePort)lastElement1.port, (RemotePort)lastElement2.port, true);
-                    if (result.length() > 0) {
-                        throw new Exception(result);
-                    }
-                }
-                if (lastElement1.port == null || lastElement2.port == null || (!lastElement1.port.isConnectedTo(lastElement2.port))) {
-                    ConnectAction connectAction = new ConnectAction(lastElement1.getPortLink(), lastElement2.getPortLink());
+                    boolean port1IsSource = inferConnectDirection(lastElement1.port, lastElement2.port) == AbstractPort.ConnectDirection.TO_TARGET;
+                    MayConnectResult result = mayConnectDirectly(port1IsSource ? lastElement1.port : lastElement2.port, port1IsSource ? lastElement2.port : lastElement1.port, false);
+                    if (result.impossibleHint != null && result.impossibleHint.length() > 0) {
+                        throw new Exception(result.impossibleHint);
+                    }
+
+                    ConnectAction connectAction = new ConnectAction(lastElement1.getPortLink(), lastElement2.getPortLink(), lastElement1.portDataType.getName(), lastElement2.portDataType.getName(), new RemoteConnectOptions(result.rating), !port1IsSource);
+                    action.getActions().add(connectAction);
+
+                } else if (lastElement1.port == null || lastElement2.port == null || (!RemoteRuntime.arePortsConnected(lastElement1.port, lastElement2.port))) {
+                    Definitions.TypeConversionRating conversionRating = Definitions.TypeConversionRating.NO_CONVERSION;
+                    boolean port1IsSourcePort = port1IsOutput && ((!outwardOnlyConnection) || outwardTrace1.size() > outwardTrace2.size());
+                    RemoteType sourceType = port1IsSourcePort ? lastElement1.portDataType : lastElement2.portDataType;
+                    RemoteType destinationType = port1IsSourcePort ? lastElement2.portDataType : lastElement1.portDataType;
+                    if (node1Runtime == node2Runtime && lastElement1.portDataType != lastElement2.portDataType) {
+                        conversionRating = node1Runtime.getTypeConversionRating(sourceType, destinationType);
+                        if (conversionRating == Definitions.TypeConversionRating.IMPOSSIBLE) {
+                            throw new Exception("Ports have incompatible data types: '" + sourceType.getName() + "' and '" + destinationType.getName() + "'");
+                        }
+                    } else if (node1Runtime != node2Runtime && (!lastElement1.portDataType.getName().equals(lastElement2.portDataType.getName()))) {
+                        conversionRating = port1IsSourcePort ? getInterRuntimeTypeConversionRating(node1Runtime, lastElement1.portDataType, node2Runtime, lastElement2.portDataType) :
+                                           getInterRuntimeTypeConversionRating(node2Runtime, lastElement2.portDataType, node1Runtime, lastElement1.portDataType);
+                        if (conversionRating == Definitions.TypeConversionRating.IMPOSSIBLE) {
+                            throw new Exception("Ports have incompatible data types: '" + sourceType.getName() + "' and '" + destinationType.getName() + "'");
+                        }
+                        // TODO: maybe shared option needs to be set for port to be created in some scenarios
+                    }
+
+                    ConnectAction connectAction = new ConnectAction(lastElement1.getPortLink(), lastElement2.getPortLink(), lastElement1.portDataType.getName(), lastElement2.portDataType.getName(), new RemoteConnectOptions(conversionRating), !port1IsSourcePort);
                     action.getActions().add(connectAction);
                 }
@@ -502 +781 @@
         return result;
     }
+
+    /**
+     * @param port Port whose URI path to obtain
+     * @return URI path of port
+     */
+    public static String getUriPath(RemotePort port) {
+        String result = "";
+        ModelNode currentElement = port;
+        while (currentElement != null) {
+            if ((currentElement instanceof RemoteRuntime) || (!(currentElement instanceof RemoteFrameworkElement))) {
+                break;
+            }
+            result = "/" + port.getName().replace("/", "%2F") + result;
+            currentElement = currentElement.getParent();
+        }
+        return result;
+    }
 }

actions/AddPortsToInterfaceAction.java

@@ -27 +27 @@
 
 import org.finroc.core.datatype.PortCreationList;
-import org.finroc.core.finstructable.EditableInterfaces;
+import org.finroc.core.remote.RemoteEditableInterfaces;
 import org.finroc.core.remote.ModelNode;
 import org.finroc.core.remote.RemoteFrameworkElement;
@@ -74 +74 @@
         }
         if (undoAction) {
-            runtime.getAdminInterface().setAnnotation(((RemoteFrameworkElement)node).getRemoteHandle(), originalInterface);
+            runtime.getAdminInterface().setAnnotation(((RemoteFrameworkElement)node).getRemoteHandle(), RemoteEditableInterfaces.TYPE_NAME, originalInterface);
             return;
         }
 
         originalInterface = ((RemoteFrameworkElement)node).getEditableInterfacesObject(); // TODO: optimization: could be done asynchronously
-        EditableInterfaces newInterface = Serialization.deepCopy(originalInterface);
+        RemoteEditableInterfaces newInterface = Serialization.deepCopy(originalInterface);
 
         // Add ports to interfaces
@@ -86 +86 @@
             for (int i = 0; i < newInterface.getStaticParameterList().size(); i++) {
                 if (newInterface.getStaticParameterList().get(i).getName().equals(entry.getKey())) {
-                    interfaceList = (PortCreationList)newInterface.getStaticParameterList().get(i).valPointer().getData();
+                    interfaceList = (PortCreationList)newInterface.getStaticParameterList().get(i).getValue().getData();
                     break;
                 }
@@ -110 +110 @@
 
         // Commit to remote runtime
-        runtime.getAdminInterface().setAnnotation(((RemoteFrameworkElement)node).getRemoteHandle(), newInterface);
+        runtime.getAdminInterface().setAnnotation(((RemoteFrameworkElement)node).getRemoteHandle(), RemoteEditableInterfaces.TYPE_NAME, newInterface);
     }
 
@@ -225 +225 @@
 
     // private constructor for undo action
-    private AddPortsToInterfaceAction(String link, EditableInterfaces originalInterface) {
+    private AddPortsToInterfaceAction(String link, RemoteEditableInterfaces originalInterface) {
         this.link = link;
-        this.originalInterface = new EditableInterfaces();
+        this.originalInterface = new RemoteEditableInterfaces();
         this.editableInterfaces = null;
         undoAction = true;
@@ -242 +242 @@
 
     /** Original interface (for undo) */
-    private EditableInterfaces originalInterface;
+    private RemoteEditableInterfaces originalInterface;
 
     /** Undo action for add ports */

actions/CompositeAction.java

@@ -69 +69 @@
         } catch (Exception e) {
             String result = menuDescription + " failed:\n  " + e.getMessage();
+            //e.printStackTrace();
             if (tryUndoExecutedActionsOnError) {
                 CompositeAction undoStepsAction = (CompositeAction)getUndoActionImplementation();

actions/ConnectAction.java

@@ -22 +22 @@
 package org.finroc.tools.finstruct.actions;
 
+import java.net.URI;
+import java.util.ArrayList;
+
 import org.finroc.core.FrameworkElementFlags;
+import org.finroc.core.remote.Definitions;
 import org.finroc.core.remote.ModelNode;
+import org.finroc.core.remote.RemoteConnectOptions;
+import org.finroc.core.remote.RemoteConnector;
 import org.finroc.core.remote.RemotePort;
 import org.finroc.core.remote.RemoteRuntime;
+import org.finroc.core.remote.RemoteUriConnector;
 import org.finroc.tools.finstruct.Finstruct;
 import org.finroc.tools.finstruct.SmartConnecting;
@@ -33 +40 @@
  * @author Max Reichardt
  *
- * Action connecting two ports.
+ * Action connecting two ports
  */
 public class ConnectAction extends FinstructAction {
 
     /**
-     * @param source Fully qualified name of source
-     * @param destination Fully qualified name of destination
-     */
-    public ConnectAction(String source, String destination) {
-        this.sourceLink = source;
-        this.destinationLink = destination;
-    }
-
-    @Override
-    protected void executeImplementation() throws Exception {
-        connectImplementation(false, "Connecting");
+     * Note that the connect direction must be correct (if reverse if false, sourceLink must refer to the actual source port; if reverse is true, destinationLink must refer to the actual source port)
+     *
+     * @param source Fully qualified name of source port
+     * @param destination Fully qualified name of destination port
+     * @param sourceTypeName Name of source port data type
+     * @param destinationTypeName Name of destination port data type
+     * @param connectOptions Connect Options. If selection of connect options is to be deferred to later, can be null. They must, however, be set before executing action.
+     * @param reverse Whether destinationLink refers to the actual source port
+     */
+    public ConnectAction(String sourceLink, String destinationLink, String sourceTypeName, String destinationTypeName, RemoteConnectOptions connectOptions, boolean reverse) {
+        this.sourceLink = reverse ? destinationLink : sourceLink;
+        this.destinationLink = reverse ? sourceLink : destinationLink;
+        this.sourceTypeName = reverse ? destinationTypeName : sourceTypeName;
+        this.destinationTypeName = reverse ? sourceTypeName : destinationTypeName;
+        this.connectOptions = connectOptions;
     }
 
@@ -61 +72 @@
             return "Connecting failed: '" + destinationLink + "' no longer exists";
         }
-        if (((RemotePort)sourceNode).isConnectedTo((RemotePort)destinationNode)) {
+        if (RemoteRuntime.arePortsConnected((RemotePort)sourceNode, (RemotePort)destinationNode)) {
             return "";
         }
         return null;
-    }
-
-    @Override
-    protected FinstructAction getUndoActionImplementation() {
-        return new DisconnectAction(sourceLink, destinationLink);
-    }
-
-    @Override
-    public String getDescriptionForEditMenu() {
-        return "Connect " + getReadableLinkForMenu(sourceLink);
     }
 
@@ -84 +85 @@
      */
     protected void connectImplementation(boolean disconnect, String actionString) throws Exception {
-        ModelNode sourceNode = Finstruct.getInstance().getIoInterface().getChildByQualifiedName(sourceLink, LINK_SEPARATOR);
-        ModelNode destinationNode = Finstruct.getInstance().getIoInterface().getChildByQualifiedName(destinationLink, LINK_SEPARATOR);
-        if (sourceNode == null && destinationNode == null) {
-            throw new Exception(actionString + " failed: Neither '" + sourceLink + "' nor '" + destinationLink + "' found");
-        }
-        if (sourceNode == null) {
-            throw new Exception(actionString + " failed: '" + sourceLink + "' not found");
-        }
-        if (!(sourceNode instanceof RemotePort)) {
-            throw new Exception(actionString + " failed: '" + sourceLink + "' is not a port");
-        }
-        if (destinationNode == null) {
-            throw new Exception(actionString + " failed: '" + destinationLink + "' not found");
-        }
-        if (!(destinationNode instanceof RemotePort)) {
-            throw new Exception(actionString + " failed: '" + destinationLink + "' is not a port");
-        }
-
-        RemotePort sourcePort = (RemotePort)sourceNode;
-        RemotePort destinationPort = (RemotePort)destinationNode;
-        String reason = SmartConnecting.mayConnectDirectly(sourcePort, destinationPort, true);
+        RemotePort sourcePort = getSourcePort();
+        RemotePort destinationPort = getDestinationPort();
+        if (sourcePort == null && destinationPort == null) {
+            throw new Exception(actionString + " failed: Neither '" + sourceLink + "' nor '" + destinationLink + "' found/available");
+        }
+        if (sourcePort == null) {
+            throw new Exception(actionString + " failed: '" + sourceLink + "' not found/available");
+        }
+        if (destinationPort == null) {
+            throw new Exception(actionString + " failed: '" + destinationLink + "' not found/available");
+        }
+        if (connectOptions == null) {
+            throw new Exception(actionString + " failed: remote connect options need to be set");
+        }
+
+        String reason = SmartConnecting.mayConnectDirectly(sourcePort, destinationPort, true).impossibleHint;
         if (reason.length() > 0) {
             throw new Exception(actionString + " failed: " + reason);
@@ -117 +113 @@
         }
 
+        String result = null;
         if (sourceRuntime != null && sourceRuntime == destinationRuntime) {
 
             if (disconnect) {
-                sourceRuntime.getAdminInterface().disconnect(sourcePort.getPort().asNetPort(), destinationPort.getPort().asNetPort());
+                sourceRuntime.getAdminInterface().disconnect(sourcePort, destinationPort);
             } else {
                 //if (!sourcePort.isConnectedTo(destinationPort)) {  // removed in order to avoid issues with any parallel incomplete actions
-                sourceRuntime.getAdminInterface().connect(sourcePort.getPort().asNetPort(), destinationPort.getPort().asNetPort());
+                if (sourceRuntime.getSerializationInfo().getRevision() == 0) {
+                    sourceRuntime.getAdminInterface().connectPorts(sourcePort, destinationPort, null);
+                } else {
+                    result = sourceRuntime.getAdminInterface().connectPorts(sourcePort, destinationPort, connectOptions);  // TODO are synchronous calls to connect sufficiently responsive?
+                }
             }
         } else {
-            String result = "No port is shared";
+            result = "No port is shared";
+            boolean legacyRuntime = sourceRuntime.getSerializationInfo().getRevision() == 0;
+
+            if (disconnect) {
+                ArrayList<RemoteConnector> connectors = new ArrayList<>();
+                sourceRuntime.getConnectors(connectors, sourcePort);
+                for (RemoteConnector connector : connectors) {
+                    if ((connector instanceof RemoteUriConnector) && connector.getPartnerPort(sourcePort, sourceRuntime) == destinationPort) {
+                        sourceRuntime.getAdminInterface().disconnect(connector);
+                        result = null;
+                    }
+                }
+                if (result == null) {
+                    return;
+                }
+            }
+
             if (sourceRuntime.getAdminInterface() != null && destinationPort.getFlag(FrameworkElementFlags.SHARED)) {
-                result = sourceRuntime.getAdminInterface().networkConnect(sourcePort.getPort().asNetPort(), "", RemoteRuntime.find(destinationPort.getPort().asNetPort()).uuid, destinationPort.getRemoteHandle(), destinationPort.getUid(), false);
+                if (legacyRuntime) {
+                    result = sourceRuntime.getAdminInterface().networkConnect(sourcePort, "", RemoteRuntime.find(destinationPort).uuid, destinationPort.getRemoteHandle(), destinationPort.getUid(), disconnect);
+                } else if (!disconnect) {
+                    URI uri = new URI("tcp", "", SmartConnecting.getUriPath(destinationPort), "");
+                    org.finroc.core.net.generic_protocol.Definitions.setServerSideConversionOptions(connectOptions, destinationConnectOptions, serializedType);
+                    result = sourceRuntime.getAdminInterface().createUriConnector(sourcePort, uri.normalize().toString(), connectOptions);
+                }
             }
             if (result != null && destinationRuntime.getAdminInterface() != null && sourcePort.getFlag(FrameworkElementFlags.SHARED)) {
-                result = destinationRuntime.getAdminInterface().networkConnect(destinationPort.getPort().asNetPort(), "", RemoteRuntime.find(sourcePort.getPort().asNetPort()).uuid, sourcePort.getRemoteHandle(), sourcePort.getUid(), false);
-            }
-            if (result != null) {
-                throw new Exception(actionString + " failed: " + result);
-            }
-        }
-    }
+                if (legacyRuntime) {
+                    result = destinationRuntime.getAdminInterface().networkConnect(destinationPort, "", RemoteRuntime.find(sourcePort).uuid, sourcePort.getRemoteHandle(), sourcePort.getUid(), disconnect);
+                } else if (!disconnect) {
+                    URI uri = new URI("tcp", "", SmartConnecting.getUriPath(sourcePort), "");
+                    org.finroc.core.net.generic_protocol.Definitions.setServerSideConversionOptions(destinationConnectOptions, connectOptions, serializedType);
+                    result = destinationRuntime.getAdminInterface().createUriConnector(destinationPort, uri.normalize().toString(), destinationConnectOptions);
+                }
+            }
+        }
+        if (result != null && result.length() > 0) {
+            throw new Exception(actionString + " failed: " + result);
+        }
+    }
+
+    @Override
+    protected void executeImplementation() throws Exception {
+        connectImplementation(false, "Connecting");
+    }
+
+
+    /**
+     * @return Remote connect options. null if they have not been set.
+     */
+    public RemoteConnectOptions getConnectOptions() {
+        return connectOptions;
+    }
+
+    /**
+     * @return Conversion rating of connection to create
+     */
+    public Definitions.TypeConversionRating getConversionRating() {
+        return (connectOptions != null) ? connectOptions.conversionRating : Definitions.TypeConversionRating.NO_CONVERSION;
+    }
+
+    @Override
+    public String getDescriptionForEditMenu() {
+        return "Connect " + getReadableLinkForMenu(sourceLink);
+    }
+
+    /**
+     * @return Fully qualified name of destination port
+     */
+    public String getDestinationLink() {
+        return destinationLink;
+    }
+
+    /**
+     * @return Remote connect options in destination runtime if this is connecting ports in two different runtimes. null if they have not been set.
+     */
+    public RemoteConnectOptions getDestinationConnectOptions() {
+        return destinationConnectOptions;
+    }
+
+    /**
+     * @return Destination port. null if is currently not available
+     */
+    public RemotePort getDestinationPort() {
+        ModelNode destinationNode = Finstruct.getInstance().getIoInterface().getChildByQualifiedName(destinationLink, LINK_SEPARATOR);
+        return (destinationNode != null && destinationNode instanceof RemotePort) ? (RemotePort)destinationNode : null;
+    }
+
+    /**
+     * @return Destination type name
+     */
+    public String getDestinationTypeName() {
+        return destinationTypeName;
+    }
+
+    /**
+     * @return Fully qualified name of source port
+     */
+    public String getSourceLink() {
+        return sourceLink;
+    }
+
+    /**
+     * @return Source port. null if is currently not available
+     */
+    public RemotePort getSourcePort() {
+        ModelNode sourceNode = Finstruct.getInstance().getIoInterface().getChildByQualifiedName(sourceLink, LINK_SEPARATOR);
+        return (sourceNode != null && sourceNode instanceof RemotePort) ? (RemotePort)sourceNode : null;
+    }
+
+    /**
+     * @return Source type name
+     */
+    public String getSourceTypeName() {
+        return sourceTypeName;
+    }
+
+    @Override
+    protected FinstructAction getUndoActionImplementation() {
+        return new DisconnectAction(sourceLink, destinationLink, sourceTypeName, destinationTypeName, connectOptions, false);
+    }
+
+    /**
+     * Set variant when ports in the same runtime are connected
+     *
+     * @param connectOptions Connect options to be used
+     */
+    public void setConnectOptions(RemoteConnectOptions connectOptions) {
+        this.connectOptions = connectOptions;
+    }
+
+    /**
+     * Set variant when ports in different runtimes are connected
+     *
+     * @param connectOptions Connect options to be used in source runtime
+     * @param serializedType Type serialized/sent over the network
+     * @param destinationConnectOptions Connect options to be used in destination runtime
+     */
+    public void setConnectOptions(RemoteConnectOptions sourceConnectOptions, String serializedType, RemoteConnectOptions destinationConnectOptions) {
+        this.connectOptions = sourceConnectOptions;
+        this.serializedType = serializedType;
+        this.destinationConnectOptions = destinationConnectOptions;
+    }
+
 
     /** Qualified links to source and destination ports to connect */
     private String sourceLink, destinationLink;
+
+    /** Names of source and destination types */
+    private String sourceTypeName, destinationTypeName;
+
+    /** Remote connect options if they have been set */
+    private RemoteConnectOptions connectOptions;
+
+    /** Remote connect options in destination runtime if this is connecting ports in two different runtimes. null if they have not been set */
+    private RemoteConnectOptions destinationConnectOptions;
+
+    /** Type serialized/sent over the network if this is connecting ports in two different runtimes. null if it has not been set */
+    private String serializedType;
+
 }

actions/DisconnectAction.java

@@ -23 +23 @@
 
 import org.finroc.core.remote.ModelNode;
+import org.finroc.core.remote.RemoteConnectOptions;
 import org.finroc.core.remote.RemotePort;
+import org.finroc.core.remote.RemoteRuntime;
 import org.finroc.tools.finstruct.Finstruct;
 
@@ -35 +37 @@
 
     /**
-     * @param source Fully qualified name of source
-     * @param destination Fully qualified name of destination
+     * @param source Fully qualified name of source port
+     * @param destination Fully qualified name of destination port
+     * @param sourceTypeName Name of source port data type
+     * @param destinationTypeName Name of destination port data type
+     * @param currentConnectOptions Connect Options of current connection (required for undo)
+     * @param reverse Whether destinationLink refers to the actual source port
      */
-    public DisconnectAction(String source, String destination) {
-        super(source, destination);
+    public DisconnectAction(String sourceLink, String destinationLink, String sourceTypeName, String destinationTypeName, RemoteConnectOptions currentConnectOptions, boolean reverse) {
+        super(sourceLink, destinationLink, sourceTypeName, destinationTypeName, new RemoteConnectOptions(), reverse);
+        this.currentConnectOptions = currentConnectOptions;
     }
 
@@ -49 +56 @@
     @Override
     protected String checkSuccessImplementation() {
-        ModelNode sourceNode = Finstruct.getInstance().getIoInterface().getChildByQualifiedName(sourceLink, LINK_SEPARATOR);
+        ModelNode sourceNode = Finstruct.getInstance().getIoInterface().getChildByQualifiedName(super.getSourceLink(), LINK_SEPARATOR);
         if (!(sourceNode instanceof RemotePort)) {
             return "";
         }
-        ModelNode destinationNode = Finstruct.getInstance().getIoInterface().getChildByQualifiedName(destinationLink, LINK_SEPARATOR);
+        ModelNode destinationNode = Finstruct.getInstance().getIoInterface().getChildByQualifiedName(super.getDestinationLink(), LINK_SEPARATOR);
         if (!(destinationNode instanceof RemotePort)) {
             return "";
         }
-        if (!((RemotePort)sourceNode).isConnectedTo((RemotePort)destinationNode)) {
+        if (!RemoteRuntime.arePortsConnected((RemotePort)sourceNode, (RemotePort)destinationNode)) {
             return "";
         }
@@ -65 +72 @@
     @Override
     protected FinstructAction getUndoActionImplementation() {
-        return new ConnectAction(sourceLink, destinationLink);
+        return new ConnectAction(super.getSourceLink(), super.getDestinationLink(), super.getSourceTypeName(), super.getDestinationTypeName(), currentConnectOptions, false);
     }
 
     @Override
     public String getDescriptionForEditMenu() {
-        return "Disonnect " + getReadableLinkForMenu(sourceLink);
+        return "Disconnect " + getReadableLinkForMenu(super.getSourceLink());
     }
 
-    /** Qualified links to source and destination ports to connect */
-    private String sourceLink, destinationLink;
+
+    /** Connect Options of current connection (required for undo) */
+    private RemoteConnectOptions currentConnectOptions;
 }

actions/FinstructAction.java

@@ -29 +29 @@
 
 import javax.swing.Timer;
+
+import org.finroc.core.remote.ModelNode;
+import org.finroc.core.remote.RemoteRuntime;
+import org.finroc.tools.finstruct.Finstruct;
 
 
@@ -186 +190 @@
 
     /**
+     * Finds remote runtime for element with specified link (qualified name)
+     *
+     * @param link Link
+     * @return Runtime for specified link. Null if no such runtime exists.
+     */
+    public static RemoteRuntime findRemoteRuntime(String link) {
+        ModelNode element = Finstruct.getInstance().getIoInterface().getChildByQualifiedName(link, LINK_SEPARATOR, true);
+        return RemoteRuntime.find(element);
+    }
+
+
+    /**
      * Must only be called after action was successfully executed.
      *

dialogs/CreateInterfacesDialog.java

@@ -39 +39 @@
 import org.finroc.core.finstructable.GroupInterface.DataClassification;
 import org.finroc.core.finstructable.GroupInterface.PortDirection;
-import org.finroc.core.parameter.StaticParameterBool;
-import org.finroc.core.parameter.StaticParameterEnum;
 import org.finroc.core.parameter.StaticParameterList;
-import org.finroc.core.plugin.RemoteCreateModuleAction;
 import org.finroc.core.port.ThreadLocalCache;
+import org.finroc.core.remote.RemoteCreateAction;
 import org.finroc.core.remote.RemoteFrameworkElement;
 import org.finroc.core.remote.RemoteRuntime;
+import org.finroc.core.remote.RemoteStaticParameterList;
 import org.finroc.tools.finstruct.Finstruct;
 import org.finroc.tools.finstruct.propertyeditor.FinrocComponentFactory;
@@ -59 +58 @@
 import org.rrlib.logging.Log;
 import org.rrlib.logging.LogLevel;
+import org.rrlib.serialization.Register;
 
 /**
@@ -114 +114 @@
 
     /** Remote action for creating interfaces */
-    private RemoteCreateModuleAction createInterfaceAction;
+    private RemoteCreateAction createInterfaceAction;
 
     /** Tree model of remote framework elements */
@@ -137 +137 @@
 
         RemoteRuntime rr = RemoteRuntime.find(element);
-        for (RemoteCreateModuleAction a : rr.getAdminInterface().getRemoteModuleTypes()) {
-            if (a.groupName.equals("core") || a.groupName.equals("finroc_plugins_runtime_construction") && a.name.equals("Interface")) {
-                createInterfaceAction = a;
+        Register<RemoteCreateAction> createActions = rr.getCreateActions();
+        for (int i = 0, n = createActions.size(); i < n; i++) {
+            RemoteCreateAction action = createActions.get(i);
+            if (action.getGroupName().equals("core") || action.getGroupName().equals("finroc_plugins_runtime_construction") && action.getName().equals("Interface")) {
+                createInterfaceAction = action;
                 break;
             }
@@ -309 +311 @@
                     for (CreationTask task : creation.tasks) {
                         if (task.create) {
-                            StaticParameterList spl = new StaticParameterList();
-                            spl.add(new StaticParameterEnum<GroupInterface.DataClassification>("", task.dataClassification));
-                            spl.add(new StaticParameterEnum<GroupInterface.PortDirection>("", task.portDirection));
-                            spl.add(new StaticParameterBool("", task.shared));
-                            spl.add(new StaticParameterBool("", task.globallyUniqueLinks));
-                            String error = rr.getAdminInterface().createModule(createInterfaceAction, task.name, element.getRemoteHandle(), spl);
+                            RemoteStaticParameterList parameters = createInterfaceAction.getParameters().instantiate();
+                            parameters.get(0).setValue(task.dataClassification);
+                            parameters.get(1).setValue(task.portDirection);
+                            parameters.get(2).setValue(task.shared);
+                            parameters.get(3).setValue(task.globallyUniqueLinks);
+                            String error = rr.getAdminInterface().createModule(createInterfaceAction, task.name, element.getRemoteHandle(), parameters);
                             if (error.length() == 0 && task.portCreationList.getSize() > 0) {
                                 setPortListCount++;
@@ -363 +365 @@
                                     RemoteRuntime rr = RemoteRuntime.find(element);
                                     int handle = element.getRemoteHandle();
-                                    StaticParameterList elementParamList = (StaticParameterList)rr.getAdminInterface().getAnnotation(handle, StaticParameterList.TYPE);
+                                    RemoteStaticParameterList elementParamList = new RemoteStaticParameterList();
+                                    elementParamList.deserialize(rr.getAdminInterface().getAnnotation(handle, StaticParameterList.TYPE.getName(), rr));
                                     elementParamList.get(0).setValue(task.portCreationList);
-                                    rr.getAdminInterface().setAnnotation(handle, elementParamList);
-
+                                    rr.getAdminInterface().setAnnotation(handle, StaticParameterList.TYPE.getName(), elementParamList);
                                     setPortListCount--;
                                     break;

dialogs/CreateModuleDialog.java

@@ -27 +27 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.SortedSet;
@@ -48 +49 @@
 import javax.swing.event.TreeModelListener;
 
-import org.finroc.core.parameter.StaticParameterList;
-import org.finroc.core.plugin.RemoteCreateModuleAction;
+import org.finroc.core.remote.RemoteCreateAction;
 import org.finroc.core.remote.RemoteFrameworkElement;
 import org.finroc.core.remote.RemoteRuntime;
+import org.finroc.core.remote.RemoteStaticParameterList;
 import org.finroc.tools.finstruct.Finstruct;
 import org.finroc.tools.finstruct.util.FilteredList;
 import org.finroc.tools.gui.util.treemodel.InterfaceTreeModel;
+import org.rrlib.serialization.Register;
 
 /**
@@ -61 +63 @@
  * Create Module Dialog
  */
-public class CreateModuleDialog extends MGridBagDialog implements ActionListener, CaretListener, ListSelectionListener, FilteredList.Filter<RemoteCreateModuleAction>, ListDataListener, TreeModelListener {
+public class CreateModuleDialog extends MGridBagDialog implements ActionListener, CaretListener, ListSelectionListener, FilteredList.Filter<RemoteCreateAction>, ListDataListener, TreeModelListener {
 
     /** UID */
@@ -68 +70 @@
     /** Dialog components */
     private JTextField filter, name;
-    private JComboBox group;
-    private FilteredList<RemoteCreateModuleAction> jlist;
+    private JComboBox<Object> group;
+    private FilteredList<RemoteCreateAction> jlist;
     private JButton next, cancel, create, load;
 
@@ -109 +111 @@
 
         // create components
-        jlist = new FilteredList<RemoteCreateModuleAction>(this);
+        jlist = new FilteredList<>(this);
         name = new JTextField();
         name.addCaretListener(this);
@@ -120 +122 @@
         bl.setHgap(4);
         library.setLayout(bl);
-        group = new JComboBox();
+        group = new JComboBox<>();
         group.addActionListener(jlist);
         library.add(group, BorderLayout.CENTER);
@@ -142 +144 @@
 
         // get create module actions
-        updateCreateModuleActions(RemoteRuntime.find(parent).getAdminInterface().getRemoteModuleTypes());
+        Register<RemoteCreateAction> createActions = RemoteRuntime.find(parent).getCreateActions();
+        updateCreateModuleActions(createActions);
 
         // show dialog
@@ -156 +159 @@
      * @param createModuleActions Current create module actions
      */
-    public void updateCreateModuleActions(List<RemoteCreateModuleAction> createModuleActions) {
+    public void updateCreateModuleActions(Register<RemoteCreateAction> createModuleActions) {
         if (createModuleActions == null) {
             return;
         }
         SortedSet<Object> groups = new TreeSet<Object>();
+        ArrayList<RemoteCreateAction> actions = new ArrayList<>(createModuleActions.size());
         groups.add("all");
-        for (RemoteCreateModuleAction rcma : createModuleActions) {
-            groups.add(rcma.groupName);
-        }
-        group.setModel(new DefaultComboBoxModel(groups.toArray()));
+        for (int i = 0, n = createModuleActions.size(); i < n; i++) {
+            RemoteCreateAction action = createModuleActions.get(i);
+            groups.add(action.getGroupName());
+            actions.add(action);
+        }
+        group.setModel(new DefaultComboBoxModel<Object>(groups.toArray()));
         updateButtonState();
-        jlist.setElements(createModuleActions);
-    }
-
-    @Override
-    public int accept(RemoteCreateModuleAction rcma) {
+        jlist.setElements(actions);
+    }
+
+    @Override
+    public int accept(RemoteCreateAction rcma) {
         String f = filter.getText();
         String g = group.getSelectedItem().toString();
@@ -177 +183 @@
             g = null;
         }
-        if (g == null || rcma.groupName.equals(g)) {
-            if (rcma.name.toLowerCase().contains(f.toLowerCase())) {
-                if (rcma.name.toLowerCase().startsWith(f.toLowerCase())) {
+        if (g == null || rcma.getGroupName().equals(g)) {
+            if (rcma.getName().toLowerCase().contains(f.toLowerCase())) {
+                if (rcma.getName().toLowerCase().startsWith(f.toLowerCase())) {
                     return 0;
                 } else {
@@ -205 +211 @@
                 String load = new LoadModuleLibraryDialog((JFrame)getOwner()).show(libs);
                 if (load != null) {
-                    updateCreateModuleActions(rr.getAdminInterface().loadModuleLibrary(load));
+                    updateCreateModuleActions(rr.loadModuleLibrary(load));
                 }
             } else {
@@ -211 +217 @@
             }
         } else if (e.getSource() == next || e.getSource() == create) {
-            RemoteCreateModuleAction rcma = jlist.getSelectedValue();
-            StaticParameterList spl = null;
+            RemoteCreateAction rcma = jlist.getSelectedValue();
+            RemoteStaticParameterList spl = null;
             if (e.getSource() == next) {
-                spl = rcma.parameters.instantiate();
+                spl = rcma.getParameters().instantiate();
                 ParameterEditDialog ped = new ParameterEditDialog(this);
                 setVisible(false);
@@ -264 +270 @@
             return;
         } else if (name.getText().equals(autoSetName)) {
-            autoSetName = jlist.getSelectedValue().name;
+            autoSetName = jlist.getSelectedValue().getName();
             name.setText(autoSetName);
         } else {
@@ -275 +281 @@
      */
     private void updateButtonState() {
-        RemoteCreateModuleAction rcma = jlist.getSelectedValue();
+        RemoteCreateAction rcma = jlist.getSelectedValue();
         boolean b = rcma != null && name.getText().length() > 0;
-        create.setEnabled(b && rcma.parameters.size() == 0);
-        next.setEnabled(b && rcma.parameters.size() > 0);
+        boolean hasParameters = b && rcma.getParameters() != null && rcma.getParameters().size() > 0;
+        create.setEnabled(b && (!hasParameters));
+        next.setEnabled(b && hasParameters);
     }
 
@@ -306 +313 @@
 
                     // possibly show edit dialog
-                    new ParameterEditDialog(this).show(createdModule, false, false);
+                    try {
+                        new ParameterEditDialog(this).show(createdModule, false, false);
+                    } catch (Exception exception) {
+                        Finstruct.showErrorMessage(exception, true);
+                    }
                     close();
                     return;

dialogs/LoadModuleLibraryDialog.java

@@ -53 +53 @@
     /** Buttons */
     private JButton load, cancel;
-    private JList list;
+    private JList<String> list;
     private String selected;
 
@@ -79 +79 @@
 
         // create components
-        list = new JList(moduleLibraries.toArray());
+        list = new JList<String>(moduleLibraries.toArray(new String[0]));
         //list.setPreferredSize(new Dimension(350, 550));
         list.setBorder(BorderFactory.createLineBorder(Color.BLACK));

dialogs/ParameterEditDialog.java

@@ -31 +31 @@
 import javax.swing.JPanel;
 
-import org.finroc.core.finstructable.EditableInterfaces;
 import org.finroc.core.parameter.StaticParameterList;
+import org.finroc.core.remote.RemoteEditableInterfaces;
 import org.finroc.core.remote.RemoteFrameworkElement;
 import org.finroc.core.remote.RemoteRuntime;
+import org.finroc.core.remote.RemoteStaticParameterList;
 import org.finroc.tools.finstruct.Finstruct;
 import org.finroc.tools.finstruct.propertyeditor.FinrocComponentFactory;
@@ -68 +69 @@
 
     /** Remote Element property list */
-    private StaticParameterList elementParamList;
+    private RemoteStaticParameterList elementParamList;
 
     /**
@@ -89 +90 @@
      * @param editInterfaces Edit element's interfaces instead of parameters?
      */
-    public void show(RemoteFrameworkElement element, boolean warnIfNoParameters, boolean editInterfaces) {
+    public void show(RemoteFrameworkElement element, boolean warnIfNoParameters, boolean editInterfaces) throws Exception {
         this.editInterfaces = editInterfaces;
         setTitle((editInterfaces ? "Edit Interfaces of " : "Edit Static Parameters of ") + element.getQualifiedName('/'));
         this.element = element;
         RemoteRuntime rr = RemoteRuntime.find(element);
+        elementParamList = new RemoteStaticParameterList();
         if (!editInterfaces) {
-            elementParamList = (StaticParameterList)rr.getAdminInterface().getAnnotation(element.getRemoteHandle(), StaticParameterList.TYPE);
+            elementParamList.deserialize(rr.getAdminInterface().getAnnotation(element.getRemoteHandle(), StaticParameterList.TYPE.getName(), rr));
         } else {
-            elementParamList = ((EditableInterfaces)rr.getAdminInterface().getAnnotation(element.getRemoteHandle(), EditableInterfaces.TYPE)).
-                               getStaticParameterList();
+            RemoteEditableInterfaces interfaces = new RemoteEditableInterfaces();
+            interfaces.deserialize(rr.getAdminInterface().getAnnotation(element.getRemoteHandle(), RemoteEditableInterfaces.TYPE_NAME, rr));
+            elementParamList = interfaces.getStaticParameterList();
         }
         if (elementParamList != null) {
@@ -115 +118 @@
      * @param fe Framework element (edited - or parent)
      */
-    public void show(StaticParameterList spl, RemoteFrameworkElement fe) {
+    public void show(RemoteStaticParameterList spl, RemoteFrameworkElement fe) {
 
         // Create property panel
@@ -160 +163 @@
                 RemoteRuntime rr = RemoteRuntime.find(element);
                 if (!editInterfaces) {
-                    rr.getAdminInterface().setAnnotation(element.getRemoteHandle(), elementParamList);
+                    rr.getAdminInterface().setAnnotation(element.getRemoteHandle(), StaticParameterList.TYPE.getName(), elementParamList);
                 } else {
-                    EditableInterfaces editableInterfaces = new EditableInterfaces();
+                    RemoteEditableInterfaces editableInterfaces = new RemoteEditableInterfaces();
                     editableInterfaces.setStaticParameterList(elementParamList);
-                    rr.getAdminInterface().setAnnotation(element.getRemoteHandle(), editableInterfaces);
+                    rr.getAdminInterface().setAnnotation(element.getRemoteHandle(), RemoteEditableInterfaces.TYPE_NAME, editableInterfaces);
                 }
             }

propertyeditor/FinrocComponentFactory.java

@@ -32 +32 @@
 import org.finroc.core.datatype.PortCreationList;
 import org.finroc.core.datatype.XML;
-import org.finroc.core.portdatabase.FinrocTypeInfo;
 import org.finroc.core.portdatabase.SerializationHelper;
 import org.finroc.core.remote.ModelNode;
 import org.finroc.core.remote.RemoteRuntime;
 import org.finroc.core.remote.RemoteType;
-import org.finroc.core.remote.RemoteTypes;
 import org.finroc.tools.gui.util.propertyeditor.BooleanEditor;
 import org.finroc.tools.gui.util.propertyeditor.ComponentFactory;
@@ -51 +49 @@
 import org.finroc.plugins.data_types.ContainsStrings;
 import org.finroc.plugins.data_types.PaintablePortData;
-import org.rrlib.finroc_core_utils.jc.ArrayWrapper;
-import org.rrlib.finroc_core_utils.jc.container.SafeConcurrentlyIterableList;
 import org.rrlib.serialization.BinarySerializable;
 import org.rrlib.serialization.EnumValue;
 import org.rrlib.serialization.PortDataListImpl;
+import org.rrlib.serialization.Register;
 import org.rrlib.serialization.Serialization;
 import org.rrlib.serialization.StringInputStream;
@@ -84 +81 @@
      */
     public static boolean isTypeSupported(DataTypeBase dt) {
-        if (FinrocTypeInfo.isCCType(dt) || FinrocTypeInfo.isStdType(dt) || ((dt instanceof RemoteType) && ((RemoteType)dt).isAdaptable())) {
+        if ((dt.getTypeTraits() & DataTypeBase.IS_DATA_TYPE) != 0) {
             Class<?> type = dt.getJavaClass();
             if (type != null) {
@@ -112 +109 @@
         } else if (DataTypeReference.class.equals(type)) {
             RemoteRuntime rr = RemoteRuntime.find(commonParent);
-            ArrayList<DataTypeReference> types = new ArrayList<DataTypeReference>();
+            ArrayList<Object> types = new ArrayList<Object>();
             if (rr == null) { // use local data types
                 for (short i = 0; i < DataTypeBase.getTypeCount(); i++) {
                     DataTypeBase dt = DataTypeBase.getType(i);
                     if (dt != null) {
-                        types.add(new DataTypeReference(dt));
+                        types.add(dt);
                     }
                 }
             } else {
-                SafeConcurrentlyIterableList<RemoteTypes.Entry> remoteTypes = rr.getRemoteTypes().getTypes();
-                ArrayWrapper<RemoteTypes.Entry> iterable = remoteTypes.getIterable();
-                for (int i = 0, n = iterable.size(); i < n; i++) {
-                    RemoteTypes.Entry entry = iterable.get(i);
-                    if (entry != null && entry.getLocalDataType() != null) {
-                        types.add(new DataTypeReference(entry.getLocalDataType()));
+                Register<RemoteType> remoteTypes = rr.getRemoteTypes();
+                for (int i = 0, n = remoteTypes.size(); i < n; i++) {
+                    RemoteType entry = remoteTypes.get(i);
+                    if (entry != null) {
+                        types.add(entry);
                     }
                 }
             }
-            wpec = new DataTypeEditor(types.toArray(new DataTypeReference[0]), null, panel);
+            wpec = new DataTypeEditor(types.toArray(new Object[0]), null, panel);
             //acc = new CoreSerializableAdapter((PropertyAccessor<BinarySerializable>)acc, type, DataTypeReference.TYPE);
         } else if (PaintablePortData.class.isAssignableFrom(type)) {

propertyeditor/PortAccessor.java

@@ -93 +93 @@
     @Override
     public Class<T> getType() {
-        return (wrapped.getDataType().getJavaClass() == null && (wrapped.getDataType().getType() == DataTypeBase.Classification.LIST || wrapped.getDataType().getType() == DataTypeBase.Classification.PTR_LIST)) ?
-               (Class<T>)PortDataListImpl.class : (Class<T>)wrapped.getDataType().getJavaClass();
+        return (wrapped.getDataType().getJavaClass() == null && (wrapped.getDataType().getTypeTraits() == DataTypeBase.IS_LIST_TYPE)) ? (Class<T>)PortDataListImpl.class : (Class<T>)wrapped.getDataType().getJavaClass();
     }
 
@@ -128 +127 @@
                 CCPortDataManager c = ThreadLocalCache.get().getUnusedInterThreadBuffer(DataTypeBase.findType(newValue.getClass(), ap.getDataType()));
                 Serialization.deepCopy(newValue, c.getObject().getData());
-                RemoteRuntime.find(RemotePort.get(ap)[0]).getAdminInterface().setRemotePortValue(ap.asNetPort(), c.getObject(), errorPrinter);
+                RemoteRuntime.find(RemotePort.get(ap)[0]).getAdminInterface().setRemotePortValue(RemotePort.get(ap)[0], c.getObject(), errorPrinter);
             } else {
                 CCPortDataManagerTL c = ThreadLocalCache.get().getUnusedBuffer(DataTypeBase.findType(newValue.getClass(), ap.getDataType()));
@@ -139 +138 @@
             Serialization.deepCopy(newValue, result.getObject().getData(), null);
             if (ap.getFlag(FrameworkElementFlags.NETWORK_ELEMENT)) {
-                RemoteRuntime.find(RemotePort.get(ap)[0]).getAdminInterface().setRemotePortValue(ap.asNetPort(), result.getObject(), errorPrinter);
+                RemoteRuntime.find(RemotePort.get(ap)[0]).getAdminInterface().setRemotePortValue(RemotePort.get(ap)[0], result.getObject(), errorPrinter);
             } else {
                 ((PortBase)wrapped).publish(result);

propertyeditor/StaticParameterAccessor.java

@@ -29 +29 @@
 import org.finroc.core.parameter.StaticParameterBase;
 import org.finroc.core.parameter.StaticParameterList;
+import org.finroc.core.remote.RemoteStaticParameterList;
 import org.finroc.tools.gui.util.propertyeditor.PropertyAccessor;
 import org.rrlib.serialization.Serialization;
@@ -41 +42 @@
 
     /** Wrapped parameter */
-    protected final StaticParameterBase wrapped;
+    protected final RemoteStaticParameterList.Parameter wrapped;
 
     protected final String namePrefix;
 
-    public StaticParameterAccessor(StaticParameterBase wrapped, String namePrefix) {
+    public StaticParameterAccessor(RemoteStaticParameterList.Parameter wrapped, String namePrefix) {
         this.wrapped = wrapped;
         this.namePrefix = namePrefix;
@@ -55 +56 @@
             return String.class;
         } else {
-            return wrapped.getType().getJavaClass();
+            return wrapped.getType().getDefaultLocalDataType().getJavaClass();
         }
     }
@@ -61 +62 @@
     @Override
     public Object get() throws Exception {
-        return Serialization.deepCopy(wrapped.valPointer().getData());
+        return Serialization.deepCopy(wrapped.getValue().getData());
     }
 
     @Override
     public void set(Object newValue) throws Exception {
-        if (newValue instanceof String) {
-            wrapped.setValue(new CoreString(newValue.toString()));
-        } else {
-            wrapped.setValue(newValue);
-        }
+        wrapped.setValue(newValue);
     }
 
@@ -88 +85 @@
      * @return List of accessors for list
      */
-    public static List < PropertyAccessor<? >> createForList(StaticParameterList spl, String namePrefix) {
+    public static List < PropertyAccessor<? >> createForList(RemoteStaticParameterList spl, String namePrefix) {
         ArrayList < PropertyAccessor<? >> result = new ArrayList < PropertyAccessor<? >> ();
         for (int i = 0; i < spl.size(); i++) {
@@ -95 +92 @@
         return result;
     }
-    public static List < PropertyAccessor<? >> createForList(StaticParameterList spl) {
+    public static List < PropertyAccessor<? >> createForList(RemoteStaticParameterList spl) {
         return createForList(spl, "");
     }

views/AbstractGraphView.java

@@ -43 +43 @@
 import org.finroc.core.Annotatable;
 import org.finroc.core.FrameworkElementFlags;
-import org.finroc.core.port.AbstractPort;
-import org.finroc.core.port.net.NetPort;
-import org.finroc.core.portdatabase.FinrocTypeInfo;
 import org.finroc.core.remote.ModelNode;
+import org.finroc.core.remote.RemoteConnector;
 import org.finroc.core.remote.RemoteFrameworkElement;
 import org.finroc.core.remote.RemotePort;
 import org.finroc.core.remote.RemoteRuntime;
+import org.finroc.core.remote.RemoteUriConnector;
 import org.finroc.plugins.data_types.StdStringList;
 import org.finroc.tools.finstruct.FinstructConnectionPanel;
@@ -58 +57 @@
 import org.rrlib.logging.Log;
 import org.rrlib.logging.LogLevel;
+import org.rrlib.serialization.rtti.DataTypeBase;
 import org.rrlib.xml.XMLNode;
 
@@ -217 +217 @@
                 if (fe.getChildAt(i) instanceof RemotePort) {
                     RemotePort remotePort = (RemotePort)fe.getChildAt(i);
-                    if (!FinrocTypeInfo.isMethodType(remotePort.getPort().getDataType(), true)) {
+                    if ((remotePort.getDataType().getTypeTraits() & DataTypeBase.IS_RPC_TYPE) == 0) {
                         boolean output = (remotePort.getFlags() & FrameworkElementFlags.IS_OUTPUT_PORT) != 0;
                         one |= output;
@@ -239 +239 @@
                 if (fe.getChildAt(i) instanceof RemotePort) {
                     RemotePort remotePort = (RemotePort)fe.getChildAt(i);
-                    if (!FinrocTypeInfo.isMethodType(remotePort.getPort().getDataType(), true)) {
+                    if ((remotePort.getDataType().getTypeTraits() & DataTypeBase.IS_RPC_TYPE) == 0) {
                         boolean input = (remotePort.getFlags() & FrameworkElementFlags.IS_OUTPUT_PORT) == 0;
                         one |= input;
@@ -402 +402 @@
     @SuppressWarnings("unchecked")
     public Collection<E> getEdges(final ModelNode root, Collection<V> allVertices) {
-        final TreeMap<E, E> result = new TreeMap<E, E>();
-        final HashMap<ModelNode, V> lookup = new HashMap<ModelNode, V>();
-        final ArrayList<AbstractPort> remoteEdgeDestinations = new ArrayList<AbstractPort>();
+        final TreeMap<E, E> result = new TreeMap<>();
+        final HashMap<ModelNode, V> lookup = new HashMap<>();
+        final ArrayList<RemoteConnector> remoteConnectors = new ArrayList<>();
         for (V v : allVertices) {
             lookup.put(v.getModelElement(), v);
         }
         for (RemotePort port : root.getPortsBelow(null)) {
-            NetPort np = port.getPort().asNetPort();
-            remoteEdgeDestinations.clear();
-            int reverseIndex = np.getRemoteEdgeDestinations(remoteEdgeDestinations);
-            for (int i = 0; i < remoteEdgeDestinations.size(); i++) {
-                AbstractPort destPort = remoteEdgeDestinations.get(i);
-                boolean reverseEdge = (i >= reverseIndex);
-                GetParentResult src = getParentInGraph(lookup, port);
-                for (RemotePort destTemp : RemotePort.get(destPort)) {
-                    GetParentResult dest = getParentInGraph(lookup, destTemp);
-                    if (src.parent != null && dest.parent != null && src.parent != dest.parent) {
-                        GetParentResult src2 = reverseEdge ? dest : src;
-                        GetParentResult dest2 = reverseEdge ? src : dest;
-                        E eNew = createEdgeInstance(src2.parent, dest2.parent);
-                        eNew.source = src2.parent;
-                        eNew.destination = dest2.parent;
-                        E e = result.get(eNew);
-                        if (e == null) {
-                            e = eNew;
-                            result.put(eNew, eNew);
+            //NetPort np = port.getPort().asNetPort();
+            remoteConnectors.clear();
+            RemoteRuntime remoteRuntime = RemoteRuntime.find(port);
+            remoteRuntime.getConnectors(remoteConnectors, port);
+            //int reverseIndex = np.getRemoteEdgeDestinations(remoteConnectors);
+            for (int i = 0; i < remoteConnectors.size(); i++) {
+                RemoteConnector connector = remoteConnectors.get(i);
+                if (port.getRemoteHandle() == connector.getOwnerPortHandle() && remoteRuntime == connector.getOwnerRuntime()) { // avoid processing connectors twice: as both ports of relevant edges are below graph, only process when 'port' is owner port
+                    boolean reverseEdge = (connector instanceof RemoteUriConnector) && ((RemoteUriConnector)connector).getCurrentPartner() == port;
+                    GetParentResult src = getParentInGraph(lookup, port);
+                    RemotePort destinationPort = connector.getPartnerPort(port, remoteRuntime);
+                    for (RemotePort destTemp : RemotePort.get(destinationPort.getPort())) {
+                        GetParentResult dest = getParentInGraph(lookup, destTemp);
+                        if (src.parent != null && dest.parent != null && src.parent != dest.parent) {
+                            GetParentResult src2 = reverseEdge ? dest : src;
+                            GetParentResult dest2 = reverseEdge ? src : dest;
+                            E eNew = createEdgeInstance(src2.parent, dest2.parent);
+                            eNew.source = src2.parent;
+                            eNew.destination = dest2.parent;
+                            E e = result.get(eNew);
+                            if (e == null) {
+                                e = eNew;
+                                result.put(eNew, eNew);
+                            }
+                            e.dataTypeFlags |= src2.dataTypeFlags | dest2.dataTypeFlags;
+                            e.addConnection(port, destTemp);
                         }
-                        e.dataTypeFlags |= src2.dataTypeFlags | dest2.dataTypeFlags;
-                        e.addConnection(port, destTemp);
                     }
                 }

views/StandardViewGraphViz.java

@@ -69 +69 @@
 import org.finroc.core.FrameworkElementFlags;
 import org.finroc.core.RuntimeEnvironment;
-import org.finroc.core.finstructable.EditableInterfaces;
 import org.finroc.core.parameter.StaticParameterList;
-import org.finroc.core.port.AbstractPort;
 import org.finroc.core.port.ThreadLocalCache;
-import org.finroc.core.port.net.NetPort;
+import org.finroc.core.remote.RemoteEditableInterfaces;
 import org.finroc.core.remote.ModelNode;
+import org.finroc.core.remote.RemoteConnector;
 import org.finroc.core.remote.RemoteFrameworkElement;
 import org.finroc.core.remote.RemotePort;
 import org.finroc.core.remote.RemoteRuntime;
+import org.finroc.core.remote.RemoteStaticParameterList;
 import org.finroc.core.util.Files;
 import org.finroc.plugins.data_types.StdStringList;
@@ -93 +93 @@
 import org.rrlib.logging.Log;
 import org.rrlib.logging.LogLevel;
+import org.rrlib.serialization.BinaryInputStream;
 import org.rrlib.xml.XMLNode;
 
@@ -353 +354 @@
             }
             if (!keepVerticesAndEdges) {
+                getFinstruct().getIoInterface().updateUriConnectors();
                 final ModelNode root = getRootElement();
 
@@ -1150 +1152 @@
             final ArrayList<ModelNode> srcPorts = new ArrayList<ModelNode>();
             final HashSet<ModelNode> destPorts = new HashSet<ModelNode>();
-            final ArrayList<AbstractPort> remoteEdgeDestinations = new ArrayList<AbstractPort>();
-
-            // all forward edges
-            if (getSource().getModelElement() != null) {
+            final ArrayList<RemoteConnector> remoteConnectors = new ArrayList<RemoteConnector>();
+
+            if (getSource().getModelElement() != null && getDestination().getModelElement() != null) {
                 ArrayList<RemotePort> remotePorts = getSource().getModelElement().getPortsBelow(null);
                 for (RemotePort remotePort : remotePorts) {
-                    NetPort np = remotePort.getPort().asNetPort();
-                    if (np != null) {
-                        boolean added = false;
-                        remoteEdgeDestinations.clear();
-                        int reverseIndex = np.getRemoteEdgeDestinations(remoteEdgeDestinations);
-                        for (int i = 0; i < reverseIndex; i++) {
-                            AbstractPort port = remoteEdgeDestinations.get(i);
-                            for (RemotePort remoteDestPort : RemotePort.get(port)) {
-                                if (remoteDestPort.isNodeAncestor(getDestination().getModelElement())) {
-                                    destPorts.add(remoteDestPort);
-                                    if (!added) {
-                                        srcPorts.add(remotePort);
-                                        added = true;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            // reverse network edges
-            if (getDestination().getModelElement() != null) {
-                ArrayList<RemotePort> remotePorts = getDestination().getModelElement().getPortsBelow(null);
-                for (RemotePort remotePort : remotePorts) {
-                    NetPort np = remotePort.getPort().asNetPort();
-                    if (np != null) {
-                        remoteEdgeDestinations.clear();
-                        int reverseIndex = np.getRemoteEdgeDestinations(remoteEdgeDestinations);
-                        for (int i = reverseIndex; i < remoteEdgeDestinations.size(); i++) {
-                            AbstractPort port = remoteEdgeDestinations.get(i);
-                            for (RemotePort remoteSourcePort : RemotePort.get(port)) {
-                                if (remoteSourcePort.isNodeAncestor(getSource().getModelElement())) {
-                                    if (!srcPorts.contains(remoteSourcePort)) {
-                                        srcPorts.add(remoteSourcePort);
-                                    }
-                                    if (!destPorts.contains(remotePort)) {
-                                        destPorts.add(remotePort);
-                                    }
+                    boolean added = false;
+                    remoteConnectors.clear();
+                    RemoteRuntime remoteRuntime = RemoteRuntime.find(remotePort);
+                    remoteRuntime.getConnectors(remoteConnectors, remotePort);
+                    for (RemoteConnector connector : remoteConnectors) {
+                        RemotePort partner = connector.getPartnerPort(remotePort, remoteRuntime);
+                        for (RemotePort remoteDestPort : RemotePort.get(partner.getPort())) {
+                            if (remoteDestPort.isNodeAncestor(getDestination().getModelElement())) {
+                                destPorts.add(remoteDestPort);
+                                if (!added) {
+                                    srcPorts.add(remotePort);
+                                    added = true;
                                 }
                             }
@@ -1513 +1487 @@
         } else if (ae.getSource() == miEditModule) {
             if (rightClickedOn instanceof RemoteFrameworkElement) {
-                new ParameterEditDialog(getFinstruct()).show((RemoteFrameworkElement)rightClickedOn, true, false);
+                try {
+                    new ParameterEditDialog(getFinstruct()).show((RemoteFrameworkElement)rightClickedOn, true, false);
+                } catch (Exception e) {
+                    Finstruct.showErrorMessage(e, true);
+                }
                 refreshViewAfter(500);
             }
@@ -1523 +1501 @@
         } else if (ae.getSource() == miEditInterfaces) {
             if (rightClickedOn instanceof RemoteFrameworkElement) {
-                new ParameterEditDialog(getFinstruct()).show((RemoteFrameworkElement)rightClickedOn, true, true);
+                try {
+                    new ParameterEditDialog(getFinstruct()).show((RemoteFrameworkElement)rightClickedOn, true, true);
+                } catch (Exception e) {
+                    Finstruct.showErrorMessage(e, true);
+                }
                 refreshViewAfter(500);
             }
@@ -1694 +1676 @@
                     if (rightClickedOn instanceof RemoteFrameworkElement) {
                         try {
-                            StaticParameterList parameterList = (StaticParameterList)rr.getAdminInterface().getAnnotation(
-                                                                    ((RemoteFrameworkElement)rightClickedOn).getRemoteHandle(), StaticParameterList.TYPE);
-                            miEditModule.setEnabled(parameterList != null);
+                            BinaryInputStream staticParameterListStream = rr.getAdminInterface().getAnnotation(((RemoteFrameworkElement)rightClickedOn).getRemoteHandle(), StaticParameterList.TYPE.getName(), rr);
+                            miEditModule.setEnabled(staticParameterListStream != null);
                         } catch (Exception exception) {}
                     }
@@ -1713 +1694 @@
                             if (structureFile.length() == 0) {
                                 try {
-                                    StaticParameterList parameterList = (StaticParameterList)rr.getAdminInterface().getAnnotation(
-                                                                            finstructableGroup.getRemoteHandle(), StaticParameterList.TYPE);
+                                    RemoteStaticParameterList parameterList = new RemoteStaticParameterList();
+                                    parameterList.deserialize(rr.getAdminInterface().getAnnotation(finstructableGroup.getRemoteHandle(), StaticParameterList.TYPE.getName(), rr));
                                     for (int i = 0; i < parameterList.size(); i++) {
                                         if (parameterList.get(i).getName().equalsIgnoreCase("xml file")) {
-                                            structureFile = parameterList.get(i).valPointer().getData().toString();
+                                            structureFile = parameterList.get(i).getValue().getData().toString();
                                             break;
                                         }
@@ -1736 +1717 @@
                         if (((RemoteFrameworkElement)rightClickedOn).getFlag(FrameworkElementFlags.FINSTRUCTABLE_GROUP)) {
                             try {
-                                EditableInterfaces editableInterfaces = (EditableInterfaces)rr.getAdminInterface().getAnnotation(
-                                        ((RemoteFrameworkElement)rightClickedOn).getRemoteHandle(), EditableInterfaces.TYPE);
-                                miEditInterfaces.setEnabled(editableInterfaces != null);
+                                BinaryInputStream editableInterfacesStream = rr.getAdminInterface().getAnnotation(((RemoteFrameworkElement)rightClickedOn).getRemoteHandle(), RemoteEditableInterfaces.TYPE_NAME, rr);
+                                miEditInterfaces.setEnabled(editableInterfacesStream != null);
                             } catch (Exception exception) {}
                         }